Source file codeParser.ml

module MenhirBasics = struct
  
  exception Error of int
  
  let _eRR =
    fun _s ->
      raise (Error _s)
  
  type token = Parser.token
  
end

include MenhirBasics

type ('s, 'r) _menhir_state = 
  | MenhirState00 : ('s, _menhir_box_interactive_command) _menhir_state
    (** State 00.
        Stack shape : .
        Start symbol: interactive_command. *)

  | MenhirState02 : (('s, 'r) _menhir_cell1_LET _menhir_cell0_ID, 'r) _menhir_state
    (** State 02.
        Stack shape : LET ID.
        Start symbol: <undetermined>. *)

  | MenhirState04 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 04.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState07 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 07.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState10 : (('s, 'r) _menhir_cell1_DATA, 'r) _menhir_state
    (** State 10.
        Stack shape : DATA.
        Start symbol: <undetermined>. *)

  | MenhirState22 : ((('s, 'r) _menhir_cell1_LET _menhir_cell0_ID, 'r) _menhir_cell1_args_spec, 'r) _menhir_state
    (** State 22.
        Stack shape : LET ID args_spec.
        Start symbol: <undetermined>. *)

  | MenhirState23 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 23.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState31 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 31.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState36 : (('s, 'r) _menhir_cell1_arg, 'r) _menhir_state
    (** State 36.
        Stack shape : arg.
        Start symbol: <undetermined>. *)

  | MenhirState41 : (('s, 'r) _menhir_cell1_entries, 'r) _menhir_state
    (** State 41.
        Stack shape : entries.
        Start symbol: <undetermined>. *)

  | MenhirState43 : (('s, 'r) _menhir_cell1_arg_spec, 'r) _menhir_state
    (** State 43.
        Stack shape : arg_spec.
        Start symbol: <undetermined>. *)

  | MenhirState48 : (('s, 'r) _menhir_cell1_term_literal, 'r) _menhir_state
    (** State 48.
        Stack shape : term_literal.
        Start symbol: <undetermined>. *)

  | MenhirState53 : (('s, 'r) _menhir_cell1_entry, 'r) _menhir_state
    (** State 53.
        Stack shape : entry.
        Start symbol: <undetermined>. *)

  | MenhirState60 : ('s, _menhir_box_script_command) _menhir_state
    (** State 60.
        Stack shape : .
        Start symbol: script_command. *)


and ('s, 'r) _menhir_cell1_arg = 
  | MenhirCell1_arg of 's * ('s, 'r) _menhir_state * (Environment.arg_full)

and ('s, 'r) _menhir_cell1_arg_spec = 
  | MenhirCell1_arg_spec of 's * ('s, 'r) _menhir_state * (Environment.param)

and ('s, 'r) _menhir_cell1_args_spec = 
  | MenhirCell1_args_spec of 's * ('s, 'r) _menhir_state * (Environment.param_list)

and ('s, 'r) _menhir_cell1_entries = 
  | MenhirCell1_entries of 's * ('s, 'r) _menhir_state * (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)) * Lexing.position

and ('s, 'r) _menhir_cell1_entry = 
  | MenhirCell1_entry of 's * ('s, 'r) _menhir_state * (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)) * Lexing.position

and ('s, 'r) _menhir_cell1_term_literal = 
  | MenhirCell1_term_literal of 's * ('s, 'r) _menhir_state * (Value.value)

and ('s, 'r) _menhir_cell1_DATA = 
  | MenhirCell1_DATA of 's * ('s, 'r) _menhir_state * (
# 3 "src/scripting/parser.mly"
       (string)
# 123 "src/scripting/codeParser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_ID = 
  | MenhirCell1_ID of 's * ('s, 'r) _menhir_state * (
# 3 "src/scripting/parser.mly"
       (string)
# 130 "src/scripting/codeParser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_ID = 
  | MenhirCell0_ID of 's * (
# 3 "src/scripting/parser.mly"
       (string)
# 137 "src/scripting/codeParser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_LET = 
  | MenhirCell1_LET of 's * ('s, 'r) _menhir_state * Lexing.position

and _menhir_box_script_command = 
  | MenhirBox_script_command of ((Environment.env -> Value.value option * Environment.env) option) [@@unboxed]

and _menhir_box_interactive_command = 
  | MenhirBox_interactive_command of (Environment.env -> Value.value option * Environment.env) [@@unboxed]

let _menhir_action_02 =
  fun _endpos_n_ _startpos__1_ _startpos_n_ n ->
    let _endpos = _endpos_n_ in
    let _startpos = _startpos__1_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _loc = (_startpos, _endpos) in
    (
# 61 "src/scripting/parser.mly"
              ( Environment.Arg (Some (n, _loc_n_), Environment.Bool_p (true, _loc)) )
# 158 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_03 =
  fun _endpos_n_ _startpos__1_ _startpos_n_ n ->
    let _endpos = _endpos_n_ in
    let _startpos = _startpos__1_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _loc = (_startpos, _endpos) in
    (
# 62 "src/scripting/parser.mly"
               ( Environment.Arg (Some (n, _loc_n_), Environment.Bool_p (false, _loc)) )
# 170 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_04 =
  fun a ->
    (
# 63 "src/scripting/parser.mly"
              ( Environment.Arg (None, a) )
# 178 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_05 =
  fun _endpos_n_ _startpos_n_ a n ->
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    (
# 64 "src/scripting/parser.mly"
                           ( Environment.Arg (Some (n, _loc_n_), a) )
# 187 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_06 =
  fun () ->
    (
# 65 "src/scripting/parser.mly"
                 ( Environment.Completion_name (None, ("", '=')) )
# 195 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_07 =
  fun () ->
    (
# 66 "src/scripting/parser.mly"
                      ( Environment.Completion_name (Some Environment.T_Bool, ("+", ' ')) )
# 203 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_08 =
  fun () ->
    (
# 67 "src/scripting/parser.mly"
                       ( Environment.Completion_name (Some Environment.T_Bool, ("-", ' '))  )
# 211 "src/scripting/codeParser.ml"
     : (Environment.arg_full))

let _menhir_action_09 =
  fun _endpos_n_ _startpos_n_ n ->
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    (
# 74 "src/scripting/parser.mly"
         ( ((n, _loc_n_), None) )
# 220 "src/scripting/codeParser.ml"
     : (Environment.param))

let _menhir_action_10 =
  fun _endpos_n_ _startpos_n_ a n ->
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    (
# 75 "src/scripting/parser.mly"
                           ( ((n, _loc_n_), Some a) )
# 229 "src/scripting/codeParser.ml"
     : (Environment.param))

let _menhir_action_11 =
  fun _endpos_a_ _startpos_a_ a ->
    let _loc_a_ = (_startpos_a_, _endpos_a_) in
    (
# 78 "src/scripting/parser.mly"
         ( Environment.Id_p (a, _loc_a_) )
# 238 "src/scripting/codeParser.ml"
     : (Environment.arg_parse))

let _menhir_action_12 =
  fun _endpos_a_ _startpos_a_ a ->
    let _loc_a_ = (_startpos_a_, _endpos_a_) in
    (
# 79 "src/scripting/parser.mly"
          ( Environment.Int_p (a, _loc_a_) )
# 247 "src/scripting/codeParser.ml"
     : (Environment.arg_parse))

let _menhir_action_13 =
  fun _endpos_a_ _startpos_a_ a ->
    let _loc_a_ = (_startpos_a_, _endpos_a_) in
    (
# 80 "src/scripting/parser.mly"
           ( Environment.Data_p (a, _loc_a_) )
# 256 "src/scripting/codeParser.ml"
     : (Environment.arg_parse))

let _menhir_action_14 =
  fun _endpos_a_ _startpos_a_ a ->
    let _loc_a_ = (_startpos_a_, _endpos_a_) in
    (
# 81 "src/scripting/parser.mly"
            ( let (lt, l) = a in match lt with Environment.IdList_lt -> Environment.VList_p (l, _loc_a_) | Environment.StringList_lt -> Environment.StringList_p (l, _loc_a_) )
# 265 "src/scripting/codeParser.ml"
     : (Environment.arg_parse))

let _menhir_action_15 =
  fun () ->
    (
# 82 "src/scripting/parser.mly"
                ( Environment.Completion_val )
# 273 "src/scripting/codeParser.ml"
     : (Environment.arg_parse))

let _menhir_action_16 =
  fun () ->
    (
# 57 "src/scripting/parser.mly"
  ( [] )
# 281 "src/scripting/codeParser.ml"
     : (Environment.arg_full list))

let _menhir_action_17 =
  fun a al ->
    (
# 58 "src/scripting/parser.mly"
                    ( a :: al )
# 289 "src/scripting/codeParser.ml"
     : (Environment.arg_full list))

let _menhir_action_18 =
  fun () ->
    (
# 70 "src/scripting/parser.mly"
  ( [] )
# 297 "src/scripting/codeParser.ml"
     : (Environment.param_list))

let _menhir_action_19 =
  fun a al ->
    (
# 71 "src/scripting/parser.mly"
                              ( a :: al )
# 305 "src/scripting/codeParser.ml"
     : (Environment.param_list))

let _menhir_action_20 =
  fun l ->
    (
# 36 "src/scripting/parser.mly"
           ( l )
# 313 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_21 =
  fun _endpos_e_ _endpos_f_ _startpos__1_ _startpos_f_ a e f ->
    let _endpos = _endpos_e_ in
    let _startpos = _startpos__1_ in
    let _loc_f_ = (_startpos_f_, _endpos_f_) in
    let _loc = (_startpos, _endpos) in
    (
# 37 "src/scripting/parser.mly"
                                                   ( fun env -> None, (Environment.add_fun env f a _loc _loc_f_ e) )
# 325 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_22 =
  fun () ->
    (
# 38 "src/scripting/parser.mly"
            ( raise (Environment.Completion (Environment.Compl_Custom ["let"])) )
# 333 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_23 =
  fun e ->
    (
# 49 "src/scripting/parser.mly"
            ( e )
# 341 "src/scripting/codeParser.ml"
     : (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)))

let _menhir_action_24 =
  fun e el ->
    (
# 50 "src/scripting/parser.mly"
                              ( fun fts blist env -> let (elft, elblist, elfun) = el fts blist env in let (eft, eblist, efun) = e elft elblist env in (eft, eblist, fun vl env v -> let (lv, env) = elfun vl env v in efun vl env lv) )
# 355 "src/scripting/codeParser.ml"
     : (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)))

let _menhir_action_25 =
  fun _endpos_a_ _endpos_f_ _startpos_f_ a f ->
    let _endpos = _endpos_a_ in
    let _startpos = _startpos_f_ in
    let _loc_f_ = (_startpos_f_, _endpos_f_) in
    let _loc = (_startpos, _endpos) in
    (
# 53 "src/scripting/parser.mly"
                  ( Environment.call_fun f a _loc _loc_f_ )
# 373 "src/scripting/codeParser.ml"
     : (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)))

let _menhir_action_26 =
  fun () ->
    (
# 54 "src/scripting/parser.mly"
            ( fun ft -> raise (Environment.Completion (Environment.Compl_Fun_name ft)) )
# 387 "src/scripting/codeParser.ml"
     : (Environment.func_type ->
  Environment.binding_list ->
  Environment.env ->
  Environment.func_type * Environment.binding_list *
  (Environment.var list ->
   Environment.env ->
   Value.value option -> Value.value option * Environment.env)))

let _menhir_action_27 =
  fun c ->
    (
# 32 "src/scripting/parser.mly"
                  ( c )
# 401 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_28 =
  fun c ->
    (
# 33 "src/scripting/parser.mly"
                       ( c )
# 409 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_29 =
  fun el t ->
    (
# 41 "src/scripting/parser.mly"
                                     (fun env -> let (_, _, elfun) = el Environment.Computation [] env in elfun [] env (Some t) )
# 417 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_30 =
  fun el ->
    (
# 42 "src/scripting/parser.mly"
               (fun env -> let (_, _, elfun) = el Environment.AtStart [] env in elfun [] env None )
# 425 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_31 =
  fun e t ->
    (
# 43 "src/scripting/parser.mly"
                                 (fun env -> let (_, _, efun) = e Environment.Computation [] env in efun [] env (Some t) )
# 433 "src/scripting/codeParser.ml"
     : (Environment.env -> Value.value option * Environment.env))

let _menhir_action_32 =
  fun c ->
    (
# 28 "src/scripting/parser.mly"
                   ( Some c )
# 441 "src/scripting/codeParser.ml"
     : ((Environment.env -> Value.value option * Environment.env) option))

let _menhir_action_33 =
  fun () ->
    (
# 29 "src/scripting/parser.mly"
      ( None )
# 449 "src/scripting/codeParser.ml"
     : ((Environment.env -> Value.value option * Environment.env) option))

let _menhir_action_34 =
  fun _endpos_d_ _startpos_d_ d ->
    let _loc_d_ = (_startpos_d_, _endpos_d_) in
    (
# 46 "src/scripting/parser.mly"
           ( Value.value_from_string d _loc_d_ )
# 458 "src/scripting/codeParser.ml"
     : (Value.value))

let _menhir_action_35 =
  fun _endpos_id_ _startpos_id_ id vl ->
    let _loc_id_ = (_startpos_id_, _endpos_id_) in
    (
# 85 "src/scripting/parser.mly"
                           ( let (lt, l) = vl in (lt, (Environment.Vl_elem (id, _loc_id_)) :: l) )
# 467 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_36 =
  fun _endpos_id_ _startpos_id_ id vl ->
    let _loc_id_ = (_startpos_id_, _endpos_id_) in
    (
# 86 "src/scripting/parser.mly"
                             ( let (_, l) = vl in (Environment.StringList_lt, (Environment.Vl_elem (id, _loc_id_)) :: l) )
# 476 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_37 =
  fun _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 ->
    let _loc_id2_ = (_startpos_id2_, _endpos_id2_) in
    let _loc_id1_ = (_startpos_id1_, _endpos_id1_) in
    (
# 87 "src/scripting/parser.mly"
                          ( (Environment.IdList_lt, [ Environment.Vl_elem (id1, _loc_id1_) ; Environment.Vl_elem (id2, _loc_id2_) ]) )
# 486 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_38 =
  fun _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 ->
    let _loc_id2_ = (_startpos_id2_, _endpos_id2_) in
    let _loc_id1_ = (_startpos_id1_, _endpos_id1_) in
    (
# 88 "src/scripting/parser.mly"
                            ( (Environment.StringList_lt, [ Environment.Vl_elem (id1, _loc_id1_) ; Environment.Vl_elem (id2, _loc_id2_) ]) )
# 496 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_39 =
  fun _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 ->
    let _loc_id2_ = (_startpos_id2_, _endpos_id2_) in
    let _loc_id1_ = (_startpos_id1_, _endpos_id1_) in
    (
# 89 "src/scripting/parser.mly"
                            ( (Environment.StringList_lt, [ Environment.Vl_elem (id1, _loc_id1_) ; Environment.Vl_elem (id2, _loc_id2_) ]) )
# 506 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_40 =
  fun _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 ->
    let _loc_id2_ = (_startpos_id2_, _endpos_id2_) in
    let _loc_id1_ = (_startpos_id1_, _endpos_id1_) in
    (
# 90 "src/scripting/parser.mly"
                              ( (Environment.StringList_lt, [ Environment.Vl_elem (id1, _loc_id1_) ; Environment.Vl_elem (id2, _loc_id2_) ]) )
# 516 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_41 =
  fun _endpos_id_ _startpos_id_ id ->
    let _loc_id_ = (_startpos_id_, _endpos_id_) in
    (
# 91 "src/scripting/parser.mly"
                              ( (Environment.IdList_lt, [ Environment.Vl_elem (id, _loc_id_) ; Environment.Completion_list_val ]) )
# 525 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_action_42 =
  fun _endpos_id_ _startpos_id_ id ->
    let _loc_id_ = (_startpos_id_, _endpos_id_) in
    (
# 92 "src/scripting/parser.mly"
                                ( (Environment.IdList_lt, [ Environment.Vl_elem (id, _loc_id_) ; Environment.Completion_list_val ]) )
# 534 "src/scripting/codeParser.ml"
     : (Environment.vlist_type * Environment.vlist_elem list))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | Parser.COLON_EQUAL ->
        "COLON_EQUAL"
    | Parser.COMMA ->
        "COMMA"
    | Parser.COMPL_ARG_NAME ->
        "COMPL_ARG_NAME"
    | Parser.COMPL_ARG_VAL ->
        "COMPL_ARG_VAL"
    | Parser.COMPL_FUN ->
        "COMPL_FUN"
    | Parser.COMPL_LET ->
        "COMPL_LET"
    | Parser.DATA _ ->
        "DATA"
    | Parser.EOI ->
        "EOI"
    | Parser.EQUAL ->
        "EQUAL"
    | Parser.ID _ ->
        "ID"
    | Parser.INF ->
        "INF"
    | Parser.INT _ ->
        "INT"
    | Parser.LET ->
        "LET"
    | Parser.MINUS ->
        "MINUS"
    | Parser.PIPE ->
        "PIPE"
    | Parser.PLUS ->
        "PLUS"
    | Parser.SEMI ->
        "SEMI"

let _menhir_fail : unit -> 'a =
  fun () ->
    Printf.eprintf "Internal failure -- please contact the parser generator's developers.\n%!";
    assert false

include struct
  
  [@@@ocaml.warning "-4-37"]
  
  let _menhir_goto_script_command : type  ttv_stack. ttv_stack -> _ -> _menhir_box_script_command =
    fun _menhir_stack _v ->
      MenhirBox_script_command _v
  
  let _menhir_run_63 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_script_command =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.SEMI ->
          let c = _v in
          let _v = _menhir_action_32 c in
          _menhir_goto_script_command _menhir_stack _v
      | _ ->
          _eRR 63
  
  let _menhir_goto_interactive_command : type  ttv_stack. ttv_stack -> _ -> _menhir_box_interactive_command =
    fun _menhir_stack _v ->
      MenhirBox_interactive_command _v
  
  let _menhir_run_56 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _menhir_box_interactive_command =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.SEMI ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.EOI ->
              let c = _v in
              let _v = _menhir_action_28 c in
              _menhir_goto_interactive_command _menhir_stack _v
          | _ ->
              _eRR 57)
      | Parser.EOI ->
          let c = _v in
          let _v = _menhir_action_27 c in
          _menhir_goto_interactive_command _menhir_stack _v
      | _ ->
          _eRR 56
  
  let _menhir_goto_command : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState60 ->
          _menhir_run_63 _menhir_stack _v _tok
      | MenhirState00 ->
          _menhir_run_56 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  let _menhir_goto_line : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let l = _v in
      let _v = _menhir_action_20 l in
      _menhir_goto_command _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_run_54 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_entry -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_entry (_menhir_stack, _menhir_s, e, _) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_31 e t in
      _menhir_goto_line _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let rec _menhir_run_03 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.EQUAL ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState04 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.INT _v ->
              _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.ID _v ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.DATA _v ->
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.COMPL_ARG_VAL ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR 4)
      | Parser.COLON_EQUAL | Parser.ID _ ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_09 _endpos_n_ _startpos_n_ n in
          _menhir_goto_arg_spec _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR 3
  
  and _menhir_run_05 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_a_, _startpos_a_, a) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_12 _endpos_a_ _startpos_a_ a in
      _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_arg_val : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState36 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState23 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_32 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState04 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_35 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let a = _v in
      let _v = _menhir_action_04 a in
      _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_arg : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_arg (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | Parser.PLUS ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState36
      | Parser.MINUS ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState36
      | Parser.INT _v_0 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState36
      | Parser.ID _v_1 ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState36
      | Parser.DATA _v_2 ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState36
      | Parser.COMPL_ARG_VAL ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState36
      | Parser.COMPL_ARG_NAME ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState36
      | Parser.EOI | Parser.INF | Parser.PIPE | Parser.SEMI ->
          let _v_3 = _menhir_action_16 () in
          _menhir_run_37 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_3 _tok
      | _ ->
          _eRR 36
  
  and _menhir_run_24 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos_n_, _startpos_n_, n) = (_startpos, _endpos, _startpos_0, _v) in
          let _v = _menhir_action_02 _endpos_n_ _startpos__1_ _startpos_n_ n in
          _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | Parser.COMPL_ARG_NAME ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_07 () in
          _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR 24
  
  and _menhir_run_27 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos_n_, _startpos_n_, n) = (_startpos, _endpos, _startpos_0, _v) in
          let _v = _menhir_action_03 _endpos_n_ _startpos__1_ _startpos_n_ n in
          _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | Parser.COMPL_ARG_NAME ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_08 () in
          _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR 27
  
  and _menhir_run_30 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.EQUAL ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState31 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.INT _v ->
              _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.ID _v ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.DATA _v ->
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.COMPL_ARG_VAL ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR 31)
      | Parser.COMMA ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
          let (_endpos_a_, _startpos_a_, a) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_11 _endpos_a_ _startpos_a_ a in
          _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR 30
  
  and _menhir_run_06 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_ID as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.COMMA ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
          let (_endpos_a_, _startpos_a_, a) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_11 _endpos_a_ _startpos_a_ a in
          _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR 6
  
  and _menhir_run_07 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.COMMA ->
              let _menhir_stack = MenhirCell1_ID (_menhir_stack, MenhirState07, _v, _startpos, _endpos) in
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer
          | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
              let MenhirCell1_ID (_menhir_stack, _menhir_s, id1, _startpos_id1_, _endpos_id1_) = _menhir_stack in
              let (_endpos_id2_, _startpos_id2_, id2) = (_endpos, _startpos, _v) in
              let _v = _menhir_action_37 _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 in
              _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id2_ _startpos_id1_ _v _menhir_s _tok
          | _ ->
              _eRR 8)
      | Parser.DATA _v ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.COMMA ->
              let _menhir_stack = MenhirCell1_DATA (_menhir_stack, MenhirState07, _v, _startpos, _endpos) in
              _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer
          | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
              let MenhirCell1_ID (_menhir_stack, _menhir_s, id1, _startpos_id1_, _endpos_id1_) = _menhir_stack in
              let (_endpos_id2_, _startpos_id2_, id2) = (_endpos, _startpos, _v) in
              let _v = _menhir_action_39 _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 in
              _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id2_ _startpos_id1_ _v _menhir_s _tok
          | _ ->
              _eRR 9)
      | Parser.COMPL_ARG_VAL ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let _endpos__3_ = _endpos in
          let _v = _menhir_action_41 _endpos_id_ _startpos_id_ id in
          _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          _eRR 7
  
  and _menhir_goto_vlist : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState36 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState23 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState04 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState07 ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState10 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_19 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_a_, _startpos_a_, a) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_14 _endpos_a_ _startpos_a_ a in
      _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_16 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_vl_, vl) = (_endpos, _v) in
      let _v = _menhir_action_35 _endpos_id_ _startpos_id_ id vl in
      _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_vl_ _startpos_id_ _v _menhir_s _tok
  
  and _menhir_run_14 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_DATA -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_DATA (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_vl_, vl) = (_endpos, _v) in
      let _v = _menhir_action_36 _endpos_id_ _startpos_id_ id vl in
      _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_vl_ _startpos_id_ _v _menhir_s _tok
  
  and _menhir_run_10 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_DATA -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.COMMA ->
              let _menhir_stack = MenhirCell1_ID (_menhir_stack, MenhirState10, _v, _startpos, _endpos) in
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer
          | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
              let MenhirCell1_DATA (_menhir_stack, _menhir_s, id1, _startpos_id1_, _endpos_id1_) = _menhir_stack in
              let (_endpos_id2_, _startpos_id2_, id2) = (_endpos, _startpos, _v) in
              let _v = _menhir_action_38 _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 in
              _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id2_ _startpos_id1_ _v _menhir_s _tok
          | _ ->
              _eRR 11)
      | Parser.DATA _v ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.COMMA ->
              let _menhir_stack = MenhirCell1_DATA (_menhir_stack, MenhirState10, _v, _startpos, _endpos) in
              _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer
          | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
              let MenhirCell1_DATA (_menhir_stack, _menhir_s, id1, _startpos_id1_, _endpos_id1_) = _menhir_stack in
              let (_endpos_id2_, _startpos_id2_, id2) = (_endpos, _startpos, _v) in
              let _v = _menhir_action_40 _endpos_id1_ _endpos_id2_ _startpos_id1_ _startpos_id2_ id1 id2 in
              _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id2_ _startpos_id1_ _v _menhir_s _tok
          | _ ->
              _eRR 12)
      | Parser.COMPL_ARG_VAL ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_DATA (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let _endpos__3_ = _endpos in
          let _v = _menhir_action_42 _endpos_id_ _startpos_id_ id in
          _menhir_goto_vlist _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          _eRR 10
  
  and _menhir_run_17 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.COMMA ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.COLON_EQUAL | Parser.COMPL_ARG_NAME | Parser.COMPL_ARG_VAL | Parser.DATA _ | Parser.EOI | Parser.ID _ | Parser.INF | Parser.INT _ | Parser.MINUS | Parser.PIPE | Parser.PLUS | Parser.SEMI ->
          let (_endpos_a_, _startpos_a_, a) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_13 _endpos_a_ _startpos_a_ a in
          _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR 17
  
  and _menhir_run_18 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_15 () in
      _menhir_goto_arg_val _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_33 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_06 () in
      _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_37 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_arg -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_arg (_menhir_stack, _menhir_s, a) = _menhir_stack in
      let (_endpos_al_, al) = (_endpos, _v) in
      let _v = _menhir_action_17 a al in
      _menhir_goto_args _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_al_ _v _menhir_s _tok
  
  and _menhir_goto_args : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState36 ->
          _menhir_run_37 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState23 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_34 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, f, _startpos_f_, _endpos_f_) = _menhir_stack in
      let (_endpos_a_, a) = (_endpos, _v) in
      let _v = _menhir_action_25 _endpos_a_ _endpos_f_ _startpos_f_ a f in
      _menhir_goto_entry _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_a_ _v _menhir_s _tok
  
  and _menhir_goto_entry : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState60 ->
          _menhir_run_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState41 ->
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState48 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState22 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_52 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.INF ->
          let _menhir_stack = MenhirCell1_entry (_menhir_stack, _menhir_s, _v, _endpos) in
          let _menhir_s = MenhirState53 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.DATA _v ->
              _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR 53)
      | Parser.EOI | Parser.PIPE | Parser.SEMI ->
          let (_endpos_e_, e) = (_endpos, _v) in
          let _v = _menhir_action_23 e in
          _menhir_goto_entries _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ _v _menhir_s _tok
      | _ ->
          _eRR 52
  
  and _menhir_run_45 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_34 _endpos_d_ _startpos_d_ d in
      _menhir_goto_term_literal _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_term_literal : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState53 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState60 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_47 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_term_literal (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | Parser.PIPE ->
          let _menhir_s = MenhirState48 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.ID _v ->
              _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Parser.COMPL_FUN ->
              _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR 48)
      | _ ->
          _eRR 47
  
  and _menhir_run_23 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.PLUS ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState23
      | Parser.MINUS ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState23
      | Parser.INT _v_0 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState23
      | Parser.ID _v_1 ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState23
      | Parser.DATA _v_2 ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState23
      | Parser.COMPL_ARG_VAL ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState23
      | Parser.COMPL_ARG_NAME ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState23
      | Parser.EOI | Parser.INF | Parser.PIPE | Parser.SEMI ->
          let _v_3 = _menhir_action_16 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_3 _tok
      | _ ->
          _eRR 23
  
  and _menhir_run_38 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _endpos__1_ = _endpos in
      let _v = _menhir_action_26 () in
      _menhir_goto_entry _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_entries : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState60 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState48 ->
          _menhir_run_49 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState22 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_55 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.PIPE ->
          let _menhir_stack = MenhirCell1_entries (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.EOI | Parser.SEMI ->
          let el = _v in
          let _v = _menhir_action_30 el in
          _menhir_goto_line _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR 55
  
  and _menhir_run_41 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_entries -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState41 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Parser.COMPL_FUN ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR 41
  
  and _menhir_run_49 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_term_literal as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.PIPE ->
          let _menhir_stack = MenhirCell1_entries (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.EOI | Parser.SEMI ->
          let MenhirCell1_term_literal (_menhir_stack, _menhir_s, t) = _menhir_stack in
          let el = _v in
          let _v = _menhir_action_29 el t in
          _menhir_goto_line _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR 49
  
  and _menhir_run_40 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LET _menhir_cell0_ID, ttv_result) _menhir_cell1_args_spec as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Parser.PIPE ->
          let _menhir_stack = MenhirCell1_entries (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer
      | Parser.EOI | Parser.SEMI ->
          let MenhirCell1_args_spec (_menhir_stack, _, a) = _menhir_stack in
          let MenhirCell0_ID (_menhir_stack, f, _startpos_f_, _endpos_f_) = _menhir_stack in
          let MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos_e_, e) = (_endpos, _v) in
          let _v = _menhir_action_21 _endpos_e_ _endpos_f_ _startpos__1_ _startpos_f_ a e f in
          _menhir_goto_command _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR 40
  
  and _menhir_run_42 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_entries -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_entries (_menhir_stack, _menhir_s, el, _) = _menhir_stack in
      let (_endpos_e_, e) = (_endpos, _v) in
      let _v = _menhir_action_24 e el in
      _menhir_goto_entries _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ _v _menhir_s _tok
  
  and _menhir_run_39 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let (_endpos_e_, e) = (_endpos, _v) in
      let _v = _menhir_action_23 e in
      _menhir_goto_entries _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_e_ _v _menhir_s _tok
  
  and _menhir_run_32 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let a = _v in
      let _v = _menhir_action_05 _endpos_n_ _startpos_n_ a n in
      _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_20 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let a = _v in
      let _v = _menhir_action_10 _endpos_n_ _startpos_n_ a n in
      _menhir_goto_arg_spec _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_arg_spec : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_arg_spec (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState43
      | Parser.COLON_EQUAL ->
          let _v_1 = _menhir_action_18 () in
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1
      | _ ->
          _eRR 43
  
  and _menhir_run_44 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_arg_spec -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_arg_spec (_menhir_stack, _menhir_s, a) = _menhir_stack in
      let al = _v in
      let _v = _menhir_action_19 a al in
      _menhir_goto_args_spec _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_args_spec : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState43 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState02 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_21 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LET _menhir_cell0_ID as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_args_spec (_menhir_stack, _menhir_s, _v) in
      let _menhir_s = MenhirState22 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Parser.COMPL_FUN ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR 22
  
  let _menhir_run_01 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_LET (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.ID _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_ID (_menhir_stack, _v, _startpos_0, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Parser.ID _v_1 ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState02
          | Parser.COLON_EQUAL ->
              let _v_2 = _menhir_action_18 () in
              _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState02
          | _ ->
              _eRR 2)
      | _ ->
          _eRR 1
  
  let _menhir_run_46 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_22 () in
      _menhir_goto_command _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_interactive_command =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState00 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.LET ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | Parser.ID _v ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Parser.DATA _v ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Parser.COMPL_LET ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | Parser.COMPL_FUN ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR 0
  
  let _menhir_run_60 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_script_command =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Parser.LET ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | Parser.ID _v ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState60
      | Parser.EOI ->
          let _v = _menhir_action_33 () in
          _menhir_goto_script_command _menhir_stack _v
      | Parser.DATA _v ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState60
      | Parser.COMPL_LET ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | Parser.COMPL_FUN ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | _ ->
          _eRR 60
  
end

let script_command =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_script_command v = _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let interactive_command =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_interactive_command v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v