Increase Menhir's verbosity during the tests.

bench/good/alphaCaml-demos-interactive.exp

+Grammar has 2 nonterminal symbols, among which 1 start symbols.
+Grammar has 6 terminal symbols.
+Grammar has 5 productions.
+nullable(expr) = false
+nullable(declarations) = false
+first(expr) = VAR FAIL CONST
+first(declarations) = VAR
+follow(expr) = PLUS EOF
+follow(declarations) = #
+Built an LR(0) automaton with 11 states.
+The grammar is not SLR(1) -- 1 states have a conflict.
+Built an LR(1) automaton with 11 states.
+One shift/reduce conflict was silently solved.
+2 out of 11 states are represented.
+0 out of 11 symbols keep track of their start position.
+0 out of 11 symbols keep track of their end position.
+6 out of 11 states have a default reduction.
+5 out of 6 productions exploit shiftreduce optimization.
+0 out of 11 states can peek at an error.
+36 functions before inlining, 7 functions after inlining.

bench/good/alphaCaml-demos-mixins.exp

+Grammar has 13 nonterminal symbols, among which 1 start symbols.
+Grammar has 25 terminal symbols.
+Grammar has 31 productions.
+nullable(variables) = true
+nullable(unary_expression) = false
+nullable(toplevel) = false
+nullable(summand_expression) = false
+nullable(record_fields) = true
+nullable(lident_pun) = false
+nullable(fields) = true
+nullable(expression) = false
+nullable(dependencies) = true
+nullable(components) = true
+nullable(bindings) = false
+nullable(binding) = false
+nullable(atomic_expression) = false
+first(variables) = LIDENT
+first(unary_expression) = MIXIN LPAREN LIDENT LCURLY FAKE DELETE CLOSE
+first(toplevel) = MIXIN LPAREN LIDENT LET LCURLY FAKE DELETE CLOSE
+first(summand_expression) = MIXIN LPAREN LIDENT LCURLY FAKE DELETE CLOSE
+first(record_fields) = VAL
+first(lident_pun) = LIDENT
+first(fields) = LIDENT
+first(expression) = MIXIN LPAREN LIDENT LET LCURLY FAKE DELETE CLOSE
+first(dependencies) = LSQUARE
+first(components) = VAL
+first(bindings) = LIDENT
+first(binding) = LIDENT
+first(atomic_expression) = MIXIN LPAREN LIDENT LCURLY
+follow(variables) = RSQUARE LIDENT
+follow(unary_expression) = VAL RPAREN RCURLY PLUS IN EOF END AND
+follow(toplevel) = #
+follow(summand_expression) = VAL RPAREN RCURLY PLUS IN EOF END AND
+follow(record_fields) = VAL RCURLY
+follow(lident_pun) = VAL LSQUARE EQUAL END
+follow(fields) = LIDENT IN
+follow(expression) = VAL RPAREN RCURLY IN EOF END AND
+follow(dependencies) = EQUAL
+follow(components) = VAL END
+follow(bindings) = IN AND
+follow(binding) = IN AND
+follow(atomic_expression) = VAL RPAREN RCURLY PLUS IN EOF END DOT AND
+Built an LR(0) automaton with 68 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 68 states.
+15 out of 68 states are represented.
+0 out of 41 symbols keep track of their start position.
+0 out of 41 symbols keep track of their end position.
+27 out of 68 states have a default reduction.
+18 out of 32 productions exploit shiftreduce optimization.
+0 out of 68 states can peek at an error.
+187 functions before inlining, 26 functions after inlining.

bench/good/alphaCaml-demos-poplmark.exp

