diff git a/src/LRijkstra.ml b/src/LRijkstra.ml
index b481d8637febacbd219ea2147faedc59a8847240..2723633d89cada38643c13e8141f99c36547bdb1 100644
 a/src/LRijkstra.ml
+++ b/src/LRijkstra.ml
@@ 139,7 +139,7 @@ let reductions_on s z : Production.index list =
let has_reduction s z : Production.index option =
assert (Terminal.real z);
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some (prod, _) >
Some prod
 None >
@@ 155,7 +155,7 @@ let has_reduction s z : Production.index option =
reduction). *)
let can_reduce s prod =
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some (prod', _) when prod = prod' >
true
 _ >
@@ 170,7 +170,7 @@ let can_reduce s prod =
let causes_an_error s z : bool =
assert (Terminal.real z);
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some _ >
false
 None >
@@ 189,7 +189,7 @@ let foreach_terminal =
[causes_an_error]. This implementation is significantly more efficient. *)
let foreach_terminal_not_causing_an_error s f =
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some _ >
(* There is a default reduction. No symbol causes an error. *)
foreach_terminal f
@@ 1087,7 +1087,7 @@ let new_fact fact =
[prod, z] such that the [current] state can reduce [prod] on [z]
and [position] accepts [prod]. *)
 match Invariant.has_default_reduction current with
+ match Default.has_default_reduction current with
 Some (prod, _) >
