functor
  (TT : TableFormat.TABLES) (IT : sig
                                    type 'a terminal
                                    type 'a nonterminal
                                    type 'a symbol =
                                        T : 'a terminal -> 'a symbol
                                      | N : 'a nonterminal -> 'a symbol
                                    type xsymbol = X : 'a symbol -> xsymbol
                                    type 'a lr1state = int
                                    val terminal : int -> xsymbol
                                    val nonterminal : int -> xsymbol
                                    val rhs :
                                      PackedIntArray.t * PackedIntArray.t
                                    val lr0_core : PackedIntArray.t
                                    val lr0_items :
                                      PackedIntArray.t * PackedIntArray.t
                                    val lr0_incoming : PackedIntArray.t
                                    val nullable : string
                                    val first : int * string
                                  end) (ET : sig
                                               type state
                                               val number : state -> int
                                               type token
                                               type terminal = int
                                               type nonterminal = int
                                               type semantic_value = Obj.t
                                               val token2terminal :
                                                 token -> terminal
                                               val token2value :
                                                 token -> semantic_value
                                               val error_terminal : terminal
                                               val error_value :
                                                 semantic_value
                                               val foreach_terminal :
                                                 (terminal -> 'a -> 'a) ->
                                                 'a -> 'a
                                               type production
                                               val production_index :
                                                 production -> int
                                               val find_production :
                                                 int -> production
                                               val default_reduction :
                                                 state ->
                                                 ('env ->
                                                  production -> 'answer) ->
                                                 ('env -> 'answer) ->
                                                 'env -> 'answer
                                               val action :
                                                 state ->
                                                 terminal ->
                                                 semantic_value ->
                                                 ('env ->
                                                  bool ->
                                                  terminal ->
                                                  semantic_value ->
                                                  state -> 'answer) ->
                                                 ('env ->
                                                  production -> 'answer) ->
                                                 ('env -> 'answer) ->
                                                 'env -> 'answer
                                               val goto_nt :
                                                 state ->
                                                 nonterminal -> state
                                               val goto_prod :
                                                 state -> production -> state
                                               val maybe_goto_nt :
                                                 state ->
                                                 nonterminal -> state option
                                               val is_start :
                                                 production -> bool
                                               exception Error
                                               type semantic_action =
                                                   (state, semantic_value,
                                                    token)
                                                   EngineTypes.env ->
                                                   (state, semantic_value)
                                                   EngineTypes.stack
                                               val semantic_action :
                                                 production ->
                                                 semantic_action
                                               val may_reduce :
                                                 state -> production -> bool
                                               val log : bool
                                               module Log :
                                                 sig
                                                   val state : state -> unit
                                                   val shift :
                                                     terminal ->
                                                     state -> unit
                                                   val reduce_or_accept :
                                                     production -> unit
                                                   val lookahead_token :
                                                     terminal ->
                                                     Lexing.position ->
                                                     Lexing.position -> unit
                                                   val initiating_error_handling :
                                                     unit -> unit
                                                   val resuming_error_handling :
                                                     unit -> unit
                                                   val handling_error :
                                                     state -> unit
                                                 end
                                             end) (E : sig
                                                         type 'a env =
                                                             (ET.state,
                                                              ET.semantic_value,
                                                              ET.token)
                                                             CamlinternalMenhirLib.EngineTypes.env
                                                       end) ->
  sig
    type 'a symbol =
        T : 'a IT.terminal -> 'a symbol
      | N : 'a IT.nonterminal -> 'a symbol
    type xsymbol = X : 'a symbol -> xsymbol
    type item = int * int
    val compare_terminals : 'a IT.terminal -> 'b IT.terminal -> int
    val compare_nonterminals : 'a IT.nonterminal -> 'b IT.nonterminal -> int
    val compare_symbols : xsymbol -> xsymbol -> int
    val compare_productions : int -> int -> int
    val compare_items : item -> item -> int
    val incoming_symbol : 'a IT.lr1state -> 'a symbol
    val items : 'a IT.lr1state -> item list
    val lhs : int -> xsymbol
    val rhs : int -> xsymbol list
    val nullable : 'a IT.nonterminal -> bool
    val first : 'a IT.nonterminal -> 'b IT.terminal -> bool
    val xfirst : xsymbol -> 'a IT.terminal -> bool
    val foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'a
    val foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'a
    val feed :
      'a symbol ->
      IncrementalEngine.position ->
      'a -> IncrementalEngine.position -> 'b E.env -> 'b E.env
  end