+Grammar has 19 nonterminal symbols, among which 1 start symbols.
+Grammar has 22 terminal symbols.
+Grammar has 46 productions.
+nullable(toplevel) = false
+nullable(Type) = false
+nullable(TyBinder) = true
+nullable(TermSeq) = false
+nullable(Term) = false
+nullable(Pattern) = false
+nullable(PathTerm) = false
+nullable(PatFields) = true
+nullable(OType) = true
+nullable(NEPatFields) = false
+nullable(NEFields) = false
+nullable(NEFieldTypes) = false
+nullable(Fields) = true
+nullable(FieldTypes) = true
+nullable(Binder) = false
+nullable(ArrowType) = false
+nullable(AppTerm) = false
+nullable(AType) = false
+nullable(ATerm) = false
+first(toplevel) = UCID LPAREN LET LCURLY LCID LAMBDA EOF
+first(Type) = UCID TTOP LPAREN LCURLY ALL
+first(TyBinder) = LEQ
+first(TermSeq) = LPAREN LET LCURLY LCID LAMBDA
+first(Term) = LPAREN LET LCURLY LCID LAMBDA
+first(Pattern) = USCORE LCURLY LCID
+first(PathTerm) = LPAREN LCURLY LCID
+first(PatFields) = LCID
+first(OType) = LEQ
+first(NEPatFields) = LCID
+first(NEFields) = LCID
+first(NEFieldTypes) = LCID
+first(Fields) = LCID
+first(FieldTypes) = LCID
+first(Binder) = COLON
+first(ArrowType) = UCID TTOP LPAREN LCURLY
+first(AppTerm) = LPAREN LCURLY LCID
+first(AType) = UCID TTOP LPAREN LCURLY
+first(ATerm) = LPAREN LCURLY LCID
+follow(toplevel) = #
+follow(Type) = SEMI RSQUARE RPAREN RCURLY EQ DOT COMMA
+follow(TyBinder) = SEMI
+follow(TermSeq) = RPAREN
+follow(Term) = SEMI RPAREN RCURLY IN COMMA
+follow(Pattern) = RCURLY EQ COMMA
+follow(PathTerm) = SEMI RPAREN RCURLY LSQUARE LPAREN LCURLY LCID IN DOT COMMA
+follow(PatFields) = RCURLY
+follow(OType) = DOT
+follow(NEPatFields) = RCURLY
+follow(NEFields) = RCURLY
+follow(NEFieldTypes) = RCURLY
+follow(Fields) = RCURLY
+follow(FieldTypes) = RCURLY
+follow(Binder) = SEMI
+follow(ArrowType) = SEMI RSQUARE RPAREN RCURLY EQ DOT COMMA
+follow(AppTerm) = SEMI RPAREN RCURLY LSQUARE LPAREN LCURLY LCID IN COMMA
+follow(AType) = SEMI RSQUARE RPAREN RCURLY EQ DOT COMMA ARROW
+follow(ATerm) = SEMI RPAREN RCURLY LSQUARE LPAREN LCURLY LCID IN DOT COMMA
+Built an LR(0) automaton with 97 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 97 states.
+32 out of 97 states are represented.
+0 out of 44 symbols keep track of their start position.
+0 out of 44 symbols keep track of their end position.
+34 out of 97 states have a default reduction.
+24 out of 47 productions exploit shiftreduce optimization.
+0 out of 97 states can peek at an error.
+266 functions before inlining, 45 functions after inlining.

bench/good/alphaCaml.exp

