LL(1) parsing

10.2.3 LL(1) parsing

  This subsection defines a function ll1 that takes a grammar and a terminal string as input, and returns one tuple: a parse tree, and the rest of the inputstring that has not been parsed. So ll1 takes a grammar, and returns a parser with Rose s as its result type. As mentioned in the beginning of this section, our parser doesn’t need backtracking anymore, since parsing with an LL(1) grammar is deterministic. Therefore, the parser type is adjusted as follows:

  type Parser b a = [b] -> (a,[b]) Using this parser type, the type of the function ll1 is:

  ll1 :: (Symbol s, Ord s) => CFG s -> Parser s (Rose s)

  LL Parsing

  Function ll1 is defined in terms of two functions. Function isll1 :: CFG s -> Bool is a function that checks whether or not a grammar is LL(1). And function gll1 (for generalised LL(1)) produces a list of rose trees for a list of symbols. ll1 is obtained from gll1 by giving gll1 the singleton list containing the start symbol of the grammar as argument.

  ll1 grammar input =

  if isll1 grammar then let ([rose], rest) = gll1 grammar [start grammar] input

  in (rose, rest) else error "ll1: grammar not LL(1)"

  So now we have to implement functions isll1 and gll1. Function isll1 is imple- mented in the following subsection. Function gll1 also uses two functions. Function grammar2ll1table takes a grammar and returns the LL(1) table: the association list that associates productions with their lookahead sets. And function choose takes a terminal symbol, and chooses a production based on the LL(1) table.

  gll1 :: (Symbol s, Ord s) => CFG s -> [s] -> Parser s [Rose s] gll1 grammar =

  let ll1table = grammar2ll1table grammar

  -- The LL(1) table. nt2prods nt = filter (\((n,l),r) -> n==nt) ll1table

  -- nt2prods returns the productions for nonterminal -- nt from the LL(1) table

  selectprod nt t = choose t (nt2prods nt)

  -- selectprod selects the production for nt from the -- LL(1) table that should be taken when t is the next -- symbol in the input.

  in \stack input ->

  case stack of

  -> ([], input) (s:ss) ->

  if isT s then -- match

  let (rts,rest) = gll1 grammar ss (tail input) in if s == head input

  then (Node s []: rts, rest)

  -- The parse tree is a leaf (a node with -- no children).

  else ([Nil], input)

  -- The input cannot be parsed

  else -- expand

  let t = head input

  (rts,zs) = gll1 grammar (selectprod s t) input

  -- Try to parse according to the production -- obtained from the LL(1) table from s.

  (rrs,vs) = gll1 grammar ss zs

  -- Parse the rest of the symbols on the -- stack.

  10.2 LL Parsing: Implementation

  in ((Node s rts): rrs, vs)

  Functions grammar2ll1table and choose, which are used in the above function gll1, are defined as follows. These functions use function lookaheadp, which returns the lookahead set of a production and is defined in one of the following subsections.

  grammar2ll1table :: (Symbol s, Ord s) => CFG s -> [((s,[s]),[s])] grammar2ll1table grammar =

  map (\x -> (x,lookaheadp grammar x)) (prods grammar) choose

  :: Eq a => a -> [((b,c),[a])] -> c

  choose t l =

  let [((s,rhs), ys)] = filter (\((x,p),q) -> t ‘elem‘ q) l in rhs

  Note that function choose assumes that there is exactly one element in the associ- ation list in which the element t occurs.