Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | STR of (
# 1 "src/parser.mly"
       (string)
# 15 "src/parser.ml"
  )
    | FIELD of (
# 2 "src/parser.mly"
       (Types.raw_replacement_field)
# 20 "src/parser.ml"
  )
    | EOF
  
end

include MenhirBasics

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

  | MenhirState01 : (('s, _menhir_box_prog) _menhir_cell1_STR, _menhir_box_prog) _menhir_state
    (** State 01.
        Stack shape : STR.
        Start symbol: prog. *)

  | MenhirState03 : (('s, _menhir_box_prog) _menhir_cell1_FIELD, _menhir_box_prog) _menhir_state
    (** State 03.
        Stack shape : FIELD.
        Start symbol: prog. *)

  | MenhirState07 : (('s, _menhir_box_prog) _menhir_cell1_string_ _menhir_cell0_FIELD, _menhir_box_prog) _menhir_state
    (** State 07.
        Stack shape : string_ FIELD.
        Start symbol: prog. *)


and ('s, 'r) _menhir_cell1_string_ = 
  | MenhirCell1_string_ of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_FIELD = 
  | MenhirCell1_FIELD of 's * ('s, 'r) _menhir_state * (
# 2 "src/parser.mly"
       (Types.raw_replacement_field)
# 57 "src/parser.ml"
)

and 's _menhir_cell0_FIELD = 
  | MenhirCell0_FIELD of 's * (
# 2 "src/parser.mly"
       (Types.raw_replacement_field)
# 64 "src/parser.ml"
)

and ('s, 'r) _menhir_cell1_STR = 
  | MenhirCell1_STR of 's * ('s, 'r) _menhir_state * (
# 1 "src/parser.mly"
       (string)
# 71 "src/parser.ml"
)

and _menhir_box_prog = 
  | MenhirBox_prog of (Types.elements) [@@unboxed]

let _menhir_action_1 =
  fun () ->
    (
# 9 "src/parser.mly"
        ( [] )
# 82 "src/parser.ml"
     : (Types.elements))

let _menhir_action_2 =
  fun f tl ->
    (
# 10 "src/parser.mly"
                         ( (Types.Field (Type_utils.sanitize_field f)) :: tl )
# 90 "src/parser.ml"
     : (Types.elements))

let _menhir_action_3 =
  fun f str tl ->
    (
# 11 "src/parser.mly"
                                        ( (Types.Text str) :: (Types.Field (Type_utils.sanitize_field f)) :: tl )
# 98 "src/parser.ml"
     : (Types.elements))

let _menhir_action_4 =
  fun str ->
    (
# 12 "src/parser.mly"
                       ( [Types.Text str] )
# 106 "src/parser.ml"
     : (Types.elements))

let _menhir_action_5 =
  fun l ->
    (
# 14 "src/parser.mly"
                         ( String.concat "" l )
# 114 "src/parser.ml"
     : (string))

let _menhir_action_6 =
  fun str ->
    (
# 17 "src/parser.mly"
              ( [str] )
# 122 "src/parser.ml"
     : (string list))

let _menhir_action_7 =
  fun str tl ->
    (
# 18 "src/parser.mly"
                                ( str :: tl )
# 130 "src/parser.ml"
     : (string list))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | EOF ->
        "EOF"
    | FIELD _ ->
        "FIELD"
    | STR _ ->
        "STR"

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_run_11 : type  ttv_stack. ttv_stack -> _ -> _menhir_box_prog =
    fun _menhir_stack _v ->
      MenhirBox_prog _v
  
  let rec _menhir_goto_prog : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_prog) _menhir_state -> _menhir_box_prog =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState00 ->
          _menhir_run_11 _menhir_stack _v
      | MenhirState03 ->
          _menhir_run_10 _menhir_stack _v
      | MenhirState07 ->
          _menhir_run_08 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_10 : type  ttv_stack. (ttv_stack, _menhir_box_prog) _menhir_cell1_FIELD -> _ -> _menhir_box_prog =
    fun _menhir_stack _v ->
      let MenhirCell1_FIELD (_menhir_stack, _menhir_s, f) = _menhir_stack in
      let tl = _v in
      let _v = _menhir_action_2 f tl in
      _menhir_goto_prog _menhir_stack _v _menhir_s
  
  and _menhir_run_08 : type  ttv_stack. (ttv_stack, _menhir_box_prog) _menhir_cell1_string_ _menhir_cell0_FIELD -> _ -> _menhir_box_prog =
    fun _menhir_stack _v ->
      let MenhirCell0_FIELD (_menhir_stack, f) = _menhir_stack in
      let MenhirCell1_string_ (_menhir_stack, _menhir_s, str) = _menhir_stack in
      let tl = _v in
      let _v = _menhir_action_3 f str tl in
      _menhir_goto_prog _menhir_stack _v _menhir_s
  
  let _menhir_run_04 : type  ttv_stack. ttv_stack -> (ttv_stack, _menhir_box_prog) _menhir_state -> _menhir_box_prog =
    fun _menhir_stack _menhir_s ->
      let _v = _menhir_action_1 () in
      _menhir_goto_prog _menhir_stack _v _menhir_s
  
  let rec _menhir_run_01 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_prog) _menhir_state -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | STR _v_0 ->
          let _menhir_stack = MenhirCell1_STR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState01
      | EOF | FIELD _ ->
          let str = _v in
          let _v = _menhir_action_6 str in
          _menhir_goto_string_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_string_list : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_prog) _menhir_state -> _ -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState00 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState07 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState03 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_05 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_prog) _menhir_state -> _ -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let l = _v in
      let _v = _menhir_action_5 l in
      match (_tok : MenhirBasics.token) with
      | FIELD _v_0 ->
          let _menhir_stack = MenhirCell1_string_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_stack = MenhirCell0_FIELD (_menhir_stack, _v_0) in
          let _menhir_s = MenhirState07 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | STR _v ->
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FIELD _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | EOF ->
              _menhir_run_04 _menhir_stack _menhir_s)
      | EOF ->
          let str = _v in
          let _v = _menhir_action_4 str in
          _menhir_goto_prog _menhir_stack _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_03 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_prog) _menhir_state -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_FIELD (_menhir_stack, _menhir_s, _v) in
      let _menhir_s = MenhirState03 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | STR _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FIELD _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | EOF ->
          _menhir_run_04 _menhir_stack _menhir_s
  
  and _menhir_run_02 : type  ttv_stack. (ttv_stack, _menhir_box_prog) _menhir_cell1_STR -> _ -> _ -> _ -> _ -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_STR (_menhir_stack, _menhir_s, str) = _menhir_stack in
      let tl = _v in
      let _v = _menhir_action_7 str tl in
      _menhir_goto_string_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState00 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | STR _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FIELD _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | EOF ->
          _menhir_run_04 _menhir_stack _menhir_s
  
end

let prog =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_prog v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v