+Grammar has 27 nonterminal symbols, among which 1 start symbols.
+Grammar has 31 terminal symbols.
+Grammar has 84 productions.
+nullable(typevars) = false
+nullable(typevar) = false
+nullable(sorts) = false
+nullable(prologue) = true
+nullable(phrase) = false
+nullable(patsummands) = false
+nullable(patsummand) = false
+nullable(patrhs) = false
+nullable(patmodifier) = false
+nullable(patlfactors) = false
+nullable(patlfactor) = false
+nullable(patfactors) = false
+nullable(patfactor) = false
+nullable(params_and_set_current) = true
+nullable(params) = true
+nullable(optional_semicolon) = true
+nullable(identifier) = false
+nullable(expsummands) = false
+nullable(expsummand) = false
+nullable(exprhs) = false
+nullable(explfactors) = false
+nullable(explfactor) = false
+nullable(expfactors) = false
+nullable(expfactor) = false
+nullable(declarations) = true
+nullable(declaration) = false
+nullable(container) = true
+first(typevars) = QUOTE
+first(typevar) = QUOTE
+first(sorts) = LID
+first(prologue) = OCAML
+first(phrase) = error TYPE SORT OCAML IDENTIFIER EOF CONTAINER
+first(patsummands) = BAR
+first(patsummand) = BAR
+first(patrhs) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LBRACE LANGLE INNER BAR ATOM
+first(patmodifier) = OUTER NEUTRAL INNER
+first(patlfactors) = error LID
+first(patlfactor) = error LID
+first(patfactors) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LANGLE INNER ATOM
+first(patfactor) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LANGLE INNER ATOM
+first(params_and_set_current) = QUOTE LPAREN
+first(params) = QUOTE LPAREN
+first(optional_semicolon) = SEMICOLON
+first(identifier) = UID LID
+first(expsummands) = BAR
+first(expsummand) = BAR
+first(exprhs) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LBRACE LANGLE INNER BAR ATOM
+first(explfactors) = error LID
+first(explfactor) = error LID
+first(expfactors) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LANGLE INNER ATOM
+first(expfactor) = error QUOTE OUTER OCAML NEUTRAL LPAREN LID LANGLE INNER ATOM
+first(declarations) = TYPE SORT IDENTIFIER CONTAINER
+first(declaration) = TYPE SORT IDENTIFIER CONTAINER
+first(container) = UID LID
+follow(typevars) = RPAREN COMMA
+follow(typevar) = RPAREN LID COMMA
+follow(sorts) = RPAREN EQUAL COMMA
+follow(prologue) = TYPE SORT IDENTIFIER EOF CONTAINER
+follow(phrase) = #
+follow(patsummands) = TYPE SORT RANGLE IDENTIFIER EOF CONTAINER BAR
+follow(patsummand) = TYPE SORT RANGLE IDENTIFIER EOF CONTAINER BAR
+follow(patrhs) = TYPE SORT RANGLE IDENTIFIER EOF CONTAINER
+follow(patmodifier) = error QUOTE LPAREN LID
+follow(patlfactors) = error SEMICOLON RBRACE
+follow(patlfactor) = error SEMICOLON RBRACE
+follow(patfactors) = error TYPE STAR SORT RANGLE IDENTIFIER EOF CONTAINER BAR
+follow(patfactor) = error TYPE STAR SORT SEMICOLON RBRACE RANGLE IDENTIFIER EOF CONTAINER BAR
+follow(params_and_set_current) = LID
+follow(params) = LID
+follow(optional_semicolon) = RBRACE
+follow(identifier) = error WITH TYPE STAR SORT SEMICOLON RBRACE RANGLE IDENTIFIER EOF CONTAINER BAR AND
+follow(expsummands) = TYPE SORT IDENTIFIER EOF CONTAINER BAR
+follow(expsummand) = TYPE SORT IDENTIFIER EOF CONTAINER BAR
+follow(exprhs) = TYPE SORT IDENTIFIER EOF CONTAINER
+follow(explfactors) = error SEMICOLON RBRACE
+follow(explfactor) = error SEMICOLON RBRACE
+follow(expfactors) = error TYPE STAR SORT IDENTIFIER EOF CONTAINER BAR
+follow(expfactor) = error TYPE STAR SORT SEMICOLON RBRACE IDENTIFIER EOF CONTAINER BAR
+follow(declarations) = TYPE SORT IDENTIFIER EOF CONTAINER
+follow(declaration) = TYPE SORT IDENTIFIER EOF CONTAINER
+follow(container) = error TYPE STAR SORT SEMICOLON RBRACE RANGLE IDENTIFIER EOF CONTAINER BAR
+Built an LR(0) automaton with 139 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 143 states.
+35 out of 143 states are represented.
+0 out of 61 symbols keep track of their start position.
+0 out of 61 symbols keep track of their end position.
+74 out of 143 states have a default reduction.
+66 out of 85 productions exploit shiftreduce optimization.
+9 out of 143 states can peek at an error.
+404 functions before inlining, 74 functions after inlining.

bench/good/alphaprolog.exp

