• jerry quinn <jlquinn optonline.net> Feb 19 2009
• Sergey Gromov <snake.scaly gmail.com> Feb 20 2009

jerry quinn <jlquinn optonline.net> writes:

Sergey Gromov Wrote:

 Thu, 19 Feb 2009 01:30:36 -0500, jerry quinn wrote:
 
 Christopher Wright Wrote:
 
 jerry quinn wrote:
 Hi there,
 
 I'm not sure if I'm missing something, but I'm having trouble seeing that a
simple declaration will parse correctly with the D grammar.
 
 If we take a declaration statment like:
 
 int x = 3;
 
 we have (my best guess):
 
 DeclarationStatement -> Declaration
 Declaration -> Decl
 Decl -> BasicType Declarators ;
 BasicType -> int
 Declarators -> DeclaratorInitializer
 DeclaratorInitializer -> Declarator = Initializer
 Declarator -> BasicType2 Identifier
 BasicType2 -> ????
 
 I'm thinking that BasicType2 is optional here, rather than required as the
grammar shows.  Is that correct?
 
 Thanks
 Jerry


 . Declaration -> Decl
 . Decl -> BasicType Declarators
 . BasicType -> "int"
 . Declarators -> DeclaratorInitializer
 . DeclaratorInitializer -> Declarator "=" Initializer
 We agree up to here.
 
 . Declarator -> Identifier
 Here, you don't need BasicType2, and if you use it, you recurse, so 
 using the rule Declarator -> BasicType2 Declarator here is useless.


 What you describe sounds like what I'd expect.
 
 Maybe I'm missing something.  The grammar shown in
http://www.digitalmars.com/d/2.0/declaration.html has the following rules:
 
 BasicType2:
         *
         [ ]
         [ Expression ]
         [ Expression .. Expression ]
         [ Type ]
         delegate Parameters FunctionAttributesopt
         function Parameters FunctionAttributesopt
 
 Declarator:
         BasicType2 Declarator DeclaratorSuffixesopt
         BasicType2 Identifier DeclaratorSuffixesopt
 
 With this definition, I don't see how you can get Declarator->Identifier.
 
 Jerry


 The grammar works the other way around:
 
 int x = 3 ;
 
 int -> BasicType(int)
 // this is either Decl or Type, need more tokens, expect Declarators,
 // Declarator, or Declarator2
 -----
 x -> Identifier(x)
 // either DeclaratorInitializer (Declarators), Declarator,
 // IdentifierList (not expecting), StructMemberInitializer (not
 // expecting), or PrimaryExpression (not expecting)
 // therefore expecting '=' or DeclaratorSuffixes
 -----
 = -> = // token
 // Identifier(x) = -> definitely DeclaratorInitializer, expecting
 // Initializer, that is , either void, AssignExpression,
 // ArrayInitializer, or StructInitializer


This is incorrect.  We have

 BasicType(int) Identifier(x) '= '

You're suggesting the Identifier begins DeclaratorInitializer, but it must
start with a Declarator.  We don't have one, because Declarator must start with
BasicType2.  This is where I think the bug in the grammar is.  If BasicType2
were optional, then the parse would complete as you showed.

 Finita la comedia.


Unfortunately, not yet fini

Sergey Gromov <snake.scaly gmail.com> writes:

Thu, 19 Feb 2009 20:55:52 -0500, jerry quinn wrote:

 Sergey Gromov Wrote:
 
 Thu, 19 Feb 2009 01:30:36 -0500, jerry quinn wrote:
 
 Christopher Wright Wrote:
 
 jerry quinn wrote:
 Hi there,
 
 I'm not sure if I'm missing something, but I'm having trouble seeing that a
simple declaration will parse correctly with the D grammar.
 
 If we take a declaration statment like:
 
 int x = 3;
 
 we have (my best guess):
 
 DeclarationStatement -> Declaration
 Declaration -> Decl
 Decl -> BasicType Declarators ;
 BasicType -> int
 Declarators -> DeclaratorInitializer
 DeclaratorInitializer -> Declarator = Initializer
 Declarator -> BasicType2 Identifier
 BasicType2 -> ????
 
 I'm thinking that BasicType2 is optional here, rather than required as the
grammar shows.  Is that correct?
 
 Thanks
 Jerry


 . Declaration -> Decl
 . Decl -> BasicType Declarators
 . BasicType -> "int"
 . Declarators -> DeclaratorInitializer
 . DeclaratorInitializer -> Declarator "=" Initializer
 We agree up to here.
 
 . Declarator -> Identifier
 Here, you don't need BasicType2, and if you use it, you recurse, so 
 using the rule Declarator -> BasicType2 Declarator here is useless.


 What you describe sounds like what I'd expect.
 
 Maybe I'm missing something.  The grammar shown in
http://www.digitalmars.com/d/2.0/declaration.html has the following rules:
 
 BasicType2:
         *
         [ ]
         [ Expression ]
         [ Expression .. Expression ]
         [ Type ]
         delegate Parameters FunctionAttributesopt
         function Parameters FunctionAttributesopt
 
 Declarator:
         BasicType2 Declarator DeclaratorSuffixesopt
         BasicType2 Identifier DeclaratorSuffixesopt
 
 With this definition, I don't see how you can get Declarator->Identifier.
 
 Jerry


 The grammar works the other way around:
 
 int x = 3 ;
 
 int -> BasicType(int)
 // this is either Decl or Type, need more tokens, expect Declarators,
 // Declarator, or Declarator2
 -----
 x -> Identifier(x)
 // either DeclaratorInitializer (Declarators), Declarator,
 // IdentifierList (not expecting), StructMemberInitializer (not
 // expecting), or PrimaryExpression (not expecting)
 // therefore expecting '=' or DeclaratorSuffixes
 -----
 = -> = // token
 // Identifier(x) = -> definitely DeclaratorInitializer, expecting
 // Initializer, that is , either void, AssignExpression,
 // ArrayInitializer, or StructInitializer


 This is incorrect.  We have 
 
 BasicType(int) Identifier(x) '= ' 
 
 You're suggesting the Identifier begins DeclaratorInitializer, but it
 must start with a Declarator.  We don't have one, because Declarator
 must start with BasicType2.  This is where I think the bug in the
 grammar is.  If BasicType2 were optional, then the parse would
 complete as you showed.


Yes D2 grammar docs turn out to be wrong.  I was using D1 grammar for my
parsing exercise.  In D1, Declarator can be just Identifier.  Therefore
I was able to reduce the statement correctly.