ll

问题 I am currently building a parser by hand. It is a LL(1) parser. At the moment, it is a great recognizer: its function parse(List tokens) decides whether or not tokens is a member of the language or not. Now, I want to build the corresponding AST for that input. However, I know how to implement it in a recursive descent way (already did it). That is, for the challenge, I implement my stack using a stack with the classical algorithm: next <- first token of the input stack <- START_SYMBOL do {

问题 Can anyone explain to me how FIRST and FOLLOW should be used in LL(1) grammar? I understand that they are used for syntax table construction, but I don't understand how. 回答1: In an LL(1) parser, the parser works by maintaining a workspace initially seeded to the start symbol followed by the end-of-string marker (usually denoted $). At each step, it does one of the following: If the first symbol of the workspace is a terminal, it matches it against the next token of input (or reports an error

问题 Can anyone explain to me how FIRST and FOLLOW should be used in LL(1) grammar? I understand that they are used for syntax table construction, but I don't understand how. 回答1: In an LL(1) parser, the parser works by maintaining a workspace initially seeded to the start symbol followed by the end-of-string marker (usually denoted $). At each step, it does one of the following: If the first symbol of the workspace is a terminal, it matches it against the next token of input (or reports an error

问题 Closed . This question needs to be more focused. It is not currently accepting answers. Want to improve this question? Update the question so it focuses on one problem only by editing this post. Closed 2 years ago . I need an algorithm to computing FIRST and FOLLOW sets for a grammar. Is there a simple algorithm or simple code for computing these? 回答1: The standard algorithm for computing FIRST and FOLLOW sets is discussed in most compiler textbooks and books on parsing algorithms. I would be

问题 I'm trying to parse a simple language. The trouble comes with parsing function calls. I'm trying to tell it that a function call is an expression followed by left parenthesis, argument list, and right parenthesis. I have something like this: expr = Forward() iden = Word(alphas+'_', alphanums+'_') integer = Word(nums) binop = operatorPrecedence(expr, ...) # irrevelant call = expr + Literal('(') + delimitedList(expr) + Literal(')') expr << call | integer | iden The problem is obvious: expr is

问题 Is it possible to create a LL(1) table-driven (non-recursive) compiler with ANTLR or ANTLR3 ? 回答1: No. However since ANTLR is open source you could modify a fork of ANTLR to do it. ANTLR builds lexers and parsers as recursive descent source code. This is why ANTLR is easy to use and popular because people can look at the source code and understand how the lexer and parser work versus looking at table entries. Because it is source code, one can also use tools to debug the source code. If ANTLR

问题 So I've been trying to write a calculator with Scala's parser, and it's been fun, except that I found that operator associativity is backwards, and that when I try to make my grammar left-recursive, even though it's completely unambiguous, I get a stack overflow. To clarify, if I have a rule like: def subtract: Parser[Int] = num ~ "-" ~ add { x => x._1._1 - x._2 } then evaluating 7 - 4 - 3 comes out to be 6 instead of 0. The way I have actually implemented this is that I am composing a binary

问题 I'm really struggling to unterstand the relationship between: LR(0) LL(0) LALR(1) SLR(1) LR(1) LL(1) I'm pretty sure LALR(1) and SLR(1) are subsets of LR(1), but I'm lost about the others. Are they all exclusive? Is LL(0) a subset of LL(1)? Thanks 回答1: The containment rules are the following: Every LR(0) grammar is also SLR(1), but not all SLR(1) grammars are LR(0). Every SLR(1) grammar is also LALR(1), but not all LALR(1) grammars are SLR(1). Every LALR(1) grammar is also LR(1), but not all

问题 All LL grammars are LR grammars, but not the other way around, but I still struggle to deal with the distinction. I'm curious about small examples, if any exist, of LR grammars which do not have an equivalent LL representation. 回答1: Well, as far as grammars are concerned, its easy -- any simple left-recursive grammar is LR (probably LR(1)) and not LL. So a list grammar like: list ::= list ',' element | element is LR(1) (assuming the production for element is) but not LL. Such grammars can be

问题 I've recently being trying to teach myself how parsers (for languages/context-free grammars) work, and most of it seems to be making sense, except for one thing. I'm focusing my attention in particular on LL(k) grammars , for which the two main algorithms seem to be the LL parser (using stack/parse table) and the Recursive Descent parser (simply using recursion). As far as I can see, the recursive descent algorithm works on all LL(k) grammars and possibly more, whereas an LL parser works on