+Grammar has 34 nonterminal symbols, among which 2 start symbols.
+Grammar has 78 terminal symbols.
+Grammar has 140 productions.
+nullable(vars) = true
+nullable(tyapp) = false
+nullable(ty0s) = true
+nullable(ty0) = false
+nullable(ty) = false
+nullable(sig_decl) = false
+nullable(qv) = false
+nullable(quantifier) = false
+nullable(qual_id) = false
+nullable(qlist) = false
+nullable(prog) = false
+nullable(preterms_brack) = false
+nullable(preterm_brack) = false
+nullable(preterm0) = false
+nullable(preterm) = false
+nullable(parse_input_line) = false
+nullable(parse) = false
+nullable(kind) = false
+nullable(infixr_preterm) = false
+nullable(infixn_preterm) = false
+nullable(infixl_preterm) = false
+nullable(infix_decl) = false
+nullable(goal_decl) = false
+nullable(goal) = false
+nullable(directive) = false
+nullable(decls) = true
+nullable(decl) = false
+nullable(dcg_term) = false
+nullable(dcg_rule) = false
+nullable(constr) = false
+nullable(const) = false
+nullable(comma_tys) = false
+nullable(app_or_qid) = false
+nullable(app) = false
+first(vars) = ID
+first(tyapp) = QUAL_ID ID
+first(ty0s) = UNDERSCORE QUAL_ID LPAREN LBRACK ID
+first(ty0) = UNDERSCORE QUAL_ID LPAREN LBRACK ID
+first(ty) = UNDERSCORE QUAL_ID LPAREN LBRACK ID
+first(sig_decl) = TYPE PRED ID FUNC CNST
+first(qv) = ID
+first(quantifier) = NEW FORALL EXISTS
+first(qual_id) = QUAL_ID ID
+first(qlist) = ID
+first(prog) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(preterms_brack) = UNDERSCORE TRUE QUAL_ID LPAREN LITERAL LBRACK INT ID CUT CHAR
+first(preterm_brack) = UNDERSCORE TRUE QUAL_ID LPAREN LITERAL LBRACK INT ID CUT CHAR
+first(preterm0) = UNDERSCORE TRUE QUAL_ID LPAREN LITERAL LBRACK INT ID CUT CHAR
+first(preterm) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(parse_input_line) = USE UNDERSCORE TYPEQ TRUE TRACE QUIT QUAL_ID OPEN NOT NEW LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FORALL EXISTS EOF CUT CHAR
+first(parse) = USE UNDERSCORE TYPEQ TYPE TRUE TRACE QUIT QUESTION QUAL_ID PRED OPEN NOT NEW NAMESPACE LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FUNC FORALL EXISTS EOF CUT CNST CHAR
+first(kind) = TYPE NAME_TYPE
+first(infixr_preterm) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(infixn_preterm) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(infixl_preterm) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(infix_decl) = INFIXR INFIXN INFIXL
+first(goal_decl) = USE UNDERSCORE TYPEQ TRUE TRACE QUIT QUAL_ID OPEN NOT NEW LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FORALL EXISTS CUT CHAR
+first(goal) = UNDERSCORE TRUE QUAL_ID NOT NEW LPAREN LITERAL LBRACK INT ID FORALL EXISTS CUT CHAR
+first(directive) = USE TYPEQ TRACE QUIT OPEN HELP
+first(decls) = USE UNDERSCORE TYPEQ TYPE TRUE TRACE QUIT QUESTION QUAL_ID PRED OPEN NOT NEW NAMESPACE LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FUNC FORALL EXISTS CUT CNST CHAR
+first(decl) = USE UNDERSCORE TYPEQ TYPE TRUE TRACE QUIT QUESTION QUAL_ID PRED OPEN NOT NEW NAMESPACE LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FUNC FORALL EXISTS CUT CNST CHAR
+first(dcg_term) = QUAL_ID LITERAL LBRACE ID CHAR
+first(dcg_rule) = QUAL_ID ID
+first(constr) = ID
+first(const) = UNDERSCORE TRUE LPAREN LITERAL LBRACK INT CUT CHAR
+first(comma_tys) = UNDERSCORE QUAL_ID LPAREN LBRACK ID
+first(app_or_qid) = QUAL_ID ID
+first(app) = QUAL_ID ID
+follow(vars) = ID EQ
+follow(tyapp) = UNDERSCORE RPAREN RBRACK QUAL_ID LPAREN LBRACK ID DOT COMMA BACKSLASH ARROW
+follow(ty0s) = UNDERSCORE QUAL_ID LPAREN LBRACK ID EQ DOT
+follow(ty0) = UNDERSCORE RPAREN RBRACK QUAL_ID LPAREN LBRACK ID EQ DOT COMMA BACKSLASH ARROW
+follow(ty) = RPAREN RBRACK DOT COMMA BACKSLASH ARROW
+follow(sig_decl) = DOT
+follow(qv) = DOT COMMA
+follow(quantifier) = ID
+follow(qual_id) = UNDERSCORE TRUE SLASH SEMI RPAREN RBRACK RBRACE QUAL_ID LPAREN LITERAL LBRACK LARROW IS INT INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 ID HASH EQ DOT DCG_ARROW DARROW CUT CONS COMMA CHAR BAR BACKSLASH ARROW
+follow(qlist) = DOT COMMA
+follow(prog) = DOT
+follow(preterms_brack) = RBRACK COMMA BAR
+follow(preterm_brack) = RBRACK CONS COMMA BAR
+follow(preterm0) = UNDERSCORE TRUE SLASH SEMI RPAREN RBRACK RBRACE QUAL_ID LPAREN LITERAL LBRACK LARROW IS INT INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 ID HASH EQ DOT DCG_ARROW DARROW CUT CONS COMMA CHAR BAR ARROW
+follow(preterm) = SLASH SEMI RPAREN RBRACE LARROW IS INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 HASH EQ DOT DARROW CONS COMMA BAR ARROW
+follow(parse_input_line) = #
+follow(parse) = #
+follow(kind) = DOT ARROW
+follow(infixr_preterm) = SLASH SEMI RPAREN RBRACE LARROW IS INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 HASH EQ DOT DARROW CONS COMMA BAR ARROW
+follow(infixn_preterm) = SLASH SEMI RPAREN RBRACE LARROW IS INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 HASH EQ DOT DARROW CONS COMMA BAR ARROW
+follow(infixl_preterm) = SLASH SEMI RPAREN RBRACE LARROW IS INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 HASH EQ DOT DARROW CONS COMMA BAR ARROW
+follow(infix_decl) = DOT
+follow(goal_decl) = DOT
+follow(goal) = DOT
+follow(directive) = DOT
+follow(decls) = USE UNDERSCORE TYPEQ TYPE TRUE TRACE RPAREN QUIT QUESTION QUAL_ID PRED OPEN NOT NEW NAMESPACE LPAREN LITERAL LBRACK INT INFIXR INFIXN INFIXL ID HELP FUNC FORALL EXISTS EOF CUT CNST CHAR
+follow(decl) = DOT
+follow(dcg_term) = SLASH SEMI DOT COMMA
+follow(dcg_rule) = DOT
+follow(constr) = SLASH SEMI RPAREN RBRACE LARROW IS INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 HASH EQ DOT DARROW CONS COMMA BAR ARROW
+follow(const) = UNDERSCORE TRUE SLASH SEMI RPAREN RBRACK RBRACE QUAL_ID LPAREN LITERAL LBRACK LARROW IS INT INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 ID HASH EQ DOT DCG_ARROW DARROW CUT CONS COMMA CHAR BAR ARROW
+follow(comma_tys) = RPAREN
+follow(app_or_qid) = SLASH SEMI DOT DCG_ARROW COMMA
+follow(app) = UNDERSCORE TRUE SLASH SEMI RPAREN RBRACK RBRACE QUAL_ID LPAREN LITERAL LBRACK LARROW IS INT INFIXR9 INFIXR8 INFIXR7 INFIXR6 INFIXR5 INFIXR4 INFIXR3 INFIXR2 INFIXR1 INFIXN9 INFIXN8 INFIXN7 INFIXN6 INFIXN5 INFIXN4 INFIXN3 INFIXN2 INFIXN1 INFIXL9 INFIXL8 INFIXL7 INFIXL6 INFIXL5 INFIXL4 INFIXL3 INFIXL2 INFIXL1 ID HASH EQ DOT DCG_ARROW DARROW CUT CONS COMMA CHAR BAR ARROW
+Built an LR(0) automaton with 259 states.
+The grammar is not SLR(1) -- 54 states have a conflict.
+Built an LR(1) automaton with 259 states.
+1418 shift/reduce conflicts were silently solved.
+87 out of 259 states are represented.
+0 out of 116 symbols keep track of their start position.
+0 out of 116 symbols keep track of their end position.
+79 out of 259 states have a default reduction.
+66 out of 142 productions exploit shiftreduce optimization.
+0 out of 259 states can peek at an error.
+701 functions before inlining, 133 functions after inlining.