if Trie.accepts prod position then
(* [new_edge] does not accept [any] as its 4th parameter, so we
@@ 1390,4 +1390,3 @@ let () =
(*  *)
end

diff git a/src/codeBackend.ml b/src/codeBackend.ml
index 14950a6b3dbae5d3bd312bdcddf9bdd01ae930ec..79a725801c3d3f94f6a034c1a976e6e6c4c251f9 100644
 a/src/codeBackend.ml
+++ b/src/codeBackend.ml
@@ 369,7 +369,7 @@ let gotopushes : Nonterminal.t > bool =
not (
Lr1.targets (fun accu _ target >
accu &&
 match Invariant.has_default_reduction target with
+ match Default.has_default_reduction target with
 Some (prod, _) >
Production.length prod > 0
 None > false
@@ 440,7 +440,7 @@ let (shiftreduce : Production.index > bool), shiftreducecount =
default reduction. *)
Invariant.fold_reduced (fun s accu >
 accu && (match Invariant.has_default_reduction s with None > false  Some _ > true)
+ accu && (match Default.has_default_reduction s with None > false  Some _ > true)
&& (runpushes s)
) prod true
@@ 474,7 +474,7 @@ let () =
else
Lr1.targets (fun accu _ target >
accu &&
 match Invariant.has_default_reduction target with
+ match Default.has_default_reduction target with
 Some (prod, _) >
shiftreduce prod
 None >
@@ 1059,7 +1059,7 @@ let initiate s =
let rundef s : valdef =
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some (prod, toks) as defred >
(* Perform reduction without looking ahead.
diff git a/src/coqBackend.ml b/src/coqBackend.ml
index 2c17bd4e0a340c547698ea2495d33296a59e9d05..69656fd295806672d062a778501932a969240bb9 100644
 a/src/coqBackend.ml
+++ b/src/coqBackend.ml
@@ 38,7 +38,7 @@ module Run (T: sig end) = struct
 Stretch.Inferred _ > assert false (* We cannot infer coq types *)
let is_final_state node =
 match Invariant.has_default_reduction node with
+ match Default.has_default_reduction node with
 Some (prod, _) > Production.is_start prod
 None > false
@@ 277,7 +277,7 @@ module Run (T: sig end) = struct
fprintf f " match state with\n";
lr1_iter_nonfinal (fun node >
fprintf f "  %s => " (print_st node);
 match Invariant.has_default_reduction node with
+ match Default.has_default_reduction node with
 Some (prod, _) >
fprintf f "Default_reduce_act %s\n" (print_prod prod)
 None >
diff git a/src/default.ml b/src/default.ml
new file mode 100644
index 0000000000000000000000000000000000000000..dc5116e4a0234f5f578f4d0c6a939ef7e44684af
 /dev/null
+++ b/src/default.ml
@@ 0,0 +1,72 @@
+open Grammar
+module C = Conflict (* artificial dependency; ensures that [Conflict] runs first *)
+
+(* Here is how we check whether state [s] should have a default reduction.
+
+ We check whether [s] has no outgoing shift transitions and only has
+ one possible reduction action. In that case, we produce a default
+ reduction action, that is, we perform reduction without consulting
+ the lookahead token. This saves code, but can alter the parser's
+ behavior in the presence of errors.
+
+ The check for default actions subsumes the check for the case where
+ [s] admits a reduce action with lookahead symbol "#". In that case,
+ it must be the only possible action  see
+ [Lr1.default_conflict_resolution]. That is, we have reached a point
+ where we have recognized a wellformed input and are now expecting
+ an endofstream. In that case, performing reduction without
+ looking at the next token is the right thing to do, since there
+ should in fact be none. The state that we reduce to will also have
+ the same property, and so on, so we will in fact end up rewinding
+ the entire stack and accepting the input when the stack becomes
+ empty.
+
+ (New as of 2012/01/23.) A state where a shift/reduce conflict was
+ solved in favor of neither (due to a use of the %nonassoc
+ directive) must not perform a default reduction. Indeed, this would
+ effectively mean that the failure that was requested by the user is
+ forgotten and replaced with a reduction. This surprising behavior
+ is present in ocamlyacc and was present in earlier versions of
+ Menhir. See e.g. http://caml.inria.fr/mantis/view.php?id=5462
+
+ There is a chance that we might run into trouble if the ideas
+ described in the above two paragraphs collide, that is, if we
+ forbid a default reduction (due to a shift/reduce conflict solved
+ by %nonassoc) in a node where we would like to have default
+ reduction on "#". This situation seems unlikely to arise, so I will
+ not do anything about it for the moment. (Furthermore, someone who
+ uses precedence declarations is looking for trouble anyway.)
+
+ Between 2012/05/25 and 2015/09/25, if [canonical] has been specified,
+ then we disallow default reductions on a normal token, because we do not
+ want to introduce any spurious actions into the automaton. We do still
+ allow default reductions on "#", since they are needed for the automaton to
+ terminate properly. From 2015/09/25 on, we again always allow default
+ reductions, as they seem to be beneficial when explaining syntax errors. *)
+
+let has_default_reduction, count =
+ Misc.tabulateo Lr1.number Lr1.fold Lr1.n (fun s >
+
+ if Lr1.forbid_default_reduction s then
+ None
+ else
+
+ let reduction = ProductionMap.is_singleton (Lr1.invert (Lr1.reductions s)) in
+ match reduction with
+  Some _ >
+ if SymbolMap.purelynonterminal (Lr1.transitions s)
+ then reduction
+ else None
+  None >
+ reduction
+
+ )
+
+let () =
+ Error.logC 1 (fun f >
+ Printf.fprintf f
+ "%d out of %d states have a default reduction.\n"
+ count Lr1.n)
+
+let () =
+ Time.tick "Computing default reductions"
diff git a/src/default.mli b/src/default.mli
new file mode 100644
index 0000000000000000000000000000000000000000..72325086c69bb8ef802e95fb3bba1190374ff5b9
 /dev/null
+++ b/src/default.mli
@@ 0,0 +1,6 @@
+open Grammar
+
+(* [has_default_reduction s] tells whether state [s] has a default reduction,
+ and, if so, upon which set of tokens. *)
+
+val has_default_reduction : Lr1.node > (Production.index * TerminalSet.t) option
diff git a/src/interpret.ml b/src/interpret.ml
index b4f6a5559f23390ac4bab83a9a4a5c73958db825..8bd033dcaba616a33764bfb74fb4e43f9a959fde 100644
 a/src/interpret.ml
+++ b/src/interpret.ml
@@ 11,7 +11,8 @@
(* *)
(******************************************************************************)
module I = Invariant (* artificial dependency; ensures that [Invariant] runs first *)
+module I = Invariant (* artificial dependency *)
+module D = Default (* artificial dependency *)
(*  *)
@@ 774,4 +775,3 @@ let () =
exit 0
)

diff git a/src/invariant.ml b/src/invariant.ml
index 395d0f749a06136c5edf2f714d5606d7792a318f..2b52def70c396e37b7c44103a534b70ed1acff81 100644
 a/src/invariant.ml
+++ b/src/invariant.ml
@@ 849,75 +849,6 @@ let errorpeekers =
let errorpeeker node =
Lr1.NodeSet.mem node errorpeekers
(*  *)
(* Here is how we check whether state [s] should have a default
 reduction.

 We check whether [s] has no outgoing shift transitions and only has
 one possible reduction action. In that case, we produce a default
 reduction action, that is, we perform reduction without consulting
 the lookahead token. This saves code, but can alter the parser's
 behavior in the presence of errors.

 The check for default actions subsumes the check for the case where
 [s] admits a reduce action with lookahead symbol "#". In that case,
 it must be the only possible action  see
 [Lr1.default_conflict_resolution]. That is, we have reached a point
 where we have recognized a wellformed input and are now expecting
 an endofstream. In that case, performing reduction without
 looking at the next token is the right thing to do, since there
 should in fact be none. The state that we reduce to will also have
 the same property, and so on, so we will in fact end up rewinding
 the entire stack and accepting the input when the stack becomes
 empty.

 (New as of 2012/01/23.) A state where a shift/reduce conflict was
 solved in favor of neither (due to a use of the %nonassoc
 directive) must not perform a default reduction. Indeed, this would
 effectively mean that the failure that was requested by the user is
 forgotten and replaced with a reduction. This surprising behavior
 is present in ocamlyacc and was present in earlier versions of
 Menhir. See e.g. http://caml.inria.fr/mantis/view.php?id=5462

 There is a chance that we might run into trouble if the ideas
 described in the above two paragraphs collide, that is, if we
 forbid a default reduction (due to a shift/reduce conflict solved
 by %nonassoc) in a node where we would like to have default
 reduction on "#". This situation seems unlikely to arise, so I will
 not do anything about it for the moment. (Furthermore, someone who
 uses precedence declarations is looking for trouble anyway.)

 Between 2012/05/25 and 2015/09/25, if [canonical] has been specified,
 then we disallow default reductions on a normal token, because we do not
 want to introduce any spurious actions into the automaton. We do still
 allow default reductions on "#", since they are needed for the automaton to
 terminate properly. From 2015/09/25 on, we again always allow default
 reductions, as they seem to be beneficial when explaining syntax errors. *)

let (has_default_reduction : Lr1.node > (Production.index * TerminalSet.t) option), hdrcount =
 Misc.tabulateo Lr1.number Lr1.fold Lr1.n (fun s >

 if Lr1.forbid_default_reduction s then
 None
 else

 let reduction = ProductionMap.is_singleton (Lr1.invert (Lr1.reductions s)) in
 match reduction with
  Some _ >
 if SymbolMap.purelynonterminal (Lr1.transitions s)
 then reduction
 else None
  None >
 reduction

 )

let () =
 Error.logC 1 (fun f >
 Printf.fprintf f
 "%d out of %d states have a default reduction.\n"
 hdrcount Lr1.n)

(*  *)
let () =
@@ 925,9 +856,7 @@ let () =
(*  *)
(* If any fatal error was signaled up to this point, stop now. This may include
 errors signaled in the modules [lr1] and [invariant] by calling the function
 [Error.grammar_warning]. *)
+(* If any fatal error was signaled up to this point, stop now. *)
let () =
if Error.errors() then
diff git a/src/invariant.mli b/src/invariant.mli
index e63fd49f7108a35fb36f6d365f7420fc0a40339e..99bbce732e474e8257e94b78f64e4d4a6a6c29e2 100644
 a/src/invariant.mli
+++ b/src/invariant.mli
@@ 129,14 +129,6 @@ val ever_reduced: Production.index > bool
val fold_reduced: (Lr1.node > 'a > 'a) > Production.index > 'a > 'a
(*  *)
(* Information about default reductions. *)

(* [has_default_reduction s] tells whether state [s] has a default reduction,
 and, if so, upon which set of tokens. *)

val has_default_reduction : Lr1.node > (Production.index * TerminalSet.t) option

(*  *)
(* Miscellaneous. *)
diff git a/src/lr1.ml b/src/lr1.ml
index 87ece8a238b80dda06fdbba9ccccfd365552842c..0bc0497a9d7a91fcb42e67d40df36f95c5e58db6 100644
 a/src/lr1.ml
+++ b/src/lr1.ml
@@ 926,8 +926,13 @@ let () =
else if !reduce_reduce > 1 then
Error.grammar_warning [] "%d states have reduce/reduce conflicts." !reduce_reduce
(* There is a global check for errors at the end of [Invariant], so we do
 not need to check & stop here. *)
+(*  *)
+
+(* If any fatal error was signaled up to this point, stop now. *)
+
+let () =
+ if Error.errors() then
+ exit 1
(*  *)
(* When requested by the code generator, apply default conflict
diff git a/src/referenceInterpreter.ml b/src/referenceInterpreter.ml
index e9eba81aa34b2775625fb214259dbe409c9f5111..4e2602533067e7bd5bd0d1ab343d23f26409496a 100644
 a/src/referenceInterpreter.ml
+++ b/src/referenceInterpreter.ml
@@ 61,7 +61,7 @@ module T = struct
let find_production = Production.i2p
let default_reduction (s : state) defred nodefred env =
 match Invariant.has_default_reduction s with
+ match Default.has_default_reduction s with
 Some (prod, _) >
defred env prod
 None >
@@ 79,7 +79,7 @@ module T = struct
[ShiftNoDiscard], depending on the existence of a default
reduction on [#] at [s']. *)
 match Invariant.has_default_reduction s' with
+ match Default.has_default_reduction s' with
 Some (_, toks) when TerminalSet.mem Terminal.sharp toks >
shift env false tok value s'
 _ >
diff git a/src/tableBackend.ml b/src/tableBackend.ml
index 9c295975ec850e115f31388ae1b7ba9363ff4488..24b0b859458002208a9fa6f339a36bf9df7caf77 100644
 a/src/tableBackend.ml
+++ b/src/tableBackend.ml
@@ 488,7 +488,7 @@ let marshal2 name m n (matrix : int list list) =
(* The action table. *)
let action node t =
 match Invariant.has_default_reduction node with
+ match Default.has_default_reduction node with
 Some _ >
(* [node] has a default reduction; in that case, the action
@@ 504,7 +504,7 @@ let action node t =
(* [node] has a transition to [target]. If [target] has a default
reduction on [#], use [ShiftNoDiscard], otherwise [ShiftDiscard]. *)
 match Invariant.has_default_reduction target with
+ match Default.has_default_reduction target with
 Some (_, toks) when TerminalSet.mem Terminal.sharp toks >
assert (TerminalSet.cardinal toks = 1);
encode_ShiftNoDiscard target
@@ 555,7 +555,7 @@ let error node t =
(* The default reductions table. *)
let default_reduction node =
 match Invariant.has_default_reduction node with
+ match Default.has_default_reduction node with
 Some (prod, _) >
encode_DefRed prod
 None >
diff git a/test/good/JSParse.exp b/test/good/JSParse.exp
index 41ceb5eac65fa02441349604d1f3c5d8724075fe..aa46db81c27f70ebbdf38f6ada21ffa79f157a07 100644
 a/test/good/JSParse.exp
+++ b/test/good/JSParse.exp
@@ 427,10 +427,10 @@ The grammar is not SLR(1)  12 states have a conflict.
Built an LR(1) automaton with 660 states.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
+239 out of 660 states have a default reduction.
224 out of 660 states are represented.
0 out of 257 symbols keep track of their start position.
0 out of 257 symbols keep track of their end position.
239 out of 660 states have a default reduction.
188 out of 362 productions exploit shiftreduce optimization.
0 out of 660 states can peek at an error.
1805 functions before inlining, 237 functions after inlining.
diff git a/test/good/K3Parser.exp b/test/good/K3Parser.exp
index 31ae6e49529fbddfc8d119d3321ac9e0f3ae7980..628cd9846b7b83a8dc23f1b48ef9190c8c836b19 100644
 a/test/good/K3Parser.exp
+++ b/test/good/K3Parser.exp
@@ 207,6 +207,7 @@ Warning: 3 states have reduce/reduce conflicts.
Warning: 576 shift/reduce conflicts were arbitrarily resolved.
Warning: 142 reduce/reduce conflicts were arbitrarily resolved.
Warning: 266 states have an endofstream conflict.
+445 out of 1441 states have a default reduction.
File "K3Parser.mly", line 399, characters 04:
Warning: symbol expr is never accepted.
File "K3Parser.mly", line 760, characters 626:
@@ 221,7 +222,6 @@ Warning: in total, 5 productions are never reduced.
639 out of 1441 states are represented.
0 out of 179 symbols keep track of their start position.
0 out of 179 symbols keep track of their end position.
445 out of 1441 states have a default reduction.
220 out of 307 productions exploit shiftreduce optimization.
297 out of 1441 states can peek at an error.
3246 functions before inlining, 579 functions after inlining.
diff git a/test/good/albatross.exp b/test/good/albatross.exp
index a064891ad86fec3b068810c4ad801bdbae0bc83a..16ead2f3625933ab57068c4a2201cbbfcd8c9dac 100644
 a/test/good/albatross.exp
+++ b/test/good/albatross.exp
@@ 337,6 +337,7 @@ Warning: the precedence level assigned to UMINUS is never useful.
File "albatross.mly", line 440, characters 2334:
Warning: this %prec declaration is never useful.
Warning: 117 states have an endofstream conflict.
+166 out of 428 states have a default reduction.
File "albatross.mly", line 202, characters 225:
Warning: production file > use_block optsemi decls is never reduced.
File "albatross.mly", line 203, characters 27:
@@ 347,7 +348,6 @@ Warning: in total, 3 productions are never reduced.
198 out of 428 states are represented.
0 out of 188 symbols keep track of their start position.
0 out of 188 symbols keep track of their end position.
166 out of 428 states have a default reduction.
130 out of 250 productions exploit shiftreduce optimization.
0 out of 428 states can peek at an error.
1201 functions before inlining, 203 functions after inlining.
diff git a/test/good/alphaCamldemosinteractive.exp b/test/good/alphaCamldemosinteractive.exp
index b89103827fb8ae71aeadba0f270dd8fe45ba468c..66a42ab126b63506f510c7dc2716d4fa268af2b4 100644
 a/test/good/alphaCamldemosinteractive.exp
+++ b/test/good/alphaCamldemosinteractive.exp
@@ 11,10 +11,10 @@ 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.
+6 out of 11 states have a default reduction.
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.
diff git a/test/good/alphaCamldemosmixins.exp b/test/good/alphaCamldemosmixins.exp
index 5222afd0682fcdfea354cf2dfadd2fdb5e47895a..0e970c614a4a2fc4b38e5856a06e4280112655c5 100644
 a/test/good/alphaCamldemosmixins.exp
+++ b/test/good/alphaCamldemosmixins.exp
@@ 43,10 +43,10 @@ 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.
+27 out of 68 states have a default reduction.
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.
diff git a/test/good/alphaCamldemospoplmark.exp b/test/good/alphaCamldemospoplmark.exp
index cb148a9194446d1077c50847d210028e7bea6408..e7876522c706d701282eda37207fcf9141760758 100644
 a/test/good/alphaCamldemospoplmark.exp
+++ b/test/good/alphaCamldemospoplmark.exp
@@ 61,10 +61,10 @@ 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.
+34 out of 97 states have a default reduction.
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.
diff git a/test/good/alphaCaml.exp b/test/good/alphaCaml.exp
index dde1adfc69f4fd8096abc63625858abba803f2bf..73fb675be7fd9ac0aca847e32cf7a412ff6652e3 100644
 a/test/good/alphaCaml.exp
+++ b/test/good/alphaCaml.exp
@@ 85,10 +85,10 @@ follow(container) = error TYPE STAR SORT SEMICOLON RBRACE RANGLE IDENTIFIER EOF
Built an LR(0) automaton with 139 states.
The grammar is SLR(1).
Built an LR(1) automaton with 143 states.
+74 out of 143 states have a default reduction.
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.
diff git a/test/good/alphaprolog.exp b/test/good/alphaprolog.exp
index ecc3af5acebecf9636218cb2b64e872d9cd054db..680c498b2c7236ca477cd73eeb036495bcd32f16 100644
 a/test/good/alphaprolog.exp
+++ b/test/good/alphaprolog.exp
@@ 107,10 +107,10 @@ 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.
+79 out of 259 states have a default reduction.
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.
diff git a/test/good/amalthea.exp b/test/good/amalthea.exp
index 9272cfade453ea3694f1647a247f894254344ed6..9f06e72f6ed111bfd0058c0a6fe1d26ec7df7949 100644
 a/test/good/amalthea.exp
+++ b/test/good/amalthea.exp
@@ 46,10 +46,10 @@ 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.
+29 out of 71 states have a default reduction.
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.
diff git a/test/good/anonymousnested.exp b/test/good/anonymousnested.exp
index d9899bfa6ff57d8e6f891a788f0d066e88b47e71..82338ef9b31f810f8e536c97a57a9f0eebfbed8e 100644
 a/test/good/anonymousnested.exp
+++ b/test/good/anonymousnested.exp
@@ 15,10 +15,10 @@ 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.
+7 out of 16 states have a default reduction.
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.
diff git a/test/good/anonymousparamredundant.exp b/test/good/anonymousparamredundant.exp
index 65d4652367bc069521411d6d48f66ca716331735..8dd5fd6f4a0e5545a8cbb3feaac9e3b0e43e8d17 100644
 a/test/good/anonymousparamredundant.exp
+++ b/test/good/anonymousparamredundant.exp
@@ 21,10 +21,10 @@ 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.
+9 out of 20 states have a default reduction.
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.
diff git a/test/good/anonymousparam.exp b/test/good/anonymousparam.exp
index 79ceade774c93f7b4c333cc8c8f4ed3976b5c263..177147127e9a9981cfa193789eb67ca83ee3b696 100644
 a/test/good/anonymousparam.exp
+++ b/test/good/anonymousparam.exp
@@ 21,10 +21,10 @@ 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.
+8 out of 15 states have a default reduction.
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.
diff git a/test/good/anonymous.exp b/test/good/anonymous.exp
index 4b96ecae779a5e18da61299bbf5594decd98ce02..ef58b40425e3b55f3e247694ff56bc84816d4878 100644
 a/test/good/anonymous.exp
+++ b/test/good/anonymous.exp
@@ 15,10 +15,10 @@ 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 have a default reduction.
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.
diff git a/test/good/atd_parser.exp b/test/good/atd_parser.exp
index 46b3bd14b4207a599341d2838b88e760f60238a9..e9027c7a1a4c2fa88e7f134e6077d7a11e379f27 100644
 a/test/good/atd_parser.exp
+++ b/test/good/atd_parser.exp
@@ 67,10 +67,10 @@ follow(afield) = error LIDENT GT
Built an LR(0) automaton with 108 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 146 states.
+60 out of 146 states have a default reduction.
50 out of 146 states are represented.
18 out of 48 symbols keep track of their start position.
21 out of 48 symbols keep track of their end position.
60 out of 146 states have a default reduction.
31 out of 65 productions exploit shiftreduce optimization.
38 out of 146 states can peek at an error.
The generated parser cannot raise Error.
diff git a/test/good/attapldeptypes.exp b/test/good/attapldeptypes.exp
index c31ecb6e21347e4b54af25fb649929126bb7a883..4eb7c5fdcc64cdaafb5f40454f6836958d37c996 100644
 a/test/good/attapldeptypes.exp
+++ b/test/good/attapldeptypes.exp
@@ 103,10 +103,10 @@ The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 111 states.
File "attapldeptypes.mly", line 84, characters 06:
Warning: the precedence level assigned to COMMA is never useful.
+38 out of 111 states have a default reduction.
37 out of 111 states are represented.
0 out of 68 symbols keep track of their start position.
0 out of 68 symbols keep track of their end position.
38 out of 111 states have a default reduction.
24 out of 43 productions exploit shiftreduce optimization.
0 out of 111 states can peek at an error.
286 functions before inlining, 40 functions after inlining.
diff git a/test/good/attaplmini.exp b/test/good/attaplmini.exp
index aa4525d77ae1e531b9af60c8b93e4df3026fc83a..94cb985b3bd10a5463ecf743f112dfd39b43b2d4 100644
 a/test/good/attaplmini.exp
+++ b/test/good/attaplmini.exp
@@ 119,10 +119,10 @@ Built an LR(0) automaton with 128 states.
The grammar is not SLR(1)  6 states have a conflict.
Built an LR(1) automaton with 128 states.
36 shift/reduce conflicts were silently solved.
+51 out of 128 states have a default reduction.
46 out of 128 states are represented.
0 out of 75 symbols keep track of their start position.
0 out of 75 symbols keep track of their end position.
51 out of 128 states have a default reduction.
36 out of 72 productions exploit shiftreduce optimization.
0 out of 128 states can peek at an error.
362 functions before inlining, 57 functions after inlining.
diff git a/test/good/attributesexpansion.exp b/test/good/attributesexpansion.exp
index 13972a9aebd013849e6b384568926fc1ff53a75c..ce034dfa01550d0bc95a9f8fcd08f4d99b44038e 100644
 a/test/good/attributesexpansion.exp
+++ b/test/good/attributesexpansion.exp
@@ 17,13 +17,13 @@ Built an LR(0) automaton with 11 states.
The grammar is SLR(1).
Built an LR(1) automaton with 11 states.
Warning: 8 states have an endofstream conflict.
+5 out of 11 states have a default reduction.
File "attributesexpansion.mly", line 13, characters 11:
Warning: production liste(C) > is never reduced.
Warning: in total, 1 productions are never reduced.
6 out of 11 states are represented.
0 out of 10 symbols keep track of their start position.
0 out of 10 symbols keep track of their end position.
5 out of 11 states have a default reduction.
3 out of 8 productions exploit shiftreduce optimization.
0 out of 11 states can peek at an error.
39 functions before inlining, 11 functions after inlining.
diff git a/test/good/attributes.exp b/test/good/attributes.exp
index 0d650ef6d7ff2b0bb8fdaf07caa91f89c4070c61..b305341f9d40bbe2e83e9d9219aa7999805b315d 100644
 a/test/good/attributes.exp
+++ b/test/good/attributes.exp
@@ 7,10 +7,10 @@ follow(main) = #
Built an LR(0) automaton with 5 states.
The grammar is SLR(1).
Built an LR(1) automaton with 5 states.
+2 out of 5 states have a default reduction.
0 out of 5 states are represented.
0 out of 7 symbols keep track of their start position.
0 out of 7 symbols keep track of their end position.
2 out of 5 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 5 states can peek at an error.
19 functions before inlining, 2 functions after inlining.
diff git a/test/good/bauer.exp b/test/good/bauer.exp
index 01ff1a05013613db508b084cc1f78f883e3ea791..282a115d622e62e92eb7da4883113499b13244ac 100644
 a/test/good/bauer.exp
+++ b/test/good/bauer.exp
@@ 33,10 +33,10 @@ follow(clause) = EOF DOT
Built an LR(0) automaton with 22 states.
The grammar is SLR(1).
Built an LR(1) automaton with 22 states.
+11 out of 22 states have a default reduction.
5 out of 22 states are represented.
0 out of 20 symbols keep track of their start position.
0 out of 20 symbols keep track of their end position.
11 out of 22 states have a default reduction.
10 out of 17 productions exploit shiftreduce optimization.
0 out of 22 states can peek at an error.
76 functions before inlining, 14 functions after inlining.
diff git a/test/good/belloeil.exp b/test/good/belloeil.exp
index 8e80c0f309bd2e22c87c0b9cc2f33cc1ac1f3635..bba493afac7287f6d78f79a143a15686eac91bd3 100644
 a/test/good/belloeil.exp
+++ b/test/good/belloeil.exp
@@ 16,10 +16,10 @@ Built an LR(1) automaton with 14 states.
3 shift/reduce conflicts were silently solved.
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
+7 out of 14 states have a default reduction.
4 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.
7 out of 14 states have a default reduction.
4 out of 8 productions exploit shiftreduce optimization.
0 out of 14 states can peek at an error.
45 functions before inlining, 7 functions after inlining.
diff git a/test/good/bibtex_parser.exp b/test/good/bibtex_parser.exp
index de502d9480d70aa82a55d7e8cddd4fc2aede0785..29bb395adc8d3f72901a4abf52a62b04f8491d82 100644
 a/test/good/bibtex_parser.exp
+++ b/test/good/bibtex_parser.exp
@@ 33,10 +33,10 @@ follow(atom) = Tsharp Trbrace Tcomma
Built an LR(0) automaton with 34 states.
The grammar is SLR(1).
Built an LR(1) automaton with 47 states.
+21 out of 47 states have a default reduction.
11 out of 47 states are represented.
0 out of 25 symbols keep track of their start position.
0 out of 25 symbols keep track of their end position.
21 out of 47 states have a default reduction.
13 out of 21 productions exploit shiftreduce optimization.
0 out of 47 states can peek at an error.
131 functions before inlining, 22 functions after inlining.
diff git a/test/good/bisonmysteriousconflict.exp b/test/good/bisonmysteriousconflict.exp
index df75bbb25c1d2da103accbf9bcaeb9b7a06b5ca4..339a1dda41a63969f212ab11d8f7f0a015e2d8d1 100644
 a/test/good/bisonmysteriousconflict.exp
+++ b/test/good/bisonmysteriousconflict.exp
@@ 22,10 +22,10 @@ follow(def) = #
Built an LR(0) automaton with 19 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 20 states.
+9 out of 20 states have a default reduction.
5 out of 20 states are represented.
0 out of 12 symbols keep track of their start position.
0 out of 12 symbols keep track of their end position.
9 out of 20 states have a default reduction.
6 out of 10 productions exploit shiftreduce optimization.
0 out of 20 states can peek at an error.
62 functions before inlining, 10 functions after inlining.
diff git a/test/good/borismini.exp b/test/good/borismini.exp
index d247dbb38f8b27cced9ee4fcf2ab519ac86a52f3..de30a58c8a93371c4e6462eb7adcb18301479bd8 100644
 a/test/good/borismini.exp
+++ b/test/good/borismini.exp
@@ 18,13 +18,13 @@ Warning: 3 states have reduce/reduce conflicts.
Warning: 5 shift/reduce conflicts were arbitrarily resolved.
Warning: 3 reduce/reduce conflicts were arbitrarily resolved.
Warning: one state has an endofstream conflict.
+3 out of 15 states have a default reduction.
File "borismini.mly", line 38, characters 210:
Warning: production debut > expr DOT is never reduced.
Warning: in total, 1 productions are never reduced.
7 out of 15 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
3 out of 15 states have a default reduction.
2 out of 8 productions exploit shiftreduce optimization.
0 out of 15 states can peek at an error.
46 functions before inlining, 11 functions after inlining.
diff git a/test/good/bran.exp b/test/good/bran.exp
index d9394a88a5e1666527454bbcfcc54002b0f408dd..7660c6f72ca0a146898b3fb254ce354e91031fef 100644
 a/test/good/bran.exp
+++ b/test/good/bran.exp
@@ 239,10 +239,10 @@ Built an LR(0) automaton with 457 states.
The grammar is not SLR(1)  84 states have a conflict.
Built an LR(1) automaton with 697 states.
2098 shift/reduce conflicts were silently solved.
+203 out of 697 states have a default reduction.
373 out of 697 states are represented.
1 out of 158 symbols keep track of their start position.
1 out of 158 symbols keep track of their end position.
203 out of 697 states have a default reduction.
109 out of 234 productions exploit shiftreduce optimization.
188 out of 697 states can peek at an error.
The generated parser cannot raise Error.
diff git a/test/good/c.exp b/test/good/c.exp
index d9ec64780d15efc3916a6fbc0d2f9c790e0a48c6..9a991d34d95c510231454d6b2a6285fe8aee8374 100644
 a/test/good/c.exp
+++ b/test/good/c.exp
@@ 196,13 +196,13 @@ Built an LR(1) automaton with 349 states.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 15 states have an endofstream conflict.
+164 out of 349 states have a default reduction.
File "c.mly", line 404, characters 016:
Warning: symbol translation_unit is never accepted.
Warning: in total, 1 productions are never reduced.
102 out of 349 states are represented.
0 out of 148 symbols keep track of their start position.
0 out of 148 symbols keep track of their end position.
164 out of 349 states have a default reduction.
134 out of 212 productions exploit shiftreduce optimization.
0 out of 349 states can peek at an error.
978 functions before inlining, 152 functions after inlining.
diff git a/test/good/c_unambiguous.exp b/test/good/c_unambiguous.exp
index 4dbf78d8c287711d144d96d2d834d10b68f33db5..1d184d652127c4dba034e482b4fc2e02152fe50c 100644
 a/test/good/c_unambiguous.exp
+++ b/test/good/c_unambiguous.exp
@@ 208,10 +208,10 @@ follow(abstract_declarator) = RPAREN COMMA
Built an LR(0) automaton with 401 states.
The grammar is not SLR(1)  3 states have a conflict.
Built an LR(1) automaton with 401 states.
+178 out of 401 states have a default reduction.
120 out of 401 states are represented.
0 out of 154 symbols keep track of their start position.
0 out of 154 symbols keep track of their end position.
178 out of 401 states have a default reduction.
131 out of 228 productions exploit shiftreduce optimization.
0 out of 401 states can peek at an error.
1104 functions before inlining, 168 functions after inlining.
diff git a/test/good/calcanonymous.exp b/test/good/calcanonymous.exp
index 205491b723b662fc7bc3fad25231b64f565c27ac..e76caccb4c09eb8ccae066b5b32190d010484392 100644
 a/test/good/calcanonymous.exp
+++ b/test/good/calcanonymous.exp
@@ 13,10 +13,10 @@ Built an LR(0) automaton with 18 states.
The grammar is not SLR(1)  5 states have a conflict.
Built an LR(1) automaton with 18 states.
20 shift/reduce conflicts were silently solved.
+7 out of 18 states have a default reduction.
7 out of 18 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.
7 out of 18 states have a default reduction.
4 out of 9 productions exploit shiftreduce optimization.
0 out of 18 states can peek at an error.
53 functions before inlining, 11 functions after inlining.
diff git a/test/good/calclocations.exp b/test/good/calclocations.exp
index 0a5c55a6d065bfe61dc17d10cda9f346b3f14d1a..76c4438d454ee412d98838372b5ff36b241f4dce 100644
 a/test/good/calclocations.exp
+++ b/test/good/calclocations.exp
@@ 11,10 +11,10 @@ Built an LR(0) automaton with 18 states.
The grammar is not SLR(1)  5 states have a conflict.
Built an LR(1) automaton with 18 states.
20 shift/reduce conflicts were silently solved.
+7 out of 18 states have a default reduction.
7 out of 18 states are represented.
4 out of 13 symbols keep track of their start position.
3 out of 13 symbols keep track of their end position.
7 out of 18 states have a default reduction.
4 out of 9 productions exploit shiftreduce optimization.
0 out of 18 states can peek at an error.
53 functions before inlining, 11 functions after inlining.
diff git a/test/good/calc.exp b/test/good/calc.exp
index afa275531b6fbc4d42e1211b892ff6ac27c137d4..a968d9e6da0d4f976e5d95f04931857dc6152288 100644
 a/test/good/calc.exp
+++ b/test/good/calc.exp
@@ 11,10 +11,10 @@ Built an LR(0) automaton with 18 states.
The grammar is not SLR(1)  5 states have a conflict.
Built an LR(1) automaton with 18 states.
20 shift/reduce conflicts were silently solved.
+7 out of 18 states have a default reduction.
7 out of 18 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.
7 out of 18 states have a default reduction.
4 out of 9 productions exploit shiftreduce optimization.
0 out of 18 states can peek at an error.
53 functions before inlining, 11 functions after inlining.
diff git a/test/good/christian.exp b/test/good/christian.exp
index 355b5b24c8d99e45ce0de32563c2bd4affd17845..f9799aa1f514af61dabcff0287e5efd12074dccf 100644
 a/test/good/christian.exp
+++ b/test/good/christian.exp
@@ 865,6 +865,7 @@ Warning: 46 states have shift/reduce conflicts.
Warning: 48 states have reduce/reduce conflicts.
Warning: 554 shift/reduce conflicts were arbitrarily resolved.
Warning: 520 reduce/reduce conflicts were arbitrarily resolved.
+444 out of 858 states have a default reduction.
File "christian.mly", line 1072, characters 215:
Warning: production embeddedPDVValue > sequenceValue is never reduced.
File "christian.mly", line 699, characters 27:
@@ 925,7 +926,6 @@ Warning: in total, 28 productions are never reduced.
214 out of 858 states are represented.
0 out of 401 symbols keep track of their start position.
0 out of 401 symbols keep track of their end position.
444 out of 858 states have a default reduction.
375 out of 587 productions exploit shiftreduce optimization.
0 out of 858 states can peek at an error.
2566 functions before inlining, 337 functions after inlining.
diff git a/test/good/cigencparser.exp b/test/good/cigencparser.exp
index 39588c89ebe76fbe8376db5c9e3f9f4c97461ccf..27be970f4f44341278856798825bf7a4c8f6454a 100644
 a/test/good/cigencparser.exp
+++ b/test/good/cigencparser.exp
@@ 201,10 +201,10 @@ follow(abstract_declarator) = KW_cparen KW_comma
Built an LR(0) automaton with 134 states.
The grammar is SLR(1).
Built an LR(1) automaton with 134 states.
+68 out of 134 states have a default reduction.
30 out of 134 states are represented.
0 out of 123 symbols keep track of their start position.
0 out of 123 symbols keep track of their end position.
68 out of 134 states have a default reduction.
54 out of 92 productions exploit shiftreduce optimization.
0 out of 134 states can peek at an error.
394 functions before inlining, 60 functions after inlining.
diff git a/test/good/cilcparser.exp b/test/good/cilcparser.exp
index 2b9c9dddaad8a54dac00271a2d06939047256b81..19599a9233e0a3891987d02783171e9454f453f4 100644
 a/test/good/cilcparser.exp
+++ b/test/good/cilcparser.exp
@@ 461,6 +461,7 @@ Warning: the precedence level assigned to VOLATILE is never useful.
File "cilcparser.mly", line 345, characters 5661:
Warning: this %prec declaration is never useful.
Warning: 20 states have an endofstream conflict.
+386 out of 1027 states have a default reduction.
File "cilcparser.mly", line 1027, characters 249:
Warning: production direct_old_proto_decl > direct_decl LPAREN RPAREN is never reduced.
File "cilcparser.mly", line 1149, characters 242:
@@ 471,7 +472,6 @@ Warning: in total, 3 productions are never reduced.
360 out of 1027 states are represented.
0 out of 237 symbols keep track of their start position.
0 out of 237 symbols keep track of their end position.
386 out of 1027 states have a default reduction.
196 out of 394 productions exploit shiftreduce optimization.
91 out of 1027 states can peek at an error.
2568 functions before inlining, 527 functions after inlining.
diff git a/test/good/cilformatparse.exp b/test/good/cilformatparse.exp
index a3ed96a2754c7b4019e9cb95ec5ab029209d217e..6bf32ada14eccb2484c9c2853537e1d42f772051 100644
 a/test/good/cilformatparse.exp
+++ b/test/good/cilformatparse.exp
@@ 226,6 +226,7 @@ Warning: this %prec declaration is never useful.
File "cilformatparse.mly", line 596, characters 2833:
Warning: this %prec declaration is never useful.
Warning: 117 states have an endofstream conflict.
+104 out of 302 states have a default reduction.
File "cilformatparse.mly", line 345, characters 010:
Warning: symbol expression is never accepted.
File "cilformatparse.mly", line 585, characters 04:
@@ 234,7 +235,6 @@ Warning: in total, 2 productions are never reduced.
100 out of 302 states are represented.
0 out of 166 symbols keep track of their start position.
0 out of 166 symbols keep track of their end position.
104 out of 302 states have a default reduction.
84 out of 148 productions exploit shiftreduce optimization.
0 out of 302 states can peek at an error.
790 functions before inlining, 135 functions after inlining.
diff git a/test/good/cimecoq.exp b/test/good/cimecoq.exp
index db0fcd64f98ada04563f8025308e648099442a01..36d20021160a304428dc0aeb69be9f4e658c8e20 100644
 a/test/good/cimecoq.exp
+++ b/test/good/cimecoq.exp
@@ 49,10 +49,10 @@ follow(comment) = SORT LEFT_PAR IDENT #
Built an LR(0) automaton with 72 states.
The grammar is SLR(1).
Built an LR(1) automaton with 77 states.
+31 out of 77 states have a default reduction.
28 out of 77 states are represented.
0 out of 37 symbols keep track of their start position.
0 out of 37 symbols keep track of their end position.
31 out of 77 states have a default reduction.
14 out of 34 productions exploit shiftreduce optimization.
0 out of 77 states can peek at an error.
211 functions before inlining, 37 functions after inlining.
diff git a/test/good/cimegenpoly.exp b/test/good/cimegenpoly.exp
index 2d93deee4eab97614f6539414813a1245a9caf8e..9fa0dc3f60586a622de66e7df528ab601dcbc24b 100644
 a/test/good/cimegenpoly.exp
+++ b/test/good/cimegenpoly.exp
@@ 26,10 +26,10 @@ Built an LR(0) automaton with 50 states.
The grammar is not SLR(1)  8 states have a conflict.
Built an LR(1) automaton with 50 states.
32 shift/reduce conflicts were silently solved.
+16 out of 50 states have a default reduction.
16 out of 50 states are represented.
0 out of 24 symbols keep track of their start position.
0 out of 24 symbols keep track of their end position.
16 out of 50 states have a default reduction.
15 out of 26 productions exploit shiftreduce optimization.
0 out of 50 states can peek at an error.
140 functions before inlining, 30 functions after inlining.
diff git a/test/good/cimeparameterizedsignatures.exp b/test/good/cimeparameterizedsignatures.exp
index 08ed93a3212d6acb966103c6bf2844f547cf9c53..10905b19248a0ce8cb749a2f8dec3c4b18e24d1b 100644
 a/test/good/cimeparameterizedsignatures.exp
+++ b/test/good/cimeparameterizedsignatures.exp
@@ 52,10 +52,10 @@ follow(constr) = SEMICOLON EOF
Built an LR(0) automaton with 62 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 62 states.
+25 out of 62 states have a default reduction.
24 out of 62 states are represented.
0 out of 31 symbols keep track of their start position.
0 out of 31 symbols keep track of their end position.
25 out of 62 states have a default reduction.
14 out of 35 productions exploit shiftreduce optimization.
0 out of 62 states can peek at an error.
183 functions before inlining, 30 functions after inlining.
diff git a/test/good/cimepolyinterp.exp b/test/good/cimepolyinterp.exp
index 43ef07d8eceac6c3ae6141afc2c5d8af846f9a9b..a8afe71795857ab21e936d9bc5aed507c4d6029e 100644
 a/test/good/cimepolyinterp.exp
+++ b/test/good/cimepolyinterp.exp
@@ 30,10 +30,10 @@ Built an LR(0) automaton with 40 states.
The grammar is not SLR(1)  4 states have a conflict.
Built an LR(1) automaton with 40 states.
16 shift/reduce conflicts were silently solved.
+13 out of 40 states have a default reduction.
12 out of 40 states are represented.
0 out of 26 symbols keep track of their start position.
0 out of 26 symbols keep track of their end position.
13 out of 40 states have a default reduction.
11 out of 20 productions exploit shiftreduce optimization.
0 out of 40 states can peek at an error.
114 functions before inlining, 24 functions after inlining.
diff git a/test/good/cimepoly.exp b/test/good/cimepoly.exp
index b41f2a9218f29c8f58fb24f05a3db5524866f000..dade080e82beac5713759370af563fa90d8168f2 100644
 a/test/good/cimepoly.exp
+++ b/test/good/cimepoly.exp
@@ 26,13 +26,13 @@ Warning: the precedence level assigned to FORALL is never useful.
Warning: 2 states have shift/reduce conflicts.
Warning: 8 shift/reduce conflicts were arbitrarily resolved.
Warning: 10 states have an endofstream conflict.
+12 out of 58 states have a default reduction.
File "cimepoly.mly", line 86, characters 04:
Warning: symbol expr is never accepted.
Warning: in total, 1 productions are never reduced.
23 out of 58 states are represented.
0 out of 31 symbols keep track of their start position.
0 out of 31 symbols keep track of their end position.
12 out of 58 states have a default reduction.
10 out of 28 productions exploit shiftreduce optimization.
0 out of 58 states can peek at an error.
154 functions before inlining, 32 functions after inlining.
diff git a/test/good/cimesignature.exp b/test/good/cimesignature.exp
index 97482d0a8fe2dab5b0bf195ec201065b918b34c9..5511e1f446c879a7cfb3c9d6652d7440ecf5f1be 100644
 a/test/good/cimesignature.exp
+++ b/test/good/cimesignature.exp
@@ 22,10 +22,10 @@ follow(arity) = SEMICOLON
Built an LR(0) automaton with 24 states.
The grammar is SLR(1).
Built an LR(1) automaton with 24 states.
+16 out of 24 states have a default reduction.
3 out of 24 states are represented.
0 out of 23 symbols keep track of their start position.
0 out of 23 symbols keep track of their end position.
16 out of 24 states have a default reduction.
15 out of 18 productions exploit shiftreduce optimization.
0 out of 24 states can peek at an error.
78 functions before inlining, 11 functions after inlining.
diff git a/test/good/cimesyntax.exp b/test/good/cimesyntax.exp
index a6e5c5b57136b87fb3ae1937b93c900d0b2e6447..14bf065072c3f9b50f2972311f29824ee3542f81 100644
 a/test/good/cimesyntax.exp
+++ b/test/good/cimesyntax.exp
@@ 189,10 +189,10 @@ Built an LR(0) automaton with 253 states.
The grammar is not SLR(1)  6 states have a conflict.
Built an LR(1) automaton with 253 states.
18 shift/reduce conflicts were silently solved.
+103 out of 253 states have a default reduction.
73 out of 253 states are represented.
0 out of 133 symbols keep track of their start position.
0 out of 133 symbols keep track of their end position.
103 out of 253 states have a default reduction.
86 out of 139 productions exploit shiftreduce optimization.
0 out of 253 states can peek at an error.
711 functions before inlining, 84 functions after inlining.
diff git a/test/good/cimeterm.exp b/test/good/cimeterm.exp
index d237c557b1961b0161f4c81d9c1a7a944a60da49..1c71c8565ad0ec545f8a7334ae3430ff034f3256 100644
 a/test/good/cimeterm.exp
+++ b/test/good/cimeterm.exp
@@ 23,10 +23,10 @@ Built an LR(0) automaton with 30 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 30 states.
2 shift/reduce conflicts were silently solved.
+10 out of 30 states have a default reduction.
8 out of 30 states are represented.
0 out of 19 symbols keep track of their start position.
0 out of 19 symbols keep track of their end position.
10 out of 30 states have a default reduction.
7 out of 15 productions exploit shiftreduce optimization.
0 out of 30 states can peek at an error.
88 functions before inlining, 13 functions after inlining.
diff git a/test/good/cimetermssignature.exp b/test/good/cimetermssignature.exp
index 0e87ed86d1d080347bb27b3a842ed12b0776782b..4f0cd6b6db43fc66187a5781d301b4493b0817c4 100644
 a/test/good/cimetermssignature.exp
+++ b/test/good/cimetermssignature.exp
@@ 41,6 +41,7 @@ Built an LR(0) automaton with 45 states.
The grammar is SLR(1).
Built an LR(1) automaton with 45 states.
Warning: 14 states have an endofstream conflict.
+24 out of 45 states have a default reduction.
File "cimetermssignature.mly", line 38, characters 26:
Warning: production signature > decl is never reduced.
File "cimetermssignature.mly", line 44, characters 213:
@@ 49,7 +50,6 @@ Warning: in total, 2 productions are never reduced.
13 out of 45 states are represented.
0 out of 32 symbols keep track of their start position.
0 out of 32 symbols keep track of their end position.
24 out of 45 states have a default reduction.
22 out of 30 productions exploit shiftreduce optimization.
0 out of 45 states can peek at an error.
137 functions before inlining, 30 functions after inlining.
diff git a/test/good/cimeterms.exp b/test/good/cimeterms.exp
index 925035996262df2186c7e39b1ecd58af455e68f5..65c98a28de649ea14f8e2d4bcf2985fe2ca1f1e3 100644
 a/test/good/cimeterms.exp
+++ b/test/good/cimeterms.exp
@@ 77,10 +77,10 @@ File "cimeterms.mly", line 31, characters 09:
Warning: the precedence level assigned to LT is never useful.
File "cimeterms.mly", line 31, characters 09:
Warning: the precedence level assigned to NE is never useful.
+42 out of 100 states have a default reduction.
28 out of 100 states are represented.
0 out of 51 symbols keep track of their start position.
0 out of 51 symbols keep track of their end position.
42 out of 100 states have a default reduction.
31 out of 59 productions exploit shiftreduce optimization.
0 out of 100 states can peek at an error.
291 functions before inlining, 46 functions after inlining.
diff git a/test/good/cimetheory.exp b/test/good/cimetheory.exp
index 8a82d82decc96e7c203c71c7e28f722aeeec87a0..cb949603ec7a14b14e50de42f4c5186f2fc0ea7e 100644
 a/test/good/cimetheory.exp
+++ b/test/good/cimetheory.exp
@@ 26,13 +26,13 @@ Built an LR(0) automaton with 47 states.
The grammar is SLR(1).
Built an LR(1) automaton with 47 states.
Warning: 11 states have an endofstream conflict.
+13 out of 47 states have a default reduction.
File "cimetheory.mly", line 32, characters 48:
Warning: production theory > decl is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 47 states are represented.
0 out of 22 symbols keep track of their start position.
0 out of 22 symbols keep track of their end position.
13 out of 47 states have a default reduction.
14 out of 14 productions exploit shiftreduce optimization.
0 out of 47 states can peek at an error.
120 functions before inlining, 11 functions after inlining.
diff git a/test/good/cimetoplevel.exp b/test/good/cimetoplevel.exp
index 2f43e2e3c352021c83c9d3b2b8e61a96f4a64d4c..eb5a9546397f1978c4ca87df576e4bcd4223d637 100644
 a/test/good/cimetoplevel.exp
+++ b/test/good/cimetoplevel.exp
@@ 35,10 +35,10 @@ File "cimetoplevel.mly", line 44, characters 09:
Warning: the precedence level assigned to FUN is never useful.
File "cimetoplevel.mly", line 79, characters 2530:
Warning: this %prec declaration is never useful.
+21 out of 91 states have a default reduction.
56 out of 91 states are represented.
0 out of 43 symbols keep track of their start position.
0 out of 43 symbols keep track of their end position.
21 out of 91 states have a default reduction.
17 out of 47 productions exploit shiftreduce optimization.
0 out of 91 states can peek at an error.
243 functions before inlining, 37 functions after inlining.
diff git a/test/good/cimeword.exp b/test/good/cimeword.exp
index 4bc66c0492a9c0ffdb1f3c2eca1529aaf978b46c..3afd6b68978a8575fab3d95c1417f548e5b492d5 100644
 a/test/good/cimeword.exp
+++ b/test/good/cimeword.exp
@@ 34,10 +34,10 @@ follow(expo) = SEMICOLON RPAR POWER LPAR IDENT EOF ARROW
Built an LR(0) automaton with 38 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 38 states.
+18 out of 38 states have a default reduction.
11 out of 38 states are represented.
0 out of 27 symbols keep track of their start position.
0 out of 27 symbols keep track of their end position.
18 out of 38 states have a default reduction.
11 out of 24 productions exploit shiftreduce optimization.
0 out of 38 states can peek at an error.
118 functions before inlining, 19 functions after inlining.
diff git a/test/good/cminor.exp b/test/good/cminor.exp
index ed3e4255782c696a40cb3d61ac0f29869f55ece6..6acec19c832a3da8152a31a93d6345f0b54bd0c6 100644
 a/test/good/cminor.exp
+++ b/test/good/cminor.exp
@@ 79,10 +79,10 @@ Built an LR(1) automaton with 216 states.
2162 shift/reduce conflicts were silently solved.
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
+45 out of 216 states have a default reduction.
82 out of 216 states are represented.
0 out of 105 symbols keep track of their start position.
0 out of 105 symbols keep track of their end position.
45 out of 216 states have a default reduction.
35 out of 117 productions exploit shiftreduce optimization.
0 out of 216 states can peek at an error.
579 functions before inlining, 101 functions after inlining.
diff git a/test/good/cocci.exp b/test/good/cocci.exp
index 3ea9f1263c87a705a7e7efa88fb5f45664088fd6..b48688ee4c297249e57485261948bb30e258639e 100644
 a/test/good/cocci.exp
+++ b/test/good/cocci.exp
@@ 607,10 +607,10 @@ Warning: 15 states have shift/reduce conflicts.
Warning: 2 states have reduce/reduce conflicts.
Warning: 138 shift/reduce conflicts were arbitrarily resolved.
Warning: 2 reduce/reduce conflicts were arbitrarily resolved.
+467 out of 1178 states have a default reduction.
408 out of 1178 states are represented.
0 out of 346 symbols keep track of their start position.
0 out of 346 symbols keep track of their end position.
467 out of 1178 states have a default reduction.
352 out of 623 productions exploit shiftreduce optimization.
0 out of 1178 states can peek at an error.
3189 functions before inlining, 454 functions after inlining.
diff git a/test/good/coercionconstraint.exp b/test/good/coercionconstraint.exp
index 8a97f3e2f16258e992701e870546053c2c3185e4..5b2dae038ba320440862b0b74cb3568b2e15bc8a 100644
 a/test/good/coercionconstraint.exp
+++ b/test/good/coercionconstraint.exp
@@ 100,10 +100,10 @@ File "coercionconstraint.mly", line 132, characters 09:
Warning: the precedence level assigned to ID is never useful.
File "coercionconstraint.mly", line 130, characters 06:
Warning: the precedence level assigned to LEFT is never useful.
+42 out of 95 states have a default reduction.
28 out of 95 states are represented.
0 out of 55 symbols keep track of their start position.
0 out of 55 symbols keep track of their end position.
42 out of 95 states have a default reduction.
27 out of 55 productions exploit shiftreduce optimization.
0 out of 95 states can peek at an error.
277 functions before inlining, 46 functions after inlining.
diff git a/test/good/coercionmini.exp b/test/good/coercionmini.exp
index 703f463b2df0691ba5d103e8c423f26fc3a2089f..bf30fdd9f1ac8246d7282c423e826558f32c7800 100644
 a/test/good/coercionmini.exp
+++ b/test/good/coercionmini.exp
@@ 163,10 +163,10 @@ Built an LR(0) automaton with 218 states.
The grammar is not SLR(1)  9 states have a conflict.
Built an LR(1) automaton with 296 states.
72 shift/reduce conflicts were silently solved.
+115 out of 296 states have a default reduction.
116 out of 296 states are represented.
0 out of 104 symbols keep track of their start position.
0 out of 104 symbols keep track of their end position.
115 out of 296 states have a default reduction.
63 out of 120 productions exploit shiftreduce optimization.
31 out of 296 states can peek at an error.
766 functions before inlining, 159 functions after inlining.
diff git a/test/good/compcert_pre_parser.exp b/test/good/compcert_pre_parser.exp
index 57fb3bd7aacf3405b7517958e4fee3c4addf9d5f..21bfa29729a03a743ec1b90ad304a4aeddf8a4c7 100644
 a/test/good/compcert_pre_parser.exp
+++ b/test/good/compcert_pre_parser.exp
@@ 320,10 +320,10 @@ Built an LR(0) automaton with 726 states.
The grammar is not SLR(1)  17 states have a conflict.
Built an LR(1) automaton with 1161 states.
One shift/reduce conflict was silently solved.
+473 out of 1161 states have a default reduction.
575 out of 1161 states are represented.
2 out of 200 symbols keep track of their start position.
1 out of 200 symbols keep track of their end position.
473 out of 1161 states have a default reduction.
190 out of 403 productions exploit shiftreduce optimization.
262 out of 1161 states can peek at an error.
The generated parser cannot raise Error.
diff git a/test/good/compcert_pre_parser_new.exp b/test/good/compcert_pre_parser_new.exp
index 9b4d4ed827e472fdbac38f1681efda6e497b2f6d..38927c419b9299be917bf5124c1072e5e27add47 100644
 a/test/good/compcert_pre_parser_new.exp
+++ b/test/good/compcert_pre_parser_new.exp
@@ 444,10 +444,10 @@ Built an LR(1) automaton with 677 states.
One shift/reduce conflict was silently solved.
Extra reductions on error were added in 99 states.
Priority played a role in 0 of these states.
+315 out of 677 states have a default reduction.
254 out of 677 states are represented.
0 out of 241 symbols keep track of their start position.
0 out of 241 symbols keep track of their end position.
315 out of 677 states have a default reduction.
200 out of 366 productions exploit shiftreduce optimization.
0 out of 677 states can peek at an error.
1871 functions before inlining, 290 functions after inlining.
diff git a/test/good/compsyn.exp b/test/good/compsyn.exp
index 764f6ae46205150428a943f36d7b15b4a5cd7550..54eaa09f1097ae8cee66bbc9b2ac75f7b062d6e9 100644
 a/test/good/compsyn.exp
+++ b/test/good/compsyn.exp
@@ 515,6 +515,7 @@ Warning: 11 states have shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: 38 shift/reduce conflicts were arbitrarily resolved.
Warning: one reduce/reduce conflict was arbitrarily resolved.
+269 out of 806 states have a default reduction.
File "compsyn.mly", line 686, characters 3636:
Warning: production KEY_IF_LPAREN_expression_RPAREN_opt > is never reduced.
File "compsyn.mly", line 688, characters 334:
@@ 525,7 +526,6 @@ Warning: in total, 3 productions are never reduced.
343 out of 806 states are represented.
0 out of 275 symbols keep track of their start position.
0 out of 275 symbols keep track of their end position.
269 out of 806 states have a default reduction.
213 out of 357 productions exploit shiftreduce optimization.
0 out of 806 states can peek at an error.
2128 functions before inlining, 255 functions after inlining.
diff git a/test/good/condition_parser.exp b/test/good/condition_parser.exp
index b6414de955b94db32021e374ad1ca12242dd3292..5d808d5b9739b04aa7adb2453b9568b60189ba22 100644
 a/test/good/condition_parser.exp
+++ b/test/good/condition_parser.exp
@@ 17,10 +17,10 @@ Built an LR(0) automaton with 26 states.
The grammar is not SLR(1)  3 states have a conflict.
Built an LR(1) automaton with 26 states.
6 shift/reduce conflicts were silently solved.
+14 out of 26 states have a default reduction.
6 out of 26 states are represented.
0 out of 21 symbols keep track of their start position.
0 out of 21 symbols keep track of their end position.
14 out of 26 states have a default reduction.
11 out of 15 productions exploit shiftreduce optimization.
0 out of 26 states can peek at an error.
77 functions before inlining, 16 functions after inlining.
diff git a/test/good/confluencefnf.exp b/test/good/confluencefnf.exp
index 7523c3740cb6a749f1332023301a76d07fb86bc6..6daaebab55d73ece8f868b3a687c0d8b45e592ee 100644
 a/test/good/confluencefnf.exp
+++ b/test/good/confluencefnf.exp
@@ 50,10 +50,10 @@ follow(bit) = Integer
Built an LR(0) automaton with 149 states.
The grammar is SLR(1).
Built an LR(1) automaton with 155 states.
+39 out of 155 states have a default reduction.
89 out of 155 states are represented.
0 out of 45 symbols keep track of their start position.
0 out of 45 symbols keep track of their end position.
39 out of 155 states have a default reduction.
33 out of 38 productions exploit shiftreduce optimization.
0 out of 155 states can peek at an error.
368 functions before inlining, 13 functions after inlining.
diff git a/test/good/confluencepsl.exp b/test/good/confluencepsl.exp
index 09cb58cba67a3196477f974081e698b4f34b57fd..b3b48ad7aa57096823bbc0d53e94b79589372378 100644
 a/test/good/confluencepsl.exp
+++ b/test/good/confluencepsl.exp
@@ 254,10 +254,10 @@ File "confluencepsl.mly", line 167, characters 06:
Warning: the precedence level assigned to W is never useful.
File "confluencepsl.mly", line 175, characters 05:
Warning: the precedence level assigned to Within is never useful.
+65 out of 296 states have a default reduction.
166 out of 296 states are represented.
0 out of 144 symbols keep track of their start position.
0 out of 144 symbols keep track of their end position.
65 out of 296 states have a default reduction.
57 out of 95 productions exploit shiftreduce optimization.
0 out of 296 states can peek at an error.
714 functions before inlining, 80 functions after inlining.
diff git a/test/good/confluence.exp b/test/good/confluence.exp
index 9c20c1babaff9d62bcd5c366ec3297268a17ff7c..86d6d26c7cc780af64c03a6e88b6dfd720f56b52 100644
 a/test/good/confluence.exp
+++ b/test/good/confluence.exp
@@ 113,10 +113,10 @@ Built an LR(1) automaton with 294 states.
4120 shift/reduce conflicts were silently solved.
File "confluence.mly", line 90, characters 05:
Warning: the precedence level assigned to OP_PROP_U is never useful.
+92 out of 294 states have a default reduction.
194 out of 294 states are represented.
0 out of 142 symbols keep track of their start position.
0 out of 142 symbols keep track of their end position.
92 out of 294 states have a default reduction.
59 out of 153 productions exploit shiftreduce optimization.
0 out of 294 states can peek at an error.
781 functions before inlining, 134 functions after inlining.
diff git a/test/good/couac.exp b/test/good/couac.exp
index 16116f4ff872144e4cc7acc959d0b6212f07201e..32f83bd1b70cdc9e720bf6d22f70caa826401b33 100644
 a/test/good/couac.exp
+++ b/test/good/couac.exp
@@ 46,10 +46,10 @@ follow(declaration) = TYPE TOKEN START RIGHT PERCENTPERCENT NONASSOC LEFT HEADER
Built an LR(0) automaton with 46 states.
The grammar is SLR(1).
Built an LR(1) automaton with 46 states.
+29 out of 46 states have a default reduction.
15 out of 46 states are represented.
0 out of 33 symbols keep track of their start position.
0 out of 33 symbols keep track of their end position.
29 out of 46 states have a default reduction.
15 out of 34 productions exploit shiftreduce optimization.
0 out of 46 states can peek at an error.
146 functions before inlining, 21 functions after inlining.
diff git a/test/good/cutdown.exp b/test/good/cutdown.exp
index c9382881bf3fc401260ac8a23a5d0a813c20f733..ce89dc5b32f2404f589679552d00e1d2dfd9baf3 100644
 a/test/good/cutdown.exp
+++ b/test/good/cutdown.exp
@@ 29,10 +29,10 @@ Warning: one state has shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: one reduce/reduce conflict was arbitrarily resolved.
+8 out of 21 states have a default reduction.
4 out of 21 states are represented.
0 out of 16 symbols keep track of their start position.
0 out of 16 symbols keep track of their end position.
8 out of 21 states have a default reduction.
6 out of 11 productions exploit shiftreduce optimization.
0 out of 21 states can peek at an error.
66 functions before inlining, 13 functions after inlining.
diff git a/test/good/dario.exp b/test/good/dario.exp
index 8da4e3b67882323cbdf5c79269c58df90ed3a542..2e9784070afa09eecec5eb5af60c2480f4ea7927 100644
 a/test/good/dario.exp
+++ b/test/good/dario.exp
@@ 20,10 +20,10 @@ Built an LR(0) automaton with 10 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 10 states.
One shift/reduce conflict was silently solved.
+6 out of 10 states have a default reduction.
3 out of 10 states are represented.
0 out of 10 symbols keep track of their start position.
0 out of 10 symbols keep track of their end position.
6 out of 10 states have a default reduction.
5 out of 8 productions exploit shiftreduce optimization.
0 out of 10 states can peek at an error.
39 functions before inlining, 7 functions after inlining.
diff git a/test/good/dml.exp b/test/good/dml.exp
index f71e1b8319a82f6f7c4eebc08d6f32143033b6ee..38508f64061204689ada2c3617fa7d34a3fe930f 100644
 a/test/good/dml.exp
+++ b/test/good/dml.exp
@@ 296,10 +296,10 @@ File "dml.mly", line 341, characters 3846:
Warning: this %prec declaration is never useful.
Warning: 15 states have shift/reduce conflicts.
Warning: 24 shift/reduce conflicts were arbitrarily resolved.
+152 out of 336 states have a default reduction.
124 out of 336 states are represented.
0 out of 143 symbols keep track of their start position.
0 out of 143 symbols keep track of their end position.
152 out of 336 states have a default reduction.
123 out of 198 productions exploit shiftreduce optimization.
0 out of 336 states can peek at an error.
943 functions before inlining, 155 functions after inlining.
diff git a/test/good/docOckXmlParser.exp b/test/good/docOckXmlParser.exp
index 781ddd5fef340cba5ecb137ca56495b56b73e0d2..a21f9fa538ab800c548a061c6b4e4a1ba952f6fb 100644
 a/test/good/docOckXmlParser.exp
+++ b/test/good/docOckXmlParser.exp
@@ 483,10 +483,10 @@ follow(argument_label) = VAR TUPLE POLY_VARIANT POLY PATH PACKAGE OBJECT CLASS A
Built an LR(0) automaton with 1124 states.
The grammar is SLR(1).
Built an LR(1) automaton with 1133 states.
+370 out of 1133 states have a default reduction.
328 out of 1133 states are represented.
0 out of 280 symbols keep track of their start position.
0 out of 280 symbols keep track of their end position.
370 out of 1133 states have a default reduction.
307 out of 412 productions exploit shiftreduce optimization.
0 out of 1133 states can peek at an error.
2844 functions before inlining, 319 functions after inlining.
diff git a/test/good/dule.exp b/test/good/dule.exp
index a7c4376f94d30088573bad88d9d88a37c8407d88..06d96897c415b551c235f24d73e7a08e13c5b53f 100644
 a/test/good/dule.exp
+++ b/test/good/dule.exp
@@ 223,10 +223,10 @@ Warning: 29 states have shift/reduce conflicts.
Warning: 2 states have reduce/reduce conflicts.
Warning: 63 shift/reduce conflicts were arbitrarily resolved.
Warning: 24 reduce/reduce conflicts were arbitrarily resolved.
+192 out of 531 states have a default reduction.
275 out of 531 states are represented.
0 out of 137 symbols keep track of their start position.
0 out of 137 symbols keep track of their end position.
192 out of 531 states have a default reduction.
84 out of 171 productions exploit shiftreduce optimization.
152 out of 531 states can peek at an error.
1292 functions before inlining, 359 functions after inlining.
diff git a/test/good/duplicated_prec.exp b/test/good/duplicated_prec.exp
index 3e9e530defb98c7eda24d98a7ee4875de490faf6..4e0a502b87b6566e0de3084a8fb73446e0b094ad 100644
 a/test/good/duplicated_prec.exp
+++ b/test/good/duplicated_prec.exp
@@ 16,10 +16,10 @@ Built an LR(0) automaton with 15 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 15 states.
One shift/reduce conflict was silently solved.
+7 out of 15 states have a default reduction.
4 out of 15 states are represented.
0 out of 12 symbols keep track of their start position.
0 out of 12 symbols keep track of their end position.
7 out of 15 states have a default reduction.
6 out of 8 productions exploit shiftreduce optimization.
0 out of 15 states can peek at an error.
47 functions before inlining, 11 functions after inlining.
diff git a/test/good/efuns.exp b/test/good/efuns.exp
index 7e7bc02c99588635855530aee82b16d7e68f7601..6834261d1e453530626bf1edcb724f00a7715db0 100644
 a/test/good/efuns.exp
+++ b/test/good/efuns.exp
@@ 13,10 +13,10 @@ follow(parse_filename) = #
Built an LR(0) automaton with 20 states.
The grammar is SLR(1).
Built an LR(1) automaton with 20 states.
+10 out of 20 states have a default reduction.
8 out of 20 states are represented.
0 out of 12 symbols keep track of their start position.
0 out of 12 symbols keep track of their end position.
10 out of 20 states have a default reduction.
8 out of 12 productions exploit shiftreduce optimization.
0 out of 20 states can peek at an error.
62 functions before inlining, 16 functions after inlining.
diff git a/test/good/emptyaction.exp b/test/good/emptyaction.exp
index d0a53ce8d41bf6289cf104ad74d4a75f67dc59d2..bff3fa15fe9d2b9e6a0fb97dccd3be5857911f32 100644
 a/test/good/emptyaction.exp
+++ b/test/good/emptyaction.exp
@@ 12,10 +12,10 @@ follow(a) = #
Built an LR(0) automaton with 5 states.
The grammar is SLR(1).
Built an LR(1) automaton with 5 states.
+3 out of 5 states have a default reduction.
0 out of 5 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 5 states have a default reduction.
3 out of 3 productions exploit shiftreduce optimization.
0 out of 5 states can peek at an error.
21 functions before inlining, 2 functions after inlining.
diff git a/test/good/endofstreamconflict.exp b/test/good/endofstreamconflict.exp
index 68cad0c932ced53e4bd0e285d9779e05fb1d31d2..5227e17c4be08bee02ca48a0378ccd3ece0edea4 100644
 a/test/good/endofstreamconflict.exp
+++ b/test/good/endofstreamconflict.exp
@@ 9,13 +9,13 @@ The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 7 states.
4 shift/reduce conflicts were silently solved.
Warning: 4 states have an endofstream conflict.
+2 out of 7 states have a default reduction.
File "endofstreamconflict.mly", line 10, characters 04:
Warning: symbol expr is never accepted.
Warning: in total, 1 productions are never reduced.
3 out of 7 states are represented.
0 out of 7 symbols keep track of their start position.
0 out of 7 symbols keep track of their end position.
2 out of 7 states have a default reduction.
2 out of 4 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
24 functions before inlining, 6 functions after inlining.
diff git a/test/good/execparser.exp b/test/good/execparser.exp
index 96a368fb5f668edd264c13921c284e8fdc65d6df..c282a299552b03eaa757092f75ab456e442805f1 100644
 a/test/good/execparser.exp
+++ b/test/good/execparser.exp
@@ 155,6 +155,7 @@ Built an LR(1) automaton with 293 states.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 83 states have an endofstream conflict.
+131 out of 293 states have a default reduction.
File "execparser.mly", line 166, characters 415:
Warning: production instructions > instruction is never reduced.
File "execparser.mly", line 167, characters 419:
@@ 163,7 +164,6 @@ Warning: in total, 2 productions are never reduced.
75 out of 293 states are represented.
0 out of 135 symbols keep track of their start position.
0 out of 135 symbols keep track of their end position.
131 out of 293 states have a default reduction.
106 out of 153 productions exploit shiftreduce optimization.
0 out of 293 states can peek at an error.
787 functions before inlining, 106 functions after inlining.
diff git a/test/good/featherweight.exp b/test/good/featherweight.exp
index 89f70f6bd314398bdf7a2fd08e4225c13bdeea40..d24070fa07373114b0c5a5b1f805e4174a1ce39a 100644
 a/test/good/featherweight.exp
+++ b/test/good/featherweight.exp
@@ 135,13 +135,13 @@ Built an LR(1) automaton with 105 states.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 17 states have an endofstream conflict.
+35 out of 105 states have a default reduction.
File "featherweight.mly", line 101, characters 124:
Warning: production toplevel > classDecs COLON termDef is never reduced.
Warning: in total, 1 productions are never reduced.
22 out of 105 states are represented.
0 out of 73 symbols keep track of their start position.
0 out of 73 symbols keep track of their end position.
35 out of 105 states have a default reduction.
24 out of 45 productions exploit shiftreduce optimization.
0 out of 105 states can peek at an error.
282 functions before inlining, 37 functions after inlining.
diff git a/test/good/filiot.exp b/test/good/filiot.exp
index 0e76aaf6601a359b720d4070ec832ee49fa03a21..6fa2d265dabeb3634192a2dc42b11ead409ee85b 100644
 a/test/good/filiot.exp
+++ b/test/good/filiot.exp
@@ 39,13 +39,13 @@ Warning: the precedence level assigned to RPAR is never useful.
File "filiot.mly", line 95, characters 05:
Warning: the precedence level assigned to TILDA is never useful.
Warning: one state has an endofstream conflict.
+46 out of 88 states have a default reduction.
File "filiot.mly", line 107, characters 11:
Warning: production main > is never reduced.
Warning: in total, 1 productions are never reduced.
18 out of 88 states are represented.
0 out of 53 symbols keep track of their start position.
0 out of 53 symbols keep track of their end position.
46 out of 88 states have a default reduction.
38 out of 51 productions exploit shiftreduce optimization.
4 out of 88 states can peek at an error.
239 functions before inlining, 31 functions after inlining.
diff git a/test/good/flowcamldocgen.exp b/test/good/flowcamldocgen.exp
index e425b497755d89505d16b1704cccd1316e71c5e3..c15d7322c819fe2ddb573150d73839e9e8c33d97 100644
 a/test/good/flowcamldocgen.exp
+++ b/test/good/flowcamldocgen.exp
@@ 10,10 +10,10 @@ follow(file) = #
Built an LR(0) automaton with 15 states.
The grammar is SLR(1).
Built an LR(1) automaton with 15 states.
+10 out of 15 states have a default reduction.
5 out of 15 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.
10 out of 15 states have a default reduction.
8 out of 9 productions exploit shiftreduce optimization.
0 out of 15 states can peek at an error.
47 functions before inlining, 14 functions after inlining.
diff git a/test/good/flowcaml.exp b/test/good/flowcaml.exp
index b2807a980b57543cfda27058caa8cd8b02135295..fb7c27a30ffc585e0c55cd74170c3e669e0f6b9d 100644
 a/test/good/flowcaml.exp
+++ b/test/good/flowcaml.exp
@@ 491,10 +491,10 @@ Warning: this %prec declaration is never useful.
Warning: 25 states have shift/reduce conflicts.
Warning: 55 shift/reduce conflicts were arbitrarily resolved.
Warning: 4 states have an endofstream conflict.
+509 out of 1552 states have a default reduction.
786 out of 1552 states are represented.
0 out of 262 symbols keep track of their start position.
0 out of 262 symbols keep track of their end position.
509 out of 1552 states have a default reduction.
226 out of 450 productions exploit shiftreduce optimization.
407 out of 1552 states can peek at an error.
3696 functions before inlining, 959 functions after inlining.
diff git a/test/good/foccpuredef.exp b/test/good/foccpuredef.exp
index 799b7797c568f5e66ff73f1058c3542118139f7f..3b11e6757a6711a2ca737c315fd845888a3d21eb 100644
 a/test/good/foccpuredef.exp
+++ b/test/good/foccpuredef.exp
@@ 22,10 +22,10 @@ follow(coll_def) = IMPORT EOF COQ CAMLI CAML
Built an LR(0) automaton with 34 states.
The grammar is SLR(1).
Built an LR(1) automaton with 34 states.
+15 out of 34 states have a default reduction.
10 out of 34 states are represented.
0 out of 22 symbols keep track of their start position.
0 out of 22 symbols keep track of their end position.
15 out of 34 states have a default reduction.
12 out of 15 productions exploit shiftreduce optimization.
0 out of 34 states can peek at an error.
95 functions before inlining, 20 functions after inlining.
diff git a/test/good/foo.exp b/test/good/foo.exp
index 403556600ca023c2eb6550151afe8fc03a6194f6..df08927c0834a774d97549324845e58ac7461e84 100644
 a/test/good/foo.exp
+++ b/test/good/foo.exp
@@ 9,13 +9,13 @@ The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 7 states.
4 shift/reduce conflicts were silently solved.
Warning: 4 states have an endofstream conflict.
+2 out of 7 states have a default reduction.
File "foo.mly", line 9, characters 03:
Warning: symbol exp is never accepted.
Warning: in total, 1 productions are never reduced.
3 out of 7 states are represented.
0 out of 7 symbols keep track of their start position.
0 out of 7 symbols keep track of their end position.
2 out of 7 states have a default reduction.
2 out of 4 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
24 functions before inlining, 6 functions after inlining.
diff git a/test/good/fork.exp b/test/good/fork.exp
index c3e0a5e5b11f032ac5c6e9b04cd7cbca5da698c2..8b69af144bf0e16d7fcbd05faf8b9179af1af9b0 100644
 a/test/good/fork.exp
+++ b/test/good/fork.exp
@@ 75,10 +75,10 @@ follow(declaration) = TYPE TERM LEMMA KIND INCLUDE EOF DEFAULT
Built an LR(0) automaton with 172 states.
The grammar is SLR(1).
Built an LR(1) automaton with 172 states.
+53 out of 172 states have a default reduction.
72 out of 172 states are represented.
22 out of 57 symbols keep track of their start position.
16 out of 57 symbols keep track of their end position.
53 out of 172 states have a default reduction.
26 out of 65 productions exploit shiftreduce optimization.
0 out of 172 states can peek at an error.
438 functions before inlining, 51 functions after inlining.
diff git a/test/good/fp.exp b/test/good/fp.exp
index 2114452b8b2eed3943e9414a9c3c4c42ed9ca8f0..c68f398bce813a8593fe2b2c429c614c9a5fa1e3 100644
 a/test/good/fp.exp
+++ b/test/good/fp.exp
@@ 37,10 +37,10 @@ Warning: the precedence level assigned to Lo is never useful.
File "fp.mly", line 28, characters 27:
Warning: the precedence level assigned to Lprim is never useful.
Warning: 22 states have an endofstream conflict.
+39 out of 91 states have a default reduction.
25 out of 91 states are represented.
0 out of 45 symbols keep track of their start position.
0 out of 45 symbols keep track of their end position.
39 out of 91 states have a default reduction.
22 out of 38 productions exploit shiftreduce optimization.
0 out of 91 states can peek at an error.
235 functions before inlining, 39 functions after inlining.
diff git a/test/good/framaccparser.exp b/test/good/framaccparser.exp
index 8c2d6db7b91740d46df1011ed2b5c3f45947a8c8..175a87fddbf7986e53e8356f0607613f858a67af 100644
 a/test/good/framaccparser.exp
+++ b/test/good/framaccparser.exp
@@ 532,6 +532,7 @@ File "framaccparser.mly", line 464, characters 5661:
Warning: this %prec declaration is never useful.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
+430 out of 1081 states have a default reduction.
File "framaccparser.mly", line 1304, characters 227:
Warning: production direct_old_proto_decl > direct_decl LPAREN RPAREN is never reduced.
File "framaccparser.mly", line 1443, characters 221:
@@ 546,7 +547,6 @@ Warning: in total, 5 productions are never reduced.
392 out of 1081 states are represented.
0 out of 267 symbols keep track of their start position.
0 out of 267 symbols keep track of their end position.
430 out of 1081 states have a default reduction.
216 out of 453 productions exploit shiftreduce optimization.
109 out of 1081 states can peek at an error.
2757 functions before inlining, 556 functions after inlining.
diff git a/test/good/framacprint_apigrammar.exp b/test/good/framacprint_apigrammar.exp
index a7de758bcbfc08023a98c579c5996b80e6803cbc..71d1c5280e704093a37f300d57b011dadd563c36 100644
 a/test/good/framacprint_apigrammar.exp
+++ b/test/good/framacprint_apigrammar.exp
@@ 13,10 +13,10 @@ follow(main) = #
Built an LR(0) automaton with 21 states.
The grammar is SLR(1).
Built an LR(1) automaton with 21 states.
+8 out of 21 states have a default reduction.
13 out of 21 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.
8 out of 21 states have a default reduction.
8 out of 8 productions exploit shiftreduce optimization.
0 out of 21 states can peek at an error.
59 functions before inlining, 6 functions after inlining.
diff git a/test/good/fsharp.exp b/test/good/fsharp.exp
index 0f1db709ff921c6375a8157737ca51f8ff26ac8b..a80af69a361408abae554c93036fbd86d2db936a 100644
 a/test/good/fsharp.exp
+++ b/test/good/fsharp.exp
@@ 1143,13 +1143,13 @@ Warning: this %prec declaration is never useful.
Warning: 148 states have shift/reduce conflicts.
Warning: 2 states have reduce/reduce conflicts.
Warning: 333 shift/reduce conflicts were arbitrarily resolved.
+1077 out of 2759 states have a default reduction.
File "fsharp.mly", line 1744, characters 446:
Warning: production conjPatternElements > conjPatternElements AMP headBindingPattern is never reduced.
Warning: in total, 1 productions are never reduced.
1398 out of 2759 states are represented.
0 out of 453 symbols keep track of their start position.
0 out of 453 symbols keep track of their end position.
1077 out of 2759 states have a default reduction.
422 out of 848 productions exploit shiftreduce optimization.
663 out of 2759 states can peek at an error.
6649 functions before inlining, 1552 functions after inlining.
diff git a/test/good/fslexpars.exp b/test/good/fslexpars.exp
index f7e4ec0ebd1247a4957351d42b3d65ed105ccdfd..c1cfc82d2e697bfb0058a6f118c331da7f68c253 100644
 a/test/good/fslexpars.exp
+++ b/test/good/fslexpars.exp
@@ 58,10 +58,10 @@ Warning: this %prec declaration is never useful.
Warning: 3 states have shift/reduce conflicts.
Warning: 21 shift/reduce conflicts were arbitrarily resolved.
Warning: 7 states have an endofstream conflict.
+23 out of 56 states have a default reduction.
23 out of 56 states are represented.
0 out of 37 symbols keep track of their start position.
0 out of 37 symbols keep track of their end position.
23 out of 56 states have a default reduction.
18 out of 33 productions exploit shiftreduce optimization.
0 out of 56 states can peek at an error.
163 functions before inlining, 30 functions after inlining.
diff git a/test/good/fstar.exp b/test/good/fstar.exp
index 96811374805f531643c68c3f7cd0c9430b9ea852..3f309a27ce03c130ece8168f8f3cdacca7327037 100644
 a/test/good/fstar.exp
+++ b/test/good/fstar.exp
@@ 500,10 +500,10 @@ Built an LR(1) automaton with 484 states.
One shift/reduce conflict was silently solved.
Warning: 6 states have shift/reduce conflicts.
Warning: 6 shift/reduce conflicts were arbitrarily resolved.
+205 out of 484 states have a default reduction.
188 out of 484 states are represented.
0 out of 279 symbols keep track of their start position.
0 out of 279 symbols keep track of their end position.
205 out of 484 states have a default reduction.
128 out of 277 productions exploit shiftreduce optimization.
0 out of 484 states can peek at an error.
1376 functions before inlining, 220 functions after inlining.
diff git a/test/good/fsyaccpars.exp b/test/good/fsyaccpars.exp
index b39541e6fa269e71d6743f453e65dbaf842a76cf..b8f5470129a6fa76dc4224ff4e689b1e5bf0ddf9 100644
 a/test/good/fsyaccpars.exp
+++ b/test/good/fsyaccpars.exp
@@ 52,13 +52,13 @@ Built an LR(1) automaton with 44 states.
File "fsyaccpars.mly", line 15, characters 05:
Warning: the precedence level assigned to BAR is never useful.
Warning: 7 states have an endofstream conflict.
+20 out of 44 states have a default reduction.
File "fsyaccpars.mly", line 30, characters 3337:
Warning: production rules > rule is never reduced.
Warning: in total, 1 productions are never reduced.
15 out of 44 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.
20 out of 44 states have a default reduction.
17 out of 29 productions exploit shiftreduce optimization.
0 out of 44 states can peek at an error.
135 functions before inlining, 26 functions after inlining.
diff git a/test/good/godiva.exp b/test/good/godiva.exp
index fa4518942b2538dfdae47b3f70db1e837623baf6..64db74a43534b559dc99b9dda994d43b13048187 100644
 a/test/good/godiva.exp
+++ b/test/good/godiva.exp
@@ 73,10 +73,10 @@ follow(build_depends_line) = VERSION UNPACKSTO SOURCES REVISION PACKAGE OPT_TARG
Built an LR(0) automaton with 109 states.
The grammar is SLR(1).
Built an LR(1) automaton with 109 states.
+60 out of 109 states have a default reduction.
9 out of 109 states are represented.
0 out of 52 symbols keep track of their start position.
0 out of 52 symbols keep track of their end position.
60 out of 109 states have a default reduction.
55 out of 68 productions exploit shiftreduce optimization.
1 out of 109 states can peek at an error.
315 functions before inlining, 54 functions after inlining.
diff git a/test/good/gromit.exp b/test/good/gromit.exp
index 575b1dc2bb504e9349a9f1226bbf1c5818df236f..8cbaa9b351a3915cce9ee8a8875bbe835a0a64c4 100644
 a/test/good/gromit.exp
+++ b/test/good/gromit.exp
@@ 48,13 +48,13 @@ Built an LR(1) automaton with 96 states.
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
Warning: 2 states have an endofstream conflict.
+55 out of 96 states have a default reduction.
File "gromit.mly", line 210, characters 1717:
Warning: production constructor_list > is never reduced.
Warning: in total, 1 productions are never reduced.
10 out of 96 states are represented.
0 out of 39 symbols keep track of their start position.
0 out of 39 symbols keep track of their end position.
55 out of 96 states have a default reduction.
52 out of 61 productions exploit shiftreduce optimization.
7 out of 96 states can peek at an error.
The generated parser cannot raise Error.
diff git a/test/good/grune924.exp b/test/good/grune924.exp
index 849f999b73dd7ee4635af927e79a8ae319278545..995281a0c8e63f6585a44ca854b72cc5be996b76 100644
 a/test/good/grune924.exp
+++ b/test/good/grune924.exp
@@ 14,13 +14,13 @@ Built an LR(0) automaton with 10 states.
The grammar is SLR(1).
Built an LR(1) automaton with 10 states.
Warning: 5 states have an endofstream conflict.
+5 out of 10 states have a default reduction.
File "grune924.mly", line 8, characters 23:
Warning: production s > e is never reduced.
Warning: in total, 1 productions are never reduced.
3 out of 10 states are represented.
0 out of 10 symbols keep track of their start position.
0 out of 10 symbols keep track of their end position.
5 out of 10 states have a default reduction.
6 out of 6 productions exploit shiftreduce optimization.
0 out of 10 states can peek at an error.
34 functions before inlining, 8 functions after inlining.
diff git a/test/good/hmxmulti.exp b/test/good/hmxmulti.exp
index 303107019e5d1f2422d88ea925b41068a0dd2fdf..7e722c70e27dfb0aa030fb5f2a2f74cc85bbf07d 100644
 a/test/good/hmxmulti.exp
+++ b/test/good/hmxmulti.exp
@@ 47,10 +47,10 @@ The grammar is not SLR(1)  4 states have a conflict.
Built an LR(1) automaton with 99 states.
Warning: 4 states have shift/reduce conflicts.
Warning: 15 shift/reduce conflicts were arbitrarily resolved.
+29 out of 99 states have a default reduction.
40 out of 99 states are represented.
0 out of 43 symbols keep track of their start position.
0 out of 43 symbols keep track of their end position.
29 out of 99 states have a default reduction.
19 out of 43 productions exploit shiftreduce optimization.
0 out of 99 states can peek at an error.
260 functions before inlining, 42 functions after inlining.
diff git a/test/good/hmxsets.exp b/test/good/hmxsets.exp
index 2411a80ca6244a1bf1e72f89e60c667a132ca60f..ec5be98fd8d89472850827b99ec09fcc3aac37e7 100644
 a/test/good/hmxsets.exp
+++ b/test/good/hmxsets.exp
@@ 32,10 +32,10 @@ follow(expression) = SEMISEMI RPAREN IN
Built an LR(0) automaton with 59 states.
The grammar is SLR(1).
Built an LR(1) automaton with 59 states.
+24 out of 59 states have a default reduction.
21 out of 59 states are represented.
0 out of 36 symbols keep track of their start position.
0 out of 36 symbols keep track of their end position.
24 out of 59 states have a default reduction.
19 out of 31 productions exploit shiftreduce optimization.
0 out of 59 states can peek at an error.
163 functions before inlining, 34 functions after inlining.
diff git a/test/good/htparser.exp b/test/good/htparser.exp
index b513b9b9518f0e9dde8711fccf1f5cdf8544b2e0..58d3ce9ce1e60ee4eb313df6a02577e9705f7181 100644
 a/test/good/htparser.exp
+++ b/test/good/htparser.exp
@@ 370,6 +370,7 @@ Warning: 5 states have reduce/reduce conflicts.
Warning: 16 shift/reduce conflicts were arbitrarily resolved.
Warning: 25 reduce/reduce conflicts were arbitrarily resolved.
Warning: 14 states have an endofstream conflict.
+187 out of 385 states have a default reduction.
File "htparser.mly", line 163, characters 05:
Warning: symbol input is never accepted.
File "htparser.mly", line 759, characters 414:
@@ 380,7 +381,6 @@ Warning: in total, 3 productions are never reduced.
92 out of 385 states are represented.
0 out of 163 symbols keep track of their start position.
0 out of 163 symbols keep track of their end position.
187 out of 385 states have a default reduction.
136 out of 226 productions exploit shiftreduce optimization.
0 out of 385 states can peek at an error.
1098 functions before inlining, 146 functions after inlining.
diff git a/test/good/ibal.exp b/test/good/ibal.exp
index 5a47f9651d0f9e98f9891ffed89bd6de4ce9442b..027119495ff600249fa2e319bd0e35801119f99b 100644
 a/test/good/ibal.exp
+++ b/test/good/ibal.exp
@@ 218,6 +218,7 @@ Only 562 states remain after resolving shift/reduce conflicts.
Warning: 48 states have shift/reduce conflicts.
Warning: 358 shift/reduce conflicts were arbitrarily resolved.
Warning: 174 states have an endofstream conflict.
+160 out of 562 states have a default reduction.
File "ibal.mly", line 163, characters 04:
Warning: symbol expr is never accepted.
File "ibal.mly", line 260, characters 728:
@@ 236,7 +237,6 @@ Warning: in total, 7 productions are never reduced.
196 out of 562 states are represented.
0 out of 147 symbols keep track of their start position.
0 out of 147 symbols keep track of their end position.
160 out of 562 states have a default reduction.
103 out of 237 productions exploit shiftreduce optimization.
0 out of 562 states can peek at an error.
1429 functions before inlining, 201 functions after inlining.
diff git a/test/good/ics.exp b/test/good/ics.exp
index 0012d928674a2d03c3d88e161e255219a9b4cf40..0717e228d6643b86a14c9a081b100d323cd6eff5 100644
 a/test/good/ics.exp
+++ b/test/good/ics.exp
@@ 242,13 +242,13 @@ Warning: the precedence level assigned to TO is never useful.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: one state has an endofstream conflict.
+152 out of 395 states have a default reduction.
File "ics.mly", line 125, characters 213:
Warning: production commandsequence > command DOT is never reduced.
Warning: in total, 1 productions are never reduced.
115 out of 395 states are represented.
0 out of 196 symbols keep track of their start position.
0 out of 196 symbols keep track of their end position.
152 out of 395 states have a default reduction.
125 out of 205 productions exploit shiftreduce optimization.
0 out of 395 states can peek at an error.
1044 functions before inlining, 145 functions after inlining.
diff git a/test/good/idl_parser.exp b/test/good/idl_parser.exp
index 087946aea8883d50b713cdf298c1785962649b41..52c26bbc2e09e195ed8a0061b3f204677ae14597 100644
 a/test/good/idl_parser.exp
+++ b/test/good/idl_parser.exp
@@ 241,10 +241,10 @@ Built an LR(0) automaton with 1270 states.
The grammar is not SLR(1)  10 states have a conflict.
Built an LR(1) automaton with 1270 states.
100 shift/reduce conflicts were silently solved.
+463 out of 1270 states have a default reduction.
308 out of 1270 states are represented.
48 out of 177 symbols keep track of their start position.
34 out of 177 symbols keep track of their end position.
463 out of 1270 states have a default reduction.
452 out of 654 productions exploit shiftreduce optimization.
0 out of 1270 states can peek at an error.
3278 functions before inlining, 183 functions after inlining.
diff git a/test/good/ilpars.exp b/test/good/ilpars.exp
index f0e870bb2aa3e5d2c60f354c396a193d9ab48ec7..ebaf9cc1dbeaf103256d2d73bab9a26d83b61729 100644
 a/test/good/ilpars.exp
+++ b/test/good/ilpars.exp
@@ 116,10 +116,10 @@ The grammar is not SLR(1)  7 states have a conflict.
Built an LR(1) automaton with 213 states.
Warning: 5 states have shift/reduce conflicts.
Warning: 5 shift/reduce conflicts were arbitrarily resolved.
+108 out of 213 states have a default reduction.
68 out of 213 states are represented.
0 out of 117 symbols keep track of their start position.
0 out of 117 symbols keep track of their end position.
108 out of 213 states have a default reduction.
84 out of 128 productions exploit shiftreduce optimization.
0 out of 213 states can peek at an error.
597 functions before inlining, 107 functions after inlining.
diff git a/test/good/infinite.exp b/test/good/infinite.exp
index 0ad6909caa677f1cef28da0c04e59bde2c1024e0..67c3126e4c783b44c04209511294c22b93bd225b 100644
 a/test/good/infinite.exp
+++ b/test/good/infinite.exp
@@ 13,13 +13,13 @@ Built an LR(0) automaton with 6 states.
The grammar is SLR(1).
Built an LR(1) automaton with 6 states.
Warning: one state has an endofstream conflict.
+3 out of 6 states have a default reduction.
File "infinite.mly", line 7, characters 23:
Warning: production dummy > A is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 6 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 6 states have a default reduction.
4 out of 4 productions exploit shiftreduce optimization.
0 out of 6 states can peek at an error.
23 functions before inlining, 3 functions after inlining.
diff git a/test/good/inlinemultilevel.exp b/test/good/inlinemultilevel.exp
index ffab2eb645538e522e1aad4a3adb6db7d04c3830..30ad976ebecc078a865c032fcc1f6419feb8bdd3 100644
 a/test/good/inlinemultilevel.exp
+++ b/test/good/inlinemultilevel.exp
@@ 12,10 +12,10 @@ follow(a) = #
Built an LR(0) automaton with 10 states.
The grammar is SLR(1).
Built an LR(1) automaton with 10 states.
+3 out of 10 states have a default reduction.
2 out of 10 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 10 states have a default reduction.
3 out of 3 productions exploit shiftreduce optimization.
0 out of 10 states can peek at an error.
31 functions before inlining, 3 functions after inlining.
diff git a/test/good/inlinemultisons.exp b/test/good/inlinemultisons.exp
index 1ae4dfb7c3968573533d08b3245e2185f920b4c0..9cfa7a53ddda0f41934e1d76b7e82eb4d94b5f7d 100644
 a/test/good/inlinemultisons.exp
+++ b/test/good/inlinemultisons.exp
@@ 9,10 +9,10 @@ follow(s) = #
Built an LR(0) automaton with 11 states.
The grammar is SLR(1).
Built an LR(1) automaton with 11 states.
+4 out of 11 states have a default reduction.
0 out of 11 states are represented.
0 out of 7 symbols keep track of their start position.
0 out of 7 symbols keep track of their end position.
4 out of 11 states have a default reduction.
4 out of 4 productions exploit shiftreduce optimization.
0 out of 11 states can peek at an error.
33 functions before inlining, 3 functions after inlining.
diff git a/test/good/inlineposition.exp b/test/good/inlineposition.exp
index 3f9531ec5007793d7fa57ff91eeac5b568468c47..d5c5b697425a3e3bd9ec2a3717a4c6e527472bf9 100644
 a/test/good/inlineposition.exp
+++ b/test/good/inlineposition.exp
@@ 33,10 +33,10 @@ follow(a1) = A
Built an LR(0) automaton with 26 states.
The grammar is SLR(1).
Built an LR(1) automaton with 26 states.
+10 out of 26 states have a default reduction.
0 out of 26 states are represented.
1 out of 15 symbols keep track of their start position.
3 out of 15 symbols keep track of their end position.
10 out of 26 states have a default reduction.
9 out of 10 productions exploit shiftreduce optimization.
0 out of 26 states can peek at an error.
77 functions before inlining, 2 functions after inlining.
diff git a/test/good/inlinerename.exp b/test/good/inlinerename.exp
index c56a2fd3c40288ae22b81f15018389310ac0b8b6..1f1902b1776a4343c1c1b8f0c811910575e214d5 100644
 a/test/good/inlinerename.exp
+++ b/test/good/inlinerename.exp
@@ 12,10 +12,10 @@ follow(a) = #
Built an LR(0) automaton with 5 states.
The grammar is SLR(1).
Built an LR(1) automaton with 6 states.
+4 out of 6 states have a default reduction.
2 out of 6 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
4 out of 6 states have a default reduction.
2 out of 3 productions exploit shiftreduce optimization.
0 out of 6 states can peek at an error.
23 functions before inlining, 3 functions after inlining.
diff git a/test/good/inlineshift.exp b/test/good/inlineshift.exp
index 9cc825e7f789e549d310a9521ea5b034f1669dde..0369f419e02da282170145c76fae332a431cd5d1 100644
 a/test/good/inlineshift.exp
+++ b/test/good/inlineshift.exp
@@ 12,10 +12,10 @@ follow(a) = #
Built an LR(0) automaton with 7 states.
The grammar is SLR(1).
Built an LR(1) automaton with 8 states.
+4 out of 8 states have a default reduction.
2 out of 8 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
4 out of 8 states have a default reduction.
2 out of 3 productions exploit shiftreduce optimization.
0 out of 8 states can peek at an error.
27 functions before inlining, 3 functions after inlining.
diff git a/test/good/inlinetest.exp b/test/good/inlinetest.exp
index 1a007c099e27b08aaa542f0f7c649be134939623..34b4b979ba2ec7132a090210d73d30bc27ddaac7 100644
 a/test/good/inlinetest.exp
+++ b/test/good/inlinetest.exp
@@ 13,10 +13,10 @@ Built an LR(0) automaton with 9 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 9 states.
4 shift/reduce conflicts were silently solved.
+4 out of 9 states have a default reduction.
3 out of 9 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
4 out of 9 states have a default reduction.
3 out of 5 productions exploit shiftreduce optimization.
0 out of 9 states can peek at an error.
31 functions before inlining, 6 functions after inlining.
diff git a/test/good/inlinewithdollar.exp b/test/good/inlinewithdollar.exp
index d039ae84e7daeafc6f96416257df5d9125d81f7a..795cc550905e9cb08cf5e1cb556ab8675efcc78d 100644
 a/test/good/inlinewithdollar.exp
+++ b/test/good/inlinewithdollar.exp
@@ 9,10 +9,10 @@ follow(s) = #
Built an LR(0) automaton with 5 states.
The grammar is SLR(1).
Built an LR(1) automaton with 5 states.
+2 out of 5 states have a default reduction.
0 out of 5 states are represented.
0 out of 5 symbols keep track of their start position.
0 out of 5 symbols keep track of their end position.
2 out of 5 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 5 states can peek at an error.
19 functions before inlining, 2 functions after inlining.
diff git a/test/good/inlineddollar.exp b/test/good/inlineddollar.exp
index 6e4808ad2a1033f75e0a5926f4be6d5172dfb8a8..086e04c88b7a94da01bd6099d8d20ed202f14445 100644
 a/test/good/inlineddollar.exp
+++ b/test/good/inlineddollar.exp
@@ 9,10 +9,10 @@ follow(t) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/inliningcapture.exp b/test/good/inliningcapture.exp
index 7ba477860b54370537e18ca58f3f7387df04dd67..33f3a8f3e5c2dd4640853a5458db0b8cb6727fcb 100644
 a/test/good/inliningcapture.exp
+++ b/test/good/inliningcapture.exp
@@ 9,10 +9,10 @@ follow(main) = #
Built an LR(0) automaton with 7 states.
The grammar is SLR(1).
Built an LR(1) automaton with 7 states.
+2 out of 7 states have a default reduction.
0 out of 7 states are represented.
4 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
2 out of 7 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
23 functions before inlining, 2 functions after inlining.
diff git a/test/good/jasmc.exp b/test/good/jasmc.exp
index f9b780892a0b0b02b93903de3e501184f840862a..dfc4b40a4245c5c11405ac0d14dc0401dc653d8e 100644
 a/test/good/jasmc.exp
+++ b/test/good/jasmc.exp
@@ 322,6 +322,7 @@ Built an LR(0) automaton with 385 states.
The grammar is SLR(1).
Built an LR(1) automaton with 385 states.
Warning: 50 states have an endofstream conflict.
+177 out of 385 states have a default reduction.
File "jasmc.mly", line 722, characters 415:
Warning: production methods > method_list is never reduced.
File "jasmc.mly", line 723, characters 33:
@@ 330,7 +331,6 @@ Warning: in total, 2 productions are never reduced.
83 out of 385 states are represented.
0 out of 179 symbols keep track of their start position.
0 out of 179 symbols keep track of their end position.
177 out of 385 states have a default reduction.
163 out of 223 productions exploit shiftreduce optimization.
2 out of 385 states can peek at an error.
1102 functions before inlining, 147 functions after inlining.
diff git a/test/good/java.exp b/test/good/java.exp
index b8367dbcf63825e86d9e6083dce2f04926da95e6..64bdee1b4847d534e197d07bc54200ab6c9ebb61 100644
 a/test/good/java.exp
+++ b/test/good/java.exp
@@ 258,10 +258,10 @@ File "java.mly", line 593, characters 5862:
Warning: this %prec declaration is never useful.
File "java.mly", line 562, characters 6166:
Warning: this %prec declaration is never useful.
+155 out of 433 states have a default reduction.
161 out of 433 states are represented.
0 out of 179 symbols keep track of their start position.
0 out of 179 symbols keep track of their end position.
155 out of 433 states have a default reduction.
111 out of 225 productions exploit shiftreduce optimization.
0 out of 433 states can peek at an error.
1170 functions before inlining, 189 functions after inlining.
diff git a/test/good/jml.exp b/test/good/jml.exp
index 500b9d0148a10837d49cf284c58db56997165069..f51f990cf8076fd46c28c813b0a5aa65a98c3988 100644
 a/test/good/jml.exp
+++ b/test/good/jml.exp
@@ 286,10 +286,10 @@ File "jml.mly", line 908, characters 6266:
Warning: this %prec declaration is never useful.
File "jml.mly", line 913, characters 5155:
Warning: this %prec declaration is never useful.
+168 out of 427 states have a default reduction.
159 out of 427 states are represented.
0 out of 185 symbols keep track of their start position.
0 out of 185 symbols keep track of their end position.
168 out of 427 states have a default reduction.
120 out of 220 productions exploit shiftreduce optimization.
0 out of 427 states can peek at an error.
1163 functions before inlining, 185 functions after inlining.
diff git a/test/good/jocamlambients.exp b/test/good/jocamlambients.exp
index 4e0a6ad2008ccd2fc18c9c069cc98bb39a688d89..cecb9acf04625d9080dc61450987aa04aea23d8c 100644
 a/test/good/jocamlambients.exp
+++ b/test/good/jocamlambients.exp
@@ 22,10 +22,10 @@ Built an LR(1) automaton with 49 states.
7 shift/reduce conflicts were silently solved.
File "jocamlambients.mly", line 22, characters 09:
Warning: the precedence level assigned to DOLLAR is never useful.
+18 out of 49 states have a default reduction.
16 out of 49 states are represented.
0 out of 26 symbols keep track of their start position.
0 out of 26 symbols keep track of their end position.
18 out of 49 states have a default reduction.
8 out of 20 productions exploit shiftreduce optimization.
0 out of 49 states can peek at an error.
129 functions before inlining, 23 functions after inlining.
diff git a/test/good/jocamlnewparser.exp b/test/good/jocamlnewparser.exp
index 8badec26794e3018ac0b9514136e9ee63ea6460b..45d0908d59460d0d8b0ffe267f6173f56fb098be 100644
 a/test/good/jocamlnewparser.exp
+++ b/test/good/jocamlnewparser.exp
@@ 469,10 +469,10 @@ File "jocamlnewparser.mly", line 1093, characters 1023:
Warning: this %prec declaration is never useful.
Warning: 52 states have shift/reduce conflicts.
Warning: 487 shift/reduce conflicts were arbitrarily resolved.
+521 out of 1607 states have a default reduction.
880 out of 1607 states are represented.
0 out of 241 symbols keep track of their start position.
0 out of 241 symbols keep track of their end position.
521 out of 1607 states have a default reduction.
236 out of 467 productions exploit shiftreduce optimization.
456 out of 1607 states can peek at an error.
3816 functions before inlining, 954 functions after inlining.
diff git a/test/good/jocaml.exp b/test/good/jocaml.exp
index 5075c397c7ac2f507e282c4edc62e8c41d4726ea..bc167d257e18a308c40cf28116f6ef5c8fcf72cf 100644
 a/test/good/jocaml.exp
+++ b/test/good/jocaml.exp
@@ 525,10 +525,10 @@ Warning: 80 states have shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: 148 shift/reduce conflicts were arbitrarily resolved.
Warning: one reduce/reduce conflict was arbitrarily resolved.
+569 out of 1824 states have a default reduction.
1002 out of 1824 states are represented.
0 out of 251 symbols keep track of their start position.
0 out of 251 symbols keep track of their end position.
569 out of 1824 states have a default reduction.
245 out of 502 productions exploit shiftreduce optimization.
511 out of 1824 states can peek at an error.
4293 functions before inlining, 1047 functions after inlining.
diff git a/test/good/jparser.exp b/test/good/jparser.exp
index eb7d41362ae980aa9ca53c13591cf6b0aa56d9a8..af326f3d009a6f5d464cffce54742760211f3a5b 100644
 a/test/good/jparser.exp
+++ b/test/good/jparser.exp
@@ 512,10 +512,10 @@ Warning: the precedence level assigned to USHR is never useful.
File "jparser.mly", line 273, characters 05:
Warning: the precedence level assigned to XOR is never useful.
Warning: 2 states have an endofstream conflict.
+326 out of 873 states have a default reduction.
333 out of 873 states are represented.
0 out of 307 symbols keep track of their start position.
0 out of 307 symbols keep track of their end position.
326 out of 873 states have a default reduction.
240 out of 415 productions exploit shiftreduce optimization.
0 out of 873 states can peek at an error.
2318 functions before inlining, 362 functions after inlining.
diff git a/test/good/judicael.exp b/test/good/judicael.exp
index 9a1da422016f9047aee2b0add01887eb523e53ff..a2479a416ac4c08cd4c813552a63f7d07236cbde 100644
 a/test/good/judicael.exp
+++ b/test/good/judicael.exp
@@ 17,13 +17,13 @@ The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 10 states.
One shift/reduce conflict was silently solved.
Warning: 3 states have an endofstream conflict.
+5 out of 10 states have a default reduction.
File "judicael.mly", line 35, characters 04:
Warning: production instruction > expr is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 10 states are represented.
0 out of 12 symbols keep track of their start position.
0 out of 12 symbols keep track of their end position.
5 out of 10 states have a default reduction.
5 out of 6 productions exploit shiftreduce optimization.
0 out of 10 states can peek at an error.
34 functions before inlining, 5 functions after inlining.
diff git a/test/good/julia.exp b/test/good/julia.exp
index 0a1c14c47ef8068894c1d4e3a40b1b1c346d9597..056bec556c35f0d72c2e7d1ec3f4f2149d1baae4 100644
 a/test/good/julia.exp
+++ b/test/good/julia.exp
@@ 14,10 +14,10 @@ Built an LR(0) automaton with 13 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 13 states.
One shift/reduce conflict was silently solved.
+5 out of 13 states have a default reduction.
3 out of 13 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.
5 out of 13 states have a default reduction.
4 out of 6 productions exploit shiftreduce optimization.
0 out of 13 states can peek at an error.
41 functions before inlining, 6 functions after inlining.
diff git a/test/good/ketti.exp b/test/good/ketti.exp
index 2c340067fb7a976a271e5281d9885f2bc0f6d4d9..df7bed07af5f620c3abf086a632ca97d1000d9b8 100644
 a/test/good/ketti.exp
+++ b/test/good/ketti.exp
@@ 18,13 +18,13 @@ Warning: 2 states have reduce/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
Warning: 2 reduce/reduce conflicts were arbitrarily resolved.
Warning: 7 states have an endofstream conflict.
+3 out of 15 states have a default reduction.
File "ketti.mly", line 5, characters 04:
Warning: symbol expr is never accepted.
Warning: in total, 1 productions are never reduced.
4 out of 15 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
3 out of 15 states have a default reduction.
3 out of 7 productions exploit shiftreduce optimization.
0 out of 15 states can peek at an error.
45 functions before inlining, 9 functions after inlining.
diff git a/test/good/kimmit.exp b/test/good/kimmit.exp
index 304b72e2555fcbeb2610383ce13020a6d439af28..4b1248b9304462810f94a1fb708fcf615f6ae9e0 100644
 a/test/good/kimmit.exp
+++ b/test/good/kimmit.exp
@@ 7,10 +7,10 @@ follow(s) = #
Built an LR(0) automaton with 3 states.
The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 5 symbols keep track of their start position.
0 out of 5 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/labltkcompiler.exp b/test/good/labltkcompiler.exp
index 18400a49c76fb1534e0f83b8546b16c9e9ada285..b4e4931d38eb0b10c506e48d1cf27a0c41042b4a 100644
 a/test/good/labltkcompiler.exp
+++ b/test/good/labltkcompiler.exp
@@ 90,10 +90,10 @@ The grammar is not SLR(1)  3 states have a conflict.
Built an LR(1) automaton with 179 states.
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
+63 out of 179 states have a default reduction.
47 out of 179 states are represented.
0 out of 62 symbols keep track of their start position.
0 out of 62 symbols keep track of their end position.
63 out of 179 states have a default reduction.
43 out of 80 productions exploit shiftreduce optimization.
0 out of 179 states can peek at an error.
472 functions before inlining, 66 functions after inlining.
diff git a/test/good/labltkppyac.exp b/test/good/labltkppyac.exp
index 8bacbec7477cc7d0d89cdf4723fc49685736f221..4959136a99a6339001ed53014ebc8d0e8ea64322 100644
 a/test/good/labltkppyac.exp
+++ b/test/good/labltkppyac.exp
@@ 13,10 +13,10 @@ Built an LR(0) automaton with 19 states.
The grammar is SLR(1).
Built an LR(1) automaton with 21 states.
Warning: 9 states have an endofstream conflict.
+10 out of 21 states have a default reduction.
7 out of 21 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.
10 out of 21 states have a default reduction.
7 out of 10 productions exploit shiftreduce optimization.
0 out of 21 states can peek at an error.
60 functions before inlining, 12 functions after inlining.
diff git a/test/good/lambdoc_rlambtex_parser.exp b/test/good/lambdoc_rlambtex_parser.exp
index 85f03cbaf2db5f14e241c60267c485dedd502809..aa5264d026a61d14838a8ad604320c8bae7f948c 100644
 a/test/good/lambdoc_rlambtex_parser.exp
+++ b/test/good/lambdoc_rlambtex_parser.exp
@@ 370,10 +370,10 @@ follow(anon_item_frag) = ITEM END_DUMMY
Built an LR(0) automaton with 381 states.
The grammar is SLR(1).
Built an LR(1) automaton with 381 states.
+196 out of 381 states have a default reduction.
140 out of 381 states are represented.
0 out of 220 symbols keep track of their start position.
0 out of 220 symbols keep track of their end position.
196 out of 381 states have a default reduction.
140 out of 217 productions exploit shiftreduce optimization.
0 out of 381 states can peek at an error.
1107 functions before inlining, 128 functions after inlining.
diff git a/test/good/lem.exp b/test/good/lem.exp
index d0b36ed9e30e25a5569597d9258d492332ac8237..04b99b764bd760eff562dd5ec45701f38f0a1b4f 100644
 a/test/good/lem.exp
+++ b/test/good/lem.exp
@@ 389,10 +389,10 @@ Warning: 2 states have shift/reduce conflicts.
Warning: 2 states have reduce/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
Warning: 2 reduce/reduce conflicts were arbitrarily resolved.
+288 out of 733 states have a default reduction.
242 out of 733 states are represented.
0 out of 242 symbols keep track of their start position.
0 out of 242 symbols keep track of their end position.
288 out of 733 states have a default reduction.
191 out of 367 productions exploit shiftreduce optimization.
0 out of 733 states can peek at an error.
1962 functions before inlining, 246 functions after inlining.
diff git a/test/good/liberty_parser.exp b/test/good/liberty_parser.exp
index 64e66831080cafa4cd2b82937f4a08bbbf819d4d..244182306875551035fef449d8655d4096ca5180 100644
 a/test/good/liberty_parser.exp
+++ b/test/good/liberty_parser.exp
@@ 1513,10 +1513,10 @@ Built an LR(0) automaton with 77 states.
The grammar is not SLR(1)  6 states have a conflict.
Built an LR(1) automaton with 81 states.
24 shift/reduce conflicts were silently solved.
+39 out of 81 states have a default reduction.
22 out of 81 states are represented.
0 out of 771 symbols keep track of their start position.
0 out of 771 symbols keep track of their end position.
39 out of 81 states have a default reduction.
31 out of 43 productions exploit shiftreduce optimization.
0 out of 81 states can peek at an error.
225 functions before inlining, 38 functions after inlining.
diff git a/test/good/link.exp b/test/good/link.exp
index f680d7eb9b80e7de1591ac13958398b4f0c01790..129aa9cbd61bc350fbad0a800172be5843900c57 100644
 a/test/good/link.exp
+++ b/test/good/link.exp
@@ 16,10 +16,10 @@ Built an LR(1) automaton with 30 states.
20 shift/reduce conflicts were silently solved.
Warning: 7 states have shift/reduce conflicts.
Warning: 36 shift/reduce conflicts were arbitrarily resolved.
+6 out of 30 states have a default reduction.
11 out of 30 states are represented.
0 out of 20 symbols keep track of their start position.
0 out of 20 symbols keep track of their end position.
6 out of 30 states have a default reduction.
6 out of 16 productions exploit shiftreduce optimization.
0 out of 30 states can peek at an error.
85 functions before inlining, 16 functions after inlining.
diff git a/test/good/links.exp b/test/good/links.exp
index b734b7f1478b5eda59cfa2a0461ed7b40ea4e8ee..fcb0eca75b9a35c0a95d5e28e2ce020dd1c7f59b 100644
 a/test/good/links.exp
+++ b/test/good/links.exp
@@ 479,10 +479,10 @@ The grammar is not SLR(1)  9 states have a conflict.
Built an LR(1) automaton with 847 states.
Warning: 2 states have reduce/reduce conflicts.
Warning: 4 reduce/reduce conflicts were arbitrarily resolved.
+385 out of 847 states have a default reduction.
249 out of 847 states are represented.
0 out of 309 symbols keep track of their start position.
0 out of 309 symbols keep track of their end position.
385 out of 847 states have a default reduction.
280 out of 478 productions exploit shiftreduce optimization.
0 out of 847 states can peek at an error.
2337 functions before inlining, 347 functions after inlining.
diff git a/test/good/llparse.exp b/test/good/llparse.exp
index 140850d91f5c784049e2e1bd0176906cbc98a61a..ae6339f8433366f2f86989b3ff707cd68726bea6 100644
 a/test/good/llparse.exp
+++ b/test/good/llparse.exp
@@ 273,10 +273,10 @@ The grammar is not SLR(1)  11 states have a conflict.
Built an LR(1) automaton with 1165 states.
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
+434 out of 1165 states have a default reduction.
434 out of 1165 states are represented.
0 out of 360 symbols keep track of their start position.
0 out of 360 symbols keep track of their end position.
434 out of 1165 states have a default reduction.
394 out of 495 productions exploit shiftreduce optimization.
0 out of 1165 states can peek at an error.
2918 functions before inlining, 429 functions after inlining.
diff git a/test/good/logic_parser.exp b/test/good/logic_parser.exp
index 373671245435beff36a5ae307a652e99104e9f5c..a826a37eabaf11b8c9282929fe23ebf803da9885 100644
 a/test/good/logic_parser.exp
+++ b/test/good/logic_parser.exp
@@ 603,10 +603,10 @@ File "logic_parser.mly", line 400, characters 3144:
Warning: this %prec declaration is never useful.
File "logic_parser.mly", line 402, characters 3851:
Warning: this %prec declaration is never useful.
+599 out of 1132 states have a default reduction.
399 out of 1132 states are represented.
0 out of 342 symbols keep track of their start position.
0 out of 342 symbols keep track of their end position.
599 out of 1132 states have a default reduction.
410 out of 663 productions exploit shiftreduce optimization.
0 out of 1132 states can peek at an error.
3118 functions before inlining, 567 functions after inlining.
diff git a/test/good/loop.exp b/test/good/loop.exp
index ce7f33119cd7f910d9985c95cba97be4c11a7814..73270b0f8abb22c80520eafaf11ec46899116d73 100644
 a/test/good/loop.exp
+++ b/test/good/loop.exp
@@ 15,13 +15,13 @@ The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 8 states.
2 shift/reduce conflicts were silently solved.
Only 7 states remain after resolving shift/reduce conflicts.
+5 out of 7 states have a default reduction.
File "loop.mly", line 26, characters 23:
Warning: production s > B is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 7 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
5 out of 7 states have a default reduction.
4 out of 5 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
27 functions before inlining, 2 functions after inlining.
diff git a/test/good/lrbutnotlalr.exp b/test/good/lrbutnotlalr.exp
index cba8f617a3d25da6cc9c0dd509d8a39d06540000..eb6c1edeb679055268b2cf53e21a047a281bd453 100644
 a/test/good/lrbutnotlalr.exp
+++ b/test/good/lrbutnotlalr.exp
@@ 13,10 +13,10 @@ follow(e) = D C
Built an LR(0) automaton with 13 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 14 states.
+5 out of 14 states have a default reduction.
2 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.
5 out of 14 states have a default reduction.
5 out of 7 productions exploit shiftreduce optimization.
0 out of 14 states can peek at an error.
44 functions before inlining, 6 functions after inlining.
diff git a/test/good/ltlparser.exp b/test/good/ltlparser.exp
index 99fde0761cb217919b88c4a58e1208d325c35323..964a7e9d492c0e348ed1be3bfbf95294b16e5eaf 100644
 a/test/good/ltlparser.exp
+++ b/test/good/ltlparser.exp
@@ 56,10 +56,10 @@ File "ltlparser.mly", line 64, characters 06:
Warning: the precedence level assigned to LTL_STAR is never useful.
Warning: 5 states have shift/reduce conflicts.
Warning: 7 shift/reduce conflicts were arbitrarily resolved.
+30 out of 93 states have a default reduction.
28 out of 93 states are represented.
0 out of 48 symbols keep track of their start position.
0 out of 48 symbols keep track of their end position.
30 out of 93 states have a default reduction.
18 out of 46 productions exploit shiftreduce optimization.
0 out of 93 states can peek at an error.
247 functions before inlining, 47 functions after inlining.
diff git a/test/good/lustreParser.exp b/test/good/lustreParser.exp
index 89f3ddf517eab220564920ba13855665a23eb511..7ab0c73e00eacaf6bd96b346911bb21d6fe78a30 100644
 a/test/good/lustreParser.exp
+++ b/test/good/lustreParser.exp
@@ 232,10 +232,10 @@ Built an LR(0) automaton with 388 states.
The grammar is not SLR(1)  29 states have a conflict.
Built an LR(1) automaton with 388 states.
563 shift/reduce conflicts were silently solved.
+135 out of 388 states have a default reduction.
132 out of 388 states are represented.
53 out of 147 symbols keep track of their start position.
2 out of 147 symbols keep track of their end position.
135 out of 388 states have a default reduction.
116 out of 189 productions exploit shiftreduce optimization.
0 out of 388 states can peek at an error.
1046 functions before inlining, 128 functions after inlining.
diff git a/test/good/macrodown.exp b/test/good/macrodown.exp
index dfed0de0a40ba4fdbc4201ba5fc092ba526e2660..2eec86d60257fa4aee092e29410e87949b3811ae 100644
 a/test/good/macrodown.exp
+++ b/test/good/macrodown.exp
@@ 157,10 +157,10 @@ File "macrodown.mly", line 221, characters 09:
Warning: the precedence level assigned to VAR is never useful.
File "macrodown.mly", line 211, characters 09:
Warning: the precedence level assigned to WHILE is never useful.
+171 out of 363 states have a default reduction.
125 out of 363 states are represented.
0 out of 106 symbols keep track of their start position.
0 out of 106 symbols keep track of their end position.
171 out of 363 states have a default reduction.
134 out of 213 productions exploit shiftreduce optimization.
0 out of 363 states can peek at an error.
979 functions before inlining, 93 functions after inlining.
diff git a/test/good/maple.exp b/test/good/maple.exp
index 9d5f0f10e72362b2773ec5a92332cdb6fa89dbfc..4c4f4dde48d5335776a48221f75e2d63350a3bd3 100644
 a/test/good/maple.exp
+++ b/test/good/maple.exp
@@ 98,10 +98,10 @@ File "maple.mly", line 85, characters 05:
Warning: the precedence level assigned to DOT is never useful.
File "maple.mly", line 84, characters 09:
Warning: the precedence level assigned to PERCENT is never useful.
+64 out of 215 states have a default reduction.
128 out of 215 states are represented.
0 out of 102 symbols keep track of their start position.
0 out of 102 symbols keep track of their end position.
64 out of 215 states have a default reduction.
48 out of 107 productions exploit shiftreduce optimization.
0 out of 215 states can peek at an error.
566 functions before inlining, 92 functions after inlining.
diff git a/test/good/mccfc.exp b/test/good/mccfc.exp
index 2314365ee2c251d65c49337c8a3080b0ddcd2e44..313fd8c963e3bbf946c1e9315e063047fee48a72 100644
 a/test/good/mccfc.exp
+++ b/test/good/mccfc.exp
@@ 340,10 +340,10 @@ File "mccfc.mly", line 1395, characters 6983:
Warning: this %prec declaration is never useful.
File "mccfc.mly", line 1401, characters 7585:
Warning: this %prec declaration is never useful.
+219 out of 519 states have a default reduction.
169 out of 519 states are represented.
0 out of 175 symbols keep track of their start position.
0 out of 175 symbols keep track of their end position.
219 out of 519 states have a default reduction.
171 out of 298 productions exploit shiftreduce optimization.
0 out of 519 states can peek at an error.
1439 functions before inlining, 225 functions after inlining.
diff git a/test/good/mccfj.exp b/test/good/mccfj.exp
index fadb89b870df61656ca3e59ddf53de767864574e..5c8c2f2e88e7d62e57735c15423e3a1266cbe0cd 100644
 a/test/good/mccfj.exp
+++ b/test/good/mccfj.exp
@@ 235,10 +235,10 @@ File "mccfj.mly", line 955, characters 6270:
Warning: this %prec declaration is never useful.
File "mccfj.mly", line 979, characters 8490:
Warning: this %prec declaration is never useful.
+109 out of 291 states have a default reduction.
77 out of 291 states are represented.
0 out of 142 symbols keep track of their start position.
0 out of 142 symbols keep track of their end position.
109 out of 291 states have a default reduction.
89 out of 173 productions exploit shiftreduce optimization.
0 out of 291 states can peek at an error.
817 functions before inlining, 131 functions after inlining.
diff git a/test/good/mccfrontends.exp b/test/good/mccfrontends.exp
index d513b374478e8af517a8981fddca1e59b6c05f79..4b1c5814a00897c7bc82a4549441d6d5ecfb04cf 100644
 a/test/good/mccfrontends.exp
+++ b/test/good/mccfrontends.exp
@@ 36,10 +36,10 @@ follow(assignment) = TokLeftBrack TokId TokEof
Built an LR(0) automaton with 22 states.
The grammar is SLR(1).
Built an LR(1) automaton with 22 states.
+11 out of 22 states have a default reduction.
5 out of 22 states are represented.
0 out of 21 symbols keep track of their start position.
0 out of 21 symbols keep track of their end position.
11 out of 22 states have a default reduction.
11 out of 14 productions exploit shiftreduce optimization.
0 out of 22 states can peek at an error.
74 functions before inlining, 9 functions after inlining.
diff git a/test/good/mccmc.exp b/test/good/mccmc.exp
index e32b9ea2b8030936d32161e5678a8e1fe72aa6e0..62252a1914a6abfa2744b18625535372441b574f 100644
 a/test/good/mccmc.exp
+++ b/test/good/mccmc.exp
@@ 32,13 +32,13 @@ Built an LR(0) automaton with 34 states.
The grammar is SLR(1).
Built an LR(1) automaton with 34 states.
Warning: 11 states have an endofstream conflict.
+13 out of 34 states have a default reduction.
File "mccmc.mly", line 71, characters 623:
Warning: production program > source_block_list is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 34 states are represented.
0 out of 24 symbols keep track of their start position.
0 out of 24 symbols keep track of their end position.
13 out of 34 states have a default reduction.
14 out of 14 productions exploit shiftreduce optimization.
0 out of 34 states can peek at an error.
94 functions before inlining, 7 functions after inlining.
diff git a/test/good/mccmoogle.exp b/test/good/mccmoogle.exp
index 02c74de85e362844beaa4bd51714b8e7e9e2cd83..56dd3fdb2b39ba886aa47b4de4fc43f4adc8f0d6 100644
 a/test/good/mccmoogle.exp
+++ b/test/good/mccmoogle.exp
@@ 206,10 +206,10 @@ File "mccmoogle.mly", line 111, characters 06:
Warning: the precedence level assigned to TokPow2 is never useful.
File "mccmoogle.mly", line 111, characters 06:
Warning: the precedence level assigned to TokTilde is never useful.
+130 out of 283 states have a default reduction.
82 out of 283 states are represented.
0 out of 127 symbols keep track of their start position.
0 out of 127 symbols keep track of their end position.
130 out of 283 states have a default reduction.
111 out of 167 productions exploit shiftreduce optimization.
0 out of 283 states can peek at an error.
802 functions before inlining, 146 functions after inlining.
diff git a/test/good/mccnaml.exp b/test/good/mccnaml.exp
index f5abd183d999d44ec54d8f7acf338ac15e072ae5..b589be895c6cef629aec7c3149b226372d091e55 100644
 a/test/good/mccnaml.exp
+++ b/test/good/mccnaml.exp
@@ 319,10 +319,10 @@ File "mccnaml.mly", line 571, characters 5764:
Warning: this %prec declaration is never useful.
File "mccnaml.mly", line 646, characters 5265:
Warning: this %prec declaration is never useful.
+141 out of 507 states have a default reduction.
189 out of 507 states are represented.
0 out of 143 symbols keep track of their start position.
0 out of 143 symbols keep track of their end position.
141 out of 507 states have a default reduction.
92 out of 230 productions exploit shiftreduce optimization.
0 out of 507 states can peek at an error.
1312 functions before inlining, 201 functions after inlining.
diff git a/test/good/mccpascal.exp b/test/good/mccpascal.exp
index 9fe00228e0f6afe168d2616d4d3d42e697256e42..a93630260e4b3575fae6d21990775678e41b0db1 100644
 a/test/good/mccpascal.exp
+++ b/test/good/mccpascal.exp
@@ 314,10 +314,10 @@ File "mccpascal.mly", line 152, characters 05:
Warning: the precedence level assigned to TokStart is never useful.
Warning: 2 states have shift/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
+188 out of 420 states have a default reduction.
120 out of 420 states are represented.
0 out of 169 symbols keep track of their start position.
0 out of 169 symbols keep track of their end position.
188 out of 420 states have a default reduction.
141 out of 197 productions exploit shiftreduce optimization.
0 out of 420 states can peek at an error.
1131 functions before inlining, 147 functions after inlining.
diff git a/test/good/mccpasqual.exp b/test/good/mccpasqual.exp
index 7efef6b5199c6c2371c9bde5bff61ea3ce62d4e8..b39b68c2a7f3af138171e4787f7e4b3a45ade3f4 100644
 a/test/good/mccpasqual.exp
+++ b/test/good/mccpasqual.exp
@@ 498,10 +498,10 @@ Warning: the precedence level assigned to prec_unary is never useful.
File "mccpasqual.mly", line 1213, characters 8398:
Warning: this %prec declaration is never useful.
Warning: 114 states have an endofstream conflict.
+354 out of 675 states have a default reduction.
180 out of 675 states are represented.
0 out of 253 symbols keep track of their start position.
0 out of 253 symbols keep track of their end position.
354 out of 675 states have a default reduction.
268 out of 367 productions exploit shiftreduce optimization.
0 out of 675 states can peek at an error.
1862 functions before inlining, 269 functions after inlining.
diff git a/test/good/mccphobos.exp b/test/good/mccphobos.exp
index 60b0bf7b90d83ace60add5b8d420a8363185c09d..dac333aecfea3240c65474204da100704b944a5e 100644
 a/test/good/mccphobos.exp
+++ b/test/good/mccphobos.exp
@@ 267,10 +267,10 @@ follow(assoc) = TokRightAssoc TokNonAssoc TokLeftAssoc TokGrammar
Built an LR(0) automaton with 217 states.
The grammar is SLR(1).
Built an LR(1) automaton with 217 states.
+101 out of 217 states have a default reduction.
62 out of 217 states are represented.
0 out of 129 symbols keep track of their start position.
0 out of 129 symbols keep track of their end position.
101 out of 217 states have a default reduction.
84 out of 150 productions exploit shiftreduce optimization.
0 out of 217 states can peek at an error.
677 functions before inlining, 87 functions after inlining.
diff git a/test/good/mccprof.exp b/test/good/mccprof.exp
index d081e2b29bacdc5103dc03d2b2d82b0ba2d510dd..95a80d5abbf6f9547a17b3147f7fe7f558cbd9f1 100644
 a/test/good/mccprof.exp
+++ b/test/good/mccprof.exp
@@ 28,10 +28,10 @@ Built an LR(0) automaton with 42 states.
The grammar is not SLR(1)  4 states have a conflict.
Built an LR(1) automaton with 42 states.
16 shift/reduce conflicts were silently solved.
+16 out of 42 states have a default reduction.
11 out of 42 states are represented.
0 out of 29 symbols keep track of their start position.
0 out of 29 symbols keep track of their end position.
16 out of 42 states have a default reduction.
13 out of 21 productions exploit shiftreduce optimization.
0 out of 42 states can peek at an error.
118 functions before inlining, 22 functions after inlining.
diff git a/test/good/mccpython.exp b/test/good/mccpython.exp
index e9ae67e0734d2bdcedcaa95f7a80c111a4c1d775..1f9c3366f61e5f81619107cdd6c742e7040a419e 100644
 a/test/good/mccpython.exp
+++ b/test/good/mccpython.exp
@@ 282,13 +282,13 @@ Warning: the precedence level assigned to Not is never useful.
File "mccpython.mly", line 149, characters 09:
Warning: the precedence level assigned to Plus is never useful.
Warning: 38 states have an endofstream conflict.
+164 out of 369 states have a default reduction.
File "mccpython.mly", line 1164, characters 318:
Warning: production file_input > file_input_list is never reduced.
Warning: in total, 1 productions are never reduced.
97 out of 369 states are represented.
0 out of 170 symbols keep track of their start position.
0 out of 170 symbols keep track of their end position.
164 out of 369 states have a default reduction.
128 out of 233 productions exploit shiftreduce optimization.
0 out of 369 states can peek at an error.
1063 functions before inlining, 141 functions after inlining.
diff git a/test/good/metaocaml.exp b/test/good/metaocaml.exp
index 425cf6591997f6baed7f4804fe78db4d84d06f27..2966e8b8fa5d9ee66e77f4a34ca4b539973242aa 100644
 a/test/good/metaocaml.exp
+++ b/test/good/metaocaml.exp
@@ 453,6 +453,7 @@ Warning: 12 states have shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: 142 shift/reduce conflicts were arbitrarily resolved.
Warning: 6 reduce/reduce conflicts were arbitrarily resolved.
+633 out of 1875 states have a default reduction.
File "metaocaml.mly", line 1164, characters 527:
Warning: production record_expr_f90 > lbl_expr_list opt_semi is never reduced.
File "metaocaml.mly", line 1146, characters 426:
@@ 463,7 +464,6 @@ Warning: in total, 3 productions are never reduced.
955 out of 1875 states are represented.
0 out of 272 symbols keep track of their start position.
0 out of 272 symbols keep track of their end position.
633 out of 1875 states have a default reduction.
263 out of 528 productions exploit shiftreduce optimization.
463 out of 1875 states can peek at an error.
4428 functions before inlining, 1113 functions after inlining.
diff git a/test/good/mezzo.exp b/test/good/mezzo.exp
index 93aa40762c7813ee4fda8ca832cfcac64b279cde..ebbb2a2ee243e6ffbd4a412073c83ececebd1029 100644
 a/test/good/mezzo.exp
+++ b/test/good/mezzo.exp
@@ 259,10 +259,10 @@ Built an LR(0) automaton with 504 states.
The grammar is not SLR(1)  27 states have a conflict.
Built an LR(1) automaton with 504 states.
197 shift/reduce conflicts were silently solved.
+186 out of 504 states have a default reduction.
190 out of 504 states are represented.
69 out of 174 symbols keep track of their start position.
92 out of 174 symbols keep track of their end position.
186 out of 504 states have a default reduction.
104 out of 259 productions exploit shiftreduce optimization.
0 out of 504 states can peek at an error.
1359 functions before inlining, 214 functions after inlining.
diff git a/test/good/miniCparser.exp b/test/good/miniCparser.exp
index 7552df87fb5370afdd38ae04ff884559cdd2cb49..0e666ad7604f31f33e84e14fa6655ead1c7e810e 100644
 a/test/good/miniCparser.exp
+++ b/test/good/miniCparser.exp
@@ 82,10 +82,10 @@ Warning: the precedence level assigned to RBRACKET is never useful.
Warning: 6 states have shift/reduce conflicts.
Warning: 6 shift/reduce conflicts were arbitrarily resolved.
Warning: 6 states have an endofstream conflict.
+68 out of 228 states have a default reduction.
80 out of 228 states are represented.
0 out of 68 symbols keep track of their start position.
0 out of 68 symbols keep track of their end position.
68 out of 228 states have a default reduction.
48 out of 88 productions exploit shiftreduce optimization.
0 out of 228 states can peek at an error.
575 functions before inlining, 91 functions after inlining.
diff git a/test/good/miniMLparser.exp b/test/good/miniMLparser.exp
index 97f8daf4feac2e6378397cf446fa00a3655e0f9a..5f2a5cb8e81445da3cec36e6d0d54aba96a2b97a 100644
 a/test/good/miniMLparser.exp
+++ b/test/good/miniMLparser.exp
@@ 81,10 +81,10 @@ Built an LR(1) automaton with 155 states.
114 shift/reduce conflicts were silently solved.
Warning: 17 states have shift/reduce conflicts.
Warning: 48 shift/reduce conflicts were arbitrarily resolved.
+38 out of 155 states have a default reduction.
56 out of 155 states are represented.
0 out of 65 symbols keep track of their start position.
0 out of 65 symbols keep track of their end position.
38 out of 155 states have a default reduction.
31 out of 71 productions exploit shiftreduce optimization.
0 out of 155 states can peek at an error.
412 functions before inlining, 65 functions after inlining.
diff git a/test/good/modelica.exp b/test/good/modelica.exp
index c3ab9b18ed967e1f4431709c7c989de37759c4a3..ff280a31b3bae552a136445b859803507a2b60c4 100644
 a/test/good/modelica.exp
+++ b/test/good/modelica.exp
@@ 401,10 +401,10 @@ File "modelica.mly", line 325, characters 108118:
Warning: this %prec declaration is never useful.
File "modelica.mly", line 326, characters 122130:
Warning: this %prec declaration is never useful.
+229 out of 612 states have a default reduction.
247 out of 612 states are represented.
2 out of 224 symbols keep track of their start position.
2 out of 224 symbols keep track of their end position.
229 out of 612 states have a default reduction.
163 out of 311 productions exploit shiftreduce optimization.
0 out of 612 states can peek at an error.
1663 functions before inlining, 236 functions after inlining.
diff git a/test/good/modelyze.exp b/test/good/modelyze.exp
index 1e23b7fe18e052ef8d59472a1c8b31eb0e90cfe9..ed61972ae9c8e11846e83156b78574650b151383 100644
 a/test/good/modelyze.exp
+++ b/test/good/modelyze.exp
@@ 119,10 +119,10 @@ File "modelyze.mly", line 203, characters 3439:
Warning: this %prec declaration is never useful.
File "modelyze.mly", line 206, characters 5156:
Warning: this %prec declaration is never useful.
+122 out of 455 states have a default reduction.
176 out of 455 states are represented.
0 out of 135 symbols keep track of their start position.
0 out of 135 symbols keep track of their end position.
122 out of 455 states have a default reduction.
74 out of 205 productions exploit shiftreduce optimization.
0 out of 455 states can peek at an error.
1153 functions before inlining, 182 functions after inlining.
diff git a/test/good/modulo.exp b/test/good/modulo.exp
index 35ba7a55c9e202b3c3443310ea50eb3103323b85..5d1d9dd512c59537e603069ff885d062c787b831 100644
 a/test/good/modulo.exp
+++ b/test/good/modulo.exp
@@ 158,10 +158,10 @@ Built an LR(0) automaton with 272 states.
The grammar is not SLR(1)  8 states have a conflict.
Built an LR(1) automaton with 272 states.
64 shift/reduce conflicts were silently solved.
+96 out of 272 states have a default reduction.
98 out of 272 states are represented.
0 out of 106 symbols keep track of their start position.
0 out of 106 symbols keep track of their end position.
96 out of 272 states have a default reduction.
62 out of 133 productions exploit shiftreduce optimization.
0 out of 272 states can peek at an error.
730 functions before inlining, 110 functions after inlining.
diff git a/test/good/multiplefunctor.exp b/test/good/multiplefunctor.exp
index 5ca0af9909697ed103e945d2b3fe00750965ebf1..5f0873c5a5bf61e02293379e84fddb53f802bfeb 100644
 a/test/good/multiplefunctor.exp
+++ b/test/good/multiplefunctor.exp
@@ 7,10 +7,10 @@ follow(main) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/nameclash1.exp b/test/good/nameclash1.exp
index dd1cfaea9815a10d1a657e200cf48861a082587b..00a3450a39c69fb57c431102133ba9e963ac1487 100644
 a/test/good/nameclash1.exp
+++ b/test/good/nameclash1.exp
@@ 18,10 +18,10 @@ follow(b) = #
Built an LR(0) automaton with 8 states.
The grammar is SLR(1).
Built an LR(1) automaton with 8 states.
+6 out of 8 states have a default reduction.
0 out of 8 states are represented.
0 out of 10 symbols keep track of their start position.
0 out of 10 symbols keep track of their end position.
6 out of 8 states have a default reduction.
6 out of 6 productions exploit shiftreduce optimization.
0 out of 8 states can peek at an error.
33 functions before inlining, 4 functions after inlining.
diff git a/test/good/netsem.exp b/test/good/netsem.exp
index c9859b889a007bf706e3b7923b491a5260c6e31a..7c269c863317bc3b5cee847dcfd090cc9a6d9857 100644
 a/test/good/netsem.exp
+++ b/test/good/netsem.exp
@@ 304,10 +304,10 @@ follow(abstime) = RPAREN COMMENT
Built an LR(0) automaton with 996 states.
The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 996 states.
+439 out of 996 states have a default reduction.
253 out of 996 states are represented.
0 out of 404 symbols keep track of their start position.
0 out of 404 symbols keep track of their end position.
439 out of 996 states have a default reduction.
332 out of 448 productions exploit shiftreduce optimization.
0 out of 996 states can peek at an error.
2545 functions before inlining, 354 functions after inlining.
diff git a/test/good/nexus.exp b/test/good/nexus.exp
index 3417962675fa2c695afce789f23001d91e4631f2..15e93d786be767465a5d95841c9fa6a12b547ef8 100644
 a/test/good/nexus.exp
+++ b/test/good/nexus.exp
@@ 284,10 +284,10 @@ Built an LR(0) automaton with 941 states.
The grammar is not SLR(1)  6 states have a conflict.
Built an LR(1) automaton with 956 states.
Warning: 5 states have an endofstream conflict.
+405 out of 956 states have a default reduction.
229 out of 956 states are represented.
0 out of 274 symbols keep track of their start position.
0 out of 274 symbols keep track of their end position.
405 out of 956 states have a default reduction.
300 out of 450 productions exploit shiftreduce optimization.
16 out of 956 states can peek at an error.
2466 functions before inlining, 420 functions after inlining.
diff git a/test/good/nmlipparser.exp b/test/good/nmlipparser.exp
index da02cc68fe9ea0d96d617a4e89f468262774fef2..3e040a1879b2ff3214412bc72c9808aa1ff87481 100644
 a/test/good/nmlipparser.exp
+++ b/test/good/nmlipparser.exp
@@ 271,13 +271,13 @@ Warning: this %prec declaration is never useful.
Warning: 100 states have shift/reduce conflicts.
Warning: 411 shift/reduce conflicts were arbitrarily resolved.
Warning: one state has an endofstream conflict.
+321 out of 999 states have a default reduction.
File "nmlipparser.mly", line 322, characters 33:
Warning: production toplevel_phrase > is never reduced.
Warning: in total, 1 productions are never reduced.
547 out of 999 states are represented.
0 out of 184 symbols keep track of their start position.
0 out of 184 symbols keep track of their end position.
321 out of 999 states have a default reduction.
140 out of 302 productions exploit shiftreduce optimization.
267 out of 999 states can peek at an error.
2371 functions before inlining, 658 functions after inlining.
diff git a/test/good/noendofstreamconflict.exp b/test/good/noendofstreamconflict.exp
index f78911373852eb2d5e360a4b396068196f17b00f..73af90cf01772dcbc8555c6a33039e4ddd2328fa 100644
 a/test/good/noendofstreamconflict.exp
+++ b/test/good/noendofstreamconflict.exp
@@ 11,10 +11,10 @@ Built an LR(0) automaton with 9 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 9 states.
4 shift/reduce conflicts were silently solved.
+4 out of 9 states have a default reduction.
3 out of 9 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
4 out of 9 states have a default reduction.
3 out of 5 productions exploit shiftreduce optimization.
0 out of 9 states can peek at an error.
31 functions before inlining, 6 functions after inlining.
diff git a/test/good/obcsym.exp b/test/good/obcsym.exp
index ba3bf3955d88887c9f93a3b8fcfbfad4e5f2feb4..791e9e9836c668b66ae6bb023baf45b8f96f74eb 100644
 a/test/good/obcsym.exp
+++ b/test/good/obcsym.exp
@@ 57,10 +57,10 @@ follow(const) = VARINFO VAR TYPE TARGET STRING REF PROCINFO PROCEDURE METHOD END
Built an LR(0) automaton with 113 states.
The grammar is SLR(1).
Built an LR(1) automaton with 113 states.
+49 out of 113 states have a default reduction.
55 out of 113 states are represented.
0 out of 57 symbols keep track of their start position.
0 out of 57 symbols keep track of their end position.
49 out of 113 states have a default reduction.
31 out of 46 productions exploit shiftreduce optimization.
0 out of 113 states can peek at an error.
295 functions before inlining, 40 functions after inlining.
diff git a/test/good/obc.exp b/test/good/obc.exp
index c4d8b7c0489f2d99b439d15be4614b451db6591d..6e7a11045a2ccb694c413466ae3fcebfd35d2f65 100644
 a/test/good/obc.exp
+++ b/test/good/obc.exp
@@ 198,10 +198,10 @@ File "obc.mly", line 40, characters 06:
Warning: the precedence level assigned to WITH is never useful.
File "obc.mly", line 402, characters 2227:
Warning: this %prec declaration is never useful.
+171 out of 403 states have a default reduction.
175 out of 403 states are represented.
0 out of 120 symbols keep track of their start position.
0 out of 120 symbols keep track of their end position.
171 out of 403 states have a default reduction.
68 out of 155 productions exploit shiftreduce optimization.
78 out of 403 states can peek at an error.
1022 functions before inlining, 243 functions after inlining.
diff git a/test/good/ocamldebugger.exp b/test/good/ocamldebugger.exp
index 69ce354927ef10febcbef48b9f3e510d06a4b51e..220a1c912a889eeb9e86d8905fb110cd75715f71 100644
 a/test/good/ocamldebugger.exp
+++ b/test/good/ocamldebugger.exp
@@ 75,10 +75,10 @@ The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 121 states.
One shift/reduce conflict was silently solved.
Warning: one state has an endofstream conflict.
+71 out of 121 states have a default reduction.
40 out of 121 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.
71 out of 121 states have a default reduction.
60 out of 68 productions exploit shiftreduce optimization.
0 out of 121 states can peek at an error.
357 functions before inlining, 61 functions after inlining.
diff git a/test/good/ocamllex.exp b/test/good/ocamllex.exp
index f7775a027628b15362372335c88b71274c993efe..056b9edaf752af04c92d2b147e26e8562ff11e9b 100644
 a/test/good/ocamllex.exp
+++ b/test/good/ocamllex.exp
@@ 44,10 +44,10 @@ Built an LR(0) automaton with 63 states.
The grammar is not SLR(1)  4 states have a conflict.
Built an LR(1) automaton with 63 states.
40 shift/reduce conflicts were silently solved.
+26 out of 63 states have a default reduction.
27 out of 63 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.
26 out of 63 states have a default reduction.
19 out of 37 productions exploit shiftreduce optimization.
0 out of 63 states can peek at an error.
182 functions before inlining, 36 functions after inlining.
diff git a/test/good/ocamltestLex.exp b/test/good/ocamltestLex.exp
index f4db6554ba4f57904974ca382fd8e43f1b734544..596a32dd2a30f8a7c3dd778c5af992d80d7d4dd3 100644
 a/test/good/ocamltestLex.exp
+++ b/test/good/ocamltestLex.exp
@@ 41,10 +41,10 @@ Warning: 3 states have shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: 14 shift/reduce conflicts were arbitrarily resolved.
Warning: 2 reduce/reduce conflicts were arbitrarily resolved.
+21 out of 44 states have a default reduction.
15 out of 44 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.
21 out of 44 states have a default reduction.
17 out of 27 productions exploit shiftreduce optimization.
0 out of 44 states can peek at an error.
131 functions before inlining, 23 functions after inlining.
diff git a/test/good/ocamltestasmcompcmm.exp b/test/good/ocamltestasmcompcmm.exp
index 46baf4d9508d44b3a0fb7d0470ce8258fa8e039f..c5e08b2bee53ce2ba87eb3715b88e56c38e482a9 100644
 a/test/good/ocamltestasmcompcmm.exp
+++ b/test/good/ocamltestasmcompcmm.exp
@@ 72,10 +72,10 @@ follow(binaryop) = STRING POINTER LPAREN LBRACKET INTCONST IDENT FLOATCONST EXIT
Built an LR(0) automaton with 220 states.
The grammar is SLR(1).
Built an LR(1) automaton with 220 states.
+117 out of 220 states have a default reduction.
54 out of 220 states are represented.
0 out of 115 symbols keep track of their start position.
0 out of 115 symbols keep track of their end position.
117 out of 220 states have a default reduction.
106 out of 123 productions exploit shiftreduce optimization.
0 out of 220 states can peek at an error.
591 functions before inlining, 47 functions after inlining.
diff git a/test/good/ocaml.exp b/test/good/ocaml.exp
index c2150649e61070eef9f925c6d34c35c993bc2e36..d75f895f504825f50cb038da499f19ee7dbb06e9 100644
 a/test/good/ocaml.exp
+++ b/test/good/ocaml.exp
@@ 652,10 +652,10 @@ File "ocaml.mly", line 594, characters 09:
Warning: the precedence level assigned to LBRACKETPERCENTPERCENT is never useful.
File "ocaml.mly", line 900, characters 5161:
Warning: this %prec declaration is never useful.
+599 out of 1538 states have a default reduction.
740 out of 1538 states are represented.
0 out of 341 symbols keep track of their start position.
0 out of 341 symbols keep track of their end position.
599 out of 1538 states have a default reduction.
398 out of 776 productions exploit shiftreduce optimization.
381 out of 1538 states can peek at an error.
4075 functions before inlining, 812 functions after inlining.
diff git a/test/good/ocamldocodoc.exp b/test/good/ocamldocodoc.exp
index 34344644cf77acc29979ae0f2b2f45afcdf75b97..7357b22de0ea42b8ffa2de02a41c764057c1e55d 100644
 a/test/good/ocamldocodoc.exp
+++ b/test/good/ocamldocodoc.exp
@@ 49,10 +49,10 @@ follow(author) = T_VERSION T_SINCE T_SEE T_RETURN T_RAISES T_PARAM T_DEPRECATED
Built an LR(0) automaton with 44 states.
The grammar is SLR(1).
Built an LR(1) automaton with 44 states.
+29 out of 44 states have a default reduction.
2 out of 44 states are represented.
0 out of 35 symbols keep track of their start position.
0 out of 35 symbols keep track of their end position.
29 out of 44 states have a default reduction.
28 out of 30 productions exploit shiftreduce optimization.
0 out of 44 states can peek at an error.
141 functions before inlining, 19 functions after inlining.
diff git a/test/good/ocamldocodoc_text.exp b/test/good/ocamldocodoc_text.exp
index f0a08e37462e8b0564ddc13003001900aa69d5fa..f3eebce1afaa05c8703ef8fbbda048ba18131730 100644
 a/test/good/ocamldocodoc_text.exp
+++ b/test/good/ocamldocodoc_text.exp
@@ 42,10 +42,10 @@ The grammar is not SLR(1)  5 states have a conflict.
Built an LR(1) automaton with 123 states.
Warning: 5 states have shift/reduce conflicts.
Warning: 5 shift/reduce conflicts were arbitrarily resolved.
+47 out of 123 states have a default reduction.
43 out of 123 states are represented.
0 out of 58 symbols keep track of their start position.
0 out of 58 symbols keep track of their end position.
47 out of 123 states have a default reduction.
42 out of 55 productions exploit shiftreduce optimization.
0 out of 123 states can peek at an error.
318 functions before inlining, 45 functions after inlining.
diff git a/test/good/ocamlwebyacc.exp b/test/good/ocamlwebyacc.exp
index 100dc4f40084b7ff81c4b2a055f9f7fe866e0cdf..b7910c0306046c4b4fda7b6f9318baa9c89d7438 100644
 a/test/good/ocamlwebyacc.exp
+++ b/test/good/ocamlwebyacc.exp
@@ 34,10 +34,10 @@ follow(general_rule) = Tident Taction EOF
Built an LR(0) automaton with 48 states.
The grammar is SLR(1).
Built an LR(1) automaton with 48 states.
+20 out of 48 states have a default reduction.
20 out of 48 states are represented.
0 out of 29 symbols keep track of their start position.
0 out of 29 symbols keep track of their end position.
20 out of 48 states have a default reduction.
15 out of 27 productions exploit shiftreduce optimization.
0 out of 48 states can peek at an error.
139 functions before inlining, 29 functions after inlining.
diff git a/test/good/oclisp.exp b/test/good/oclisp.exp
index 0fac345c0674c73500f4bcb6b3783e5db8760be5..f1f7558d13bcaa0c022a23b164c06790d10a0920 100644
 a/test/good/oclisp.exp
+++ b/test/good/oclisp.exp
@@ 22,10 +22,10 @@ follow(atom) = RBRACKET QUOTE NAME LBRACKET DOT #
Built an LR(0) automaton with 16 states.
The grammar is SLR(1).
Built an LR(1) automaton with 25 states.
+16 out of 25 states have a default reduction.
7 out of 25 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.
16 out of 25 states have a default reduction.
6 out of 11 productions exploit shiftreduce optimization.
0 out of 25 states can peek at an error.
72 functions before inlining, 18 functions after inlining.
diff git a/test/good/oflux.exp b/test/good/oflux.exp
index 2118b463f63b6fe72477a362d78947feb4e19852..d913cd7550908a24eef1087af3e0baead0452a0a 100644
 a/test/good/oflux.exp
+++ b/test/good/oflux.exp
@@ 181,10 +181,10 @@ File "oflux.mly", line 76, characters 05:
Warning: the precedence level assigned to PLUS is never useful.
File "oflux.mly", line 77, characters 05:
Warning: the precedence level assigned to STAR is never useful.
+117 out of 250 states have a default reduction.
75 out of 250 states are represented.
0 out of 129 symbols keep track of their start position.
0 out of 129 symbols keep track of their end position.
117 out of 250 states have a default reduction.
73 out of 137 productions exploit shiftreduce optimization.
0 out of 250 states can peek at an error.
696 functions before inlining, 87 functions after inlining.
diff git a/test/good/ojacare.exp b/test/good/ojacare.exp
index e649f5a54692e550d201df644949a5321dd06870..92ac174f417e6e2c935bbcae2203ff1f026da70a 100644
 a/test/good/ojacare.exp
+++ b/test/good/ojacare.exp
@@ 80,10 +80,10 @@ follow(ann) = RBRACKET COMMA
Built an LR(0) automaton with 157 states.
The grammar is not SLR(1)  2 states have a conflict.
Built an LR(1) automaton with 157 states.
+71 out of 157 states have a default reduction.
70 out of 157 states are represented.
0 out of 63 symbols keep track of their start position.
0 out of 63 symbols keep track of their end position.
71 out of 157 states have a default reduction.
54 out of 84 productions exploit shiftreduce optimization.
0 out of 157 states can peek at an error.
428 functions before inlining, 56 functions after inlining.
diff git a/test/good/omake_ast_parse.exp b/test/good/omake_ast_parse.exp
index 131612f61cef5e2308d0494330ea6bcbecf96af2..98768b0434f0e9d0d853173368828d546d5a6ec2 100644
 a/test/good/omake_ast_parse.exp
+++ b/test/good/omake_ast_parse.exp
@@ 235,10 +235,10 @@ follow(apply) = TokWhite TokVarQuote TokVar TokStringQuote TokString TokRightPar
Built an LR(0) automaton with 552 states.
The grammar is not SLR(1)  7 states have a conflict.
Built an LR(1) automaton with 552 states.
+412 out of 552 states have a default reduction.
85 out of 552 states are represented.
0 out of 112 symbols keep track of their start position.
0 out of 112 symbols keep track of their end position.
412 out of 552 states have a default reduction.
370 out of 443 productions exploit shiftreduce optimization.
0 out of 552 states can peek at an error.
1632 functions before inlining, 225 functions after inlining.
diff git a/test/good/omake_shell_parse.exp b/test/good/omake_shell_parse.exp
index cb9a738d97a0cbe77394cbaa040276d39fd02b97..c7fd549ff76c506fb06a94b0c0e8b01603950840 100644
 a/test/good/omake_shell_parse.exp
+++ b/test/good/omake_shell_parse.exp
@@ 42,10 +42,10 @@ File "omake_shell_parse.mly", line 263, characters 4862:
Warning: this %prec declaration is never useful.
File "omake_shell_parse.mly", line 270, characters 5576:
Warning: this %prec declaration is never useful.
+24 out of 51 states have a default reduction.
18 out of 51 states are represented.
0 out of 29 symbols keep track of their start position.
0 out of 29 symbols keep track of their end position.
24 out of 51 states have a default reduction.
24 out of 33 productions exploit shiftreduce optimization.
0 out of 51 states can peek at an error.
152 functions before inlining, 27 functions after inlining.
diff git a/test/good/onerrorreduceinlined.exp b/test/good/onerrorreduceinlined.exp
index 9ff7a500fdfe4387b9c9ee87b9c2c8670f28eb56..7ea0b0170dbd3eca47538376a5049fa6cade148e 100644
 a/test/good/onerrorreduceinlined.exp
+++ b/test/good/onerrorreduceinlined.exp
@@ 11,10 +11,10 @@ follow(main) = #
Built an LR(0) automaton with 5 states.
The grammar is SLR(1).
Built an LR(1) automaton with 5 states.
+3 out of 5 states have a default reduction.
0 out of 5 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 5 states have a default reduction.
3 out of 3 productions exploit shiftreduce optimization.
0 out of 5 states can peek at an error.
20 functions before inlining, 3 functions after inlining.
diff git a/test/good/onerrorreduceunreachable.exp b/test/good/onerrorreduceunreachable.exp
index f1e4915ab23ab2c4202dd3c7a647323e9ed0b5fc..66d5763e10ef62db1859782465846b56742d15b0 100644
 a/test/good/onerrorreduceunreachable.exp
+++ b/test/good/onerrorreduceunreachable.exp
@@ 9,10 +9,10 @@ follow(main) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/option2.exp b/test/good/option2.exp
index 21a4845f188251b991b9c2198c0711328a2bb952..010f9a5fa0acd81420e4acc79fe20d75347984fe 100644
 a/test/good/option2.exp
+++ b/test/good/option2.exp
@@ 11,10 +11,10 @@ follow(main) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+3 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 4 states have a default reduction.
3 out of 3 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
19 functions before inlining, 1 functions after inlining.
diff git a/test/good/parameterizednonterminal.exp b/test/good/parameterizednonterminal.exp
index e023eda2714f7f4abddddc2a5c8f3dc522311c9d..6dd7850153712ffe2117938030b3a13b13245ac0 100644
 a/test/good/parameterizednonterminal.exp
+++ b/test/good/parameterizednonterminal.exp
@@ 16,10 +16,10 @@ follow(a) = #
Built an LR(0) automaton with 7 states.
The grammar is SLR(1).
Built an LR(1) automaton with 7 states.
+5 out of 7 states have a default reduction.
0 out of 7 states are represented.
0 out of 8 symbols keep track of their start position.
0 out of 8 symbols keep track of their end position.
5 out of 7 states have a default reduction.
5 out of 5 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
29 functions before inlining, 2 functions after inlining.
diff git a/test/good/parse_xquery.exp b/test/good/parse_xquery.exp
index 400f38bfde2d4b498014814d009343145bb84868..9412fce2ed95089f1bbcf2966e1e38ac330befdf 100644
 a/test/good/parse_xquery.exp
+++ b/test/good/parse_xquery.exp
@@ 424,10 +424,10 @@ Warning: the precedence level assigned to WHERE is never useful.
File "parse_xquery.mly", line 289, characters 05:
Warning: the precedence level assigned to WHILE is never useful.
Warning: 268 states have an endofstream conflict.
+298 out of 1017 states have a default reduction.
411 out of 1017 states are represented.
0 out of 374 symbols keep track of their start position.
0 out of 374 symbols keep track of their end position.
298 out of 1017 states have a default reduction.
189 out of 403 productions exploit shiftreduce optimization.
0 out of 1017 states can peek at an error.
2546 functions before inlining, 335 functions after inlining.
diff git a/test/good/parser_cocci_menhir.exp b/test/good/parser_cocci_menhir.exp
index 5ee9ed61cb3d282cd83f547000524a7e05b0c7c3..7aab808ff7e72f041e280afc417a948f26b07ad2 100644
 a/test/good/parser_cocci_menhir.exp
+++ b/test/good/parser_cocci_menhir.exp
@@ 961,10 +961,10 @@ Built an LR(0) automaton with 2103 states.
The grammar is not SLR(1)  88 states have a conflict.
Built an LR(1) automaton with 2103 states.
954 shift/reduce conflicts were silently solved.
+905 out of 2103 states have a default reduction.
691 out of 2103 states are represented.
0 out of 544 symbols keep track of their start position.
0 out of 544 symbols keep track of their end position.
905 out of 2103 states have a default reduction.
738 out of 1138 productions exploit shiftreduce optimization.
0 out of 2103 states can peek at an error.
5682 functions before inlining, 746 functions after inlining.
diff git a/test/good/parser_cpp.exp b/test/good/parser_cpp.exp
index 7bd4c80ee85fe9295c2f42caf70d26c018e16547..5323a90c57a4de51953086bc39d5e514d81cda35 100644
 a/test/good/parser_cpp.exp
+++ b/test/good/parser_cpp.exp
@@ 565,13 +565,13 @@ Built an LR(1) automaton with 1094 states.
Warning: 2 states have shift/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
Warning: 257 states have an endofstream conflict.
+492 out of 1094 states have a default reduction.
File "parser_cpp.mly", line 410, characters 04:
Warning: symbol expr is never accepted.
Warning: in total, 1 productions are never reduced.
332 out of 1094 states are represented.
0 out of 351 symbols keep track of their start position.
0 out of 351 symbols keep track of their end position.
492 out of 1094 states have a default reduction.
331 out of 546 productions exploit shiftreduce optimization.
0 out of 1094 states can peek at an error.
2920 functions before inlining, 507 functions after inlining.
diff git a/test/good/parser_css.exp b/test/good/parser_css.exp
index cd4eba4682f151010a3f730679bcb21fb3610a73..db86ee0edeb0b84df7c36304901322714302bb2d 100644
 a/test/good/parser_css.exp
+++ b/test/good/parser_css.exp
@@ 119,10 +119,10 @@ File "parser_css.mly", line 76, characters 05:
Warning: the precedence level assigned to PLUS is never useful.
File "parser_css.mly", line 77, characters 05:
Warning: the precedence level assigned to QUOTIENT is never useful.
+56 out of 94 states have a default reduction.
19 out of 94 states are represented.
0 out of 75 symbols keep track of their start position.
0 out of 75 symbols keep track of their end position.
56 out of 94 states have a default reduction.
52 out of 66 productions exploit shiftreduce optimization.
0 out of 94 states can peek at an error.
289 functions before inlining, 42 functions after inlining.
diff git a/test/good/parser_java.exp b/test/good/parser_java.exp
index e2b19e65bbc96c7389e4f84f0973abb4bd81fd55..9662c98aada3b3e9de82d2c5cb4ed82e84f08cfe 100644
 a/test/good/parser_java.exp
+++ b/test/good/parser_java.exp
@@ 620,10 +620,10 @@ follow(abstract_method_declaration) = VOLATILE VOID TRANSIENT SYNCHRONIZED STRIC
Built an LR(0) automaton with 757 states.
The grammar is not SLR(1)  22 states have a conflict.
Built an LR(1) automaton with 757 states.
+322 out of 757 states have a default reduction.
244 out of 757 states are represented.
0 out of 301 symbols keep track of their start position.
0 out of 301 symbols keep track of their end position.
322 out of 757 states have a default reduction.
275 out of 435 productions exploit shiftreduce optimization.
0 out of 757 states can peek at an error.
2151 functions before inlining, 302 functions after inlining.
diff git a/test/good/parser_js.exp b/test/good/parser_js.exp
index 1bb6f17fd206787d5e9cca76fe1e9659fba334b6..0712ce3970203a0b6970765d16bf1b4f955233ae 100644
 a/test/good/parser_js.exp
+++ b/test/good/parser_js.exp
@@ 472,10 +472,10 @@ File "parser_js.mly", line 638, characters 3443:
Warning: this %prec declaration is never useful.
Warning: 2 states have shift/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
+276 out of 714 states have a default reduction.
288 out of 714 states are represented.
0 out of 246 symbols keep track of their start position.
0 out of 246 symbols keep track of their end position.
276 out of 714 states have a default reduction.
192 out of 392 productions exploit shiftreduce optimization.
0 out of 714 states can peek at an error.
1967 functions before inlining, 247 functions after inlining.
diff git a/test/good/parser_php.exp b/test/good/parser_php.exp
index 4603cd83775afcdfe136e37b1e39750d69dab3e2..7bdc5815997a22701942d8afc64614bc17b10be6 100644
 a/test/good/parser_php.exp
+++ b/test/good/parser_php.exp
@@ 559,13 +559,13 @@ Warning: the precedence level assigned to T_OBJECT_OPERATOR is never useful.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 31 states have an endofstream conflict.
+480 out of 1160 states have a default reduction.
File "parser_php.mly", line 309, characters 318:
Warning: production sgrep_spatch_pattern > TCOLON type_php is never reduced.
Warning: in total, 1 productions are never reduced.
499 out of 1160 states are represented.
0 out of 363 symbols keep track of their start position.
0 out of 363 symbols keep track of their end position.
480 out of 1160 states have a default reduction.
390 out of 630 productions exploit shiftreduce optimization.
0 out of 1160 states can peek at an error.
3129 functions before inlining, 482 functions after inlining.
diff git a/test/good/parser_raw.exp b/test/good/parser_raw.exp
index e16a9b03caed5bab5e59549de2f7950b943e81b9..988c371686ebe8389fd19721bc03deaee8361c64 100644
 a/test/good/parser_raw.exp
+++ b/test/good/parser_raw.exp
@@ 698,10 +698,10 @@ File "parser_raw.mly", line 2230, characters 2839:
Warning: this %prec declaration is never useful.
File "parser_raw.mly", line 2232, characters 4556:
Warning: this %prec declaration is never useful.
+525 out of 1500 states have a default reduction.
749 out of 1500 states are represented.
198 out of 339 symbols keep track of their start position.
242 out of 339 symbols keep track of their end position.
525 out of 1500 states have a default reduction.
320 out of 705 productions exploit shiftreduce optimization.
0 out of 1500 states can peek at an error.
3918 functions before inlining, 546 functions after inlining.
diff git a/test/good/petit1.exp b/test/good/petit1.exp
index 0b4c03131081a1d4d387a5ef89c5671e60d94311..d6dd0615618503c3a52df01315a5141e89d7a1df 100644
 a/test/good/petit1.exp
+++ b/test/good/petit1.exp
@@ 85,10 +85,10 @@ Built an LR(0) automaton with 149 states.
The grammar is not SLR(1)  20 states have a conflict.
Built an LR(1) automaton with 149 states.
128 shift/reduce conflicts were silently solved.
+40 out of 149 states have a default reduction.
49 out of 149 states are represented.
12 out of 73 symbols keep track of their start position.
11 out of 73 symbols keep track of their end position.
40 out of 149 states have a default reduction.
27 out of 70 productions exploit shiftreduce optimization.
0 out of 149 states can peek at an error.
400 functions before inlining, 70 functions after inlining.
diff git a/test/good/photos.exp b/test/good/photos.exp
index 18febdd9fcd38c7383c12bbe7db5cc349e4de961..196f11842b4835d5eb8fdbe7ae3452f289bfa9d1 100644
 a/test/good/photos.exp
+++ b/test/good/photos.exp
@@ 22,10 +22,10 @@ Built an LR(0) automaton with 38 states.
The grammar is SLR(1).
Built an LR(1) automaton with 39 states.
Warning: 21 states have an endofstream conflict.
+19 out of 39 states have a default reduction.
8 out of 39 states are represented.
0 out of 26 symbols keep track of their start position.
0 out of 26 symbols keep track of their end position.
19 out of 39 states have a default reduction.
18 out of 22 productions exploit shiftreduce optimization.
0 out of 39 states can peek at an error.
111 functions before inlining, 22 functions after inlining.
diff git a/test/good/phpparser.exp b/test/good/phpparser.exp
index 13abc6c661ca4d8fa0c77bb6ce9bb5ebbac4cffc..caaff324bc918850c02c7018899522d561849c1c 100644
 a/test/good/phpparser.exp
+++ b/test/good/phpparser.exp
@@ 338,10 +338,10 @@ File "phpparser.mly", line 201, characters 3744:
Warning: this %prec declaration is never useful.
File "phpparser.mly", line 202, characters 3745:
Warning: this %prec declaration is never useful.
+130 out of 321 states have a default reduction.
111 out of 321 states are represented.
0 out of 174 symbols keep track of their start position.
0 out of 174 symbols keep track of their end position.
130 out of 321 states have a default reduction.
93 out of 182 productions exploit shiftreduce optimization.
0 out of 321 states can peek at an error.
906 functions before inlining, 133 functions after inlining.
diff git a/test/good/pippijn.exp b/test/good/pippijn.exp
index 777318ac19fdbdb1a058feacf4b8da9bb3fba47a..d4ce382608d078ba0b2398e234f193b5514a9551 100644
 a/test/good/pippijn.exp
+++ b/test/good/pippijn.exp
@@ 632,10 +632,10 @@ Built an LR(0) automaton with 1031 states.
The grammar is not SLR(1)  21 states have a conflict.
Built an LR(1) automaton with 1031 states.
One shift/reduce conflict was silently solved.
+588 out of 1031 states have a default reduction.
340 out of 1031 states are represented.
170 out of 450 symbols keep track of their start position.
178 out of 450 symbols keep track of their end position.
588 out of 1031 states have a default reduction.
419 out of 628 productions exploit shiftreduce optimization.
0 out of 1031 states can peek at an error.
2910 functions before inlining, 457 functions after inlining.
diff git a/test/good/pre_parser.exp b/test/good/pre_parser.exp
index 59b16d84eff8835a02e55b17fd23cf2544d2f986..a1f4cbd38d459c590205e74be19db686d14bea4d 100644
 a/test/good/pre_parser.exp
+++ b/test/good/pre_parser.exp
@@ 423,10 +423,10 @@ Built an LR(1) automaton with 597 states.
2 shift/reduce conflicts were silently solved.
Extra reductions on error were added in 101 states.
Priority played a role in 0 of these states.
+283 out of 597 states have a default reduction.
223 out of 597 states are represented.
0 out of 235 symbols keep track of their start position.
0 out of 235 symbols keep track of their end position.
283 out of 597 states have a default reduction.
171 out of 354 productions exploit shiftreduce optimization.
0 out of 597 states can peek at an error.
1692 functions before inlining, 255 functions after inlining.
diff git a/test/good/prec_inline.exp b/test/good/prec_inline.exp
index 205491b723b662fc7bc3fad25231b64f565c27ac..e76caccb4c09eb8ccae066b5b32190d010484392 100644
 a/test/good/prec_inline.exp
+++ b/test/good/prec_inline.exp
@@ 13,10 +13,10 @@ Built an LR(0) automaton with 18 states.
The grammar is not SLR(1)  5 states have a conflict.
Built an LR(1) automaton with 18 states.
20 shift/reduce conflicts were silently solved.
+7 out of 18 states have a default reduction.
7 out of 18 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.
7 out of 18 states have a default reduction.
4 out of 9 productions exploit shiftreduce optimization.
0 out of 18 states can peek at an error.
53 functions before inlining, 11 functions after inlining.
diff git a/test/good/privateandpublic1.exp b/test/good/privateandpublic1.exp
index c3779cb3616ea48b10549a5ccb3798c80f4f3926..33b2f61fb31b108bcdfdc715143877a8b6101f35 100644
 a/test/good/privateandpublic1.exp
+++ b/test/good/privateandpublic1.exp
@@ 17,10 +17,10 @@ follow(a) = C
Built an LR(0) automaton with 6 states.
The grammar is SLR(1).
Built an LR(1) automaton with 6 states.
+5 out of 6 states have a default reduction.
0 out of 6 states are represented.
0 out of 8 symbols keep track of their start position.
0 out of 8 symbols keep track of their end position.
5 out of 6 states have a default reduction.
4 out of 5 productions exploit shiftreduce optimization.
0 out of 6 states can peek at an error.
27 functions before inlining, 1 functions after inlining.
diff git a/test/good/promelaparser.exp b/test/good/promelaparser.exp
index 30a141383fb0af84400c39f3c4614f04f742c26f..dee23340ca9f114918cbf57d74a57b7c1da10e76 100644
 a/test/good/promelaparser.exp
+++ b/test/good/promelaparser.exp
@@ 36,10 +36,10 @@ File "promelaparser.mly", line 51, characters 09:
Warning: the precedence level assigned to PROMELA_FALSE is never useful.
File "promelaparser.mly", line 51, characters 09:
Warning: the precedence level assigned to PROMELA_TRUE is never useful.
+23 out of 48 states have a default reduction.
11 out of 48 states are represented.
0 out of 35 symbols keep track of their start position.
0 out of 35 symbols keep track of their end position.
23 out of 48 states have a default reduction.
20 out of 26 productions exploit shiftreduce optimization.
0 out of 48 states can peek at an error.
137 functions before inlining, 22 functions after inlining.
diff git a/test/good/promelaparser_withexps.exp b/test/good/promelaparser_withexps.exp
index a33c22d4adb516cc54b17375cf2b7b772f7d01cf..269a060d4692ef94ef759977dc1fc81d339c5309 100644
 a/test/good/promelaparser_withexps.exp
+++ b/test/good/promelaparser_withexps.exp
@@ 81,10 +81,10 @@ File "promelaparser_withexps.mly", line 50, characters 09:
Warning: the precedence level assigned to PROMELA_TRUE is never useful.
Warning: 4 states have shift/reduce conflicts.
Warning: 4 shift/reduce conflicts were arbitrarily resolved.
+43 out of 98 states have a default reduction.
26 out of 98 states are represented.
0 out of 58 symbols keep track of their start position.
0 out of 58 symbols keep track of their end position.
43 out of 98 states have a default reduction.
28 out of 52 productions exploit shiftreduce optimization.
0 out of 98 states can peek at an error.
270 functions before inlining, 45 functions after inlining.
diff git a/test/good/prooflang.exp b/test/good/prooflang.exp
index 8b49e1178d89d46933ff5cf38613659f1f142a19..d243ae956365f54767b782df04a90f78aa2dd21f 100644
 a/test/good/prooflang.exp
+++ b/test/good/prooflang.exp
@@ 87,10 +87,10 @@ Built an LR(1) automaton with 147 states.
Warning: 2 states have shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
+41 out of 147 states have a default reduction.
51 out of 147 states are represented.
0 out of 66 symbols keep track of their start position.
0 out of 66 symbols keep track of their end position.
41 out of 147 states have a default reduction.
22 out of 48 productions exploit shiftreduce optimization.
0 out of 147 states can peek at an error.
370 functions before inlining, 38 functions after inlining.
diff git a/test/good/public1.exp b/test/good/public1.exp
index a484ab7e9575187b814c2117c1369e8fba7c763f..602e293899677282226a550ce12e4108ef5aadc6 100644
 a/test/good/public1.exp
+++ b/test/good/public1.exp
@@ 10,10 +10,10 @@ follow(s) = #
Built an LR(0) automaton with 3 states.
The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/publicinline1.exp b/test/good/publicinline1.exp
index bdb9cd1174689e13a394fda5b2c72e81e239043f..b95262327ab7ead58020852a7c3448ece7422094 100644
 a/test/good/publicinline1.exp
+++ b/test/good/publicinline1.exp
@@ 9,10 +9,10 @@ follow(a) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+3 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
3 out of 4 states have a default reduction.
3 out of 3 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
18 functions before inlining, 2 functions after inlining.
diff git a/test/good/pxpm2parsergen.exp b/test/good/pxpm2parsergen.exp
index bf37c3c2235abab7ea2a89abc93d93bba1114786..a9e3497152c6c27dcd4422bf222a232b09b70e61 100644
 a/test/good/pxpm2parsergen.exp
+++ b/test/good/pxpm2parsergen.exp
@@ 61,10 +61,10 @@ follow(actual_arguments) = Uname Loop_star Lname Lbracket Error Dollar Code
Built an LR(0) automaton with 77 states.
The grammar is SLR(1).
Built an LR(1) automaton with 77 states.
+33 out of 77 states have a default reduction.
22 out of 77 states are represented.
0 out of 39 symbols keep track of their start position.
0 out of 39 symbols keep track of their end position.
33 out of 77 states have a default reduction.
31 out of 37 productions exploit shiftreduce optimization.
0 out of 77 states can peek at an error.
214 functions before inlining, 37 functions after inlining.
diff git a/test/good/pxpucs2_to_utf8.exp b/test/good/pxpucs2_to_utf8.exp
index 3b995ee5cfa62b9644dd2442ef8ba61e47ea6d0e..b8490003bce3b0fe0850621ed65d65847f0994cb 100644
 a/test/good/pxpucs2_to_utf8.exp
+++ b/test/good/pxpucs2_to_utf8.exp
@@ 16,10 +16,10 @@ follow(declaration) = LET EOF
Built an LR(0) automaton with 20 states.
The grammar is SLR(1).
Built an LR(1) automaton with 20 states.
+8 out of 20 states have a default reduction.
4 out of 20 states are represented.
0 out of 17 symbols keep track of their start position.
0 out of 17 symbols keep track of their end position.
8 out of 20 states have a default reduction.
7 out of 9 productions exploit shiftreduce optimization.
0 out of 20 states can peek at an error.
59 functions before inlining, 12 functions after inlining.
diff git a/test/good/rdf_sparql_parser.exp b/test/good/rdf_sparql_parser.exp
index 070c0c725e28ac834d739b178bc4f71fd98863e1..4fdf9bd01f62b0cff8b00bc0444b36e8e0a86ff6 100644
 a/test/good/rdf_sparql_parser.exp
+++ b/test/good/rdf_sparql_parser.exp
@@ 488,10 +488,10 @@ Warning: 13 states have shift/reduce conflicts.
Warning: 11 states have reduce/reduce conflicts.
Warning: 65 shift/reduce conflicts were arbitrarily resolved.
Warning: 356 reduce/reduce conflicts were arbitrarily resolved.
+305 out of 720 states have a default reduction.
291 out of 720 states are represented.
146 out of 302 symbols keep track of their start position.
152 out of 302 symbols keep track of their end position.
305 out of 720 states have a default reduction.
246 out of 375 productions exploit shiftreduce optimization.
0 out of 720 states can peek at an error.
1980 functions before inlining, 254 functions after inlining.
diff git a/test/good/reason_parser.exp b/test/good/reason_parser.exp
index c5ca519d639f6ed8f657b36613af208c01ea8201..b42ff6b369d9150efbf8b6188a596a0384aeae98 100644
 a/test/good/reason_parser.exp
+++ b/test/good/reason_parser.exp
@@ 943,10 +943,10 @@ Built an LR(1) automaton with 2902 states.
1772 shift/reduce conflicts were silently solved.
Extra reductions on error were added in 570 states.
Priority played a role in 0 of these states.
+1171 out of 2902 states have a default reduction.
1420 out of 2902 states are represented.
237 out of 442 symbols keep track of their start position.
307 out of 442 symbols keep track of their end position.
1171 out of 2902 states have a default reduction.
461 out of 895 productions exploit shiftreduce optimization.
702 out of 2902 states can peek at an error.
7017 functions before inlining, 1610 functions after inlining.
diff git a/test/good/ruby18_parser.exp b/test/good/ruby18_parser.exp
index ac83c2d335010b9d6e5329f9366a34ef6fdc10b9..905aa0256d499198f03d757cf5d835e817b60546 100644
 a/test/good/ruby18_parser.exp
+++ b/test/good/ruby18_parser.exp
@@ 405,10 +405,10 @@ Warning: the precedence level assigned to UMINUS_NUM is never useful.
Warning: 8 states have shift/reduce conflicts.
Warning: 8 shift/reduce conflicts were arbitrarily resolved.
Warning: 333 states have an endofstream conflict.
+637 out of 1469 states have a default reduction.
698 out of 1469 states are represented.
0 out of 260 symbols keep track of their start position.
0 out of 260 symbols keep track of their end position.
637 out of 1469 states have a default reduction.
255 out of 485 productions exploit shiftreduce optimization.
306 out of 1469 states can peek at an error.
3560 functions before inlining, 940 functions after inlining.
diff git a/test/good/sage.exp b/test/good/sage.exp
index d62514200c08b18e81374ae709b86472b4055796..a5b6279ef85aa8e56426a626a282793b2322edba 100644
 a/test/good/sage.exp
+++ b/test/good/sage.exp
@@ 149,13 +149,13 @@ Warning: this %prec declaration is never useful.
Warning: 22 states have shift/reduce conflicts.
Warning: 46 shift/reduce conflicts were arbitrarily resolved.
Warning: 40 states have an endofstream conflict.
+31 out of 183 states have a default reduction.
File "sage.mly", line 417, characters 04:
Warning: symbol term is never accepted.
Warning: in total, 1 productions are never reduced.
114 out of 183 states are represented.
0 out of 103 symbols keep track of their start position.
0 out of 103 symbols keep track of their end position.
31 out of 183 states have a default reduction.
26 out of 71 productions exploit shiftreduce optimization.
0 out of 183 states can peek at an error.
463 functions before inlining, 70 functions after inlining.
diff git a/test/good/scilabParser.exp b/test/good/scilabParser.exp
index e49f5a8d071ddf4d2d952eaaa8ea463ee2a193e6..91f592b326c5dd6368ff087dd7a442f232f7d243 100644
 a/test/good/scilabParser.exp
+++ b/test/good/scilabParser.exp
@@ 270,6 +270,7 @@ Warning: this %prec declaration is never useful.
File "scilabParser.mly", line 2579, characters 4150:
Warning: this %prec declaration is never useful.
Warning: 261 states have an endofstream conflict.
+206 out of 652 states have a default reduction.
File "scilabParser.mly", line 79, characters 221:
Warning: production program > expressionLineBreak is never reduced.
File "scilabParser.mly", line 84, characters 11:
@@ 278,7 +279,6 @@ Warning: in total, 2 productions are never reduced.
334 out of 652 states are represented.
0 out of 147 symbols keep track of their start position.
0 out of 147 symbols keep track of their end position.
206 out of 652 states have a default reduction.
195 out of 425 productions exploit shiftreduce optimization.
0 out of 652 states can peek at an error.
1801 functions before inlining, 265 functions after inlining.
diff git a/test/good/self.exp b/test/good/self.exp
index 11cbe80d9993bfe21edce614da2b58c50ed14018..7a86d51d3dbea63162b0fc4ff3d9851ff891f582 100644
 a/test/good/self.exp
+++ b/test/good/self.exp
@@ 11,10 +11,10 @@ follow(dummy) = #
Built an LR(0) automaton with 3 states.
The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 5 symbols keep track of their start position.
0 out of 5 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/simnml.exp b/test/good/simnml.exp
index 1eb53e656d62ebf97d6ec2622421e587a7ee4f63..794218cb284ebf5198f6c6c221aee1ea7c27385f 100644
 a/test/good/simnml.exp
+++ b/test/good/simnml.exp
@@ 260,10 +260,10 @@ File "simnml.mly", line 148, characters 05:
Warning: the precedence level assigned to DOUBLE_DOT is never useful.
File "simnml.mly", line 133, characters 06:
Warning: the precedence level assigned to EQ is never useful.
+144 out of 508 states have a default reduction.
161 out of 508 states are represented.
0 out of 171 symbols keep track of their start position.
0 out of 171 symbols keep track of their end position.
144 out of 508 states have a default reduction.
123 out of 235 productions exploit shiftreduce optimization.
0 out of 508 states can peek at an error.
1334 functions before inlining, 200 functions after inlining.
diff git a/test/good/simpleifconflict.exp b/test/good/simpleifconflict.exp
index 5eb1471dd701f53c27d875dad81a25d545a8e07f..3fe9abd3fd37ed59e113e43e1285f5ad534cdefd 100644
 a/test/good/simpleifconflict.exp
+++ b/test/good/simpleifconflict.exp
@@ 10,10 +10,10 @@ Built an LR(1) automaton with 14 states.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 4 states have an endofstream conflict.
+6 out of 14 states have a default reduction.
5 out of 14 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
6 out of 14 states have a default reduction.
2 out of 5 productions exploit shiftreduce optimization.
0 out of 14 states can peek at an error.
40 functions before inlining, 10 functions after inlining.
diff git a/test/good/spike.exp b/test/good/spike.exp
index 79fb2c6147b9159a58e0c4f83d885d590333255b..ac058e5244afc1882fc60eeb6006a58fb3e9eadc 100644
 a/test/good/spike.exp
+++ b/test/good/spike.exp
@@ 382,13 +382,13 @@ Built an LR(0) automaton with 552 states.
The grammar is not SLR(1)  3 states have a conflict.
Built an LR(1) automaton with 687 states.
Warning: 17 states have an endofstream conflict.
+270 out of 687 states have a default reduction.
File "spike.mly", line 1833, characters 015:
Warning: symbol list_of_systems is never accepted.
Warning: in total, 1 productions are never reduced.
189 out of 687 states are represented.
0 out of 229 symbols keep track of their start position.
0 out of 229 symbols keep track of their end position.
270 out of 687 states have a default reduction.
179 out of 306 productions exploit shiftreduce optimization.
0 out of 687 states can peek at an error.
1819 functions before inlining, 256 functions after inlining.
diff git a/test/good/splitpublicsymbolwithrenaming.exp b/test/good/splitpublicsymbolwithrenaming.exp
index e2dd49429ff09699bc4e63515ad591d3bde220e3..9bf9c3af0a1577611318d8bd42c21949a5384522 100644
 a/test/good/splitpublicsymbolwithrenaming.exp
+++ b/test/good/splitpublicsymbolwithrenaming.exp
@@ 12,10 +12,10 @@ follow(liste(A)) = B
Built an LR(0) automaton with 8 states.
The grammar is SLR(1).
Built an LR(1) automaton with 8 states.
+3 out of 8 states have a default reduction.
2 out of 8 states are represented.
0 out of 8 symbols keep track of their start position.
0 out of 8 symbols keep track of their end position.
3 out of 8 states have a default reduction.
2 out of 4 productions exploit shiftreduce optimization.
0 out of 8 states can peek at an error.
28 functions before inlining, 6 functions after inlining.
diff git a/test/good/splitpublicsymbol.exp b/test/good/splitpublicsymbol.exp
index 77a29912c3d78101809d46cb9c8bd2c7df64134e..0f4ce3bb0c1a88301ab383a34b272ef61ef45d7b 100644
 a/test/good/splitpublicsymbol.exp
+++ b/test/good/splitpublicsymbol.exp
@@ 12,10 +12,10 @@ follow(liste(A)) = EOF
Built an LR(0) automaton with 6 states.
The grammar is SLR(1).
Built an LR(1) automaton with 6 states.
+3 out of 6 states have a default reduction.
2 out of 6 states are represented.
0 out of 7 symbols keep track of their start position.
0 out of 7 symbols keep track of their end position.
3 out of 6 states have a default reduction.
2 out of 4 productions exploit shiftreduce optimization.
0 out of 6 states can peek at an error.
24 functions before inlining, 6 functions after inlining.
diff git a/test/good/subiso.exp b/test/good/subiso.exp
index 12f74492c5842b7bb2d0228abc06308933329450..e062ca8b748795007bca6fac9b47ad67756e88b3 100644
 a/test/good/subiso.exp
+++ b/test/good/subiso.exp
@@ 25,10 +25,10 @@ Built an LR(1) automaton with 20 states.
7 shift/reduce conflicts were silently solved.
File "subiso.mly", line 34, characters 09:
Warning: the precedence level assigned to ASSIGNS is never useful.
+6 out of 20 states have a default reduction.
7 out of 20 states are represented.
0 out of 18 symbols keep track of their start position.
0 out of 18 symbols keep track of their end position.
6 out of 20 states have a default reduction.
6 out of 10 productions exploit shiftreduce optimization.
0 out of 20 states can peek at an error.
60 functions before inlining, 12 functions after inlining.
diff git a/test/good/subtleconflictpager.exp b/test/good/subtleconflictpager.exp
index 38341122bb913b5854c3183bad67323c35db1d8a..8eb066e8eb7ac2895b59443fac945f3a0c2313c2 100644
 a/test/good/subtleconflictpager.exp
+++ b/test/good/subtleconflictpager.exp
@@ 21,13 +21,13 @@ The grammar is not SLR(1)  1 states have a conflict.
Built an LR(1) automaton with 16 states.
One shift/reduce conflict was silently solved.
Only 15 states remain after resolving shift/reduce conflicts.
+8 out of 15 states have a default reduction.
File "subtleconflictpager.mly", line 27, characters 25:
Warning: production a > A B is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 15 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.
8 out of 15 states have a default reduction.
9 out of 9 productions exploit shiftreduce optimization.
0 out of 15 states can peek at an error.
49 functions before inlining, 5 functions after inlining.
diff git a/test/good/symbolstartofs.exp b/test/good/symbolstartofs.exp
index c02aebda019743142281f344fe9e2b4e36ddb7ee..c728ca1371cfb77222d7d258f1a71b5e8eaaa6b4 100644
 a/test/good/symbolstartofs.exp
+++ b/test/good/symbolstartofs.exp
@@ 7,10 +7,10 @@ follow(main) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
1 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/symbolstartpos.exp b/test/good/symbolstartpos.exp
index bbe20ea963c5606e136cfe532cbb1c87cfd5e794..8bcd2e5de9027ab42f80d1ee88e424880e03a870 100644
 a/test/good/symbolstartpos.exp
+++ b/test/good/symbolstartpos.exp
@@ 22,10 +22,10 @@ follow(bar) = A
Built an LR(0) automaton with 14 states.
The grammar is SLR(1).
Built an LR(1) automaton with 14 states.
+8 out of 14 states have a default reduction.
2 out of 14 states are represented.
6 out of 12 symbols keep track of their start position.
5 out of 12 symbols keep track of their end position.
8 out of 14 states have a default reduction.
5 out of 8 productions exploit shiftreduce optimization.
0 out of 14 states can peek at an error.
48 functions before inlining, 5 functions after inlining.
diff git a/test/good/sysver.exp b/test/good/sysver.exp
index 9f8d439f34a9cac098cdcb70272de668e0401fab..615c508c8ac464e0c9c1521cba7e3a734047baf0 100644
 a/test/good/sysver.exp
+++ b/test/good/sysver.exp
@@ 2085,6 +2085,7 @@ Warning: 1245 states have reduce/reduce conflicts.
Warning: 5132 shift/reduce conflicts were arbitrarily resolved.
Warning: 7328 reduce/reduce conflicts were arbitrarily resolved.
Warning: 742 states have an endofstream conflict.
+4989 out of 16538 states have a default reduction.
File "sysver.mly", line 11593, characters 3131:
Warning: production class_scope_type_identifier_9 > is never reduced.
File "sysver.mly", line 8251, characters 321:
@@ 2147,7 +2148,6 @@ Warning: in total, 29 productions are never reduced.
5810 out of 16538 states are represented.
0 out of 1012 symbols keep track of their start position.
0 out of 1012 symbols keep track of their end position.
4989 out of 16538 states have a default reduction.
3881 out of 5222 productions exploit shiftreduce optimization.
0 out of 16538 states can peek at an error.
38747 functions before inlining, 1365 functions after inlining.
diff git a/test/good/talparser.exp b/test/good/talparser.exp
index 3df378d552acb1b57e2b83b5c5d55b8d66a4a97f..f9914fd93d9db9a6fe824f72fe430a024e145d29 100644
 a/test/good/talparser.exp
+++ b/test/good/talparser.exp
@@ 304,10 +304,10 @@ One shift/reduce conflict was silently solved.
Warning: one state has shift/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 80 states have an endofstream conflict.
+386 out of 1184 states have a default reduction.
396 out of 1184 states are represented.
0 out of 343 symbols keep track of their start position.
0 out of 343 symbols keep track of their end position.
386 out of 1184 states have a default reduction.
250 out of 413 productions exploit shiftreduce optimization.
0 out of 1184 states can peek at an error.
2884 functions before inlining, 359 functions after inlining.
diff git a/test/good/tonyrc_parse.exp b/test/good/tonyrc_parse.exp
index 5699b629dbb301690964422165feb51e729b41a7..456bbc004177fa1cca2ce446fc64aec01a0afbe4 100644
 a/test/good/tonyrc_parse.exp
+++ b/test/good/tonyrc_parse.exp
@@ 21,10 +21,10 @@ follow(rcfile) = #
Built an LR(0) automaton with 19 states.
The grammar is SLR(1).
Built an LR(1) automaton with 19 states.
+12 out of 19 states have a default reduction.
3 out of 19 states are represented.
0 out of 18 symbols keep track of their start position.
0 out of 18 symbols keep track of their end position.
12 out of 19 states have a default reduction.
9 out of 14 productions exploit shiftreduce optimization.
0 out of 19 states can peek at an error.
63 functions before inlining, 13 functions after inlining.
diff git a/test/good/tonyxmlparse.exp b/test/good/tonyxmlparse.exp
index b9d2c0a7e117ab3f6ea9bc0322196eb906e3e456..201f9bcb7ee5446fffa28ba73e0107ccc2532680 100644
 a/test/good/tonyxmlparse.exp
+++ b/test/good/tonyxmlparse.exp
@@ 104,10 +104,10 @@ follow(attribute) = SLASHCLOSE NAME CLOSE
Built an LR(0) automaton with 75 states.
The grammar is SLR(1).
Built an LR(1) automaton with 75 states.
+45 out of 75 states have a default reduction.
16 out of 75 states are represented.
0 out of 60 symbols keep track of their start position.
0 out of 60 symbols keep track of their end position.
45 out of 75 states have a default reduction.
38 out of 50 productions exploit shiftreduce optimization.
1 out of 75 states can peek at an error.
236 functions before inlining, 24 functions after inlining.
diff git a/test/good/toy.exp b/test/good/toy.exp
index 537cc5aa6091d2ec15cf72390a62ef71eb9b23e8..ac24a5af0b10058c18d54b8d0b99d9baac9b0c87 100644
 a/test/good/toy.exp
+++ b/test/good/toy.exp
@@ 71,10 +71,10 @@ The grammar is not SLR(1)  17 states have a conflict.
Built an LR(1) automaton with 154 states.
Warning: 15 states have shift/reduce conflicts.
Warning: 85 shift/reduce conflicts were arbitrarily resolved.
+51 out of 154 states have a default reduction.
60 out of 154 states are represented.
0 out of 72 symbols keep track of their start position.
0 out of 72 symbols keep track of their end position.
51 out of 154 states have a default reduction.
32 out of 78 productions exploit shiftreduce optimization.
0 out of 154 states can peek at an error.
411 functions before inlining, 70 functions after inlining.
diff git a/test/good/tptp2cime.exp b/test/good/tptp2cime.exp
index 5b04f7f85e11f4491dd00e42cf065aa851c10530..07ce82807d0169826ca72e9158560c4f209a8077 100644
 a/test/good/tptp2cime.exp
+++ b/test/good/tptp2cime.exp
@@ 65,10 +65,10 @@ File "tptp2cime.mly", line 23, characters 05:
Warning: the precedence level assigned to TERMLIST is never useful.
File "tptp2cime.mly", line 83, characters 1321:
Warning: this %prec declaration is never useful.
+20 out of 54 states have a default reduction.
14 out of 54 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.
20 out of 54 states have a default reduction.
18 out of 23 productions exploit shiftreduce optimization.
0 out of 54 states can peek at an error.
151 functions before inlining, 22 functions after inlining.
diff git a/test/good/typage.exp b/test/good/typage.exp
index 2c3dcce70b88cc244dbb1acefc3f6fc8307073c4..eb406827c2631de873949250545743514a546ad5 100644
 a/test/good/typage.exp
+++ b/test/good/typage.exp
@@ 23,10 +23,10 @@ Built an LR(0) automaton with 46 states.
The grammar is not SLR(1)  3 states have a conflict.
Built an LR(1) automaton with 46 states.
3 shift/reduce conflicts were silently solved.
+11 out of 46 states have a default reduction.
14 out of 46 states are represented.
0 out of 28 symbols keep track of their start position.
0 out of 28 symbols keep track of their end position.
11 out of 46 states have a default reduction.
11 out of 20 productions exploit shiftreduce optimization.
0 out of 46 states can peek at an error.
124 functions before inlining, 21 functions after inlining.
diff git a/test/good/typedfreshml.exp b/test/good/typedfreshml.exp
index d71f346ccae8eaf0251110ae3d0879e2f19bd127..12e79322fe88705d963847a7648bb266e10f9db9 100644
 a/test/good/typedfreshml.exp
+++ b/test/good/typedfreshml.exp
@@ 133,10 +133,10 @@ Built an LR(0) automaton with 202 states.
The grammar is not SLR(1)  12 states have a conflict.
Built an LR(1) automaton with 202 states.
28 shift/reduce conflicts were silently solved.
+84 out of 202 states have a default reduction.
62 out of 202 states are represented.
36 out of 98 symbols keep track of their start position.
31 out of 98 symbols keep track of their end position.
84 out of 202 states have a default reduction.
64 out of 112 productions exploit shiftreduce optimization.
0 out of 202 states can peek at an error.
565 functions before inlining, 99 functions after inlining.
diff git a/test/good/unigram.exp b/test/good/unigram.exp
index 47f90bc94e034559b7ddc58d69e74c07d2968ad2..eb36cd552ce0d2a84d30b9d148414c03dd2830bb 100644
 a/test/good/unigram.exp
+++ b/test/good/unigram.exp
@@ 192,10 +192,10 @@ The grammar is not SLR(1)  67 states have a conflict.
Built an LR(1) automaton with 453 states.
Warning: 48 states have shift/reduce conflicts.
Warning: 220 shift/reduce conflicts were arbitrarily resolved.
+176 out of 453 states have a default reduction.
170 out of 453 states are represented.
0 out of 184 symbols keep track of their start position.
0 out of 184 symbols keep track of their end position.
176 out of 453 states have a default reduction.
147 out of 238 productions exploit shiftreduce optimization.
10 out of 453 states can peek at an error.
1212 functions before inlining, 148 functions after inlining.
diff git a/test/good/unreachablesymbol.exp b/test/good/unreachablesymbol.exp
index cae7f6792bad9dc0ddb65cf9d9d47adcb8e19dc2..0ff915dfac33e52f1011663a3820ca2b1e3cc316 100644
 a/test/good/unreachablesymbol.exp
+++ b/test/good/unreachablesymbol.exp
@@ 9,10 +9,10 @@ follow(main) = #
Built an LR(0) automaton with 3 states.
The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 5 symbols keep track of their start position.
0 out of 5 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/unusedattribute.exp b/test/good/unusedattribute.exp
index 7d6658a85c989fc4322c746b9dd68be980197355..07a8babf3cf489a30cfcf03d7593a37e7daf69f1 100644
 a/test/good/unusedattribute.exp
+++ b/test/good/unusedattribute.exp
@@ 15,13 +15,13 @@ Built an LR(0) automaton with 7 states.
The grammar is SLR(1).
Built an LR(1) automaton with 7 states.
Warning: 2 states have an endofstream conflict.
+3 out of 7 states have a default reduction.
File "../../src/standard.mly", line 183, characters 1616:
Warning: production list(C) > is never reduced.
Warning: in total, 1 productions are never reduced.
2 out of 7 states are represented.
0 out of 8 symbols keep track of their start position.
0 out of 8 symbols keep track of their end position.
3 out of 7 states have a default reduction.
3 out of 4 productions exploit shiftreduce optimization.
0 out of 7 states can peek at an error.
25 functions before inlining, 4 functions after inlining.
diff git a/test/good/unusedpseudotoken.exp b/test/good/unusedpseudotoken.exp
index 45088ca860e799ff63cb56a4dd500cc466e9968b..fffecb0d04189601a8d02cdfedad9786016b2732 100644
 a/test/good/unusedpseudotoken.exp
+++ b/test/good/unusedpseudotoken.exp
@@ 13,10 +13,10 @@ The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
File "unusedpseudotoken.mly", line 3, characters 05:
Warning: the precedence level assigned to zorro is never useful.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/unusedtoken1.exp b/test/good/unusedtoken1.exp
index a2c9cb1e22d3589456a60173be3a01e78b86e986..227ee7e3190f34a4e5659ea4a40dd836e9ece4e2 100644
 a/test/good/unusedtoken1.exp
+++ b/test/good/unusedtoken1.exp
@@ 9,10 +9,10 @@ follow(a) = #
Built an LR(0) automaton with 3 states.
The grammar is SLR(1).
Built an LR(1) automaton with 3 states.
+2 out of 3 states have a default reduction.
0 out of 3 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 3 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 3 states can peek at an error.
15 functions before inlining, 1 functions after inlining.
diff git a/test/good/unusedvalue.exp b/test/good/unusedvalue.exp
index 22b70da486bc0672d341e7dbf1c018b3c8731106..908e3328f698df775949d8ccd9f2c194f1aded72 100644
 a/test/good/unusedvalue.exp
+++ b/test/good/unusedvalue.exp
@@ 7,10 +7,10 @@ follow(main) = #
Built an LR(0) automaton with 4 states.
The grammar is SLR(1).
Built an LR(1) automaton with 4 states.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/uppercase.exp b/test/good/uppercase.exp
index dde02c7a3e3c0fdced0d73b101d02ca7566c30a8..5cf975d494212b548a1bfda4ac5217d037a7d3f6 100644
 a/test/good/uppercase.exp
+++ b/test/good/uppercase.exp
@@ 13,10 +13,10 @@ follow(AB) = EOF A
Built an LR(0) automaton with 8 states.
The grammar is SLR(1).
Built an LR(1) automaton with 8 states.
+4 out of 8 states have a default reduction.
2 out of 8 states are represented.
0 out of 9 symbols keep track of their start position.
0 out of 9 symbols keep track of their end position.
4 out of 8 states have a default reduction.
3 out of 5 productions exploit shiftreduce optimization.
0 out of 8 states can peek at an error.
30 functions before inlining, 5 functions after inlining.
diff git a/test/good/uselesspriorities.exp b/test/good/uselesspriorities.exp
index 32ae2ea3fa5b1545bb867088703a5affafe22648..044de8959ce590c558f79ca595e7184c15716568 100644
 a/test/good/uselesspriorities.exp
+++ b/test/good/uselesspriorities.exp
@@ 19,10 +19,10 @@ File "uselesspriorities.mly", line 4, characters 05:
Warning: the precedence level assigned to TIMES is never useful.
Warning: one state has shift/reduce conflicts.
Warning: 2 shift/reduce conflicts were arbitrarily resolved.
+5 out of 9 states have a default reduction.
2 out of 9 states are represented.
0 out of 10 symbols keep track of their start position.
0 out of 10 symbols keep track of their end position.
5 out of 9 states have a default reduction.
5 out of 6 productions exploit shiftreduce optimization.
0 out of 9 states can peek at an error.
33 functions before inlining, 8 functions after inlining.
diff git a/test/good/uselesspseudotoken.exp b/test/good/uselesspseudotoken.exp
index a3b51d9aa86c73c8c1c3914523fdb985b085ea42..74044dd6863f6b67a68d2aa9257e9a5db471a3c1 100644
 a/test/good/uselesspseudotoken.exp
+++ b/test/good/uselesspseudotoken.exp
@@ 11,10 +11,10 @@ File "uselesspseudotoken.mly", line 3, characters 05:
Warning: the precedence level assigned to zorro is never useful.
File "uselesspseudotoken.mly", line 10, characters 1924:
Warning: this %prec declaration is never useful.
+2 out of 4 states have a default reduction.
0 out of 4 states are represented.
0 out of 6 symbols keep track of their start position.
0 out of 6 symbols keep track of their end position.
2 out of 4 states have a default reduction.
2 out of 2 productions exploit shiftreduce optimization.
0 out of 4 states can peek at an error.
17 functions before inlining, 2 functions after inlining.
diff git a/test/good/verilog.exp b/test/good/verilog.exp
index 677511606c3ac6e4b14f52fe82e3a67287e238b8..07330f4e8f75631a654f54c8f47ed3c88583701d 100644
 a/test/good/verilog.exp
+++ b/test/good/verilog.exp
@@ 682,10 +682,10 @@ Warning: 14 states have shift/reduce conflicts.
Warning: 14 states have reduce/reduce conflicts.
Warning: 81 shift/reduce conflicts were arbitrarily resolved.
Warning: 260 reduce/reduce conflicts were arbitrarily resolved.
+3376 out of 10829 states have a default reduction.
2375 out of 10829 states are represented.
0 out of 534 symbols keep track of their start position.
0 out of 534 symbols keep track of their end position.
3376 out of 10829 states have a default reduction.
3207 out of 3491 productions exploit shiftreduce optimization.
0 out of 10829 states can peek at an error.
25378 functions before inlining, 525 functions after inlining.
diff git a/test/good/wallace.exp b/test/good/wallace.exp
index 64e729c4566ee622d59b9d10be416eb6ef2cf5b3..4c0223adb7b9b293bdf4d07529bbdf80ad6fd3b0 100644
 a/test/good/wallace.exp
+++ b/test/good/wallace.exp
@@ 119,10 +119,10 @@ The grammar is not SLR(1)  19 states have a conflict.
Built an LR(1) automaton with 291 states.
Warning: 16 states have shift/reduce conflicts.
Warning: 85 shift/reduce conflicts were arbitrarily resolved.
+100 out of 291 states have a default reduction.
96 out of 291 states are represented.
0 out of 110 symbols keep track of their start position.
0 out of 110 symbols keep track of their end position.
100 out of 291 states have a default reduction.
64 out of 140 productions exploit shiftreduce optimization.
0 out of 291 states can peek at an error.
763 functions before inlining, 114 functions after inlining.
diff git a/test/good/whyclparser.exp b/test/good/whyclparser.exp
index c77305c0e3d2ce937041e280dfeef2740ecd8142..8e2cb0e50bb97658a3bc582d98ee23d85b86ef63 100644
 a/test/good/whyclparser.exp
+++ b/test/good/whyclparser.exp
@@ 118,10 +118,10 @@ Built an LR(0) automaton with 281 states.
The grammar is not SLR(1)  27 states have a conflict.
Built an LR(1) automaton with 281 states.
421 shift/reduce conflicts were silently solved.
+87 out of 281 states have a default reduction.
78 out of 281 states are represented.
0 out of 123 symbols keep track of their start position.
0 out of 123 symbols keep track of their end position.
87 out of 281 states have a default reduction.
84 out of 148 productions exploit shiftreduce optimization.
0 out of 281 states can peek at an error.
751 functions before inlining, 100 functions after inlining.
diff git a/test/good/whycparser.exp b/test/good/whycparser.exp
index 6c38456f84e39ab89467edad26d18484f3e8076f..4b806ed010c20b083de6d108ef04912520def1f2 100644
 a/test/good/whycparser.exp
+++ b/test/good/whycparser.exp
@@ 243,10 +243,10 @@ Warning: one state has shift/reduce conflicts.
Warning: one state has reduce/reduce conflicts.
Warning: one shift/reduce conflict was arbitrarily resolved.
Warning: 24 reduce/reduce conflicts were arbitrarily resolved.
+188 out of 402 states have a default reduction.
126 out of 402 states are represented.
0 out of 168 symbols keep track of their start position.
0 out of 168 symbols keep track of their end position.
188 out of 402 states have a default reduction.
150 out of 249 productions exploit shiftreduce optimization.
0 out of 402 states can peek at an error.
1135 functions before inlining, 180 functions after inlining.
diff git a/test/good/xpath_parser.exp b/test/good/xpath_parser.exp
index 073682c9ece7d918f810a980cede31e24b690119..e18b974bdd03e086edb8562a413b826cda343e55 100644
 a/test/good/xpath_parser.exp
+++ b/test/good/xpath_parser.exp
@@ 70,10 +70,10 @@ Built an LR(0) automaton with 94 states.
The grammar is SLR(1).
Built an LR(1) automaton with 95 states.
Warning: 54 states have an endofstream conflict.
+34 out of 95 states have a default reduction.
29 out of 95 states are represented.
0 out of 57 symbols keep track of their start position.
0 out of 57 symbols keep track of their end position.
34 out of 95 states have a default reduction.
31 out of 60 productions exploit shiftreduce optimization.
0 out of 95 states can peek at an error.
278 functions before inlining, 56 functions after inlining.
diff git a/test/good/yann.exp b/test/good/yann.exp
index 695cf6d82b91b47a151f5e788311489b31a7242f..9c1ff8dd5e86b51bf0b254196aafb5e2afdfb595 100644
 a/test/good/yann.exp
+++ b/test/good/yann.exp
@@ 25,13 +25,13 @@ Built an LR(1) automaton with 25 states.
Warning: 2 states have reduce/reduce conflicts.
Warning: 6 reduce/reduce conflicts were arbitrarily resolved.
Warning: 13 states have an endofstream conflict.
+9 out of 25 states have a default reduction.
File "yann.mly", line 28, characters 225:
Warning: production term > term PLUS tensorproduct is never reduced.
Warning: in total, 1 productions are never reduced.
7 out of 25 states are represented.
0 out of 16 symbols keep track of their start position.
0 out of 16 symbols keep track of their end position.
9 out of 25 states have a default reduction.
7 out of 14 productions exploit shiftreduce optimization.
0 out of 25 states can peek at an error.
75 functions before inlining, 16 functions after inlining.
diff git a/test/good/yaparser.exp b/test/good/yaparser.exp
index 9490a5ef61dfa78ce2a706ad42cc0ff89414c684..9272066c8bc70bd58fd5e47e9ac729dcc6206f76 100644
 a/test/good/yaparser.exp
+++ b/test/good/yaparser.exp
@@ 124,6 +124,7 @@ Warning: this %prec declaration is never useful.
File "yaparser.mly", line 288, characters 2228:
Warning: this %prec declaration is never useful.
Warning: 4 states have an endofstream conflict.
+60 out of 154 states have a default reduction.
File "yaparser.mly", line 323, characters 442:
Warning: production arith_relation > arith_relation_mul PLUS arith_relation is never reduced.
File "yaparser.mly", line 330, characters 443:
@@ 134,7 +135,6 @@ Warning: in total, 3 productions are never reduced.
40 out of 154 states are represented.
0 out of 68 symbols keep track of their start position.
0 out of 68 symbols keep track of their end position.
60 out of 154 states have a default reduction.
47 out of 78 productions exploit shiftreduce optimization.
0 out of 154 states can peek at an error.
413 functions before inlining, 61 functions after inlining.
diff git a/test/good/zenon.exp b/test/good/zenon.exp
index 3ec8fc2e5a65a285e70c78b166b2241a8c56251f..c6d5543d18b2ae38a8a32bcea9074ec4578713a5 100644
 a/test/good/zenon.exp
+++ b/test/good/zenon.exp
@@ 94,10 +94,10 @@ Built an LR(1) automaton with 315 states.
40 shift/reduce conflicts were silently solved.
File "zenon.mly", line 97, characters 09:
Warning: the precedence level assigned to EQUAL is never useful.
+92 out of 315 states have a default reduction.
127 out of 315 states are represented.
0 out of 89 symbols keep track of their start position.
0 out of 89 symbols keep track of their end position.
92 out of 315 states have a default reduction.
46 out of 97 productions exploit shiftreduce optimization.
0 out of 315 states can peek at an error.
763 functions before inlining, 104 functions after inlining.
diff git a/test/good/zyvaall.exp b/test/good/zyvaall.exp
index 10f62714fecabce743412a440356143bd2ce0dd5..8891c6e33da5cdc88d3aa260184d577ea1a07f79 100644
 a/test/good/zyvaall.exp
+++ b/test/good/zyvaall.exp
@@ 73,10 +73,10 @@ Built an LR(1) automaton with 147 states.
110 shift/reduce conflicts were silently solved.
File "zyvaall.mly", line 19, characters 05:
Warning: the precedence level assigned to EQUALEQUAL is never useful.
+36 out of 147 states have a default reduction.
74 out of 147 states are represented.
0 out of 68 symbols keep track of their start position.
0 out of 68 symbols keep track of their end position.
36 out of 147 states have a default reduction.
22 out of 63 productions exploit shiftreduce optimization.
0 out of 147 states can peek at an error.
383 functions before inlining, 70 functions after inlining.
diff git a/test/good/zyvaflo.exp b/test/good/zyvaflo.exp
index fc0799a7cf19c4632a26c35980c440b736dea1f2..df729bf91e094575b60b53d125d6e9e0359646ae 100644
 a/test/good/zyvaflo.exp
+++ b/test/good/zyvaflo.exp
@@ 71,10 +71,10 @@ Built an LR(1) automaton with 149 states.
110 shift/reduce conflicts were silently solved.
File "zyvaflo.mly", line 21, characters 05:
Warning: the precedence level assigned to EQUALEQUAL is never useful.
+38 out of 149 states have a default reduction.
74 out of 149 states are represented.
0 out of 69 symbols keep track of their start position.
0 out of 69 symbols keep track of their end position.
38 out of 149 states have a default reduction.
24 out of 65 productions exploit shiftreduce optimization.
0 out of 149 states can peek at an error.
389 functions before inlining, 72 functions after inlining.