Parameter `Make.Parser`

include Ocaml_preprocess.MenhirLib.IncrementalEngine.INCREMENTAL_ENGINE

type token

type production

type 'a env

type 'a checkpoint = private

| InputNeeded of 'a Parser.env
| Shifting of 'a Parser.env * 'a Parser.env * bool
| AboutToReduce of 'a Parser.env * Parser.production
| HandlingError of 'a Parser.env
| Accepted of 'a
| Rejected

val offer : 
  'a Parser.checkpoint ->
  (Parser.token
   * Ocaml_preprocess.MenhirLib.IncrementalEngine.position
   * Ocaml_preprocess.MenhirLib.IncrementalEngine.position) ->
  'a Parser.checkpoint

type strategy = [

| `Legacy
| `Simplified

]

val resume : 
  ?strategy:Parser.strategy ->
  'a Parser.checkpoint ->
  'a Parser.checkpoint

type supplier =
  unit ->
  Parser.token
  * Ocaml_preprocess.MenhirLib.IncrementalEngine.position
  * Ocaml_preprocess.MenhirLib.IncrementalEngine.position

val lexer_lexbuf_to_supplier : 
  (Stdlib.Lexing.lexbuf -> Parser.token) ->
  Stdlib.Lexing.lexbuf ->
  Parser.supplier

val loop : 
  ?strategy:Parser.strategy ->
  Parser.supplier ->
  'a Parser.checkpoint ->
  'a

val loop_handle : 
  ('a -> 'answer) ->
  ('a Parser.checkpoint -> 'answer) ->
  Parser.supplier ->
  'a Parser.checkpoint ->
  'answer

val loop_handle_undo : 
  ('a -> 'answer) ->
  ('a Parser.checkpoint -> 'a Parser.checkpoint -> 'answer) ->
  Parser.supplier ->
  'a Parser.checkpoint ->
  'answer

val shifts : 'a Parser.checkpoint -> 'a Parser.env option

val acceptable : 
  'a Parser.checkpoint ->
  Parser.token ->
  Ocaml_preprocess.MenhirLib.IncrementalEngine.position ->
  bool

type 'a lr1state

val number : _ Parser.lr1state -> int

val production_index : Parser.production -> int

val find_production : int -> Parser.production

type element =

| Element : 'a Parser.lr1state * 'a * Ocaml_preprocess.MenhirLib.IncrementalEngine.position * Ocaml_preprocess.MenhirLib.IncrementalEngine.position -> Parser.element

type stack = Parser.element Ocaml_preprocess.MenhirLib.General.stream

val stack : 'a Parser.env -> Parser.stack

val top : 'a Parser.env -> Parser.element option

val pop_many : int -> 'a Parser.env -> 'a Parser.env option

val get : int -> 'a Parser.env -> Parser.element option

val current_state_number : 'a Parser.env -> int

val equal : 'a Parser.env -> 'a Parser.env -> bool

val positions : 
  'a Parser.env ->
  Ocaml_preprocess.MenhirLib.IncrementalEngine.position
  * Ocaml_preprocess.MenhirLib.IncrementalEngine.position

val env_has_default_reduction : 'a Parser.env -> bool

val state_has_default_reduction : _ Parser.lr1state -> bool

val pop : 'a Parser.env -> 'a Parser.env option

val force_reduction : Parser.production -> 'a Parser.env -> 'a Parser.env

val input_needed : 'a Parser.env -> 'a Parser.checkpoint

include Ocaml_preprocess.MenhirLib.IncrementalEngine.INSPECTION
  with type 'a lr1state := 'a Parser.lr1state
  with type production := Parser.production
  with type 'a env := 'a Parser.env

include Ocaml_preprocess.MenhirLib.IncrementalEngine.SYMBOLS

type 'a terminal

type 'a nonterminal

type 'a symbol =

| T : 'a Parser.terminal -> 'a Parser.symbol
| N : 'a Parser.nonterminal -> 'a Parser.symbol

type xsymbol =

| X : 'a Parser.symbol -> Parser.xsymbol

type item = Parser.production * int

val compare_terminals : _ Parser.terminal -> _ Parser.terminal -> int

val compare_nonterminals : _ Parser.nonterminal -> _ Parser.nonterminal -> int

val compare_symbols : Parser.xsymbol -> Parser.xsymbol -> int

val compare_productions : Parser.production -> Parser.production -> int

val compare_items : Parser.item -> Parser.item -> int

val incoming_symbol : 'a Parser.lr1state -> 'a Parser.symbol

val items : _ Parser.lr1state -> Parser.item list

val lhs : Parser.production -> Parser.xsymbol

val rhs : Parser.production -> Parser.xsymbol list

val nullable : _ Parser.nonterminal -> bool

val first : _ Parser.nonterminal -> _ Parser.terminal -> bool

val xfirst : Parser.xsymbol -> _ Parser.terminal -> bool

val foreach_terminal : (Parser.xsymbol -> 'a -> 'a) -> 'a -> 'a

val foreach_terminal_but_error : (Parser.xsymbol -> 'a -> 'a) -> 'a -> 'a

val feed : 
  'a Parser.symbol ->
  Ocaml_preprocess.MenhirLib.IncrementalEngine.position ->
  'a ->
  Ocaml_preprocess.MenhirLib.IncrementalEngine.position ->
  'b Parser.env ->
  'b Parser.env

Parameter Make.Parser

Parameter `Make.Parser`