Functor CamlinternalMenhirLib.TableInterpreter.MakeEngineTable

module MakeEngineTable:
  (T: CamlinternalMenhirLib.TableFormat.TABLES) =>

    CamlinternalMenhirLib.EngineTypes.TABLE with
      type state = int and
      type token = T.token and
      type semantic_value = Obj.t and
      type production = int and
      type terminal = int and
      type nonterminal = int;

Parameters:

T : CamlinternalMenhirLib.TableFormat.TABLES

---

type state;

let number: state => int;

type token;

type terminal;

type nonterminal;

type semantic_value;

let token2terminal: token => terminal;

let token2value: token => semantic_value;

let error_terminal: terminal;

let error_value: semantic_value;

let foreach_terminal: ((terminal, 'a) => 'a, 'a) => 'a;

type production;

let production_index: production => int;

let find_production: int => production;

let default_reduction:
  (state, ('env, production) => 'answer, 'env => 'answer, 'env) => 'answer;

let action:
  (
    state,
    terminal,
    semantic_value,
    ('env, bool, terminal, semantic_value, state) => 'answer,
    ('env, production) => 'answer,
    'env => 'answer,
    'env
  ) =>
  'answer;

let goto_nt: (state, nonterminal) => state;

let goto_prod: (state, production) => state;

let maybe_goto_nt: (state, nonterminal) => option(state);

let is_start: production => bool;

exception Error;

type semantic_action =
  CamlinternalMenhirLib.EngineTypes.env(state, semantic_value, token) =>
  CamlinternalMenhirLib.EngineTypes.stack(state, semantic_value);

let semantic_action: production => semantic_action;

let may_reduce: (state, production) => bool;

let log: bool;

module Log: sig .. end