bench/good/amalthea.exp

+Grammar has 14 nonterminal symbols, among which 1 start symbols.
+Grammar has 17 terminal symbols.
+Grammar has 35 productions.
+nullable(stmttail) = false
+nullable(stmt) = false
+nullable(patom) = false
+nullable(parse_io_module) = false
+nullable(paramlisttail) = true
+nullable(paramlist) = false
+nullable(imports) = true
+nullable(importlist) = true
+nullable(idlist) = true
+nullable(expr) = false
+nullable(export) = true
+nullable(eatom) = false
+nullable(decll) = true
+nullable(atom) = false
+first(stmttail) = Lstring Lsemi Llpar Lint
+first(stmt) = Llambda
+first(patom) = Lstring Llpar Lint Lident
+first(parse_io_module) = Lvariable Lprimitive Llambda Limport Lident Lexport Ldeclare
+first(paramlisttail) = Lstring Lsemi Llpar Llambda Lint Lident
+first(paramlist) = Lstring Lsemi Llpar Llambda Lint Lident
+first(imports) = Limport
+first(importlist) = Lcolon
+first(idlist) = Lident
+first(expr) = Llambda Lident
+first(export) = Lexport
+first(eatom) = Lstring Llpar Llambda Lint Lident
+first(decll) = Lvariable Lprimitive Ldeclare
+first(atom) = Lstring Llpar Lint
+follow(stmttail) = Lrpar Lperiod Lend
+follow(stmt) = Lrpar Lperiod Lend
+follow(patom) = Lstring Lsemi Lrpar Lperiod Llpar Llambda Lint Lident Lend
+follow(parse_io_module) = #
+follow(paramlisttail) = Lrpar Lperiod Lend
+follow(paramlist) = Lrpar Lperiod Lend
+follow(imports) = Lvariable Lprimitive Llambda Lident Lexport Ldeclare
+follow(importlist) = Lperiod
+follow(idlist) = Lstring Lsemi Lperiod Llpar Lint
+follow(expr) = Lrpar Lperiod Lend
+follow(export) = Lvariable Lprimitive Llambda Lident Ldeclare
+follow(eatom) = Lrpar Lperiod Lend
+follow(decll) = Llambda Lident
+follow(atom) = Lstring Lsemi Lrpar Lperiod Llpar Llambda Lint Lident Lend
+Built an LR(0) automaton with 71 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 71 states.
+24 out of 71 states are represented.
+0 out of 34 symbols keep track of their start position.
+0 out of 34 symbols keep track of their end position.
+29 out of 71 states have a default reduction.
+19 out of 36 productions exploit shiftreduce optimization.
+0 out of 71 states can peek at an error.
+198 functions before inlining, 33 functions after inlining.

