# Copyright 2005-2007 Kevin Reid, under the terms of the MIT X license
# found at http://www.opensource.org/licenses/mit-license.html ................

  ? def <parser> := <import:org.cubik.cle.parser.*>; null
  
  ? def makeLALR1Parser := <parser:makeLALR1Parser>
  # value: <makeLALR1Parser>
  
  ? makeLALR1Parser :DeepFrozen
  # value: <makeLALR1Parser>

  ? def s as DeepFrozen {}; def l as DeepFrozen {}; def r as DeepFrozen {}; def id as DeepFrozen {}; def star as DeepFrozen {}; def eq as DeepFrozen {}; null
  
  ? def mapStream := <import:org.cubik.cle.io.mapStream>; null
  
  ? def identityValues as DeepFrozen { to run(s) :any { return [s, s] }}; null
  
  ? def parser := makeLALR1Parser("from cl-yacc test 4-20",
  >                               s,
  >                               [id, star, eq],
  >                               [[s, [l, eq, r]],
  >                                [s, [r]],
  >                                [l, [star, r]],
  >                                [l, [id]],
  >                                [r, [l]]],
  >                               ["tokenFunction" => identityValues])
  # value: <from cl-yacc test 4-20 LALR(1) parser>

  ? parser :DeepFrozen
  # value: <from cl-yacc test 4-20 LALR(1) parser>
  
  ? parser.parse([star, id, eq, star, star, id].asStream())
  # value: [[<star>, [[<id>]]], <eq>, [[<star>, [[<star>, [[<id>]]]]]]]
  
  ? def broken := parser.parse([eq].asStream())
  # value: <ref broken by problem: parse error: expected one of [<id>, <star>], got <eq>>
  
  ? def ParseError := makeLALR1Parser.getParseError()
  > def p :ParseError := Ref.optProblem(broken)
  # value: problem: parse error: expected one of [<id>, <star>], got <eq>
  
  ? [p.getExpected(), p.getFound()]
  # value: [[<id>, <star>].asSet(), <eq>]

EOF parse errors

  ? def broken := makeLALR1Parser("_", 1, [2], [[1, [2]]], ["tokenFunction" => identityValues]).parse([2, 2].asStream())
  # value: <ref broken by problem: parse error: expected one of [null], got 2>

Actions

  ? def parser := makeLALR1Parser("action test",
  >                               "a",
  >                               ["c"],
  >                               [["a", ["b"], 
  >                                   fn x {`[$x]`}],
  >                                ["b", ["c", "c"], 
  >                                   fn x,y {`$x $y`}]],
  >                               ["tokenFunction" => \
  >                                fn s { [s(0,1), s] }])
  # value: <action test LALR(1) parser>

  ? parser.parse(["carrots", "celery"].asStream())
  # value: "[carrots celery]"

quasi-parser

  ? def lalr1__quasiParser := makeLALR1Parser.getLalr1__quasiParser()
  # value: <lalr1__quasiParser>

  ? def parser := lalr1`"quasi-form cl-yacc test 4-20" := s.
  >                     s := l $eq r.
  >                     s := r.
  >                     l := $star r.
  >                     l := $id.
  >                     r := l.`
  # value: <quasi-form cl-yacc test 4-20 quasi-defined LALR(1) parser>

  ? parser :DeepFrozen
  # value: <quasi-form cl-yacc test 4-20 quasi-defined LALR(1) parser>
  
  ? parser.parse(mapStream(any, [star, id, eq, star, star, id].asStream(), identityValues))
  # value: [[<star>, [[<id>]]], <eq>, [[<star>, [[<star>, [[<id>]]]]]]]

  ? def p :ParseError := Ref.optProblem(parser.parse([[eq, eq]].asStream()))
  # value: problem: parse error: expected one of [<id>, <star>], got <eq>

  ? [p.getExpected(), p.getFound()]
  # value: [[<id>, <star>].asSet(), <eq>]

EOF parse errors from quasi-parser

  ? def broken := lalr1`"eoftest" := ${"x"}.`.parse([["x", null], ["x", null]].asStream())
  # value: <ref broken by problem: parse error: expected one of [null], got "x">

bad terminal
  ? lalr1`"_" := ${"x"}.`.parse([["y", null]].asStream())
  # problem: "y" is not a terminal symbol in <_ quasi-defined LALR(1) parser>

quasi-parser with actions

  ? def calls(verb :String) :any { return def caller as DeepFrozen { 
  >   match [=="run", [rec] + args] { 
  >     E.call(rec, verb, args) }}}
  > null

  ? lalr1`"sums" := sum.
  >       sum := ${'1'} => ${calls("getCodepoint")}. 
  >       sum := sum ${'+'} sum => ${def _(l,_,r) :any {return l + r}}.
  >      `.parse(mapStream(any, "1+1+1".asStream(), identityValues))
  # value: 147


Bug: actions were being counted as terminals for the duplicate terminal check

  ? lalr1`"_" := x. x := ${"y"} => ${"y"}.`
  # value: <_ quasi-defined LALR(1) parser>



XXX parse error details
XXX error propagation if the stream fails
XXX eof errors
XXX quasi's behavior if start symbol is undefined