"Nick Sabalausky" <a...@a.a> wrote in message news:hbblfe$2k4...@digitalmars.com... > "Ellery Newcomer" <ellery-newco...@utulsa.edu> wrote in message > news:hbaom1$138...@digitalmars.com... >> >> Well, let's see here... >> >> PrimExp -> structLiteral >> PrimExp -> functionLiteral >> >> and suppose >> >> structLiteral => { /* really, really looooooooooong expression*/ } >> >> functionLiteral => { statement } >> functionLiteral => { /* really, really looooooooooong expression*/ ; } >> >> In an LL(k) parser, when you get to PrimExp, you have to know which >> choice to make based on the first k lookahead characters (probably >> translates to '{' and one token past that). Obviously, that won't work >> for this piece, so it isn't LL(k). You have to try parsing the one, and >> back up and parse the other if the first one fails (dmd should do this, >> but currently it just looks ahead for the first semicolon. come to think >> of it, I should try patching that..) >> >> ANTLR has pretty good support for backtracking, so writing a D grammar >> for it wasn't too difficult, but then the resultant performance isn't >> anything near what I'd like. >> >> But what I'm wondering about LALR is will it have to back up if it >> chooses wrong, or can it sail on through in one parse attempt. I bet it >> can. > > I'll write up a test in a minute,
No sweat :) ----------------------------------------------------------- "Start Symbol" = <Program> ! ------ Terminals Identifier = {Letter}{AlphaNumeric}* Statement = 'foo' ! ------ Rules <Program> ::= <Prim Exp> | <Program> <Prim Exp> <Prim Exp> ::= <StructLit> | <Func Lit> <StructLit> ::= '{' <Expression> '}' <Func Lit> ::= '{' Statement '}' | '{' <Expression> ';' '}' <Expression> ::= <Expression> '+' <Mult Exp> | <Expression> '-' <Mult Exp> | <Mult Exp> <Mult Exp> ::= <Mult Exp> '*' <Negate Exp> | <Mult Exp> '/' <Negate Exp> | <Negate Exp> <Negate Exp> ::= '-' <Value> | <Value> <Value> ::= Identifier | '(' <Expression> ')' -----------------------------------------------------------