bench/good/anonymous-nested.exp

 Warning: you are using the standard library and/or the %inline keyword. We
 recommend switching on --infer in order to avoid obscure type error messages.
+Grammar has 3 nonterminal symbols, among which 1 start symbols.
+Grammar has 5 terminal symbols.
+Grammar has 6 productions.
+nullable(phrase) = false
+nullable(foo) = false
+nullable(bar) = false
+first(phrase) = C A
+first(foo) = A
+first(bar) = C
+follow(phrase) = #
+follow(foo) = EOF C A
+follow(bar) = EOF C A
+Built an LR(0) automaton with 16 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 16 states.
+3 out of 16 states are represented.
+0 out of 11 symbols keep track of their start position.
+0 out of 11 symbols keep track of their end position.
+7 out of 16 states have a default reduction.
+7 out of 7 productions exploit shiftreduce optimization.
+0 out of 16 states can peek at an error.
+48 functions before inlining, 6 functions after inlining.

bench/good/anonymous-param-redundant.exp

 Warning: you are using the standard library and/or the %inline keyword. We
 recommend switching on --infer in order to avoid obscure type error messages.
+Grammar has 5 nonterminal symbols, among which 2 start symbols.
+Grammar has 5 terminal symbols.
+Grammar has 9 productions.
+nullable(seplist(A)) = false
+nullable(phrase) = false
+nullable(other) = false
+nullable(list(__anonymous_0(A,B))) = true
+nullable(embedded(__anonymous_1)) = false
+first(seplist(A)) = A
+first(phrase) = C
+first(other) = A
+first(list(__anonymous_0(A,B))) = B A
+first(embedded(__anonymous_1)) = D C
+follow(seplist(A)) = EOF
+follow(phrase) = #
+follow(other) = #
+follow(list(__anonymous_0(A,B))) = EOF D
+follow(embedded(__anonymous_1)) = A
+Built an LR(0) automaton with 20 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 20 states.
+6 out of 20 states are represented.
+0 out of 14 symbols keep track of their start position.
+0 out of 14 symbols keep track of their end position.
+9 out of 20 states have a default reduction.
+6 out of 11 productions exploit shiftreduce optimization.
+0 out of 20 states can peek at an error.
+63 functions before inlining, 13 functions after inlining.

