Index: attribute.dd
===================================================================
--- attribute.dd	(revision 1638)
+++ attribute.dd	(working copy)
@@ -2,37 +2,11 @@
 
 $(SPEC_S Attributes,
 
-$(GRAMMAR
-$(GNAME AttributeSpecifier):
-    $(I Attribute) $(B :)
-    $(I Attribute) $(I DeclarationBlock)
+$(AttributeSpecifier_production)
+$(Attribute_production)
 
-$(GNAME Attribute):
-    $(LINK2 #linkage, $(I LinkageAttribute))
-    $(LINK2 #align, $(I AlignAttribute))
-    $(LINK2 pragma.html, $(I Pragma))
-    $(LINK2 #deprecated, $(B deprecated))
-    $(GLINK ProtectionAttribute)
-    $(B static)
-    $(B final)
-    $(LINK2 #override, $(B override))
-    $(LINK2 #abstract, $(B abstract))
-    $(LINK2 #const, $(B const))
-    $(LINK2 #auto, $(B auto))
-    $(LINK2 #scope, $(B scope))
-$(V2    $(LINK2 #gshared, $(B __gshared))
-    $(LINK2 #shared, $(B shared))
-    $(LINK2 #immutable, $(B immutable))
-    $(LINK2 #inout, $(B inout))
-    $(LINK2 #disable, $(B @disable))
-)
+$(DeclarationBlock_production)
 
-$(GNAME DeclarationBlock):
-    $(LINK2 module.html#DeclDef, $(I DeclDef))
-    $(B { })
-    $(B {) $(LINK2 module.html#DeclDefs, $(I DeclDefs)) $(B })
-)
-
 	$(P Attributes are a way to modify one or more declarations.
 	The general forms are:
 	)
@@ -78,20 +52,9 @@
 
 <h2>$(LNAME2 linkage, Linkage Attribute)</h2>
 
-$(GRAMMAR
-$(GNAME LinkageAttribute):
-	$(B extern)
-	$(B extern) $(B $(LPAREN)) $(I LinkageType) $(B $(RPAREN))
+$(LinkageAttribute_production)
+$(LinkageType_production)
 
-$(GNAME LinkageType):
-	$(B C)
-	$(B C++)
-	$(B D)
-	$(B Windows)
-	$(B Pascal)
-	$(B System)
-)
-
 	$(P D provides an easy way to call C functions and operating
 	system API functions, as compatibility with both is essential.
 	The $(I LinkageType) is case sensitive, and is meant to be
@@ -141,11 +104,7 @@
 
 <h2>$(LNAME2 align, Align Attribute)</h2>
 
-$(GRAMMAR
-$(GNAME AlignAttribute):
-	$(B align)
-	$(B align) $(B $(LPAREN)) $(I Integer) $(B $(RPAREN))
-)
+$(AlignAttribute_production)
 
 	$(P Specifies the alignment of struct members. $(B align) by itself
 	sets it to the default, which matches the default member alignment
@@ -227,14 +186,7 @@
 
 <h2>Protection Attribute</h2>
 
-$(GRAMMAR
-$(GNAME ProtectionAttribute):
-    $(B private)
-    $(B package)
-    $(B protected)
-    $(B public)
-    $(B export)
-)
+$(ProtectionAttribute_production)
 
 	$(P Protection is an attribute that is one of
 	$(B private), $(B package), $(B protected),
Index: class.dd
===================================================================
--- class.dd	(revision 1638)
+++ class.dd	(working copy)
@@ -23,55 +23,16 @@
 	$(P A class declaration is defined:
 	)
 
-$(GRAMMAR
-$(GNAME ClassDeclaration):
-	$(B class) $(I Identifier) $(I BaseClassList) $(I ClassBody)
-	$(LINK2 template.html#ClassTemplateDeclaration, $(I ClassTemplateDeclaration))
+$(ClassDeclaration_production)
+$(BaseClassList_production)
+$(SuperClass_production)
+$(InterfaceClasses_production)
+$(InterfaceClass_production)
+$(Protection_production)
+$(ClassBody_production)
+$(ClassBodyDeclarations_production)
+$(ClassBodyDeclaration_production)
 
-$(GNAME BaseClassList):
-	$(I Empty)
-	$(B :) $(I SuperClass)
-	$(B :) $(I SuperClass) $(B ,) $(I InterfaceClasses)
-	$(B :) $(I InterfaceClass)
-
-$(GNAME SuperClass):
-	$(I Identifier)
-	$(I Protection) $(I Identifier)
-
-$(GNAME InterfaceClasses):
-	$(I InterfaceClass)
-	$(I InterfaceClass) $(B ,) $(I InterfaceClasses)
-
-$(GNAME InterfaceClass):
-	$(I Identifier)
-	$(I Protection) $(I Identifier)
-
-$(GNAME Protection):
-	$(B private)
-	$(B package)
-	$(B public)
-	$(B export)
-
-$(GNAME ClassBody):
-	$(B {) $(B })
-	$(B {) $(I ClassBodyDeclarations) $(B })
-
-$(GNAME ClassBodyDeclarations):
-	$(I ClassBodyDeclaration)
-	$(I ClassBodyDeclaration) $(I ClassBodyDeclarations)
-
-$(GNAME ClassBodyDeclaration):
-	$(I Declaration)
-	$(GLINK Constructor)
-	$(GLINK Destructor)
-	$(GLINK StaticConstructor)
-	$(GLINK StaticDestructor)
-	$(GLINK Invariant)
-	$(GLINK UnitTest)
-	$(GLINK ClassAllocator)
-	$(GLINK ClassDeallocator)
-)
-
 Classes consist of:
 
 $(UL
@@ -242,10 +203,7 @@
 
 <h3>$(LNAME2 constructors, Constructors)</h3>
 
-$(GRAMMAR
-$(GNAME Constructor):
-	$(B this) $(I Parameters) $(I FunctionBody)
-)
+$(Constructor_production)
 
 	$(P Members are always initialized to the
 	$(LNAME2 class-default-initializer, default initializer)
@@ -417,10 +375,7 @@
 
 <h3>$(LNAME2 destructors, Destructors)</h3>
 
-$(GRAMMAR
-$(GNAME Destructor):
-	$(B ~this()) $(I FunctionBody)
-)
+$(Destructor_production)
 
 	The garbage collector calls the destructor function when the object
 	is deleted. The syntax 
@@ -477,10 +432,7 @@
 
 <h3>Static Constructors</h3>
 
-$(GRAMMAR
-$(GNAME StaticConstructor):
-	$(B static this()) $(I FunctionBody)
-)
+$(StaticConstructor_production)
 
 	A static constructor is defined as a function that performs
 	initializations before the 
@@ -571,10 +523,7 @@
 
 <h3>Static Destructors</h3>
 
-$(GRAMMAR
-$(GNAME StaticDestructor):
-	$(B static ~this()) $(I FunctionBody)
-)
+$(StaticDestructor_production)
 
 	A static destructor is defined as a special static function with the
 	syntax $(TT static ~this()).
@@ -616,10 +565,7 @@
 $(V2
 <h3>Shared Static Constructors</h3>
 
-$(GRAMMAR
-$(GNAME SharedStaticConstructor):
-	$(B shared static this()) $(I FunctionBody)
-)
+$(SharedStaticConstructor_production)
 
 	$(P Shared static constructors are executed before any $(GLINK StaticConstructor)s,
 	and are intended for initializing any shared global data.
@@ -627,10 +573,7 @@
 
 <h3>Shared Static Destructors</h3>
 
-$(GRAMMAR
-$(GNAME SharedStaticDestructor):
-	$(B shared static ~this()) $(I FunctionBody)
-)
+$(SharedStaticDestructor_production)
 
 	$(P Shared static destructors are executed at program termination
 	in the reverse order that
@@ -640,10 +583,7 @@
 
 <h3>$(LNAME2 invariants, Class Invariants)</h3>
 
-$(GRAMMAR
-$(GNAME Invariant):
-	$(B invariant()) $(I BlockStatement)
-)
+$(Invariant_production)
 
     Class invariants are used to specify characteristics of a class that always
     must be true (except while executing a member function). For example, a
@@ -722,10 +662,7 @@
 
 <h3>$(LNAME2 allocators, Class Allocators)</h3>
 
-$(GRAMMAR
-$(GNAME ClassAllocator):
-	$(B new) $(I Parameters) $(I FunctionBody)
-)
+$(ClassAllocator_production)
 
 	A class member function of the form:
 
@@ -789,10 +726,7 @@
 
 <h3>$(LNAME2 deallocators, Class Deallocators)</h3>
 
-$(GRAMMAR
-$(GNAME ClassDeallocator):
-	$(B delete) $(I Parameters) $(I FunctionBody)
-)
+$(ClassDeallocator_production)
 
 	A class member function of the form:
 
@@ -834,10 +768,7 @@
 $(V2
 <h3>$(LNAME2 AliasThis, Alias This)</h3>
 
-$(GRAMMAR
-$(GNAME AliasThis):
-	$(B alias) $(I Identifier) $(B this;)
-)
+$(AliasThis_production)
 
 	$(P An $(I AliasThis) declaration names another class or struct member
 	to which any undefined lookups will be forwarded.
@@ -1143,14 +1074,9 @@
 	a $(I NewAnonClassExpression):
 	)
 
-$(GRAMMAR
-$(GNAME NewAnonClassExpression):
-    $(B new) $(I PerenArgumentList)<sub>opt</sub> $(B class) $(I PerenArgumentList)<sub>opt</sub> $(I SuperClass)<sub>opt</sub> $(I InterfaceClasses)<sub>opt</sub> $(I ClassBody)
+$(NewAnonClassExpression_production)
+$(PerenArgumentList_production)
 
-$(GNAME PerenArgumentList):
-    $(B $(LPAREN))$(I ArgumentList)$(B $(RPAREN))
-)
-
 	$(P which is equivalent to:
 	)
 
Index: declaration.dd
===================================================================
--- declaration.dd	(revision 1638)
+++ declaration.dd	(working copy)
@@ -2,214 +2,43 @@
 
 $(SPEC_S Declarations,
 
-$(GRAMMAR
-$(GNAME Declaration):
-$(V1        $(B typedef) $(I Decl)
-)        $(B alias) $(I Decl)
-        $(I Decl)
-
-$(GNAME Decl):
-        $(GLINK StorageClasses) $(I Decl)
-        $(GLINK BasicType) $(GLINK Declarators) $(B ;)
-        $(GLINK BasicType) $(GLINK Declarator) $(LINK2 function.html#FunctionBody, $(I FunctionBody))
-	$(GLINK AutoDeclaration)
-
-$(GNAME Declarators):
-        $(I DeclaratorInitializer)
-        $(I DeclaratorInitializer) $(B ,) $(GLINK DeclaratorIdentifierList)
-
-$(GNAME DeclaratorInitializer):
-        $(GLINK Declarator)
-        $(GLINK Declarator) $(B =) $(GLINK Initializer)
-
-$(GNAME DeclaratorIdentifierList):
-        $(GLINK DeclaratorIdentifier)
-        $(GLINK DeclaratorIdentifier) $(B ,) $(I DeclaratorIdentifierList)
-
-$(GNAME DeclaratorIdentifier):
-        $(I Identifier)
-        $(I Identifier) $(B =) $(GLINK Initializer)
-
-$(GNAME BasicType):
-	$(GLINK BasicTypeX)
-        $(B .)$(GLINK IdentifierList)
-        $(GLINK IdentifierList)
-        $(GLINK Typeof)
-        $(GLINK Typeof) $(B .) $(GLINK IdentifierList)
-$(V2          $(B const$(LPAREN)) $(GLINK type) $(B $(RPAREN))
-        $(B immutable$(LPAREN)) $(GLINK type) $(B $(RPAREN))
-        $(B shared$(LPAREN)) $(GLINK type) $(B $(RPAREN))
-        $(B inout$(LPAREN)) $(GLINK type) $(B $(RPAREN))
-)
-
-$(GNAME BasicTypeX):
-        $(B bool)
-        $(B byte)
-        $(B ubyte)
-        $(B short)
-        $(B ushort)
-        $(B int)
-        $(B uint)
-        $(B long)
-        $(B ulong)
-        $(B char)
-        $(B wchar)
-        $(B dchar)
-        $(B float)
-        $(B double)
-        $(B real)
-        $(B ifloat)
-        $(B idouble)
-        $(B ireal)
-        $(B cfloat)
-        $(B cdouble)
-        $(B creal)
-        $(B void)
-
-$(GNAME BasicType2):
-        $(B *)
-        $(B [ ])
-        $(B [) $(VEXPRESSION) $(B ])
-        $(B [) $(VEXPRESSION) .. $(VEXPRESSION) $(B ])
-        $(B [) $(I Type) $(B ])
-        $(B delegate) $(GLINK Parameters) $(V2 $(GLINK FunctionAttributes)$(OPT))
-        $(B function) $(GLINK Parameters) $(V2 $(GLINK FunctionAttributes)$(OPT))
-
-$(GNAME Declarator):
-        $(GLINK BasicType2)$(OPT) $(I Declarator) $(GLINK DeclaratorSuffixes)$(OPT)
-        $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK DeclaratorSuffixes)$(OPT)
-
-$(GNAME DeclaratorSuffixes):
-        $(GLINK DeclaratorSuffix)
-        $(GLINK DeclaratorSuffix) $(I DeclaratorSuffixes)
-
-$(GNAME DeclaratorSuffix):
-        $(B [ ])
-        $(B [) $(VEXPRESSION) $(B ])
-        $(B [) $(I Type) $(B ])
-	$(LINK2 template.html#TemplateParameterList, $(I TemplateParameterList))$(OPT) $(GLINK Parameters) $(V2 $(GLINK MemberFunctionAttributes)<sub>opt</sub>)
-
-$(GNAME IdentifierList):
-        $(I Identifier)
-        $(I Identifier) $(B .) $(I IdentifierList)
-        $(I TemplateInstance)
-        $(I TemplateInstance) $(B .) $(I IdentifierList)
-
-$(GNAME StorageClasses):
-	$(GLINK StorageClass)
-	$(GLINK StorageClass) $(I StorageClasses)
-
-$(GNAME StorageClass):
-        $(B abstract)
-        $(B auto)
-        $(B const)
-        $(B deprecated)
-        $(B extern)
-        $(B final)
+$(Declaration_production)
+$(Decl_production)
+$(Declarators_production)
+$(DeclaratorInitializer_production)
+$(DeclaratorIdentifierList_production)
+$(DeclaratorIdentifier_production)
+$(BasicType_production)
+$(BasicTypeX_production)
+$(BasicType2_production)
+$(Declarator_production)
+$(DeclaratorSuffixes_production)
+$(DeclaratorSuffix_production)
+$(IdentifierList_production)
+$(StorageClasses_production)
+$(StorageClass_production)
+$(Type_production)
+$(Declarator2_production)
+$(Parameters_production)
+$(ParameterList_production)
+$(Parameter_production)
+$(InOut_production)
 $(V2
-        $(B immutable)
-        $(B inout)
-        $(B shared)
-	$(B nothrow)
-        $(B override)
-	$(B pure)
-)        $(B scope)
-        $(B static)
-        $(B synchronized)
-
-$(GNAME Type):
-        $(GLINK BasicType)
-        $(GLINK BasicType) $(GLINK Declarator2)
-
-$(GNAME Declarator2):
-        $(GLINK BasicType2) $(I Declarator2)
-        $(B $(LPAREN)) $(I Declarator2) $(B $(RPAREN))
-        $(B $(LPAREN)) $(I Declarator2) $(B $(RPAREN)) $(GLINK DeclaratorSuffixes)
-
-$(GNAME Parameters):
-	$(B $(LPAREN)) $(GLINK ParameterList) $(B $(RPAREN))
-	$(B ( ))
-
-$(GNAME ParameterList):
-        $(GLINK Parameter)
-        $(GLINK Parameter) $(B ,) $(I ParameterList)
-        $(GLINK Parameter) $(B ...)
-        $(B ...)
-
-$(GNAME Parameter):
-        $(GLINK Declarator)
-        $(GLINK Declarator) = $(I DefaultInitializerExpression)
-        $(I InOut) $(GLINK Declarator)
-        $(I InOut) $(GLINK Declarator) = $(I DefaultInitializerExpression)
-
-$(GNAME InOut):
-        $(B in)
-        $(B out)
-        $(B ref)
-        $(B lazy)
-
-$(V2
-$(GNAME FunctionAttributes):
-	$(GLINK FunctionAttribute)
-	$(GLINK FunctionAttribute) $(I FunctionAttributes)
-
-$(GNAME FunctionAttribute):
-	$(B nothrow)
-	$(B pure)
+$(FunctionAttributes_production)
+$(FunctionAttribute_production)
 )
-$(GNAME MemberFunctionAttributes):
-	$(GLINK MemberFunctionAttribute)
-	$(GLINK MemberFunctionAttribute) $(I MemberFunctionAttributes)
+$(MemberFunctionAttributes_production)
+$(MemberFunctionAttribute_production)
+$(DefaultInitializerExpression_production)
+$(Initializer_production)
+$(NonVoidInitializer_production)
+$(ArrayInitializer_production)
+$(ArrayMemberInitializations_production)
+$(ArrayMemberInitialization_production)
+$(StructInitializer_production)
+$(StructMemberInitializers_production)
+$(StructMemberInitializer_production)
 
-$(GNAME MemberFunctionAttribute):
-	$(B const)
-	$(B immutable)
-	$(B inout)
-	$(B shared)
-	$(GLINK FunctionAttribute)
-
-$(GNAME DefaultInitializerExpression):
-	$(ASSIGNEXPRESSION)
-$(V2
-	$(B __FILE__)
-	$(B __LINE__))
-
-$(GNAME Initializer):
-        $(GLINK VoidInitializer)
-	$(GLINK NonVoidInitializer)
-
-$(GNAME NonVoidInitializer):
-        $(ASSIGNEXPRESSION)
-        $(GLINK ArrayInitializer)
-        $(GLINK StructInitializer)
-
-$(GNAME ArrayInitializer):
-	$(B [ ])
-	$(B [) $(GLINK ArrayMemberInitializations) $(B ])
-
-$(GNAME ArrayMemberInitializations):
-	$(GLINK ArrayMemberInitialization)
-	$(GLINK ArrayMemberInitialization) $(B ,)
-	$(GLINK ArrayMemberInitialization) $(B ,) $(I ArrayMemberInitializations)
-
-$(GNAME ArrayMemberInitialization):
-	$(GLINK NonVoidInitializer)
-	$(ASSIGNEXPRESSION) $(B :) $(GLINK NonVoidInitializer)
-
-$(GNAME StructInitializer):
-	$(B {  })
-	$(B {) $(GLINK StructMemberInitializers) $(B })
-
-$(GNAME StructMemberInitializers):
-	$(GLINK StructMemberInitializer)
-	$(GLINK StructMemberInitializer) $(B ,)
-	$(GLINK StructMemberInitializer) $(B ,) $(I StructMemberInitializers)
-
-$(GNAME StructMemberInitializer):
-	$(GLINK NonVoidInitializer)
-	$(I Identifier) $(B :) $(GLINK NonVoidInitializer)
-)
-
 <h3>Declaration Syntax</h3>
 
 $(P Declaration syntax generally reads right to left:)
@@ -271,10 +100,7 @@
 
 <h3><a name="AutoDeclaration">Implicit Type Inference</a></h3>
 
-$(GRAMMAR
-$(GNAME AutoDeclaration):
-	$(I StorageClasses) $(I Identifier) $(B =) $(ASSIGNEXPRESSION) $(B ;)
-)
+$(AutoDeclaration_production)
 
 	$(P If a declaration starts with a $(I StorageClass) and has
 	a $(I NonVoidInitializer) from which the type can be inferred,
@@ -493,11 +319,7 @@
 
 <h3><a name="typeof">typeof</a></h3>
 
-$(GRAMMAR
-$(GNAME Typeof):
-        $(B typeof $(LPAREN)) $(EXPRESSION) $(B $(RPAREN))
-        $(B typeof $(LPAREN)) $(B return) $(B $(RPAREN))
-)
+$(Typeof_production)
 
 	$(P 
 	$(I Typeof) is a way to specify a type based on the type
@@ -573,10 +395,7 @@
 
 <h3>Void Initializations</h3>
 
-$(GRAMMAR
-$(GNAME VoidInitializer):
-	$(B void)
-)
+$(VoidInitializer_production)
 
 	Normally, variables are initialized either with an explicit
 	$(I Initializer) or are set to the default value for the
Index: doc.ddoc
===================================================================
--- doc.ddoc	(revision 1638)
+++ doc.ddoc	(working copy)
@@ -42,7 +42,7 @@
 	)
 	</div>
 
-	<div id="lastupdate">Last update $(DATETIME)</div>
+	<div id="lastupdate">Last update </div>
 </div>
 
 $(BODY)
Index: enum.dd
===================================================================
--- enum.dd	(revision 1638)
+++ enum.dd	(working copy)
@@ -2,35 +2,13 @@
 
 $(SPEC_S Enums - Enumerated Types,
 
-$(GRAMMAR
-$(GNAME EnumDeclaration):
-	$(B enum) $(I EnumTag) $(I EnumBody)
-	$(B enum) $(I EnumBody)
-	$(B enum) $(I EnumTag) $(B :) $(I EnumBaseType) $(I EnumBody)
-	$(B enum) $(B :) $(I EnumBaseType) $(I EnumBody)
+$(EnumDeclaration_production)
+$(EnumTag_production)
+$(EnumBaseType_production)
+$(EnumBody_production)
+$(EnumMembers_production)
+$(EnumMember_production)
 
-$(GNAME EnumTag):
-	$(I Identifier)
-
-$(GNAME EnumBaseType):
-	$(I Type)
-
-$(GNAME EnumBody):
-	$(B ;)
-	$(B {) $(I EnumMembers) $(B })
-
-$(GNAME EnumMembers):
-	$(I EnumMember)
-	$(I EnumMember) $(B ,)
-	$(I EnumMember) $(B ,) $(I EnumMembers)
-
-$(GNAME EnumMember):
-	$(I Identifier)
-	$(I Identifier) $(B =) $(ASSIGNEXPRESSION)
-$(V2
-	$(I Type) $(I Identifier) $(B =) $(ASSIGNEXPRESSION))
-)
-
 	$(P Enum declarations are used to define a group of constants.
 	They come in two forms:
 	)
Index: expression.dd
===================================================================
--- expression.dd	(revision 1638)
+++ expression.dd	(working copy)
@@ -68,11 +68,7 @@
 
 <h2><a name="Expression">Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME Expression):
-	$(GLINK AssignExpression)
-	$(GLINK AssignExpression) $(B ,) $(I Expression)
-)
+$(Expression_production)
 
 	The left operand of the $(B ,) is evaluated, then the right operand
 	is evaluated. The type of the expression is the type of the right
@@ -81,25 +77,7 @@
 
 <h2>Assign Expressions</h2>
 
-$(GRAMMAR
-$(GNAME AssignExpression):
-	$(GLINK ConditionalExpression)
-	$(GLINK ConditionalExpression) $(B =) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B +=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B -=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B *=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B /=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B %=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B &=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B |=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B ^=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B ~=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B &lt;&lt;=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B &gt;&gt;=) $(I AssignExpression)
-	$(GLINK ConditionalExpression) $(B &gt;&gt;&gt;=) $(I AssignExpression)
-$(V2
-	$(GLINK ConditionalExpression) $(B ^^=) $(I AssignExpression))
-)
+$(AssignExpression_production)
 
 	The right operand is implicitly converted to the type of the
 	left operand, and assigned to it. The result type is the type
@@ -127,11 +105,7 @@
 
 <h2>Conditional Expressions</h2>
 
-$(GRAMMAR
-$(GNAME ConditionalExpression):
-	$(GLINK OrOrExpression)
-	$(GLINK OrOrExpression) $(B ?) $(GLINK Expression) $(B :) $(I ConditionalExpression)
-)
+$(ConditionalExpression_production)
 
 	The first expression is converted to bool, and is evaluated.
 	If it is true, then the second expression is evaluated, and
@@ -145,11 +119,7 @@
 
 <h2>OrOr Expressions</h2>
 
-$(GRAMMAR
-$(GNAME OrOrExpression):
-	$(GLINK AndAndExpression)
-	$(I OrOrExpression) $(B ||) $(GLINK AndAndExpression)
-)
+$(OrOrExpression_production)
 
 	The result type of an $(I OrOrExpression) is bool,
 	unless the right operand
@@ -172,13 +142,8 @@
 
 <h2>AndAnd Expressions</h2>
 
-$(GRAMMAR
-$(GNAME AndAndExpression):
-	$(GLINK OrExpression)
-	$(I AndAndExpression) $(B &&) $(GLINK OrExpression)
+$(AndAndExpression_production)
 
-)
-
 	$(P The result type of an $(I AndAndExpression) is bool, unless the right operand
 	has type void, when the result is type void.
 	)
@@ -209,53 +174,30 @@
 
 <h3>Or Expressions</h3>
 
-$(GRAMMAR
-$(GNAME OrExpression):
-	$(GLINK XorExpression)
-	$(I OrExpression) $(B |) $(GLINK XorExpression)
-)
+$(OrExpression_production)
 
 	The operands are OR'd together.
 
 <h3>Xor Expressions</h3>
 
-$(GRAMMAR
-$(GNAME XorExpression):
-	$(GLINK AndExpression)
-	$(I XorExpression) $(B ^) $(GLINK AndExpression)
-)
+$(XorExpression_production)
 
 	The operands are XOR'd together.
 
 <h3>And Expressions</h3>
 
-$(GRAMMAR
-$(GNAME AndExpression):
-	$(GLINK CmpExpression)
-	$(I AndExpression) $(B &) $(GLINK CmpExpression)
-)
+$(AndExpression_production)
 
 	The operands are AND'd together.
 
 
 <h2><a name="CmpExpression">Compare Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME CmpExpression):
-	$(GLINK ShiftExpression)
-	$(GLINK EqualExpression)
-	$(GLINK IdentityExpression)
-	$(GLINK RelExpression)
-	$(GLINK InExpression)
-)
+$(CmpExpression_production)
 
 <h2><a name="EqualExpression">Equality Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME EqualExpression):
-	$(GLINK ShiftExpression) $(B ==) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !=) $(GLINK ShiftExpression)
-)
+$(EqualExpression_production)
 
 	Equality expressions compare the two operands for equality ($(B ==))
 	or inequality ($(B !=)).
@@ -317,11 +259,7 @@
 
 <h3><a name="IdentityExpression">Identity Expressions</a></h3>
 
-$(GRAMMAR
-$(GNAME IdentityExpression):
-	$(GLINK ShiftExpression) $(B is) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !is) $(GLINK ShiftExpression)
-)
+$(IdentityExpression_production)
 
 	$(P The $(B is) compares for identity.
 	To compare for not identity, use $(TT $(I e1) $(B !is) $(I e2)).
@@ -352,21 +290,7 @@
 
 <h2>Relational Expressions</h2>
 
-$(GRAMMAR
-$(GNAME RelExpression):
-	$(GLINK ShiftExpression) $(B &lt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B &lt;=) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B &gt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B &gt;=) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&lt;&gt;=) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&lt;&gt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B &lt;&gt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B &lt;&gt;=) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&gt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&gt;=) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&lt;) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !&lt;=) $(GLINK ShiftExpression)
-)
+$(RelExpression_production)
 
 	First, the integral promotions are done on the operands.
 	The result type of a relational expression is bool.
@@ -521,11 +445,7 @@
 
 <h2><a name="InExpression">In Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME InExpression):
-	$(GLINK ShiftExpression) $(B in) $(GLINK ShiftExpression)
-	$(GLINK ShiftExpression) $(B !in) $(GLINK ShiftExpression)
-)
+$(InExpression_production)
 
 	$(P An associative array can be tested to see if an element is in the array:
 	)
@@ -551,13 +471,7 @@
 
 <h2>Shift Expressions</h2>
 
-$(GRAMMAR
-$(GNAME ShiftExpression):
-	$(GLINK AddExpression)
-	$(I ShiftExpression) $(B &lt;&lt;) $(GLINK AddExpression)
-	$(I ShiftExpression) $(B &gt;&gt;) $(GLINK AddExpression)
-	$(I ShiftExpression) $(B &gt;&gt;&gt;) $(GLINK AddExpression)
-)
+$(ShiftExpression_production)
 
 	The operands must be integral types, and undergo the usual integral
 	promotions. The result type is the type of the left operand after
@@ -580,13 +494,7 @@
 
 <h2>Add Expressions</h2>
 
-$(GRAMMAR
-$(GNAME AddExpression):
-	$(GLINK MulExpression)
-	$(I AddExpression) $(B +) $(GLINK MulExpression)
-	$(I AddExpression) $(B -) $(GLINK MulExpression)
-	$(GLINK CatExpression)
-)
+$(AddExpression_production)
 
 	$(P If the operands are of integral types, they undergo integral
 	promotions, and then are brought to a common type using the
@@ -622,10 +530,7 @@
 
 <h2>Cat Expressions</h2>
 
-$(GRAMMAR
-$(GNAME CatExpression):
-	$(I AddExpression) $(B ~) $(GLINK MulExpression)
-)
+$(CatExpression_production)
 
 	$(P A $(I CatExpression) concatenates arrays, producing
 	a dynmaic array with the result. The arrays must be
@@ -637,25 +542,9 @@
 
 <h2>Mul Expressions</h2>
 
-$(V1
-$(GRAMMAR
-$(GNAME MulExpression):
-	$(GLINK UnaryExpression)
-	$(I MulExpression) $(B *) $(GLINK UnaryExpression)
-	$(I MulExpression) $(B /) $(GLINK UnaryExpression)
-	$(I MulExpression) $(B %) $(GLINK UnaryExpression)
-)
-)
-$(V2
-$(GRAMMAR
-$(GNAME MulExpression):
-	$(GLINK PowExpression)
-	$(I MulExpression) $(B *) $(GLINK PowExpression)
-	$(I MulExpression) $(B /) $(GLINK PowExpression)
-	$(I MulExpression) $(B %) $(GLINK PowExpression)
-)
-)
+$(MulExpression_production)
 
+
 	$(P The operands must be arithmetic types. They undergo integral
 	promotions, and then are brought to a common type using the
 	usual arithmetic conversions.
@@ -685,11 +574,7 @@
 $(V2
 <h2><a name="PowExpression">Pow Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME PowExpression):
-	$(GLINK UnaryExpression)
-	$(GLINK UnaryExpression) ^^ $(I PowExpression)
-)
+$(PowExpression_production)
 
 	$(P $(I PowExpression) raises its left operand to the power of its
 	right operand.
@@ -698,49 +583,16 @@
 
 <h2><a name="UnaryExpression">Unary Expressions</a></h2>
 
-$(GRAMMAR
-$(GNAME UnaryExpression):
-	$(GLINK PostfixExpression)
-	$(B &amp;) $(I UnaryExpression)
-	$(B ++) $(I UnaryExpression)
-	$(B --) $(I UnaryExpression)
-	$(B *) $(I UnaryExpression)
-	$(B -) $(I UnaryExpression)
-	$(B +) $(I UnaryExpression)
-	$(B !) $(I UnaryExpression)
-	$(B ~) $(I UnaryExpression)
-	$(B $(LPAREN)) $(I Type) $(B $(RPAREN) .) $(I Identifier)
-	$(GLINK NewExpression)
-	$(GLINK DeleteExpression)
-	$(GLINK CastExpression)
-	$(LINK2 class.html#anonymous, $(I NewAnonClassExpression))
-)
+$(UnaryExpression_production)
 
 
 <h3>New Expressions</h3>
 
-$(GRAMMAR
-$(GNAME NewExpression):
-	$(I NewArguments) $(I Type) $(B [) $(GLINK AssignExpression) $(B ])
-	$(I NewArguments) $(I Type) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
-	$(I NewArguments) $(I Type)
-	$(I NewArguments) $(I ClassArguments) $(I BaseClasslist)<sub>opt</sub> $(B {) $(I DeclDefs) $(B } )
+$(NewExpression_production)
+$(NewArguments_production)
+$(ClassArguments_production)
+$(ArgumentList_production)
 
-$(GNAME NewArguments):
-	$(B new $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
-	$(B new ( ))
-	$(B new)
-
-$(GNAME ClassArguments):
-	$(B class $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
-	$(B class ( ))
-	$(B class)
-
-$(GNAME ArgumentList):
-	$(GLINK AssignExpression)
-	$(GLINK AssignExpression) $(B ,) $(I ArgumentList)
-)
-
 	$(P $(I NewExpression)s are used to allocate memory on the garbage
 	collected heap (default) or using a class or struct specific allocator.
 	)
@@ -798,10 +650,7 @@
 
 <h3>Delete Expressions</h3>
 
-$(GRAMMAR
-$(GNAME DeleteExpression):
-	$(B delete) $(GLINK UnaryExpression)
-)
+$(DeleteExpression_production)
 	$(P If the $(I UnaryExpression) is a class object reference, and
 	there is a destructor for that class, the destructor
 	is called for that object instance.
@@ -838,10 +687,7 @@
 
 <h3>Cast Expressions</h3>
 
-$(GRAMMAR
-$(GNAME CastExpression):
-	$(B cast $(LPAREN)) $(I Type) $(B $(RPAREN)) $(GLINK UnaryExpression)
-)
+$(CastExpression_production)
 
 	$(P A $(I CastExpression) converts the $(I UnaryExpression)
 	to $(I Type).
@@ -919,25 +765,11 @@
 
 <h2>Postfix Expressions</h2>
 
-$(GRAMMAR
-$(GNAME PostfixExpression):
-	$(GLINK PrimaryExpression)
-	$(I PostfixExpression) $(B .) $(I Identifier)
-	$(I PostfixExpression) $(B .) $(GLINK NewExpression)
-	$(I PostfixExpression) $(B ++)
-	$(I PostfixExpression) $(B --)
-	$(I PostfixExpression) $(B ( ))
-	$(I PostfixExpression) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
-	$(GLINK IndexExpression)
-	$(GLINK SliceExpression)
-)
+$(PostfixExpression_production)
 
 <h2>Index Expressions</h2>
 
-$(GRAMMAR
-$(GNAME IndexExpression):
-	$(GLINK PostfixExpression) $(B [) $(GLINK ArgumentList) $(B ])
-)
+$(IndexExpression_production)
 
 	$(P $(I PostfixExpression) is evaluated.
 
@@ -964,11 +796,7 @@
 
 <h2>Slice Expressions</h2>
 
-$(GRAMMAR
-$(GNAME SliceExpression):
-	$(GLINK PostfixExpression) $(B [ ])
-	$(GLINK PostfixExpression) $(B [) $(GLINK AssignExpression) $(B ..) $(GLINK AssignExpression) $(B ])
-)
+$(SliceExpression_production)
 
 	$(P $(I PostfixExpression) is evaluated.
 	if $(I PostfixExpression) is an expression of type
@@ -1006,38 +834,7 @@
 
 <h2>Primary Expressions</h2>
 
-$(GRAMMAR
-$(GNAME PrimaryExpression):
-	$(I Identifier)
-	$(B .)$(I Identifier)
-	$(LINK2 template.html#TemplateInstance, $(I TemplateInstance))
-	$(LINK2 #this, $(B this))
-	$(LINK2 #super, $(B super))
-	$(LINK2 #null, $(B null))
-	$(B true)
-	$(B false)
-	$(B $)
-$(V2
-	$(B __FILE__)
-	$(B __LINE__))
-	$(GLINK2 lex, IntegerLiteral)
-	$(GLINK2 lex, FloatLiteral)
-	$(GLINK CharacterLiteral)
-	$(GLINK StringLiterals)
-	$(GLINK ArrayLiteral)
-	$(GLINK AssocArrayLiteral)
-	$(GLINK FunctionLiteral)
-	$(GLINK AssertExpression)
-	$(GLINK MixinExpression)
-	$(GLINK ImportExpression)
-	$(I BasicType) $(B .) $(I Identifier)
-	$(LINK2 declaration.html#Typeof, $(I Typeof))
-	$(GLINK TypeidExpression)
-	$(GLINK IsExpression)
-	$(B $(LPAREN)) $(I Expression) $(B $(RPAREN))
-$(V2
-	$(LINK2 traits.html#TraitsExpression, $(I TraitsExpression)))
-)
+$(PrimaryExpression_production)
 
 <h3>.Identifier</h3>
 
@@ -1120,11 +917,7 @@
 
 <h3>String Literals</h3>
 
-$(GRAMMAR
-$(GNAME StringLiterals):
-	$(LINK2 lex.html#StringLiteral, $(I StringLiteral))
-	$(I StringLiterals) $(LINK2 lex.html#StringLiteral, $(I StringLiteral))
-)
+$(StringLiterals_production)
 
 	$(P String literals can implicitly convert to any
 	of the following types, they have equal weight:
@@ -1159,10 +952,7 @@
 
 <h3>Array Literals</h3>
 
-$(GRAMMAR
-$(GNAME ArrayLiteral):
-	$(B [) $(GLINK ArgumentList) $(B ])
-)
+$(ArrayLiteral_production)
 
 	$(P Array literals are a comma-separated list of $(GLINK AssignExpression)s
 	between square brackets [ and ].
@@ -1219,24 +1009,12 @@
 
 <h3>Associative Array Literals</h3>
 
-$(GRAMMAR
-$(GNAME AssocArrayLiteral):
-	$(B [) $(I KeyValuePairs) $(B ])
+$(AssocArrayLiteral_production)
+$(KeyValuePairs_production)
+$(KeyValuePair_production)
+$(KeyExpression_production)
+$(ValueExpression_production)
 
-$(GNAME KeyValuePairs):
-	$(I KeyValuePair)
-	$(I KeyValuePair) $(B ,) $(I KeyValuePairs)
-
-$(GNAME KeyValuePair):
-	$(I KeyExpression) $(B :) $(I ValueExpression)
-
-$(GNAME KeyExpression):
-	$(GLINK ConditionalExpression)
-
-$(GNAME ValueExpression):
-	$(GLINK ConditionalExpression)
-)
-
 	$(P Associative array literals are a comma-separated list of
 	$(I key):$(I value) pairs
 	between square brackets [ and ].
@@ -1263,20 +1041,9 @@
 
 <h3>Function Literals</h3>
 
-$(GRAMMAR
-$(GNAME FunctionLiteral):
-	$(B function) $(I Type)<sub>opt</sub> $(I ParameterAttributes) <sub>opt</sub> $(I FunctionBody)
-	$(B delegate) $(I Type)<sub>opt</sub> $(I ParameterAttributes) <sub>opt</sub> $(I FunctionBody)
-	$(I ParameterAttributes) $(I FunctionBody)
-	$(I FunctionBody)
+$(FunctionLiteral_production)
+$(ParameterAttributes_production)
 
-$(GNAME ParameterAttributes):
-	$(LINK2 declaration.html#Parameters, $(I Parameters))
-$(V2
-	$(LINK2 declaration.html#Parameters, $(I Parameters)) $(LINK2 declaration.html#FunctionAttributes, $(I FunctionAttributes))
-)
-)
-
 	$(I FunctionLiteral)s enable embedding anonymous functions
 	and anonymous delegates directly into expressions.
 	$(I Type) is the return type of the function or delegate,
@@ -1386,11 +1153,7 @@
 
 <h3>Assert Expressions</h3>
 
-$(GRAMMAR
-$(GNAME AssertExpression):
-	$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
-	$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B ,) $(GLINK AssignExpression) $(B $(RPAREN))
-)
+$(AssertExpression_production)
 
 	$(P Asserts evaluate the $(I expression). If the result is false,
 	an $(B AssertError) is thrown. If the result is true, then no
@@ -1437,10 +1200,7 @@
 
 <h3><a name="MixinExpression">Mixin Expressions</a></h3>
 
-$(GRAMMAR
-$(GNAME MixinExpression):
-	$(B mixin $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
-)
+$(MixinExpression_production)
 
 	$(P The $(I AssignExpression) must evaluate at compile time
 	to a constant string.
@@ -1457,10 +1217,7 @@
 
 <h3><a name="ImportExpression">Import Expressions</a></h3>
 
-$(GRAMMAR
-$(GNAME ImportExpression):
-	$(B import $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
-)
+$(ImportExpression_production)
 
 	$(P The $(I AssignExpression) must evaluate at compile time
 	to a constant string.
@@ -1485,11 +1242,7 @@
 
 <h3><a name="typeidexpression">Typeid Expressions</a></h3>
 
-$(GRAMMAR
-$(GNAME TypeidExpression):
-    $(B typeid $(LPAREN)) $(I Type) $(B $(RPAREN))
-$(V2      $(B typeid $(LPAREN)) $(I Expression) $(B $(RPAREN)))
-)
+$(TypeidExpression_production)
 
 $(V1
 	$(P Returns an instance of class
@@ -1533,37 +1286,9 @@
 
 <h3><a name="IsExpression">IsExpression</a></h3>
 
-$(GRAMMAR
-$(GNAME IsExpression):
-	$(B is $(LPAREN)) $(I Type) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
-	$(V2 $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
-	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
-)
+$(IsExpression_production)
+$(TypeSpecialization_production)
 
-$(GNAME TypeSpecialization):
-	$(I Type)
-$(V1	$(B typedef)
-)	$(B struct)
-	$(B union)
-	$(B class)
-	$(B interface)
-	$(B enum)
-	$(B function)
-	$(B delegate)
-	$(B super)
-$(V2
-	$(B const)
-	$(B immutable)
-	$(B inout)
-	$(B shared)
-	$(B return)
-))
-
 	$(I IsExpression)s are evaluated at compile time and are
 	used for checking for valid types, comparing types for equivalence,
 	determining if one type can be implicitly converted to another,
@@ -1737,7 +1462,7 @@
 	$(I TypeSpecialization) or, if $(I TypeSpecialization) is
 	dependent on $(I Identifier), the deduced type.
 	)
-
+<!-- missing -->
 	$(P If $(I TypeSpecialization) is one of
 $(V1		$(B typedef)
 )		$(B struct)
Index: function.dd
===================================================================
--- function.dd	(revision 1638)
+++ function.dd	(working copy)
@@ -2,27 +2,12 @@
 
 $(SPEC_S Functions,
 
-$(GRAMMAR
-$(GNAME FunctionBody):
-	$(LINK2 statement.html#BlockStatement, $(I BlockStatement))
-	$(I BodyStatement)
-	$(I InStatement) $(I BodyStatement)
-	$(I OutStatement) $(I BodyStatement)
-	$(I InStatement) $(I OutStatement) $(I BodyStatement)
-	$(I OutStatement) $(I InStatement) $(I BodyStatement)
+$(FunctionBody_production)
+$(InStatement_production)
+$(OutStatement_production)
+$(BodyStatement_production)
 
-$(GNAME InStatement):
-	$(B in) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
 
-$(GNAME OutStatement):
-	$(B out) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
-	$(B out) $(B $(LPAREN)) $(I Identifier) $(B $(RPAREN)) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
-
-$(GNAME BodyStatement):
-	$(B body) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
-)
-
-
 <h3>Function Return Values</h3>
 
 	$(P Function return values are considered to be rvalues.
Index: g_macros.ddoc
===================================================================
--- g_macros.ddoc	(revision 0)
+++ g_macros.ddoc	(revision 0)
@@ -0,0 +1,1518 @@
+Pragma_production = $(GRAMMAR
+$(GNAME Pragma):
+    $(B pragma) $(B $(LPAREN)) $(I Identifier) $(B $(RPAREN))
+    $(B pragma) $(B $(LPAREN)) $(I Identifier) $(B ,) $(LINK2 expression.html#ArgumentList, $(I ArgumentList)) $(B $(RPAREN))
+)
+AttributeSpecifier_production = $(GRAMMAR
+$(GNAME AttributeSpecifier):
+    $(I Attribute) $(B :)
+    $(I Attribute) $(I DeclarationBlock)
+)
+Attribute_production = $(GRAMMAR
+$(GNAME Attribute):
+    $(LINK2 #linkage, $(I LinkageAttribute))
+    $(LINK2 #align, $(I AlignAttribute))
+    $(LINK2 pragma.html, $(I Pragma))
+    $(LINK2 #deprecated, $(B deprecated))
+    $(GLINK ProtectionAttribute)
+    $(B static)
+    $(B final)
+    $(LINK2 #override, $(B override))
+    $(LINK2 #abstract, $(B abstract))
+    $(LINK2 #const, $(B const))
+    $(LINK2 #auto, $(B auto))
+    $(LINK2 #scope, $(B scope))
+$(V2    $(LINK2 #gshared, $(B __gshared))
+)    $(LINK2 #shared, $(B shared))
+    $(LINK2 #immutable, $(B immutable))
+    $(LINK2 #inout, $(B inout))
+    $(LINK2 #disable, $(B @disable))
+)
+DeclarationBlock_production = $(GRAMMAR
+$(GNAME DeclarationBlock):
+    $(LINK2 module.html#DeclDef, $(I DeclDef))
+    $(B { })
+    $(B {) $(LINK2 module.html#DeclDefs, $(I DeclDefs)) $(B })
+)
+LinkageAttribute_production = $(GRAMMAR
+$(GNAME LinkageAttribute):
+	$(B extern)
+	$(B extern) $(B $(LPAREN)) $(I LinkageType) $(B $(RPAREN))
+)
+LinkageType_production = $(GRAMMAR
+$(GNAME LinkageType):
+	$(B C)
+	$(B C++)
+	$(B D)
+	$(B Windows)
+	$(B Pascal)
+	$(B System)
+)
+AlignAttribute_production = $(GRAMMAR
+$(GNAME AlignAttribute):
+	$(B align)
+	$(B align) $(B $(LPAREN)) $(I Integer) $(B $(RPAREN))
+)
+ProtectionAttribute_production = $(GRAMMAR
+$(GNAME ProtectionAttribute):
+    $(B private)
+    $(B package)
+    $(B protected)
+    $(B public)
+    $(B export)
+    $(B const)
+    $(B override)
+    $(B scope)
+    $(B auto)
+    $(B static)
+)
+ClassDeclaration_production = $(GRAMMAR
+$(GNAME ClassDeclaration):
+	$(B class) $(I Identifier) $(I BaseClassList) $(I ClassBody)
+	$(LINK2 template.html#ClassTemplateDeclaration, $(I ClassTemplateDeclaration))
+)
+BaseClassList_production = $(GRAMMAR
+$(GNAME BaseClassList):
+	$(I Empty)
+	$(B :) $(I SuperClass)
+	$(B :) $(I SuperClass) $(B ,) $(I InterfaceClasses)
+	$(B :) $(I InterfaceClass)
+)
+SuperClass_production = $(GRAMMAR
+$(GNAME SuperClass):
+	$(I Identifier)
+	$(I Protection) $(I Identifier)
+)
+InterfaceClasses_production = $(GRAMMAR
+$(GNAME InterfaceClasses):
+	$(I InterfaceClass)
+	$(I InterfaceClass) $(B ,) $(I InterfaceClasses)
+)
+InterfaceClass_production = $(GRAMMAR
+$(GNAME InterfaceClass):
+	$(I Identifier)
+	$(I Protection) $(I Identifier)
+)
+Protection_production = $(GRAMMAR
+$(GNAME Protection):
+	$(B private)
+	$(B package)
+	$(B public)
+	$(B export)
+)
+ClassBody_production = $(GRAMMAR
+$(GNAME ClassBody):
+	$(B {) $(B })
+	$(B {) $(I ClassBodyDeclarations) $(B })
+)
+ClassBodyDeclarations_production = $(GRAMMAR
+$(GNAME ClassBodyDeclarations):
+	$(I ClassBodyDeclaration)
+	$(I ClassBodyDeclaration) $(I ClassBodyDeclarations)
+)
+ClassBodyDeclaration_production = $(GRAMMAR
+$(GNAME ClassBodyDeclaration):
+	$(I Declaration)
+	$(GLINK Constructor)
+	$(GLINK Destructor)
+	$(GLINK StaticConstructor)
+	$(GLINK StaticDestructor)
+	$(GLINK Invariant)
+	$(GLINK UnitTest)
+	$(GLINK ClassAllocator)
+	$(GLINK ClassDeallocator)
+)
+Constructor_production = $(GRAMMAR
+$(GNAME Constructor):
+	$(B this) $(I Parameters) $(I FunctionBody)
+)
+Destructor_production = $(GRAMMAR
+$(GNAME Destructor):
+	$(B ~this()) $(I FunctionBody)
+)
+StaticConstructor_production = $(GRAMMAR
+$(GNAME StaticConstructor):
+	$(B static this()) $(I FunctionBody)
+)
+StaticDestructor_production = $(GRAMMAR
+$(GNAME StaticDestructor):
+	$(B static ~this()) $(I FunctionBody)
+)
+SharedStaticConstructor_production = $(GRAMMAR
+$(GNAME SharedStaticConstructor):
+	$(B shared static this()) $(I FunctionBody)
+)
+SharedStaticDestructor_production = $(GRAMMAR
+$(GNAME SharedStaticDestructor):
+	$(B shared static ~this()) $(I FunctionBody)
+)
+Invariant_production = $(GRAMMAR
+$(GNAME Invariant):
+	$(B invariant()) $(I BlockStatement)
+)
+ClassAllocator_production = $(GRAMMAR
+$(GNAME ClassAllocator):
+	$(B new) $(I Parameters) $(I FunctionBody)
+)
+ClassDeallocator_production = $(GRAMMAR
+$(GNAME ClassDeallocator):
+	$(B delete) $(I Parameters) $(I FunctionBody)
+)
+AliasThis_production = $(GRAMMAR
+$(GNAME AliasThis):
+	$(B alias) $(I Identifier) $(B this;)
+)
+NewAnonClassExpression_production = $(GRAMMAR
+$(GNAME NewAnonClassExpression):
+    $(B new) $(I PerenArgumentList)<sub>opt</sub> $(B class) $(I PerenArgumentList)<sub>opt</sub> $(I SuperClass)<sub>opt</sub> $(I InterfaceClasses)<sub>opt</sub> $(I ClassBody)
+)
+PerenArgumentList_production = $(GRAMMAR
+$(GNAME PerenArgumentList):
+    $(B $(LPAREN))$(I ArgumentList)$(B $(RPAREN))
+)
+Declaration_production = $(GRAMMAR
+$(GNAME Declaration):
+$(V1        $(B typedef) $(I Decl)
+)        $(B alias) $(I Decl)
+        $(I Decl)
+)
+Decl_production = $(GRAMMAR
+$(GNAME Decl):
+        $(GLINK StorageClasses) $(I Decl)
+        $(GLINK BasicType) $(GLINK Declarators) $(B ;)
+        $(GLINK BasicType) $(GLINK Declarator) $(LINK2 function.html#FunctionBody, $(I FunctionBody))
+	$(GLINK AutoDeclaration)
+)
+Declarators_production = $(GRAMMAR
+$(GNAME Declarators):
+        $(I DeclaratorInitializer)
+        $(I DeclaratorInitializer) $(B ,) $(GLINK DeclaratorIdentifierList)
+)
+DeclaratorInitializer_production = $(GRAMMAR
+$(GNAME DeclaratorInitializer):
+        $(GLINK Declarator)
+        $(GLINK Declarator) $(B =) $(GLINK Initializer)
+)
+DeclaratorIdentifierList_production = $(GRAMMAR
+$(GNAME DeclaratorIdentifierList):
+        $(GLINK DeclaratorIdentifier)
+        $(GLINK DeclaratorIdentifier) $(B ,) $(I DeclaratorIdentifierList)
+)
+DeclaratorIdentifier_production = $(GRAMMAR
+$(GNAME DeclaratorIdentifier):
+        $(I Identifier)
+        $(I Identifier) $(B =) $(GLINK Initializer)
+)
+BasicType_production = $(GRAMMAR
+$(GNAME BasicType):
+	$(GLINK BasicTypeX)
+        $(B .)$(GLINK IdentifierList)
+        $(GLINK IdentifierList)
+        $(GLINK Typeof)
+        $(GLINK Typeof) $(B .) $(GLINK IdentifierList)
+$(V2          $(B const$(LPAREN)) $(GLINK type) $(B $(RPAREN))
+        $(B immutable$(LPAREN)) $(GLINK type) $(B $(RPAREN))
+        $(B shared$(LPAREN)) $(GLINK type) $(B $(RPAREN))
+        $(B inout$(LPAREN)) $(GLINK type) $(B $(RPAREN))
+)
+)
+BasicTypeX_production = $(GRAMMAR
+$(GNAME BasicTypeX):
+        $(B bool)
+        $(B byte)
+        $(B ubyte)
+        $(B short)
+        $(B ushort)
+        $(B int)
+        $(B uint)
+        $(B long)
+        $(B ulong)
+        $(B char)
+        $(B wchar)
+        $(B dchar)
+        $(B float)
+        $(B double)
+        $(B real)
+        $(B ifloat)
+        $(B idouble)
+        $(B ireal)
+        $(B cfloat)
+        $(B cdouble)
+        $(B creal)
+        $(B void)
+)
+BasicType2_production = $(GRAMMAR
+$(GNAME BasicType2):
+        $(B *)
+        $(B [ ])
+        $(B [) $(VEXPRESSION) $(B ])
+        $(B [) $(VEXPRESSION) .. $(VEXPRESSION) $(B ])
+        $(B [) $(I Type) $(B ])
+        $(B delegate) $(GLINK Parameters) $(V2 $(GLINK FunctionAttributes)$(OPT))
+        $(B function) $(GLINK Parameters) $(V2 $(GLINK FunctionAttributes)$(OPT))
+)
+Declarator_production = $(GRAMMAR
+$(GNAME Declarator):
+        $(GLINK BasicType2)$(OPT) $(I Declarator) $(GLINK DeclaratorSuffixes)$(OPT)
+        $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK DeclaratorSuffixes)$(OPT)
+)
+DeclaratorSuffixes_production = $(GRAMMAR
+$(GNAME DeclaratorSuffixes):
+        $(GLINK DeclaratorSuffix)
+        $(GLINK DeclaratorSuffix) $(I DeclaratorSuffixes)
+)
+DeclaratorSuffix_production = $(GRAMMAR
+$(GNAME DeclaratorSuffix):
+        $(B [ ])
+        $(B [) $(VEXPRESSION) $(B ])
+        $(B [) $(I Type) $(B ])
+	$(LINK2 template.html#TemplateParameterList, $(I TemplateParameterList))$(OPT) $(GLINK Parameters) $(V2 $(GLINK MemberFunctionAttributes)<sub>opt</sub>)
+)
+IdentifierList_production = $(GRAMMAR
+$(GNAME IdentifierList):
+        $(I Identifier)
+        $(I Identifier) $(B .) $(I IdentifierList)
+        $(I TemplateInstance)
+        $(I TemplateInstance) $(B .) $(I IdentifierList)
+)
+StorageClasses_production = $(GRAMMAR
+$(GNAME StorageClasses):
+	$(GLINK StorageClass)
+	$(GLINK StorageClass) $(I StorageClasses)
+)
+StorageClass_production = $(GRAMMAR
+$(GNAME StorageClass):
+        $(B abstract)
+        $(B auto)
+        $(B const)
+        $(B deprecated)
+        $(B extern)
+        $(B final)
+$(V2
+         $(B immutable)
+        $(B inout)
+        $(B shared)
+	$(B nothrow)
+        $(B override)
+	$(B pure)
+)        $(B scope)
+        $(B static)
+        $(B synchronized)
+)
+Type_production = $(GRAMMAR
+$(GNAME Type):
+        $(GLINK BasicType)
+        $(GLINK BasicType) $(GLINK Declarator2)
+)
+Declarator2_production = $(GRAMMAR
+$(GNAME Declarator2):
+        $(GLINK BasicType2) $(I Declarator2)
+        $(B $(LPAREN)) $(I Declarator2) $(B $(RPAREN))
+        $(B $(LPAREN)) $(I Declarator2) $(B $(RPAREN)) $(GLINK DeclaratorSuffixes)
+)
+Parameters_production = $(GRAMMAR
+$(GNAME Parameters):
+	$(B $(LPAREN)) $(GLINK ParameterList) $(B $(RPAREN))
+	$(B ( ))
+)
+ParameterList_production = $(GRAMMAR
+$(GNAME ParameterList):
+        $(GLINK Parameter)
+        $(GLINK Parameter) $(B ,) $(I ParameterList)
+        $(GLINK Parameter) $(B ...)
+        $(B ...)
+)
+Parameter_production = $(GRAMMAR
+$(GNAME Parameter):
+        $(GLINK Declarator)
+        $(GLINK Declarator) = $(I DefaultInitializerExpression)
+        $(I InOut) $(GLINK Declarator)
+        $(I InOut) $(GLINK Declarator) = $(I DefaultInitializerExpression)
+)
+InOut_production = $(GRAMMAR
+$(GNAME InOut):
+        $(B in)
+        $(B out)
+        $(B ref)
+        $(B lazy)
+)
+FunctionAttributes_production = $(GRAMMAR
+$(GNAME FunctionAttributes):
+	$(GLINK FunctionAttribute)
+	$(GLINK FunctionAttribute) $(I FunctionAttributes)
+)
+FunctionAttribute_production = $(GRAMMAR
+$(GNAME FunctionAttribute):
+	$(B nothrow)
+	$(B pure)
+)
+MemberFunctionAttributes_production = $(GRAMMAR
+$(GNAME MemberFunctionAttributes):
+	$(GLINK MemberFunctionAttribute)
+	$(GLINK MemberFunctionAttribute) $(I MemberFunctionAttributes)
+)
+MemberFunctionAttribute_production = $(GRAMMAR
+$(GNAME MemberFunctionAttribute):
+	$(B const)
+	$(B immutable)
+	$(B inout)
+	$(B shared)
+	$(GLINK FunctionAttribute)
+)
+DefaultInitializerExpression_production = $(GRAMMAR
+$(GNAME DefaultInitializerExpression):
+	$(ASSIGNEXPRESSION)
+$(V2	$(B __FILE__)
+	$(B __LINE__))
+)
+Initializer_production = $(GRAMMAR
+$(GNAME Initializer):
+        $(GLINK VoidInitializer)
+	$(GLINK NonVoidInitializer)
+)
+NonVoidInitializer_production = $(GRAMMAR
+$(GNAME NonVoidInitializer):
+        $(ASSIGNEXPRESSION)
+        $(GLINK ArrayInitializer)
+        $(GLINK StructInitializer)
+)
+ArrayInitializer_production = $(GRAMMAR
+$(GNAME ArrayInitializer):
+	$(B [ ])
+	$(B [) $(GLINK ArrayMemberInitializations) $(B ])
+)
+ArrayMemberInitializations_production = $(GRAMMAR
+$(GNAME ArrayMemberInitializations):
+	$(GLINK ArrayMemberInitialization)
+	$(GLINK ArrayMemberInitialization) $(B ,)
+	$(GLINK ArrayMemberInitialization) $(B ,) $(I ArrayMemberInitializations)
+)
+ArrayMemberInitialization_production = $(GRAMMAR
+$(GNAME ArrayMemberInitialization):
+	$(GLINK NonVoidInitializer)
+	$(ASSIGNEXPRESSION) $(B :) $(GLINK NonVoidInitializer)
+)
+StructInitializer_production = $(GRAMMAR
+$(GNAME StructInitializer):
+	$(B {  })
+	$(B {) $(GLINK StructMemberInitializers) $(B })
+)
+StructMemberInitializers_production = $(GRAMMAR
+$(GNAME StructMemberInitializers):
+	$(GLINK StructMemberInitializer)
+	$(GLINK StructMemberInitializer) $(B ,)
+	$(GLINK StructMemberInitializer) $(B ,) $(I StructMemberInitializers)
+)
+StructMemberInitializer_production = $(GRAMMAR
+$(GNAME StructMemberInitializer):
+	$(GLINK NonVoidInitializer)
+	$(I Identifier) $(B :) $(GLINK NonVoidInitializer)
+)
+AutoDeclaration_production = $(GRAMMAR
+$(GNAME AutoDeclaration):
+	$(I StorageClasses) $(I Identifier) $(B =) $(ASSIGNEXPRESSION) $(B ;)
+)
+Typeof_production = $(GRAMMAR
+$(GNAME Typeof):
+        $(B typeof $(LPAREN)) $(EXPRESSION) $(B $(RPAREN))
+        $(B typeof $(LPAREN)) $(B return) $(B $(RPAREN))
+)
+VoidInitializer_production = $(GRAMMAR
+$(GNAME VoidInitializer):
+	$(B void)
+)
+EnumDeclaration_production = $(GRAMMAR
+$(GNAME EnumDeclaration):
+	$(B enum) $(I EnumTag) $(I EnumBody)
+	$(B enum) $(I EnumBody)
+	$(B enum) $(I EnumTag) $(B :) $(I EnumBaseType) $(I EnumBody)
+	$(B enum) $(B :) $(I EnumBaseType) $(I EnumBody)
+)
+EnumTag_production = $(GRAMMAR
+$(GNAME EnumTag):
+	$(I Identifier)
+)
+EnumBaseType_production = $(GRAMMAR
+$(GNAME EnumBaseType):
+	$(I Type)
+)
+EnumBody_production = $(GRAMMAR
+$(GNAME EnumBody):
+	$(B ;)
+	$(B {) $(I EnumMembers) $(B })
+)
+EnumMembers_production = $(GRAMMAR
+$(GNAME EnumMembers):
+	$(I EnumMember)
+	$(I EnumMember) $(B ,)
+	$(I EnumMember) $(B ,) $(I EnumMembers)
+)
+EnumMember_production = $(GRAMMAR
+$(GNAME EnumMember):
+	$(I Identifier)
+	$(I Identifier) $(B =) $(ASSIGNEXPRESSION)
+$(V2
+	$(I Type) $(I Identifier) $(B =) $(ASSIGNEXPRESSION))
+)
+Expression_production = $(GRAMMAR
+$(GNAME Expression):
+	$(GLINK AssignExpression)
+	$(GLINK AssignExpression) $(B ,) $(I Expression)
+)
+AssignExpression_production = $(GRAMMAR
+$(GNAME AssignExpression):
+	$(GLINK ConditionalExpression)
+	$(GLINK ConditionalExpression) $(B =) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B +=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B -=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B *=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B /=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B %=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B &=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B |=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B ^=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B ~=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B &lt;&lt;=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B &gt;&gt;=) $(I AssignExpression)
+	$(GLINK ConditionalExpression) $(B &gt;&gt;&gt;=) $(I AssignExpression)
+$(V2
+	$(GLINK ConditionalExpression) $(B ^^=) $(I AssignExpression))
+)
+ConditionalExpression_production = $(GRAMMAR
+$(GNAME ConditionalExpression):
+	$(GLINK OrOrExpression)
+	$(GLINK OrOrExpression) $(B ?) $(GLINK Expression) $(B :) $(I ConditionalExpression)
+)
+OrOrExpression_production = $(GRAMMAR
+$(GNAME OrOrExpression):
+	$(GLINK AndAndExpression)
+	$(I OrOrExpression) $(B ||) $(GLINK AndAndExpression)
+)
+AndAndExpression_production = $(GRAMMAR
+$(GNAME AndAndExpression):
+	$(GLINK OrExpression)
+	$(I AndAndExpression) $(B &&) $(GLINK OrExpression)
+
+)
+OrExpression_production = $(GRAMMAR
+$(GNAME OrExpression):
+	$(GLINK XorExpression)
+	$(I OrExpression) $(B |) $(GLINK XorExpression)
+)
+XorExpression_production = $(GRAMMAR
+$(GNAME XorExpression):
+	$(GLINK AndExpression)
+	$(I XorExpression) $(B ^) $(GLINK AndExpression)
+)
+AndExpression_production = $(GRAMMAR
+$(GNAME AndExpression):
+	$(GLINK CmpExpression)
+	$(I AndExpression) $(B &) $(GLINK CmpExpression)
+)
+CmpExpression_production = $(GRAMMAR
+$(GNAME CmpExpression):
+	$(GLINK ShiftExpression)
+	$(GLINK EqualExpression)
+	$(GLINK IdentityExpression)
+	$(GLINK RelExpression)
+	$(GLINK InExpression)
+)
+EqualExpression_production = $(GRAMMAR
+$(GNAME EqualExpression):
+	$(GLINK ShiftExpression) $(B ==) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !=) $(GLINK ShiftExpression)
+)
+IdentityExpression_production = $(GRAMMAR
+$(GNAME IdentityExpression):
+	$(GLINK ShiftExpression) $(B is) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !is) $(GLINK ShiftExpression)
+)
+RelExpression_production = $(GRAMMAR
+$(GNAME RelExpression):
+	$(GLINK ShiftExpression) $(B &lt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B &lt;=) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B &gt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B &gt;=) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&lt;&gt;=) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&lt;&gt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B &lt;&gt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B &lt;&gt;=) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&gt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&gt;=) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&lt;) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !&lt;=) $(GLINK ShiftExpression)
+)
+InExpression_production = $(GRAMMAR
+$(GNAME InExpression):
+	$(GLINK ShiftExpression) $(B in) $(GLINK ShiftExpression)
+	$(GLINK ShiftExpression) $(B !in) $(GLINK ShiftExpression)
+)
+ShiftExpression_production = $(GRAMMAR
+$(GNAME ShiftExpression):
+	$(GLINK AddExpression)
+	$(I ShiftExpression) $(B &lt;&lt;) $(GLINK AddExpression)
+	$(I ShiftExpression) $(B &gt;&gt;) $(GLINK AddExpression)
+	$(I ShiftExpression) $(B &gt;&gt;&gt;) $(GLINK AddExpression)
+)
+AddExpression_production = $(GRAMMAR
+$(GNAME AddExpression):
+	$(GLINK MulExpression)
+	$(I AddExpression) $(B +) $(GLINK MulExpression)
+	$(I AddExpression) $(B -) $(GLINK MulExpression)
+	$(GLINK CatExpression)
+)
+CatExpression_production = $(GRAMMAR
+$(GNAME CatExpression):
+	$(I AddExpression) $(B ~) $(GLINK MulExpression)
+)
+MulExpression_production = $(V1 $(GRAMMAR
+$(GNAME MulExpression):
+	$(GLINK UnaryExpression)
+	$(I MulExpression) $(B *) $(GLINK UnaryExpression)
+	$(I MulExpression) $(B /) $(GLINK UnaryExpression)
+	$(I MulExpression) $(B %) $(GLINK UnaryExpression)
+))
+$(V2 $(GRAMMAR
+	$(GNAME MulExpression):
+	$(GLINK PowExpression)
+	$(I MulExpression) $(B *) $(GLINK PowExpression)
+	$(I MulExpression) $(B /) $(GLINK PowExpression)
+	$(I MulExpression) $(B %) $(GLINK PowExpression)
+))
+PowExpression_production = $(GRAMMAR
+$(GNAME PowExpression):
+	$(GLINK UnaryExpression)
+	$(GLINK UnaryExpression) ^^ $(I PowExpression)
+)
+UnaryExpression_production = $(GRAMMAR
+$(GNAME UnaryExpression):
+	$(GLINK PostfixExpression)
+	$(B &amp;) $(I UnaryExpression)
+	$(B ++) $(I UnaryExpression)
+	$(B --) $(I UnaryExpression)
+	$(B *) $(I UnaryExpression)
+	$(B -) $(I UnaryExpression)
+	$(B +) $(I UnaryExpression)
+	$(B !) $(I UnaryExpression)
+	$(B ~) $(I UnaryExpression)
+	$(B $(LPAREN)) $(I Type) $(B $(RPAREN) .) $(I Identifier)
+	$(GLINK NewExpression)
+	$(GLINK DeleteExpression)
+	$(GLINK CastExpression)
+	$(LINK2 class.html#anonymous, $(I NewAnonClassExpression))
+)
+NewExpression_production = $(GRAMMAR
+$(GNAME NewExpression):
+	$(I NewArguments) $(I Type) $(B [) $(GLINK AssignExpression) $(B ])
+	$(I NewArguments) $(I Type) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
+	$(I NewArguments) $(I Type)
+	$(I NewArguments) $(I ClassArguments) $(I BaseClasslist)<sub>opt</sub> $(B {) $(I DeclDefs) $(B } )
+)
+NewArguments_production = $(GRAMMAR
+$(GNAME NewArguments):
+	$(B new $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
+	$(B new ( ))
+	$(B new)
+)
+ClassArguments_production = $(GRAMMAR
+$(GNAME ClassArguments):
+	$(B class $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
+	$(B class ( ))
+	$(B class)
+)
+ArgumentList_production = $(GRAMMAR
+$(GNAME ArgumentList):
+	$(GLINK AssignExpression)
+	$(GLINK AssignExpression) $(B ,) $(I ArgumentList)
+)
+DeleteExpression_production = $(GRAMMAR
+$(GNAME DeleteExpression):
+	$(B delete) $(GLINK UnaryExpression)
+)
+CastExpression_production = $(GRAMMAR
+$(GNAME CastExpression):
+	$(B cast $(LPAREN)) $(I Type) $(B $(RPAREN)) $(GLINK UnaryExpression)
+)
+PostfixExpression_production = $(GRAMMAR
+$(GNAME PostfixExpression):
+	$(GLINK PrimaryExpression)
+	$(I PostfixExpression) $(B .) $(I Identifier)
+	$(I PostfixExpression) $(B .) $(GLINK NewExpression)
+	$(I PostfixExpression) $(B ++)
+	$(I PostfixExpression) $(B --)
+	$(I PostfixExpression) $(B ( ))
+	$(I PostfixExpression) $(B $(LPAREN)) $(GLINK ArgumentList) $(B $(RPAREN))
+	$(GLINK IndexExpression)
+	$(GLINK SliceExpression)
+)
+IndexExpression_production = $(GRAMMAR
+$(GNAME IndexExpression):
+	$(GLINK PostfixExpression) $(B [) $(GLINK ArgumentList) $(B ])
+)
+SliceExpression_production = $(GRAMMAR
+$(GNAME SliceExpression):
+	$(GLINK PostfixExpression) $(B [ ])
+	$(GLINK PostfixExpression) $(B [) $(GLINK AssignExpression) $(B ..) $(GLINK AssignExpression) $(B ])
+)
+PrimaryExpression_production = $(GRAMMAR
+$(GNAME PrimaryExpression):
+	$(I Identifier)
+	$(B .)$(I Identifier)
+	$(LINK2 template.html#TemplateInstance, $(I TemplateInstance))
+	$(LINK2 #this, $(B this))
+	$(LINK2 #super, $(B super))
+	$(LINK2 #null, $(B null))
+	$(B true)
+	$(B false)
+	$(B $)
+$(V2
+	$(B __FILE__)
+	$(B __LINE__))
+	$(GLINK2 lex, IntegerLiteral)
+	$(GLINK2 lex, FloatLiteral)
+	$(GLINK CharacterLiteral)
+	$(GLINK StringLiterals)
+	$(GLINK ArrayLiteral)
+	$(GLINK AssocArrayLiteral)
+	$(GLINK FunctionLiteral)
+	$(GLINK AssertExpression)
+	$(GLINK MixinExpression)
+	$(GLINK ImportExpression)
+	$(I BasicType) $(B .) $(I Identifier)
+	$(LINK2 declaration.html#Typeof, $(I Typeof))
+	$(GLINK TypeidExpression)
+	$(GLINK IsExpression)
+	$(B $(LPAREN)) $(I Expression) $(B $(RPAREN))
+$(V2
+	$(LINK2 traits.html#TraitsExpression, $(I TraitsExpression)))
+)
+StringLiterals_production = $(GRAMMAR
+$(GNAME StringLiterals):
+	$(LINK2 lex.html#StringLiteral, $(I StringLiteral))
+	$(I StringLiterals) $(LINK2 lex.html#StringLiteral, $(I StringLiteral))
+)
+ArrayLiteral_production = $(GRAMMAR
+$(GNAME ArrayLiteral):
+	$(B [) $(GLINK ArgumentList) $(B ])
+)
+AssocArrayLiteral_production = $(GRAMMAR
+$(GNAME AssocArrayLiteral):
+	$(B [) $(I KeyValuePairs) $(B ])
+)
+KeyValuePairs_production = $(GRAMMAR
+$(GNAME KeyValuePairs):
+	$(I KeyValuePair)
+	$(I KeyValuePair) $(B ,) $(I KeyValuePairs)
+)
+KeyValuePair_production = $(GRAMMAR
+$(GNAME KeyValuePair):
+	$(I KeyExpression) $(B :) $(I ValueExpression)
+)
+KeyExpression_production = $(GRAMMAR
+$(GNAME KeyExpression):
+	$(GLINK ConditionalExpression)
+)
+ValueExpression_production = $(GRAMMAR
+$(GNAME ValueExpression):
+	$(GLINK ConditionalExpression)
+)
+FunctionLiteral_production = $(GRAMMAR
+$(GNAME FunctionLiteral):
+	$(B function) $(I Type)<sub>opt</sub> $(I ParameterAttributes) <sub>opt</sub> $(I FunctionBody)
+	$(B delegate) $(I Type)<sub>opt</sub> $(I ParameterAttributes) <sub>opt</sub> $(I FunctionBody)
+	$(I ParameterAttributes) $(I FunctionBody)
+	$(I FunctionBody)
+)
+ParameterAttributes_production = $(GRAMMAR
+$(GNAME ParameterAttributes):
+	$(LINK2 declaration.html#Parameters, $(I Parameters))
+$(V2
+	$(LINK2 declaration.html#Parameters, $(I Parameters)) $(LINK2 declaration.html#FunctionAttributes, $(I FunctionAttributes))
+)
+)
+AssertExpression_production = $(GRAMMAR
+$(GNAME AssertExpression):
+	$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
+	$(B assert $(LPAREN)) $(GLINK AssignExpression) $(B ,) $(GLINK AssignExpression) $(B $(RPAREN))
+)
+MixinExpression_production = $(GRAMMAR
+$(GNAME MixinExpression):
+	$(B mixin $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
+)
+ImportExpression_production = $(GRAMMAR
+$(GNAME ImportExpression):
+	$(B import $(LPAREN)) $(GLINK AssignExpression) $(B $(RPAREN))
+)
+TypeidExpression_production = $(GRAMMAR
+$(GNAME TypeidExpression):
+    $(B typeid $(LPAREN)) $(I Type) $(B $(RPAREN))
+$(V2      $(B typeid $(LPAREN)) $(I Expression) $(B $(RPAREN)))
+)
+IsExpression_production = $(GRAMMAR
+$(GNAME IsExpression):
+	$(B is $(LPAREN)) $(I Type) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B $(RPAREN))
+	$(V2 $(B is $(LPAREN)) $(I Type) $(I Identifier) $(B :) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
+	$(B is $(LPAREN)) $(I Type) $(I Identifier) $(B ==) $(I TypeSpecialization) $(B ,) $(I TemplateParameterList) $(B $(RPAREN))
+)
+)
+TypeSpecialization_production = $(GRAMMAR
+$(GNAME TypeSpecialization):
+	$(I Type)
+$(V1	$(B typedef)
+)	$(B struct)
+	$(B union)
+	$(B class)
+	$(B interface)
+	$(B enum)
+	$(B function)
+	$(B delegate)
+	$(B super)
+$(V2
+	$(B const)
+	$(B immutable)
+	$(B inout)
+	$(B shared)
+	$(B return)
+))
+FunctionBody_production = $(GRAMMAR
+$(GNAME FunctionBody):
+	$(LINK2 statement.html#BlockStatement, $(I BlockStatement))
+	$(I BodyStatement)
+	$(I InStatement) $(I BodyStatement)
+	$(I OutStatement) $(I BodyStatement)
+	$(I InStatement) $(I OutStatement) $(I BodyStatement)
+	$(I OutStatement) $(I InStatement) $(I BodyStatement)
+)
+InStatement_production = $(GRAMMAR
+$(GNAME InStatement):
+	$(B in) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
+)
+OutStatement_production = $(GRAMMAR
+$(GNAME OutStatement):
+	$(B out) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
+	$(B out) $(B $(LPAREN)) $(I Identifier) $(B $(RPAREN)) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
+)
+BodyStatement_production = $(GRAMMAR
+$(GNAME BodyStatement):
+	$(B body) $(LINK2 statement.html#BlockStatement, $(I BlockStatement))
+)
+InterfaceDeclaration_production = $(GRAMMAR
+$(GNAME InterfaceDeclaration):
+	$(B interface) $(I Identifier) $(BaseInterfaceList) $(I InterfaceBody)
+	$(LINK2 template.html#InterfaceTemplateDeclaration, $(I InterfaceTemplateDeclaration))
+)
+BaseInterfaceList_production = $(GRAMMAR
+$(GNAME BaseInterfaceList):
+	$(I Empty)
+	$(B :) $(LINK2 class.html#InterfaceClasses, $(I InterfaceClasses))
+)
+InterfaceBody_production = $(GRAMMAR
+$(GNAME InterfaceBody):
+	$(B {) DeclDefs $(B })
+)
+Module_production = $(GRAMMAR
+$(GNAME Module):
+	$(GLINK ModuleDeclaration) $(GLINK DeclDefs)
+	$(GLINK DeclDefs)
+)
+DeclDefs_production = $(GRAMMAR
+$(GNAME DeclDefs):
+	$(I DeclDef)
+	$(I DeclDef) $(I DeclDefs)
+)
+DeclDef_production = $(GRAMMAR
+$(GNAME DeclDef):
+	$(LINK2 attribute.html#AttributeSpecifier, $(I AttributeSpecifier))
+	$(GLINK ImportDeclaration)
+	$(I EnumDeclaration)
+	$(I ClassDeclaration)
+	$(I InterfaceDeclaration)
+	$(I AggregateDeclaration)
+	$(I Declaration)
+	$(I Constructor)
+	$(I Destructor)
+	$(I Invariant)
+	$(I UnitTest)
+	$(I StaticConstructor)
+	$(I StaticDestructor)
+$(V2
+	$(I SharedStaticConstructor)
+	$(I SharedStaticDestructor)
+)	$(LINK2 version.html#ConditionalDeclaration, $(I ConditionalDeclaration))
+	$(LINK2 version.html#StaticAssert, $(I StaticAssert))
+	$(LINK2 template.html#TemplateDeclaration, $(I TemplateDeclaration))
+	$(LINK2 template-mixin.html#TemplateMixin, $(I TemplateMixin))
+	$(GLINK MixinDeclaration)
+	$(B ;)
+)
+ModuleDeclaration_production = $(GRAMMAR
+$(GNAME ModuleDeclaration):
+	$(B module) $(I ModuleFullyQualifiedName) $(B ;)
+)
+ModuleFullyQualifiedName_production = $(GRAMMAR
+$(GNAME ModuleFullyQualifiedName):
+	$(I ModuleName)
+	$(I Packages) $(B .) $(I ModuleName)
+)
+ModuleName_production = $(GRAMMAR
+$(GNAME ModuleName):
+	$(I Identifier)
+)
+Packages_production = $(GRAMMAR
+$(GNAME Packages):
+	$(I PackageName)
+	$(I Packages) $(B .) $(I PackageName)
+)
+PackageName_production = $(GRAMMAR
+$(GNAME PackageName):
+	$(I Identifier)
+)
+ImportDeclaration_production = $(GRAMMAR
+$(GNAME ImportDeclaration):
+	$(B import) $(I ImportList) $(B ;)
+	$(B static import) $(I ImportList) $(B ;)
+)
+ImportList_production = $(GRAMMAR
+$(GNAME ImportList):
+	$(I Import)
+	$(I ImportBindings)
+	$(I Import) $(B ,) $(I ImportList)
+)
+Import_production = $(GRAMMAR
+$(GNAME Import):
+	$(I ModuleFullyQualifiedName)
+	$(I ModuleAliasIdentifier) $(B =) $(I ModuleFullyQualifiedName)
+)
+ImportBindings_production = $(GRAMMAR
+$(GNAME ImportBindings):
+	$(I Import) $(B :) $(I ImportBindList)
+)
+ImportBindList_production = $(GRAMMAR
+$(GNAME ImportBindList):
+	$(I ImportBind)
+	$(I ImportBind) $(B ,) $(I ImportBindList)
+)
+ImportBind_production = $(GRAMMAR
+$(GNAME ImportBind):
+	$(I Identifier)
+	$(I Identifier) = $(I Identifier)
+)
+ModuleAliasIdentifier_production = $(GRAMMAR
+$(GNAME ModuleAliasIdentifier):
+	$(I Identifier)
+)
+MixinDeclaration_production = $(GRAMMAR
+$(GNAME MixinDeclaration):
+    $(B mixin) $(B $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN)) $(B ;)
+)
+Statement_production = $(GRAMMAR
+$(GNAME Statement):
+    $(B ;)
+    $(GLINK NonEmptyStatement)
+    $(GLINK ScopeBlockStatement)
+)
+NoScopeNonEmptyStatement_production = $(GRAMMAR
+$(GNAME NoScopeNonEmptyStatement):
+    $(GLINK NonEmptyStatement)
+    $(GLINK BlockStatement)
+)
+NoScopeStatement_production = $(GRAMMAR
+$(GNAME NoScopeStatement):
+    $(B ;)
+    $(GLINK NonEmptyStatement)
+    $(GLINK BlockStatement)
+)
+NonEmptyOrScopeBlockStatement_production = $(GRAMMAR
+$(GNAME NonEmptyOrScopeBlockStatement):
+    $(GLINK NonEmptyStatement)
+    $(GLINK ScopeBlockStatement)
+)
+NonEmptyStatement_production = $(GRAMMAR
+$(GNAME NonEmptyStatement):
+    $(GLINK LabeledStatement)
+    $(GLINK ExpressionStatement)
+    $(GLINK DeclarationStatement)
+    $(GLINK IfStatement)
+    $(GLINK WhileStatement)
+    $(GLINK DoStatement)
+    $(GLINK ForStatement)
+    $(GLINK ForeachStatement)
+    $(GLINK SwitchStatement)
+$(V2      $(GLINK FinalSwitchStatement)
+)    $(GLINK CaseStatement)
+$(V2      $(GLINK CaseRangeStatement)
+)    $(GLINK DefaultStatement)
+    $(GLINK ContinueStatement)
+    $(GLINK BreakStatement)
+    $(GLINK ReturnStatement)
+    $(GLINK GotoStatement)
+    $(GLINK WithStatement)
+    $(GLINK SynchronizedStatement)
+    $(GLINK TryStatement)
+    $(GLINK ScopeGuardStatement)
+    $(GLINK ThrowStatement)
+$(V1    $(GLINK VolatileStatement)
+)    $(GLINK AsmStatement)
+    $(GLINK PragmaStatement)
+    $(GLINK MixinStatement)
+$(V2      $(GLINK ForeachRangeStatement))
+    $(LINK2 version.html#ConditionalStatement, $(I ConditionalStatement))
+    $(LINK2 version.html#StaticAssert, $(I StaticAssert))
+    $(LINK2 template-mixin.html#TemplateMixin, $(I TemplateMixin))
+)
+ScopeStatement_production = $(GRAMMAR
+$(I ScopeStatement):
+    $(GLINK NonEmptyStatement)
+    $(GLINK BlockStatement)
+)
+ScopeBlockStatement_production = $(GRAMMAR
+$(I ScopeBlockStatement):
+    $(GLINK BlockStatement)
+)
+LabeledStatement_production = $(GRAMMAR
+$(I LabeledStatement):
+    $(I Identifier) : $(PSSEMI)
+)
+BlockStatement_production = $(GRAMMAR
+$(I BlockStatement):
+    $(B { })
+    $(B {) $(I StatementList) $(B })
+)
+StatementList_production = $(GRAMMAR
+$(GNAME StatementList):
+    $(PSSEMI_PSCURLYSCOPE)
+    $(PSSEMI_PSCURLYSCOPE) $(I StatementList)
+)
+ExpressionStatement_production = $(GRAMMAR
+$(I ExpressionStatement):
+    $(EXPRESSION) $(B ;)
+)
+DeclarationStatement_production = $(GRAMMAR
+$(I DeclarationStatement):
+    $(I Declaration)
+)
+IfStatement_production = $(GRAMMAR
+$(I IfStatement):
+	$(B if $(LPAREN)) $(I IfCondition) $(B $(RPAREN)) $(I ThenStatement)
+	$(B if $(LPAREN)) $(I IfCondition) $(B $(RPAREN)) $(I ThenStatement) $(B else) $(I ElseStatement)
+)
+IfCondition_production = $(GRAMMAR
+$(GNAME IfCondition):
+	$(EXPRESSION)
+	$(B auto) $(I Identifier) $(B =) $(EXPRESSION)
+	$(I Declarator) $(B =) $(EXPRESSION)
+)
+ThenStatement_production = $(GRAMMAR
+$(GNAME ThenStatement):
+	$(PSSCOPE)
+)
+ElseStatement_production = $(GRAMMAR
+$(GNAME ElseStatement):
+	$(PSSCOPE)
+)
+WhileStatement_production = $(GRAMMAR
+$(I WhileStatement):
+    $(B while $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+)
+DoStatement_production = $(GRAMMAR
+$(I DoStatement):
+    $(B do) $(PSSCOPE) $(B  while $(LPAREN)) $(EXPRESSION) $(B $(RPAREN))
+)
+ForStatement_production = $(GRAMMAR
+$(I ForStatement):
+	$(B for $(LPAREN))$(I Initialize) $(I Test) $(B ;) $(I Increment)$(B $(RPAREN)) $(PSSCOPE)
+)
+Initialize_production = $(GRAMMAR
+$(GNAME Initialize):
+	$(B ;)
+	$(PS0)
+)
+Test_production = $(GRAMMAR
+$(GNAME Test):
+	$(I empty)
+	$(EXPRESSION)
+)
+Increment_production = $(GRAMMAR
+$(GNAME Increment):
+	$(I empty)
+	$(EXPRESSION)
+)
+ForeachStatement_production = $(GRAMMAR
+$(I ForeachStatement):
+    $(I Foreach) $(B $(LPAREN))$(I ForeachTypeList) $(B ;) $(I Aggregate)$(B $(RPAREN)) $(PS0)
+)
+Foreach_production = $(GRAMMAR
+$(GNAME Foreach):
+    $(B foreach)
+    $(B foreach_reverse)
+)
+ForeachTypeList_production = $(GRAMMAR
+$(GNAME ForeachTypeList):
+    $(I ForeachType)
+    $(I ForeachType) , $(I ForeachTypeList)
+)
+ForeachType_production = $(GRAMMAR
+$(GNAME ForeachType):
+    $(B ref) $(I Type) $(I Identifier)
+    $(I Type) $(I Identifier)
+    $(B ref) $(I Identifier)
+    $(I Identifier)
+)
+Aggregate_production = $(GRAMMAR
+$(GNAME Aggregate):
+    $(EXPRESSION)
+)
+SwitchStatement_production = $(GRAMMAR
+$(I SwitchStatement):
+	$(B switch $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+)
+CaseStatement_production = $(GRAMMAR
+$(GNAME CaseStatement):
+	$(B case) $(LINK2 expression.html#ArgumentList, $(I ArgumentList)) $(B :) $(PSSEMI_PSCURLYSCOPE)
+)
+CaseRangeStatement_production = $(GRAMMAR
+$(GNAME CaseRangeStatement):
+	$(B case) $(I FirstExp) $(B : .. case) $(I LastExp) $(B :) $(PSSEMI_PSCURLYSCOPE)
+)
+FirstExp_production = $(GRAMMAR
+$(I FirstExp):
+	$(I AssignExpression)
+)
+LastExp_production = $(GRAMMAR
+$(I LastExp):
+	$(I AssignExpression)
+)
+DefaultStatement_production = $(GRAMMAR
+$(GNAME DefaultStatement):
+	$(B default :) $(PSSEMI_PSCURLYSCOPE)
+)
+FinalSwitchStatement_production = $(GRAMMAR
+$(I FinalSwitchStatement):
+	$(B final switch $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+)
+ContinueStatement_production = $(GRAMMAR
+$(I ContinueStatement):
+    $(B continue;)
+    $(B continue) $(I Identifier) $(B ;)
+)
+BreakStatement_production = $(GRAMMAR
+$(I BreakStatement):
+    $(B break;)
+    $(B break) $(I Identifier) $(B ;)
+)
+ReturnStatement_production = $(GRAMMAR
+$(I ReturnStatement):
+    $(B return;)
+    $(B return) $(EXPRESSION) $(B ;)
+)
+GotoStatement_production = $(GRAMMAR
+$(I GotoStatement):
+    $(B goto) $(I Identifier) $(B ;)
+    $(B goto) $(B default) $(B ;)
+    $(B goto) $(B case) $(B ;)
+    $(B goto) $(B case) $(EXPRESSION) $(B ;)
+)
+WithStatement_production = $(GRAMMAR
+$(I WithStatement):
+	$(B with) $(B $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+	$(B with) $(B $(LPAREN)) $(LINK2 template.html#Symbol, $(I Symbol)) $(B $(RPAREN)) $(PSSCOPE)
+	$(B with) $(B $(LPAREN)) $(LINK2 template.html#TemplateInstance, $(I TemplateInstance)) $(B $(RPAREN)) $(PSSCOPE)
+)
+SynchronizedStatement_production = $(GRAMMAR
+$(I SynchronizedStatement):
+    $(B synchronized) $(PSSCOPE)
+    $(B synchronized $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+)
+TryStatement_production = $(GRAMMAR
+$(I TryStatement):
+	$(B try) $(PSSCOPE) $(I Catches)
+	$(B try) $(PSSCOPE) $(I Catches) $(I FinallyStatement)
+	$(B try) $(PSSCOPE) $(I FinallyStatement)
+)
+Catches_production = $(GRAMMAR
+$(GNAME Catches):
+	$(I LastCatch)
+	$(I Catch)
+	$(I Catch) $(I Catches)
+)
+LastCatch_production = $(GRAMMAR
+$(GNAME LastCatch):
+	$(B catch) $(PS0)
+)
+Catch_production = $(GRAMMAR
+$(GNAME Catch):
+	$(B catch $(LPAREN)) $(I CatchParameter) $(B $(RPAREN)) $(PS0)
+)
+CatchParameter_production = $(GRAMMAR
+$(GNAME CatchParameter):
+	$(I BasicType) $(I Identifier)
+)
+FinallyStatement_production = $(GRAMMAR
+$(GNAME FinallyStatement):
+	$(B finally) $(PS0)
+)
+ThrowStatement_production = $(GRAMMAR
+$(I ThrowStatement):
+	$(B throw) $(EXPRESSION) $(B ;)
+)
+ScopeGuardStatement_production = $(GRAMMAR
+$(I ScopeGuardStatement):
+	$(B scope(exit)) $(PSCURLYSCOPE)
+	$(B scope(success)) $(PSCURLYSCOPE)
+	$(B scope(failure)) $(PSCURLYSCOPE)
+)
+VolatileStatement_production = $(GRAMMAR
+$(I VolatileStatement):
+	$(B volatile) $(PSSEMI_PSCURLYSCOPE)
+	$(B volatile) $(B ;)
+)
+AsmStatement_production = $(GRAMMAR
+$(GNAME AsmStatement):
+	$(B asm { })
+	$(B asm {) $(I AsmInstructionList) $(B })
+)
+AsmInstructionList_production = $(GRAMMAR
+$(GNAME AsmInstructionList):
+	$(I AsmInstruction) $(B ;)
+	$(I AsmInstruction) $(B ;) $(I AsmInstructionList)
+)
+PragmaStatement_production = $(GRAMMAR
+$(I PragmaStatement):
+    $(LINK2 pragma.html, $(I Pragma)) $(PSSEMI)
+)
+MixinStatement_production = $(GRAMMAR
+$(I MixinStatement):
+    $(B mixin) $(B $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN)) $(B ;)
+)
+ForeachRangeStatement_production = $(GRAMMAR
+$(I ForeachRangeStatement):
+    $(GLINK Foreach) $(LPAREN)$(GLINK ForeachType) $(B ;) $(I LwrExpression) $(B ..) $(I UprExpression) $(B $(RPAREN)) $(PSSCOPE)
+)
+LwrExpression_production = $(GRAMMAR
+$(GNAME LwrExpression):
+    $(EXPRESSION)
+)
+UprExpression_production = $(GRAMMAR
+$(GNAME UprExpression):
+    $(EXPRESSION)
+)
+AggregateDeclaration_production = $(GRAMMAR
+$(GNAME AggregateDeclaration):
+	$(B struct) $(I Identifier) $(I StructBody)
+	$(B union) $(I Identifier) $(I StructBody)
+	$(B struct) $(I Identifier) $(B ;)
+	$(B union) $(I Identifier) $(B ;)
+	$(LINK2 template.html#StructTemplateDeclaration, $(I StructTemplateDeclaration))
+	$(LINK2 template.html#UnionTemplateDeclaration, $(I UnionTemplateDeclaration))
+)
+StructBody_production = $(GRAMMAR
+$(GNAME StructBody):
+	$(B {) $(B })
+	$(B {) $(I StructBodyDeclarations) $(B })
+)
+StructBodyDeclarations_production = $(GRAMMAR
+$(GNAME StructBodyDeclarations):
+	$(I StructBodyDeclaration)
+	$(I StructBodyDeclaration) $(I StructBodyDeclarations)
+)
+StructBodyDeclaration_production = $(GRAMMAR
+$(GNAME StructBodyDeclaration):
+	$(I Declaration)
+	$(I StaticConstructor)
+	$(I StaticDestructor)
+	$(I Invariant)
+	$(I UnitTest)
+	$(I StructAllocator)
+	$(I StructDeallocator)
+	$(V2 $(GLINK StructConstructor)
+	$(GLINK StructPostblit)
+	$(GLINK StructDestructor))
+$(V2
+	$(LINK2 class.html#AliasThis, $(I AliasThis))
+)
+)
+StructAllocator_production = $(GRAMMAR
+$(GNAME StructAllocator):
+	$(I ClassAllocator)
+)
+StructDeallocator_production = $(GRAMMAR
+$(GNAME StructDeallocator):
+	$(I ClassDeallocator)
+)
+StructConstructor_production = $(GRAMMAR
+$(GNAME StructConstructor):
+    $(B this( $(I ParameterList) )) $(I FunctionBody)
+)
+StructPostblit_production = $(GRAMMAR
+$(GNAME StructPostblit):
+    $(B this(this)) $(I FunctionBody)
+)
+StructDestructor_production = $(GRAMMAR
+$(GNAME StructDestructor):
+    $(B ~this()) $(I FunctionBody)
+)
+TemplateDeclaration_production = $(GRAMMAR
+$(GNAME TemplateDeclaration):
+	$(B template) $(GLINK TemplateIdentifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt)))
+		$(B {) DeclDefs $(B })
+)
+TemplateIdentifier_production = $(GRAMMAR
+$(GNAME TemplateIdentifier):
+	$(I Identifier)
+)
+TemplateParameterList_production = $(GRAMMAR
+$(GNAME TemplateParameterList):
+	$(I TemplateParameter)
+	$(I TemplateParameter) , $(I TemplateParameterList)
+)
+TemplateParameter_production = $(GRAMMAR
+$(GNAME TemplateParameter):
+	$(GLINK TemplateTypeParameter)
+	$(GLINK TemplateValueParameter)
+	$(GLINK TemplateAliasParameter)
+	$(GLINK TemplateTupleParameter)
+$(V2
+	$(GLINK TemplateThisParameter))
+)
+TemplateInstance_production = $(GRAMMAR
+$(GNAME TemplateInstance):
+	$(GLINK TemplateIdentifier) $(B !$(LPAREN)) $(GLINK TemplateArgumentList) $(B $(RPAREN))
+$(V2
+	$(GLINK TemplateIdentifier) $(B !) $(GLINK TemplateSingleArgument)
+)
+)
+TemplateArgumentList_production = $(GRAMMAR
+$(GNAME TemplateArgumentList):
+	$(GLINK TemplateArgument)
+	$(GLINK TemplateArgument) , $(I TemplateArgumentList)
+)
+TemplateArgument_production = $(GRAMMAR
+$(GNAME TemplateArgument):
+	$(I Type)
+	$(ASSIGNEXPRESSION)
+	$(I Symbol)
+)
+Symbol_production = $(GRAMMAR
+$(GNAME Symbol):
+	$(I SymbolTail)
+	$(B .) $(I SymbolTail)
+)
+SymbolTail_production = $(GRAMMAR
+$(GNAME SymbolTail):
+	$(I Identifier)
+	$(I Identifier) $(B .) $(I SymbolTail)
+	$(GLINK TemplateInstance)
+	$(GLINK TemplateInstance) $(B .) $(I SymbolTail)
+)
+TemplateSingleArgument_production = $(GRAMMAR
+$(GNAME TemplateSingleArgument):
+	$(I Identifier)
+	$(GLINK2 declaration, BasicTypeX)
+	$(GLINK2 lex, CharacterLiteral)
+	$(GLINK2 lex, StringLiteral)
+	$(GLINK2 lex, IntegerLiteral)
+	$(GLINK2 lex, FloatLiteral)
+	$(B true)
+	$(B false)
+	$(B null)
+	$(B __FILE__)
+	$(B __LINE__)
+
+)
+TemplateTypeParameter_production = $(GRAMMAR
+$(GNAME TemplateTypeParameter):
+	$(I Identifier)
+	$(I Identifier) $(I TemplateTypeParameterSpecialization)
+	$(I Identifier) $(I TemplateTypeParameterDefault)
+	$(I Identifier) $(I TemplateTypeParameterSpecialization) $(I TemplateTypeParameterDefault)
+)
+TemplateTypeParameterSpecialization_production = $(GRAMMAR
+$(GNAME TemplateTypeParameterSpecialization):
+	 $(B :) $(I Type)
+)
+TemplateTypeParameterDefault_production = $(GRAMMAR
+$(GNAME TemplateTypeParameterDefault):
+	 $(B =) $(I Type)
+)
+TemplateThisParameter_production = $(GRAMMAR
+$(GNAME TemplateThisParameter):
+	$(B this) $(I TemplateTypeParameter)
+)
+TemplateValueParameter_production = $(GRAMMAR
+$(GNAME TemplateValueParameter):
+    $(I Declaration)
+    $(I Declaration) $(I TemplateValueParameterSpecialization)
+    $(I Declaration) $(I TemplateValueParameterDefault)
+    $(I Declaration) $(I TemplateValueParameterSpecialization) $(I TemplateValueParameterDefault)
+)
+TemplateValueParameterSpecialization_production = $(GRAMMAR
+$(GNAME TemplateValueParameterSpecialization):
+    $(B :) $(LINK2 expression.html#ConditionalExpression, $(I ConditionalExpression))
+)
+TemplateValueParameterDefault_production = $(GRAMMAR
+$(GNAME TemplateValueParameterDefault):
+$(V2
+    $(B = __FILE__)
+    $(B = __LINE__))
+    $(B =) $(LINK2 expression.html#ConditionalExpression, $(I ConditionalExpression))
+)
+TemplateAliasParameter_production = $(GRAMMAR
+$(GNAME TemplateAliasParameter):
+    $(B alias) $(I Identifier) $(I TemplateAliasParameterSpecialization)$(SUB $(I opt)) $(I TemplateAliasParameterDefault)$(SUB $(I opt))
+)
+TemplateAliasParameterSpecialization_production = $(GRAMMAR
+$(GNAME TemplateAliasParameterSpecialization):
+     $(B :) $(I Type)
+)
+TemplateAliasParameterDefault_production = $(GRAMMAR
+$(GNAME TemplateAliasParameterDefault):
+     $(B =) $(I Type)
+)
+TemplateTupleParameter_production = $(GRAMMAR
+$(GNAME TemplateTupleParameter):
+	$(I Identifier) $(B ...)
+)
+ClassTemplateDeclaration_production = $(GRAMMAR
+$(GNAME ClassTemplateDeclaration):
+    $(B class) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(I BaseClassList) $(I ClassBody)
+)
+StructTemplateDeclaration_production = $(GRAMMAR
+$(GNAME StructTemplateDeclaration):
+    $(B struct) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))
+)
+UnionTemplateDeclaration_production = $(GRAMMAR
+$(GNAME UnionTemplateDeclaration):
+    $(B union) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))
+)
+InterfaceTemplateDeclaration_production = $(GRAMMAR
+$(GNAME InterfaceTemplateDeclaration):
+    $(B interface) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 interface.html#BaseInterfaceList, $(I BaseInterfaceList)) $(LINK2 interface.html#InterfaceBody, $(I InterfaceBody))
+)
+ConditionalDeclaration_production = $(GRAMMAR
+$(GNAME ConditionalDeclaration):
+    $(GLINK Condition) $(I CCDeclarationBlock)
+    $(GLINK Condition) $(I CCDeclarationBlock) $(B else) $(I CCDeclarationBlock)
+    $(GLINK Condition) $(B :) $(I Declarations)
+)
+CCDeclarationBlock_production = $(GRAMMAR
+$(GNAME CCDeclarationBlock):
+    $(LINK2 declaration.html#Declaration, $(I Declaration))
+    $(B {) $(I Declarations) $(B })
+    $(B { })
+)
+Declarations_production = $(GRAMMAR
+$(GNAME Declarations):
+    $(LINK2 declaration.html#Declaration, $(I Declaration))
+    $(LINK2 declaration.html#Declaration, $(I Declaration)) $(I Declarations)
+)
+ConditionalStatement_production = $(GRAMMAR
+$(GNAME ConditionalStatement):
+    $(GLINK Condition) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement))
+    $(GLINK Condition) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement)) $(B else) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement))
+)
+Condition_production = $(GRAMMAR
+$(GNAME Condition):
+    $(LINK2 #version, $(I VersionCondition))
+    $(LINK2 #debug, $(I DebugCondition))
+    $(LINK2 #staticif, $(I StaticIfCondition))
+)
+VersionCondition_production = $(GRAMMAR
+$(GNAME VersionCondition):
+	$(B version $(LPAREN)) $(I Integer) $(B $(RPAREN))
+	$(B version $(LPAREN)) $(I Identifier) $(B $(RPAREN))
+$(V2
+	$(B version $(LPAREN)) $(B unittest) $(B $(RPAREN)))
+)
+VersionSpecification_production = $(GRAMMAR
+$(GNAME VersionSpecification):
+    $(B version =) $(I Identifier) $(B ;)
+    $(B version =) $(I Integer) $(B ;)
+)
+DebugCondition_production = $(GRAMMAR
+$(GNAME DebugCondition):
+    $(B debug)
+    $(B debug $(LPAREN)) $(I Integer) $(B $(RPAREN))
+    $(B debug $(LPAREN)) $(I Identifier) $(B $(RPAREN))
+)
+DebugSpecification_production = $(GRAMMAR
+$(GNAME DebugSpecification):
+    $(B debug =) $(I Identifier) $(B ;)
+    $(B debug =) $(I Integer) $(B ;)
+)
+StaticIfCondition_production = $(GRAMMAR
+$(GNAME StaticIfCondition):
+    $(B static if $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN))
+)
+StaticAssert_production = $(GRAMMAR
+$(GNAME StaticAssert):
+    $(B static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN);)
+    $(B static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(B ,) $(ASSIGNEXPRESSION) $(B $(RPAREN);)
+)
+TemplateMixinDeclaration_production = $(GRAMMAR
+$(GNAME TemplateMixinDeclaration):
+	$(V2 $(B mixin)) $(B template) $(TEMPLATEIDENTIFIER) $(B $(LPAREN)) $(TEMPLATEPARAMETERLIST) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt)))
+		$(B {) DeclDefs $(B })
+)
+TemplateMixin_production = $(GRAMMAR
+$(GNAME TemplateMixin):
+	$(B mixin) $(TEMPLATEIDENTIFIER) $(B ;)
+	$(B mixin) $(TEMPLATEIDENTIFIER) $(GLINK MixinIdentifier) $(B ;)
+	$(B mixin) $(TEMPLATEIDENTIFIER) $(B !$(LPAREN)) $(TEMPLATEARGUMENTLIST) $(B $(RPAREN)) $(B ;)
+	$(B mixin) $(TEMPLATEIDENTIFIER) $(B !$(LPAREN)) $(TEMPLATEARGUMENTLIST) $(B $(RPAREN)) $(GLINK MixinIdentifier) $(B ;)
+)
+MixinIdentifier_production = $(GRAMMAR
+$(GNAME MixinIdentifier):
+	$(I Identifier)
+)
+TraitsExpression_production = $(GRAMMAR
+$(GNAME TraitsExpression):
+    $(B __traits) $(B $(LPAREN)) $(I TraitsKeyword) $(B ,) $(I TraitsArguments) $(B $(RPAREN))
+)
+TraitsKeyword_production = $(GRAMMAR
+$(GNAME TraitsKeyword):
+    $(B isAbstractClass)
+    $(B isArithmetic)
+    $(B isAssociativeArray)
+    $(B isFinalClass)
+    $(B isFloating)
+    $(B isIntegral)
+    $(B isScalar)
+    $(B isStaticArray)
+    $(B isUnsigned)
+    $(B isVirtualFunction)
+    $(B isAbstractFunction)
+    $(B isFinalFunction)
+$(V2      $(GBLINK isStaticFunction)
+)    $(GBLINK isRef)
+    $(GBLINK isOut)
+    $(GBLINK isLazy)
+    $(B hasMember)
+$(V2      $(GBLINK identifier)
+)    $(B getMember)
+$(V2      $(GBLINK getOverloads)
+)    $(GBLINK getVirtualFunctions)
+    $(B classInstanceSize)
+    $(GBLINK allMembers)
+    $(GBLINK derivedMembers)
+    $(B isSame)
+    $(B compiles)
+)
+TraitsArguments_production = $(GRAMMAR
+$(GNAME TraitsArguments):
+    $(I TraitsArgument)
+    $(I TraitsArgument) $(B ,) $(I TraitsArguments)
+)
+TraitsArgument_production = $(GRAMMAR
+$(GNAME TraitsArgument):
+    $(I AssignExpression)
+    $(I Type)
+)
+UnitTest_production = $(GRAMMAR
+$(GNAME UnitTest):
+	$(B unittest) $(I FunctionBody)
+)
\ No newline at end of file
Index: interface.dd
===================================================================
--- interface.dd	(revision 1638)
+++ interface.dd	(working copy)
@@ -2,19 +2,10 @@
 
 $(SPEC_S Interfaces,
 
-$(GRAMMAR
-$(GNAME InterfaceDeclaration):
-	$(B interface) $(I Identifier) $(BaseInterfaceList) $(I InterfaceBody)
-	$(LINK2 template.html#InterfaceTemplateDeclaration, $(I InterfaceTemplateDeclaration))
+$(InterfaceDeclaration_production)
+$(BaseInterfaceList_production)
+$(InterfaceBody_production)
 
-$(GNAME BaseInterfaceList):
-	$(I Empty)
-	$(B :) $(LINK2 class.html#InterfaceClasses, $(I InterfaceClasses))
-
-$(GNAME InterfaceBody):
-	$(B {) DeclDefs $(B })
-)
-
 	$(P Interfaces describe a list of functions that a class that inherits
 	from the interface must implement.
 	A class that implements an interface can be converted to a reference
Index: module.dd
===================================================================
--- module.dd	(revision 1638)
+++ module.dd	(working copy)
@@ -2,41 +2,11 @@
 
 $(SPEC_S Modules,
 
-$(GRAMMAR
-$(GNAME Module):
-	$(GLINK ModuleDeclaration) $(GLINK DeclDefs)
-	$(GLINK DeclDefs)
+$(Module_production)
+$(DeclDefs_production)
+$(DeclDef_production)
 
-$(GNAME DeclDefs):
-	$(I DeclDef)
-	$(I DeclDef) $(I DeclDefs)
 
-$(GNAME DeclDef):
-	$(LINK2 attribute.html#AttributeSpecifier, $(I AttributeSpecifier))
-	$(GLINK ImportDeclaration)
-	$(I EnumDeclaration)
-	$(I ClassDeclaration)
-	$(I InterfaceDeclaration)
-	$(I AggregateDeclaration)
-	$(I Declaration)
-	$(I Constructor)
-	$(I Destructor)
-	$(I Invariant)
-	$(I UnitTest)
-	$(I StaticConstructor)
-	$(I StaticDestructor)
-$(V2
-	$(I SharedStaticConstructor)
-	$(I SharedStaticDestructor)
-)	$(LINK2 version.html#ConditionalDeclaration, $(I ConditionalDeclaration))
-	$(LINK2 version.html#StaticAssert, $(I StaticAssert))
-	$(LINK2 template.html#TemplateDeclaration, $(I TemplateDeclaration))
-	$(LINK2 template-mixin.html#TemplateMixin, $(I TemplateMixin))
-	$(GLINK MixinDeclaration)
-	$(B ;)
-)
-
-
 	$(P Modules have a one-to-one correspondence with source files.
 	The module name is the file name with the path and extension
 	stripped off.
@@ -87,25 +57,12 @@
 	same name (stripped of path and extension) of the source file name.
 	)
 
-$(GRAMMAR
-$(GNAME ModuleDeclaration):
-	$(B module) $(I ModuleFullyQualifiedName) $(B ;)
+$(ModuleDeclaration_production)
+$(ModuleFullyQualifiedName_production)
+$(ModuleName_production)
+$(Packages_production)
+$(PackageName_production)
 
-$(GNAME ModuleFullyQualifiedName):
-	$(I ModuleName)
-	$(I Packages) $(B .) $(I ModuleName)
-
-$(GNAME ModuleName):
-	$(I Identifier)
-
-$(GNAME Packages):
-	$(I PackageName)
-	$(I Packages) $(B .) $(I PackageName)
-
-$(GNAME PackageName):
-	$(I Identifier)
-)
-
 	$(P The $(I Identifiers) preceding the rightmost are the $(I Packages)
 	that the module is in. The packages correspond to directory names in
 	the source file path.
@@ -137,35 +94,14 @@
 	by using the $(I ImportDeclaration):
 	)
 
-$(GRAMMAR
-$(GNAME ImportDeclaration):
-	$(B import) $(I ImportList) $(B ;)
-	$(B static import) $(I ImportList) $(B ;)
+$(ImportDeclaration_production)
+$(ImportList_production)
+$(Import_production)
+$(ImportBindings_production)
+$(ImportBindList_production)
+$(ImportBind_production)
+$(ModuleAliasIdentifier_production)
 
-$(GNAME ImportList):
-	$(I Import)
-	$(I ImportBindings)
-	$(I Import) $(B ,) $(I ImportList)
-
-$(GNAME Import):
-	$(I ModuleFullyQualifiedName)
-	$(I ModuleAliasIdentifier) $(B =) $(I ModuleFullyQualifiedName)
-
-$(GNAME ImportBindings):
-	$(I Import) $(B :) $(I ImportBindList)
-
-$(GNAME ImportBindList):
-	$(I ImportBind)
-	$(I ImportBind) $(B ,) $(I ImportBindList)
-
-$(GNAME ImportBind):
-	$(I Identifier)
-	$(I Identifier) = $(I Identifier)
-
-$(GNAME ModuleAliasIdentifier):
-	$(I Identifier)
-)
-
 	$(P There are several forms of the $(I ImportDeclaration),
 	from generalized to fine-grained importing.)
 
@@ -451,10 +387,7 @@
 
 <h2>$(LNAME2 MixinDeclaration, Mixin Declaration)</h2>
 
-$(GRAMMAR
-$(GNAME MixinDeclaration):
-    $(B mixin) $(B $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN)) $(B ;)
-)
+$(MixinDeclaration_production)
 
 	$(P The $(ASSIGNEXPRESSION)
 	must evaluate at compile time
Index: pragma.dd
===================================================================
--- pragma.dd	(revision 1638)
+++ pragma.dd	(working copy)
@@ -2,11 +2,7 @@
 
 $(SPEC_S Pragmas,
 
-$(GRAMMAR
-$(GNAME Pragma):
-    $(B pragma) $(B $(LPAREN)) $(I Identifier) $(B $(RPAREN))
-    $(B pragma) $(B $(LPAREN)) $(I Identifier) $(B ,) $(LINK2 expression.html#ArgumentList, $(I ArgumentList)) $(B $(RPAREN))
-)
+$(Pragma_production)
 
 
 	$(P Pragmas are a way to pass special information to the compiler
Index: statement.dd
===================================================================
--- statement.dd	(revision 1638)
+++ statement.dd	(working copy)
@@ -5,65 +5,15 @@
 C and C++ programmers will find the D statements very familiar, with a few
 interesting additions.
 
-$(GRAMMAR
-$(GNAME Statement):
-    $(B ;)
-    $(GLINK NonEmptyStatement)
-    $(GLINK ScopeBlockStatement)
+$(Statement_production)
+$(NoScopeNonEmptyStatement_production)
+$(NoScopeStatement_production)
+$(NonEmptyOrScopeBlockStatement_production)
+$(NonEmptyStatement_production)
 
-$(GNAME NoScopeNonEmptyStatement):
-    $(GLINK NonEmptyStatement)
-    $(GLINK BlockStatement)
-
-$(GNAME NoScopeStatement):
-    $(B ;)
-    $(GLINK NonEmptyStatement)
-    $(GLINK BlockStatement)
-
-$(GNAME NonEmptyOrScopeBlockStatement):
-    $(GLINK NonEmptyStatement)
-    $(GLINK ScopeBlockStatement)
-
-$(GNAME NonEmptyStatement):
-    $(GLINK LabeledStatement)
-    $(GLINK ExpressionStatement)
-    $(GLINK DeclarationStatement)
-    $(GLINK IfStatement)
-    $(GLINK WhileStatement)
-    $(GLINK DoStatement)
-    $(GLINK ForStatement)
-    $(GLINK ForeachStatement)
-    $(GLINK SwitchStatement)
-$(V2      $(GLINK FinalSwitchStatement)
-)    $(GLINK CaseStatement)
-$(V2      $(GLINK CaseRangeStatement)
-)    $(GLINK DefaultStatement)
-    $(GLINK ContinueStatement)
-    $(GLINK BreakStatement)
-    $(GLINK ReturnStatement)
-    $(GLINK GotoStatement)
-    $(GLINK WithStatement)
-    $(GLINK SynchronizedStatement)
-    $(GLINK TryStatement)
-    $(GLINK ScopeGuardStatement)
-    $(GLINK ThrowStatement)
-$(V1    $(GLINK VolatileStatement)
-)    $(GLINK AsmStatement)
-    $(GLINK PragmaStatement)
-    $(GLINK MixinStatement)
-$(V2      $(GLINK ForeachRangeStatement))
-    $(LINK2 version.html#ConditionalStatement, $(I ConditionalStatement))
-    $(LINK2 version.html#StaticAssert, $(I StaticAssert))
-    $(LINK2 template-mixin.html#TemplateMixin, $(I TemplateMixin))
-)
-
 <h2>$(LNAME2 ScopeStatement, Scope Statements)</h2>
 
-$(GRAMMAR
-$(I ScopeStatement):
-    $(GLINK NonEmptyStatement)
-    $(GLINK BlockStatement)
-)
+$(ScopeStatement_production)
 
 	$(P A new scope for local symbols
 	is introduced for the $(I NonEmptyStatement)
@@ -108,10 +58,7 @@
 
 <h2>$(LNAME2 ScopeBlockStatement, Scope Block Statements)</h2>
 
-$(GRAMMAR
-$(I ScopeBlockStatement):
-    $(GLINK BlockStatement)
-)
+$(ScopeBlockStatement_production)
 
 	$(P A scope block statement introduces a new scope for the
 	$(GLINK BlockStatement).
@@ -123,10 +70,7 @@
 	precedes a statement.
 )
 
-$(GRAMMAR
-$(I LabeledStatement):
-    $(I Identifier) : $(PSSEMI)
-)
+$(LabeledStatement_production)
 
 $(P
 	Any statement can be labeled, including empty statements,
@@ -145,26 +89,16 @@
 
 <h2>$(LNAME2 BlockStatement, Block Statement)</h2>
 
-$(GRAMMAR
-$(I BlockStatement):
-    $(B { })
-    $(B {) $(I StatementList) $(B })
+$(BlockStatement_production)
+$(StatementList_production)
 
-$(GNAME StatementList):
-    $(PSSEMI_PSCURLYSCOPE)
-    $(PSSEMI_PSCURLYSCOPE) $(I StatementList)
-)
-
 $(P
 	A block statement is a sequence of statements enclosed
 	by { }. The statements are executed in lexical order.
 )
 <h2>$(LNAME2 ExpressionStatement, Expression Statement)</h2>
 
-$(GRAMMAR
-$(I ExpressionStatement):
-    $(EXPRESSION) $(B ;)
-)
+$(ExpressionStatement_production)
 
 	The expression is evaluated.
 	<p>
@@ -187,10 +121,7 @@
 
 	Declaration statements declare variables and types.
 
-$(GRAMMAR
-$(I DeclarationStatement):
-    $(I Declaration)
-)
+$(DeclarationStatement_production)
 
 	$(P Some declaration statements:)
 
@@ -204,23 +135,11 @@
 
 	If statements provide simple conditional execution of statements.
 
-$(GRAMMAR
-$(I IfStatement):
-	$(B if $(LPAREN)) $(I IfCondition) $(B $(RPAREN)) $(I ThenStatement)
-	$(B if $(LPAREN)) $(I IfCondition) $(B $(RPAREN)) $(I ThenStatement) $(B else) $(I ElseStatement)
+$(IfStatement_production)
+$(IfCondition_production)
+$(ThenStatement_production)
+$(ElseStatement_production)
 
-$(GNAME IfCondition):
-	$(EXPRESSION)
-	$(B auto) $(I Identifier) $(B =) $(EXPRESSION)
-	$(I Declarator) $(B =) $(EXPRESSION)
-
-$(GNAME ThenStatement):
-	$(PSSCOPE)
-
-$(GNAME ElseStatement):
-	$(PSSCOPE)
-)
-
 	$(EXPRESSION) is evaluated and must have a type that
 	can be converted to a boolean. If it's true the
 	$(I ThenStatement) is transferred to, else the $(I ElseStatement)
@@ -264,10 +183,7 @@
 
 <h2>$(LNAME2 WhileStatement, While Statement)</h2>
 
-$(GRAMMAR
-$(I WhileStatement):
-    $(B while $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
-)
+$(WhileStatement_production)
 
 	While statements implement simple loops.
 
@@ -293,10 +209,7 @@
 
 <h2>$(LNAME2 DoStatement, Do Statement)</h2>
 
-$(GRAMMAR
-$(I DoStatement):
-    $(B do) $(PSSCOPE) $(B  while $(LPAREN)) $(EXPRESSION) $(B $(RPAREN))
-)
+$(DoStatement_production)
 
 	Do while statements implement simple loops.
 
@@ -324,23 +237,11 @@
 	For statements implement loops with initialization,
 	test, and increment clauses.
 
-$(GRAMMAR
-$(I ForStatement):
-	$(B for $(LPAREN))$(I Initialize) $(I Test) $(B ;) $(I Increment)$(B $(RPAREN)) $(PSSCOPE)
+$(ForStatement_production)
+$(Initialize_production)
+$(Test_production)
+$(Increment_production)
 
-$(GNAME Initialize):
-	$(B ;)
-	$(PS0)
-
-$(GNAME Test):
-	$(I empty)
-	$(EXPRESSION)
-
-$(GNAME Increment):
-	$(I empty)
-	$(EXPRESSION)
-)
-
 	$(P $(I Initialize) is executed.
 	$(I Test) is evaluated and must have a type that
 	can be converted to a boolean. If it's true the
@@ -397,28 +298,12 @@
 
 	A foreach statement loops over the contents of an aggregate.
 
-$(GRAMMAR
-$(I ForeachStatement):
-    $(I Foreach) $(B $(LPAREN))$(I ForeachTypeList) $(B ;) $(I Aggregate)$(B $(RPAREN)) $(PS0)
+$(ForeachStatement_production)
+$(Foreach_production)
+$(ForeachTypeList_production)
+$(ForeachType_production)
+$(Aggregate_production)
 
-$(GNAME Foreach):
-    $(B foreach)
-    $(B foreach_reverse)
-
-$(GNAME ForeachTypeList):
-    $(I ForeachType)
-    $(I ForeachType) , $(I ForeachTypeList)
-
-$(GNAME ForeachType):
-    $(B ref) $(I Type) $(I Identifier)
-    $(I Type) $(I Identifier)
-    $(B ref) $(I Identifier)
-    $(I Identifier)
-
-$(GNAME Aggregate):
-    $(EXPRESSION)
-)
-
 $(P
 	$(I Aggregate) is evaluated. It must evaluate to an expression
 	of type static array, dynamic array, associative array,
@@ -802,26 +687,13 @@
 	statements depending on the value of the switch
 	expression.
 
-$(GRAMMAR
-$(I SwitchStatement):
-	$(B switch $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
+$(SwitchStatement_production)
+$(CaseStatement_production)
+$(V2 $(CaseRangeStatement_production)
+$(FirstExp_production)
+$(LastExp_production)
+)$(DefaultStatement_production)
 
-$(GNAME CaseStatement):
-	$(B case) $(LINK2 expression.html#ArgumentList, $(I ArgumentList)) $(B :) $(PSSEMI_PSCURLYSCOPE)
-
-$(V2 $(GNAME CaseRangeStatement):
-	$(B case) $(I FirstExp) $(B : .. case) $(I LastExp) $(B :) $(PSSEMI_PSCURLYSCOPE)
-
-$(I FirstExp):
-	$(I AssignExpression)
-
-$(I LastExp):
-	$(I AssignExpression)
-)
-$(GNAME DefaultStatement):
-	$(B default :) $(PSSEMI_PSCURLYSCOPE)
-)
-
 	$(P $(EXPRESSION) is evaluated. The result type T must be
 	of integral type or $(CODE char[]), $(CODE wchar[]) or $(CODE dchar[]).
 	The result is
@@ -946,10 +818,7 @@
 $(V2
 <h2>$(LNAME2 FinalSwitchStatement, Final Switch Statement)</h2>
 
-$(GRAMMAR
-$(I FinalSwitchStatement):
-	$(B final switch $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
-)
+$(FinalSwitchStatement_production)
 
 	$(P A final switch statement is just like a switch statement,
 	except that:)
@@ -967,11 +836,7 @@
 
 <h2>$(LNAME2 ContinueStatement, Continue Statement)</h2>
 
-$(GRAMMAR
-$(I ContinueStatement):
-    $(B continue;)
-    $(B continue) $(I Identifier) $(B ;)
-)
+$(ContinueStatement_production)
 
 	A continue aborts the current iteration of its enclosing loop
 	statement, and starts the next iteration.
@@ -1006,11 +871,7 @@
 
 <h2>$(LNAME2 BreakStatement, Break Statement)</h2>
 
-$(GRAMMAR
-$(I BreakStatement):
-    $(B break;)
-    $(B break) $(I Identifier) $(B ;)
-)
+$(BreakStatement_production)
 
 	A break exits the enclosing statement.
 
@@ -1042,11 +903,7 @@
 
 <h2>$(LNAME2 ReturnStatement, Return Statement)</h2>
 
-$(GRAMMAR
-$(I ReturnStatement):
-    $(B return;)
-    $(B return) $(EXPRESSION) $(B ;)
-)
+$(ReturnStatement_production)
 
 	A return exits the current function and supplies its return
 	value.
@@ -1097,13 +954,7 @@
 
 <h2>$(LNAME2 GotoStatement, Goto Statement)</h2>
 
-$(GRAMMAR
-$(I GotoStatement):
-    $(B goto) $(I Identifier) $(B ;)
-    $(B goto) $(B default) $(B ;)
-    $(B goto) $(B case) $(B ;)
-    $(B goto) $(B case) $(EXPRESSION) $(B ;)
-)
+$(GotoStatement_production)
 
 	A goto transfers to the statement labeled with
 	$(I Identifier).
@@ -1157,12 +1008,7 @@
 	The with statement is a way to simplify repeated references
 	to the same object.
 
-$(GRAMMAR
-$(I WithStatement):
-	$(B with) $(B $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
-	$(B with) $(B $(LPAREN)) $(LINK2 template.html#Symbol, $(I Symbol)) $(B $(RPAREN)) $(PSSCOPE)
-	$(B with) $(B $(LPAREN)) $(LINK2 template.html#TemplateInstance, $(I TemplateInstance)) $(B $(RPAREN)) $(PSSCOPE)
-)
+$(WithStatement_production)
 
 	where $(EXPRESSION) evaluates to a class reference or struct
 	instance.
@@ -1241,11 +1087,7 @@
 	a mutex to synchronize access among multiple threads.
 	)
 
-$(GRAMMAR
-$(I SynchronizedStatement):
-    $(B synchronized) $(PSSCOPE)
-    $(B synchronized $(LPAREN)) $(EXPRESSION) $(B $(RPAREN)) $(PSSCOPE)
-)
+$(SynchronizedStatement_production)
 
 	$(P Synchronized allows only one thread at a time to execute
 	$(I ScopeStatement) by using a mutex.
@@ -1282,30 +1124,13 @@
 
 	Exception handling is done with the try-catch-finally statement.
 
-$(GRAMMAR
-$(I TryStatement):
-	$(B try) $(PSSCOPE) $(I Catches)
-	$(B try) $(PSSCOPE) $(I Catches) $(I FinallyStatement)
-	$(B try) $(PSSCOPE) $(I FinallyStatement)
+$(TryStatement_production)
+$(Catches_production)
+$(LastCatch_production)
+$(Catch_production)
+$(CatchParameter_production)
+$(FinallyStatement_production)
 
-$(GNAME Catches):
-	$(I LastCatch)
-	$(I Catch)
-	$(I Catch) $(I Catches)
-
-$(GNAME LastCatch):
-	$(B catch) $(PS0)
-
-$(GNAME Catch):
-	$(B catch $(LPAREN)) $(I CatchParameter) $(B $(RPAREN)) $(PS0)
-
-$(GNAME CatchParameter):
-	$(I BasicType) $(I Identifier)
-
-$(GNAME FinallyStatement):
-	$(B finally) $(PS0)
-)
-
 	$(P $(I CatchParameter) declares a variable v of type T, where T is
 	Object
 	or derived from Object. v is initialized by the throw expression if
@@ -1382,10 +1207,7 @@
 
 	Throw an exception.
 
-$(GRAMMAR
-$(I ThrowStatement):
-	$(B throw) $(EXPRESSION) $(B ;)
-)
+$(ThrowStatement_production)
 
 	$(EXPRESSION) is evaluated and must be an Object reference.
 	The Object reference is thrown as an exception.
@@ -1396,12 +1218,7 @@
 
 <h2>$(LNAME2 ScopeGuardStatement, Scope Guard Statement)</h2>
 
-$(GRAMMAR
-$(I ScopeGuardStatement):
-	$(B scope(exit)) $(PSCURLYSCOPE)
-	$(B scope(success)) $(PSCURLYSCOPE)
-	$(B scope(failure)) $(PSCURLYSCOPE)
-)
+$(ScopeGuardStatement_production)
 
 	The $(I ScopeGuardStatement) executes $(PSCURLYSCOPE) at the close
 	of the current scope, rather than at the point where the
@@ -1492,11 +1309,7 @@
 
 	No code motion occurs across volatile statement boundaries.
 
-$(GRAMMAR
-$(I VolatileStatement):
-	$(B volatile) $(PSSEMI_PSCURLYSCOPE)
-	$(B volatile) $(B ;)
-)
+$(VolatileStatement_production)
 
 	$(PSSEMI_PSCURLYSCOPE) is evaluated.
 	Memory writes occurring before the $(PSSEMI_PSCURLYSCOPE) are
@@ -1513,16 +1326,9 @@
 
 	Inline assembler is supported with the asm statement:
 
-$(GRAMMAR
-$(GNAME AsmStatement):
-	$(B asm { })
-	$(B asm {) $(I AsmInstructionList) $(B })
+$(AsmStatement_production)
+$(AsmInstructionList_production)
 
-$(GNAME AsmInstructionList):
-	$(I AsmInstruction) $(B ;)
-	$(I AsmInstruction) $(B ;) $(I AsmInstructionList)
-)
-
 	An asm statement enables the direct use of assembly language
 	instructions. This makes it easy to obtain direct access to special
 	CPU features without resorting to an external assembler. The
@@ -1594,17 +1400,11 @@
 
 <h2>$(LNAME2 PragmaStatement, Pragma Statement)</h2>
 
-$(GRAMMAR
-$(I PragmaStatement):
-    $(LINK2 pragma.html, $(I Pragma)) $(PSSEMI)
-)
+$(PragmaStatement_production)
 
 <h2>$(LNAME2 MixinStatement, Mixin Statement)</h2>
 
-$(GRAMMAR
-$(I MixinStatement):
-    $(B mixin) $(B $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN)) $(B ;)
-)
+$(MixinStatement_production)
 
 	$(P The $(ASSIGNEXPRESSION) must evaluate at compile time
 	to a constant string.
@@ -1642,17 +1442,10 @@
 
 	A foreach range statement loops over the specified range.
 
-$(GRAMMAR
-$(I ForeachRangeStatement):
-    $(GLINK Foreach) $(LPAREN)$(GLINK ForeachType) $(B ;) $(I LwrExpression) $(B ..) $(I UprExpression) $(B $(RPAREN)) $(PSSCOPE)
+$(ForeachRangeStatement_production)
+$(LwrExpression_production)
+$(UprExpression_production)
 
-$(GNAME LwrExpression):
-    $(EXPRESSION)
-
-$(GNAME UprExpression):
-    $(EXPRESSION)
-)
-
 	$(P
 	$(I ForeachType) declares a variable with either an explicit type,
 	or a type inferred from $(I LwrExpression) and $(I UprExpression).
Index: struct.dd
===================================================================
--- struct.dd	(revision 1638)
+++ struct.dd	(working copy)
@@ -350,45 +350,13 @@
 )
 	)
 
-$(GRAMMAR
-$(GNAME AggregateDeclaration):
-	$(B struct) $(I Identifier) $(I StructBody)
-	$(B union) $(I Identifier) $(I StructBody)
-	$(B struct) $(I Identifier) $(B ;)
-	$(B union) $(I Identifier) $(B ;)
-	$(LINK2 template.html#StructTemplateDeclaration, $(I StructTemplateDeclaration))
-	$(LINK2 template.html#UnionTemplateDeclaration, $(I UnionTemplateDeclaration))
+$(AggregateDeclaration_production)
+$(StructBody_production)
+$(StructBodyDeclarations_production)
+$(StructBodyDeclaration_production)
+$(StructAllocator_production)
+$(StructDeallocator_production)
 
-$(GNAME StructBody):
-	$(B {) $(B })
-	$(B {) $(I StructBodyDeclarations) $(B })
-
-$(GNAME StructBodyDeclarations):
-	$(I StructBodyDeclaration)
-	$(I StructBodyDeclaration) $(I StructBodyDeclarations)
-
-$(GNAME StructBodyDeclaration):
-	$(I Declaration)
-	$(I StaticConstructor)
-	$(I StaticDestructor)
-	$(I Invariant)
-	$(I UnitTest)
-	$(I StructAllocator)
-	$(I StructDeallocator)
-	$(V2 $(GLINK StructConstructor)
-	$(GLINK StructPostblit)
-	$(GLINK StructDestructor))
-$(V2
-	$(LINK2 class.html#AliasThis, $(I AliasThis))
-)
-
-$(GNAME StructAllocator):
-	$(I ClassAllocator)
-
-$(GNAME StructDeallocator):
-	$(I ClassDeallocator)
-)
-
 $(P They work like they do in C, with the following exceptions:)
 
 $(UL
@@ -573,10 +541,7 @@
 $(V2
 $(SECTION3 <a name="Struct-Constructor">Struct Constructors</a>,
 
-$(GRAMMAR
-$(GNAME StructConstructor):
-    $(B this( $(I ParameterList) )) $(I FunctionBody)
-)
+$(StructConstructor_production)
 
 	$(P Struct constructors are used to initialize an instance
 	of a struct.
@@ -590,10 +555,7 @@
 $(V2
 $(SECTION3 <a name="StructPostblit">Struct Postblits</a>,
 
-$(GRAMMAR
-$(GNAME StructPostblit):
-    $(B this(this)) $(I FunctionBody)
-)
+$(StructPostblit_production)
 
 	$(P $(I Copy construction) is defined as initializing
 	 a struct instance from another struct of the same type.
@@ -635,10 +597,7 @@
 $(V2
 $(SECTION3 <a name="StructDestructor">Struct Destructors</a>,
 
-$(GRAMMAR
-$(GNAME StructDestructor):
-    $(B ~this()) $(I FunctionBody)
-)
+$(StructDestructor_production)
 
 	$(P Destructors are called when an object goes out of scope.
 	Their purpose is to free up resources owned by the struct
Index: template-mixin.dd
===================================================================
--- template-mixin.dd	(revision 1638)
+++ template-mixin.dd	(working copy)
@@ -6,21 +6,10 @@
 	the body of a $(I TemplateDeclaration) and inserts them
 	into the current context.
 
-$(GRAMMAR
-$(GNAME TemplateMixinDeclaration):
-	$(V2 $(B mixin)) $(B template) $(TEMPLATEIDENTIFIER) $(B $(LPAREN)) $(TEMPLATEPARAMETERLIST) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt)))
-		$(B {) DeclDefs $(B })
+$(TemplateMixinDeclaration_production)
+$(TemplateMixin_production)
+$(MixinIdentifier_production)
 
-$(GNAME TemplateMixin):
-	$(B mixin) $(TEMPLATEIDENTIFIER) $(B ;)
-	$(B mixin) $(TEMPLATEIDENTIFIER) $(GLINK MixinIdentifier) $(B ;)
-	$(B mixin) $(TEMPLATEIDENTIFIER) $(B !$(LPAREN)) $(TEMPLATEARGUMENTLIST) $(B $(RPAREN)) $(B ;)
-	$(B mixin) $(TEMPLATEIDENTIFIER) $(B !$(LPAREN)) $(TEMPLATEARGUMENTLIST) $(B $(RPAREN)) $(GLINK MixinIdentifier) $(B ;)
-
-$(GNAME MixinIdentifier):
-	$(I Identifier)
-)
-
 	$(P A $(I TemplateMixin) can occur in declaration lists of modules,
 	classes, structs, unions, and as a statement.
 	The $(I TemplateIdentifier) refers to a $(I TemplateDeclaration).
Index: template.dd
===================================================================
--- template.dd	(revision 1638)
+++ template.dd	(working copy)
@@ -10,27 +10,11 @@
 	Templates are defined with a $(I TemplateDeclaration):
 )
 
-$(GRAMMAR
-$(GNAME TemplateDeclaration):
-	$(B template) $(GLINK TemplateIdentifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt)))
-		$(B {) DeclDefs $(B })
+$(TemplateDeclaration_production)
+$(TemplateIdentifier_production)
+$(TemplateParameterList_production)
+$(TemplateParameter_production)
 
-$(GNAME TemplateIdentifier):
-	$(I Identifier)
-
-$(GNAME TemplateParameterList):
-	$(I TemplateParameter)
-	$(I TemplateParameter) , $(I TemplateParameterList)
-
-$(GNAME TemplateParameter):
-	$(GLINK TemplateTypeParameter)
-	$(GLINK TemplateValueParameter)
-	$(GLINK TemplateAliasParameter)
-	$(GLINK TemplateTupleParameter)
-$(V2
-	$(GLINK TemplateThisParameter))
-)
-
 $(P	The body of the $(I TemplateDeclaration) must be syntactically correct
 	even if never instantiated. Semantic analysis is not done until
 	instantiated. A template forms its own scope, and the template
@@ -63,48 +47,13 @@
 	Templates are explicitly instantiated with:
 )
 
-$(GRAMMAR
-$(GNAME TemplateInstance):
-	$(GLINK TemplateIdentifier) $(B !$(LPAREN)) $(GLINK TemplateArgumentList) $(B $(RPAREN))
-$(V2
-	$(GLINK TemplateIdentifier) $(B !) $(GLINK TemplateSingleArgument)
-)
+$(TemplateInstance_production)
+$(TemplateArgumentList_production)
+$(TemplateArgument_production)
+$(Symbol_production)
+$(SymbolTail_production)
+$(V2 $(TemplateSingleArgument_production))
 
-$(GNAME TemplateArgumentList):
-	$(GLINK TemplateArgument)
-	$(GLINK TemplateArgument) , $(I TemplateArgumentList)
-
-$(GNAME TemplateArgument):
-	$(I Type)
-	$(ASSIGNEXPRESSION)
-	$(I Symbol)
-
-$(GNAME Symbol):
-	$(I SymbolTail)
-	$(B .) $(I SymbolTail)
-
-$(GNAME SymbolTail):
-	$(I Identifier)
-	$(I Identifier) $(B .) $(I SymbolTail)
-	$(GLINK TemplateInstance)
-	$(GLINK TemplateInstance) $(B .) $(I SymbolTail)
-
-$(V2
-$(GNAME TemplateSingleArgument):
-	$(I Identifier)
-	$(GLINK2 declaration, BasicTypeX)
-	$(GLINK2 lex, CharacterLiteral)
-	$(GLINK2 lex, StringLiteral)
-	$(GLINK2 lex, IntegerLiteral)
-	$(GLINK2 lex, FloatLiteral)
-	$(B true)
-	$(B false)
-	$(B null)
-	$(B __FILE__)
-	$(B __LINE__)
-)
-)
-
 $(P
 	Once instantiated, the declarations inside the template, called
 	the template members, are in the scope
@@ -324,20 +273,10 @@
 
 <h2>Template Type Parameters</h2>
 
-$(GRAMMAR
-$(GNAME TemplateTypeParameter):
-	$(I Identifier)
-	$(I Identifier) $(I TemplateTypeParameterSpecialization)
-	$(I Identifier) $(I TemplateTypeParameterDefault)
-	$(I Identifier) $(I TemplateTypeParameterSpecialization) $(I TemplateTypeParameterDefault)
+$(TemplateTypeParameter_production)
+$(TemplateTypeParameterSpecialization_production)
+$(TemplateTypeParameterDefault_production)
 
-$(GNAME TemplateTypeParameterSpecialization):
-	 $(B :) $(I Type)
-
-$(GNAME TemplateTypeParameterDefault):
-	 $(B =) $(I Type)
-)
-
 <h3>Specialization</h3>
 
 	$(P Templates may be specialized for particular types of arguments
@@ -370,10 +309,7 @@
 $(V2
 <h2>Template This Parameters</h2>
 
-$(GRAMMAR
-$(GNAME TemplateThisParameter):
-	$(B this) $(I TemplateTypeParameter)
-)
+$(TemplateThisParameter_production)
 
 	$(P $(I TemplateThisParameter)s are used in member function templates
 	to pick up the type of the $(I this) reference.
@@ -410,24 +346,11 @@
 
 <h2>Template Value Parameters</h2>
 
-$(GRAMMAR
-$(GNAME TemplateValueParameter):
-    $(I Declaration)
-    $(I Declaration) $(I TemplateValueParameterSpecialization)
-    $(I Declaration) $(I TemplateValueParameterDefault)
-    $(I Declaration) $(I TemplateValueParameterSpecialization) $(I TemplateValueParameterDefault)
+$(TemplateValueParameter_production)
+$(TemplateValueParameterSpecialization_production)
+$(TemplateValueParameterDefault_production)
 
-$(GNAME TemplateValueParameterSpecialization):
-    $(B :) $(LINK2 expression.html#ConditionalExpression, $(I ConditionalExpression))
-
-$(GNAME TemplateValueParameterDefault):
 $(V2
-    $(B = __FILE__)
-    $(B = __LINE__))
-    $(B =) $(LINK2 expression.html#ConditionalExpression, $(I ConditionalExpression))
-)
-
-$(V2
 	$(P The $(CODE __FILE__) and $(CODE __LINE__) expand to the source
 	file name and line number at the point of instantiation.)
 )
@@ -469,17 +392,10 @@
 
 <h2>$(LNAME2 aliasparameters, Template Alias Parameters)</h2>
 
-$(GRAMMAR
-$(GNAME TemplateAliasParameter):
-    $(B alias) $(I Identifier) $(I TemplateAliasParameterSpecialization)$(SUB $(I opt)) $(I TemplateAliasParameterDefault)$(SUB $(I opt))
+$(TemplateAliasParameter_production)
+$(TemplateAliasParameterSpecialization_production)
+$(TemplateAliasParameterDefault_production)
 
-$(GNAME TemplateAliasParameterSpecialization):
-     $(B :) $(I Type)
-
-$(GNAME TemplateAliasParameterDefault):
-     $(B =) $(I Type)
-)
-
 	$(P Alias parameters enable templates to be parameterized with
 	any type of D symbol, including global names, local names, typedef
 	names, module names, template names, and template instance names.
@@ -614,10 +530,7 @@
 
 <h2>$(LNAME2 variadic-templates, Template Tuple Parameters)</h2>
 
-$(GRAMMAR
-$(GNAME TemplateTupleParameter):
-	$(I Identifier) $(B ...)
-)
+$(TemplateTupleParameter_production)
 
 	$(P If the last template parameter in the $(I TemplateParameterList)
 	is declared as a $(I TemplateTupleParameter),
@@ -779,10 +692,7 @@
 
 <h2>Class Templates</h2>
 
-$(GRAMMAR
-$(GNAME ClassTemplateDeclaration):
-    $(B class) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(I BaseClassList) $(I ClassBody)
-)
+$(ClassTemplateDeclaration_production)
 
 	$(P If a template declares exactly one member, and that member is a class
 	with the same name as the template:
@@ -811,17 +721,10 @@
 
 <h2>Struct, Union, and Interface Templates</h2>
 
-$(GRAMMAR
-$(GNAME StructTemplateDeclaration):
-    $(B struct) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))
+$(StructTemplateDeclaration_production)
+$(UnionTemplateDeclaration_production)
+$(InterfaceTemplateDeclaration_production)
 
-$(GNAME UnionTemplateDeclaration):
-    $(B union) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))
-
-$(GNAME InterfaceTemplateDeclaration):
-    $(B interface) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 interface.html#BaseInterfaceList, $(I BaseInterfaceList)) $(LINK2 interface.html#InterfaceBody, $(I InterfaceBody))
-)
-
 	$(P Analogously to class templates, struct, union and interfaces
 	can be transformed into templates by supplying a template parameter list.
 	)
Index: traits.dd
===================================================================
--- traits.dd	(revision 1638)
+++ traits.dd	(working copy)
@@ -11,47 +11,11 @@
 	as required.
 	)
 
-$(GRAMMAR
-$(GNAME TraitsExpression):
-    $(B __traits) $(B $(LPAREN)) $(I TraitsKeyword) $(B ,) $(I TraitsArguments) $(B $(RPAREN))
+$(TraitsExpression_production)
+$(TraitsKeyword_production)
+$(TraitsArguments_production)
+$(TraitsArgument_production)
 
-$(GNAME TraitsKeyword):
-    $(B isAbstractClass)
-    $(B isArithmetic)
-    $(B isAssociativeArray)
-    $(B isFinalClass)
-    $(B isFloating)
-    $(B isIntegral)
-    $(B isScalar)
-    $(B isStaticArray)
-    $(B isUnsigned)
-    $(B isVirtualFunction)
-    $(B isAbstractFunction)
-    $(B isFinalFunction)
-$(V2      $(GBLINK isStaticFunction)
-)    $(GBLINK isRef)
-    $(GBLINK isOut)
-    $(GBLINK isLazy)
-    $(B hasMember)
-$(V2      $(GBLINK identifier)
-)    $(B getMember)
-$(V2      $(GBLINK getOverloads)
-)    $(GBLINK getVirtualFunctions)
-    $(B classInstanceSize)
-    $(GBLINK allMembers)
-    $(GBLINK derivedMembers)
-    $(B isSame)
-    $(B compiles)
-
-$(GNAME TraitsArguments):
-    $(I TraitsArgument)
-    $(I TraitsArgument) $(B ,) $(I TraitsArguments)
-
-$(GNAME TraitsArgument):
-    $(I AssignExpression)
-    $(I Type)
-)
-
 $(H2 isArithmetic)
 
 	$(P If the arguments are all either types that are arithmetic types,
Index: unittest.dd
===================================================================
--- unittest.dd	(revision 1638)
+++ unittest.dd	(working copy)
@@ -2,10 +2,7 @@
 
 $(SPEC_S $(TITLE),
 
-$(GRAMMAR
-$(GNAME UnitTest):
-	$(B unittest) $(I FunctionBody)
-)
+$(UnitTest_production)
 
 	$(P Unit tests are a series of test cases applied to a module to determine
 	if it is working properly. Ideally, unit tests should be run every
Index: version.dd
===================================================================
--- version.dd	(revision 1638)
+++ version.dd	(working copy)
@@ -8,26 +8,11 @@
 	directives $(CODE #if) / $(CODE #else) / $(CODE #endif).)
 	)
 
-$(GRAMMAR
-$(GNAME ConditionalDeclaration):
-    $(GLINK Condition) $(I CCDeclarationBlock)
-    $(GLINK Condition) $(I CCDeclarationBlock) $(B else) $(I CCDeclarationBlock)
-    $(GLINK Condition) $(B :) $(I Declarations)
+$(ConditionalDeclaration_production)
+$(CCDeclarationBlock_production)
+$(Declarations_production)
+$(ConditionalStatement_production)
 
-$(GNAME CCDeclarationBlock):
-    $(LINK2 declaration.html#Declaration, $(I Declaration))
-    $(B {) $(I Declarations) $(B })
-    $(B { })
-
-$(GNAME Declarations):
-    $(LINK2 declaration.html#Declaration, $(I Declaration))
-    $(LINK2 declaration.html#Declaration, $(I Declaration)) $(I Declarations)
-
-$(GNAME ConditionalStatement):
-    $(GLINK Condition) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement))
-    $(GLINK Condition) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement)) $(B else) $(LINK2 statement.html#NoScopeNonEmptyStatement, $(I NoScopeNonEmptyStatement))
-)
-
 	$(P If the $(GLINK Condition) is satisfied, then the following
 	$(I CCDeclarationBlock) or $(I Statement) is compiled in.
 	If it is not satisfied, the $(I CCDeclarationBlock) or $(I Statement)
@@ -55,12 +40,7 @@
 	$(P $(I Condition) comes in the following forms:
 	)
 
-$(GRAMMAR
-$(GNAME Condition):
-    $(LINK2 #version, $(I VersionCondition))
-    $(LINK2 #debug, $(I DebugCondition))
-    $(LINK2 #staticif, $(I StaticIfCondition))
-)
+$(Condition_production)
 
 <h2>$(LNAME2 version, Version Condition)</h2>
 
@@ -68,13 +48,7 @@
 	with a single source file.
 	)
 
-$(GRAMMAR
-$(GNAME VersionCondition):
-	$(B version $(LPAREN)) $(I Integer) $(B $(RPAREN))
-	$(B version $(LPAREN)) $(I Identifier) $(B $(RPAREN))
-$(V2
-	$(B version $(LPAREN)) $(B unittest) $(B $(RPAREN)))
-)
+$(VersionCondition_production)
 
 	$(P The $(I VersionCondition) is satisfied if the $(I Integer)
 	is greater than or equal to the current $(I version level),
@@ -122,11 +96,7 @@
 
 <h3>$(LNAME2 VersionSpecification, Version Specification)</h3>
 
-$(GRAMMAR
-$(GNAME VersionSpecification):
-    $(B version =) $(I Identifier) $(B ;)
-    $(B version =) $(I Integer) $(B ;)
-)
+$(VersionSpecification_production)
 
 	$(P The version specification makes it straightforward to group
 	a set of features under one major version, for example:
@@ -299,12 +269,7 @@
 	with $(CODE #ifdef DEBUG) / $(CODE #endif) pairs.
 	)
 
-$(GRAMMAR
-$(GNAME DebugCondition):
-    $(B debug)
-    $(B debug $(LPAREN)) $(I Integer) $(B $(RPAREN))
-    $(B debug $(LPAREN)) $(I Identifier) $(B $(RPAREN))
-)
+$(DebugCondition_production)
 
 	$(P The $(B debug) condition is satisfied when the $(B -debug) switch is
 	thrown on the compiler.
@@ -331,11 +296,7 @@
 
 <h3>Debug Specification</h3>
 
-$(GRAMMAR
-$(GNAME DebugSpecification):
-    $(B debug =) $(I Identifier) $(B ;)
-    $(B debug =) $(I Integer) $(B ;)
-)
+$(DebugSpecification_production)
 
 	$(P Debug identifiers and levels are set either by the command line switch
 	$(B -debug) or by a $(I DebugSpecification).
@@ -372,10 +333,7 @@
 
 <h2>$(LNAME2 staticif, Static If Condition)</h2>
 
-$(GRAMMAR
-$(GNAME StaticIfCondition):
-    $(B static if $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN))
-)
+$(StaticIfCondition_production)
 
 	$(P $(ASSIGNEXPRESSION) is implicitly converted to a boolean type,
 	and is evaluated at compile time.
@@ -453,11 +411,7 @@
 
 <h2>$(LNAME2 static-assert, $(LNAME2 StaticAssert, Static Assert))</h2>
 
-$(GRAMMAR
-$(GNAME StaticAssert):
-    $(B static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(B $(RPAREN);)
-    $(B static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(B ,) $(ASSIGNEXPRESSION) $(B $(RPAREN);)
-)
+$(StaticAssert_production)
 
 	$(P $(ASSIGNEXPRESSION) is evaluated at compile time, and converted
 	to a boolean value. If the value is true, the static assert
