Source file json_path_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | TO
    | STRING of 
# 7 "json_path/json_path_parser.mly"
       (string)
# 16 "json_path/json_path_parser.ml"
  
    | RBRACKET
    | MINUS
    | LBRACKET
    | LAST
    | INTEGER of 
# 5 "json_path/json_path_parser.mly"
       (int)
# 25 "json_path/json_path_parser.ml"
  
    | IDENTIFIER of 
# 6 "json_path/json_path_parser.mly"
       (string)
# 30 "json_path/json_path_parser.ml"
  
    | EOF
    | DOUBLE_ASTERISK
    | DOT
    | DOLLAR
    | ASTERISK
  
end

include MenhirBasics

# 1 "json_path/json_path_parser.mly"
  
  open Ast

# 46 "json_path/json_path_parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState01 : ('s, _menhir_box_path_expression) _menhir_state
    (** State 01.
        Stack shape : <empty>.
        Start symbol: path_expression. *)

  | MenhirState02 : (('s, _menhir_box_path_expression) _menhir_cell1_LBRACKET, _menhir_box_path_expression) _menhir_state
    (** State 02.
        Stack shape : LBRACKET.
        Start symbol: path_expression. *)

  | MenhirState11 : ((('s, _menhir_box_path_expression) _menhir_cell1_LBRACKET, _menhir_box_path_expression) _menhir_cell1_array_index, _menhir_box_path_expression) _menhir_state
    (** State 11.
        Stack shape : LBRACKET array_index.
        Start symbol: path_expression. *)

  | MenhirState20 : (('s, _menhir_box_path_expression) _menhir_cell1_path_leg, _menhir_box_path_expression) _menhir_state
    (** State 20.
        Stack shape : path_leg.
        Start symbol: path_expression. *)


and ('s, 'r) _menhir_cell1_array_index = 
  | MenhirCell1_array_index of 's * ('s, 'r) _menhir_state * (Ast.array_index)

and ('s, 'r) _menhir_cell1_path_leg = 
  | MenhirCell1_path_leg of 's * ('s, 'r) _menhir_state * (Ast.path_leg)

and ('s, 'r) _menhir_cell1_DOT = 
  | MenhirCell1_DOT of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LBRACKET = 
  | MenhirCell1_LBRACKET of 's * ('s, 'r) _menhir_state

and _menhir_box_path_expression = 
  | MenhirBox_path_expression of (Ast.t) [@@unboxed]

let _menhir_action_01 =
  fun n ->
    (
# 43 "json_path/json_path_parser.mly"
                ( Index n )
# 90 "json_path/json_path_parser.ml"
     : (Ast.array_index))

let _menhir_action_02 =
  fun () ->
    (
# 44 "json_path/json_path_parser.mly"
             ( Wildcard )
# 98 "json_path/json_path_parser.ml"
     : (Ast.array_index))

let _menhir_action_03 =
  fun () ->
    (
# 45 "json_path/json_path_parser.mly"
         ( Last )
# 106 "json_path/json_path_parser.ml"
     : (Ast.array_index))

let _menhir_action_04 =
  fun n ->
    (
# 46 "json_path/json_path_parser.mly"
                           ( LastOffset n )
# 114 "json_path/json_path_parser.ml"
     : (Ast.array_index))

let _menhir_action_05 =
  fun idx ->
    (
# 39 "json_path/json_path_parser.mly"
                                        ( ArrayAccess idx )
# 122 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_06 =
  fun range ->
    (
# 40 "json_path/json_path_parser.mly"
                                          ( ArrayRange range )
# 130 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_07 =
  fun end_idx start ->
    (
# 49 "json_path/json_path_parser.mly"
                                                 ( { start_idx = start; end_idx } )
# 138 "json_path/json_path_parser.ml"
     : (Ast.range))

let _menhir_action_08 =
  fun id ->
    (
# 35 "json_path/json_path_parser.mly"
                    ( id )
# 146 "json_path/json_path_parser.ml"
     : (string))

let _menhir_action_09 =
  fun s ->
    (
# 36 "json_path/json_path_parser.mly"
               ( s )
# 154 "json_path/json_path_parser.ml"
     : (string))

let _menhir_action_10 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 162 "json_path/json_path_parser.ml"
     : (Ast.path_leg list))

let _menhir_action_11 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 170 "json_path/json_path_parser.ml"
     : (Ast.path_leg list))

let _menhir_action_12 =
  fun key_name ->
    (
# 31 "json_path/json_path_parser.mly"
                            ( Member key_name )
# 178 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_13 =
  fun () ->
    (
# 32 "json_path/json_path_parser.mly"
                 ( MemberWildcard )
# 186 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_14 =
  fun legs ->
    (
# 23 "json_path/json_path_parser.mly"
                                     ( { scope = "$"; legs } )
# 194 "json_path/json_path_parser.ml"
     : (Ast.t))

let _menhir_action_15 =
  fun _1 ->
    (
# 26 "json_path/json_path_parser.mly"
           ( _1 )
# 202 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_16 =
  fun _1 ->
    (
# 27 "json_path/json_path_parser.mly"
                   ( _1 )
# 210 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_action_17 =
  fun () ->
    (
# 28 "json_path/json_path_parser.mly"
                    ( DoubleWildcard )
# 218 "json_path/json_path_parser.ml"
     : (Ast.path_leg))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | TO ->
        "TO"
    | STRING _ ->
        "STRING"
    | RBRACKET ->
        "RBRACKET"
    | MINUS ->
        "MINUS"
    | LBRACKET ->
        "LBRACKET"
    | LAST ->
        "LAST"
    | INTEGER _ ->
        "INTEGER"
    | IDENTIFIER _ ->
        "IDENTIFIER"
    | EOF ->
        "EOF"
    | DOUBLE_ASTERISK ->
        "DOUBLE_ASTERISK"
    | DOT ->
        "DOT"
    | DOLLAR ->
        "DOLLAR"
    | ASTERISK ->
        "ASTERISK"

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_24 : type  ttv_stack. ttv_stack -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _v ->
      let legs = _v in
      let _v = _menhir_action_14 legs in
      MenhirBox_path_expression _v
  
  let rec _menhir_run_22 : type  ttv_stack. (ttv_stack, _menhir_box_path_expression) _menhir_cell1_path_leg -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _v ->
      let MenhirCell1_path_leg (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_11 x xs in
      _menhir_goto_list_path_leg_ _menhir_stack _v _menhir_s
  
  and _menhir_goto_list_path_leg_ : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState20 ->
          _menhir_run_22 _menhir_stack _v
      | MenhirState01 ->
          _menhir_run_24 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  let rec _menhir_run_02 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState02 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LAST ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | INTEGER _v ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ASTERISK ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_03 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | MINUS ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | INTEGER _v ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let n = _v in
              let _v = _menhir_action_04 n in
              _menhir_goto_array_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | RBRACKET | TO ->
          let _v = _menhir_action_03 () in
          _menhir_goto_array_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_array_index : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState02 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState11 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_10 : type  ttv_stack. ((ttv_stack, _menhir_box_path_expression) _menhir_cell1_LBRACKET as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_path_expression) _menhir_state -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | TO ->
          let _menhir_stack = MenhirCell1_array_index (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState11 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LAST ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTEGER _v ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ASTERISK ->
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s) = _menhir_stack in
          let idx = _v in
          let _v = _menhir_action_05 idx in
          _menhir_goto_array_location _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_06 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let n = _v in
      let _v = _menhir_action_01 n in
      _menhir_goto_array_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_07 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_02 () in
      _menhir_goto_array_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_array_location : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_16 _1 in
      _menhir_goto_path_leg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_path_leg : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_path_leg (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LBRACKET ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | DOUBLE_ASTERISK ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | DOT ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | EOF ->
          let _v_0 = _menhir_action_10 () in
          _menhir_run_22 _menhir_stack _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_14 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_17 () in
      _menhir_goto_path_leg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_15 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | STRING _v ->
          let _menhir_stack = MenhirCell1_DOT (_menhir_stack, _menhir_s) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let s = _v in
          let _v = _menhir_action_09 s in
          _menhir_goto_key_name _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | IDENTIFIER _v ->
          let _menhir_stack = MenhirCell1_DOT (_menhir_stack, _menhir_s) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let id = _v in
          let _v = _menhir_action_08 id in
          _menhir_goto_key_name _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | ASTERISK ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_13 () in
          _menhir_goto_member _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_key_name : type  ttv_stack. (ttv_stack, _menhir_box_path_expression) _menhir_cell1_DOT -> _ -> _ -> _ -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_DOT (_menhir_stack, _menhir_s) = _menhir_stack in
      let key_name = _v in
      let _v = _menhir_action_12 key_name in
      _menhir_goto_member _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_member : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_path_expression) _menhir_state -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_15 _1 in
      _menhir_goto_path_leg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_12 : type  ttv_stack. ((ttv_stack, _menhir_box_path_expression) _menhir_cell1_LBRACKET, _menhir_box_path_expression) _menhir_cell1_array_index -> _ -> _ -> _ -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_array_index (_menhir_stack, _, start) = _menhir_stack in
      let end_idx = _v in
      let _v = _menhir_action_07 end_idx start in
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s) = _menhir_stack in
          let range = _v in
          let _v = _menhir_action_06 range in
          _menhir_goto_array_location _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_path_expression =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DOLLAR ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LBRACKET ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
          | DOUBLE_ASTERISK ->
              _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
          | DOT ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
          | EOF ->
              let _v = _menhir_action_10 () in
              _menhir_run_24 _menhir_stack _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
end

let path_expression =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_path_expression v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

# 51 "json_path/json_path_parser.mly"
  

# 477 "json_path/json_path_parser.ml"