bench/good/anonymous-param.exp

 Warning: you are using the standard library and/or the %inline keyword. We
 recommend switching on --infer in order to avoid obscure type error messages.
+Grammar has 5 nonterminal symbols, among which 1 start symbols.
+Grammar has 5 terminal symbols.
+Grammar has 9 productions.
+nullable(phrase) = false
+nullable(mixed_list(C,D)) = true
+nullable(mixed_list(A,B)) = true
+nullable(list(__anonymous_0(C,D))) = true
+nullable(list(__anonymous_0(A,B))) = true
+first(phrase) = EOF D C B A
+first(mixed_list(C,D)) = D C
+first(mixed_list(A,B)) = B A
+first(list(__anonymous_0(C,D))) = D C
+first(list(__anonymous_0(A,B))) = B A
+follow(phrase) = #
+follow(mixed_list(C,D)) = EOF
+follow(mixed_list(A,B)) = EOF D C
+follow(list(__anonymous_0(C,D))) = EOF
+follow(list(__anonymous_0(A,B))) = EOF D C
+Built an LR(0) automaton with 15 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 15 states.
+6 out of 15 states are represented.
+0 out of 13 symbols keep track of their start position.
+0 out of 13 symbols keep track of their end position.
+8 out of 15 states have a default reduction.
+8 out of 10 productions exploit shiftreduce optimization.
+0 out of 15 states can peek at an error.
+51 functions before inlining, 12 functions after inlining.

bench/good/anonymous.exp

 Warning: you are using the standard library and/or the %inline keyword. We
 recommend switching on --infer in order to avoid obscure type error messages.
+Grammar has 3 nonterminal symbols, among which 1 start symbols.
+Grammar has 5 terminal symbols.
+Grammar has 7 productions.
+nullable(phrase) = false
+nullable(list(__anonymous_1)) = true
+nullable(list(__anonymous_0)) = true
+first(phrase) = EOF D C B A
+first(list(__anonymous_1)) = D
+first(list(__anonymous_0)) = C B A
+follow(phrase) = #
+follow(list(__anonymous_1)) = EOF
+follow(list(__anonymous_0)) = EOF D
+Built an LR(0) automaton with 14 states.
+The grammar is SLR(1).
+Built an LR(1) automaton with 14 states.
+6 out of 14 states are represented.
+0 out of 11 symbols keep track of their start position.
+0 out of 11 symbols keep track of their end position.
+6 out of 14 states have a default reduction.
+2 out of 8 productions exploit shiftreduce optimization.
+0 out of 14 states can peek at an error.
+45 functions before inlining, 12 functions after inlining.

bench/good/atd_parser.exp

+Grammar has 21 nonterminal symbols, among which 1 start symbols.
+Grammar has 24 terminal symbols.
+Grammar has 64 productions.
+nullable(variant_list0) = false
+nullable(variant_list) = false
+nullable(variant) = false
+nullable(type_var_list) = false
+nullable(type_param) = true
+nullable(type_inst) = false
+nullable(type_expr) = false
+nullable(type_args) = true
+nullable(type_arg_list) = false
+nullable(module_item) = false
+nullable(module_body) = false
+nullable(full_module) = false
+nullable(field_name) = false
+nullable(field_list) = false
+nullable(field) = false
+nullable(cartesian_product) = true
+nullable(asection) = false
+nullable(annot_expr) = false
+nullable(annot) = true
+nullable(afield_list) = true
+nullable(afield) = false
+first(variant_list0) = UIDENT INHERIT
+first(variant_list) = UIDENT INHERIT BAR
+first(variant) = UIDENT INHERIT
+first(type_var_list) = TIDENT
+first(type_param) = TIDENT OP_PAREN
+first(type_inst) = TIDENT OP_PAREN OP_CURL OP_BRACK LIDENT
+first(type_expr) = TIDENT OP_PAREN OP_CURL OP_BRACK LIDENT
+first(type_args) = TIDENT OP_PAREN OP_CURL OP_BRACK LIDENT
+first(type_arg_list) = TIDENT OP_PAREN OP_CURL OP_BRACK LIDENT
+first(module_item) = TYPE