Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR : exn =
    Error
  
  type token = 
    | SEMI
    | RPAR
    | PROPNAME of (
# 120 "lib/parser.mly"
      (string)
# 16 "lib/parser.ml"
  )
    | PROPCONTENT of (
# 120 "lib/parser.mly"
      (string)
# 21 "lib/parser.ml"
  )
    | LPAR
    | EOF
  
end

include MenhirBasics

type _menhir_env = {
  _menhir_lexer: Lexing.lexbuf -> token;
  _menhir_lexbuf: Lexing.lexbuf;
  _menhir_token: token;
  mutable _menhir_error: bool
}

and _menhir_state = 
  | MenhirState17
  | MenhirState14
  | MenhirState10
  | MenhirState7
  | MenhirState4
  | MenhirState3
  | MenhirState2
  | MenhirState1
  | MenhirState0

# 18 "lib/parser.mly"
  
open Sgftypes

let text_of_string str = Text str

let point_of_string str = Point (str.[0], str.[1])

let move_of_string str =
  try Move (Some (str.[0], str.[1]))
  with Invalid_argument _ -> Move None

let double_of_string = function
  | "1" -> Normal
  | "2" -> Emph
  | _   -> failwith "double_of_string"

let color_of_string = function
  | "B" | "b" -> Black
  | "W" | "w" -> White
  | s -> failwith (Printf.sprintf "color_of_string: got %s" s)

let number_of_string ?range str =
  let number = int_of_string str in match range with
    | Some (a,b) -> assert (number >= a && number <= b); Number number
    | None -> Number number

let real_of_string str = Real (float_of_string str)

let compose_of_string ~f ?s str =
  let open String in
  try
    let len = length str in
    let i = index str ':' in
    let a = sub str 0 i in
    let b = sub str (i+1) (len-i-1) in
    (match s with
     | None -> Compose (f a, f b)
     | Some s -> Compose (f a, s b))
  with Not_found -> invalid_arg "compose_of_string"

let property_of_tuple pname pvalues =
  let pvalue = try List.hd pvalues with Failure _ -> "" in
  match pname with
    (* Move *)
    | "B" | "W" -> pname, List (List.map move_of_string pvalues)
    | "KO" -> pname, One Empty
    | "MN" -> pname, One (number_of_string pvalue)

    (* Setup *)
    | "AB" | "AE" | "AW" -> pname, List (List.map point_of_string pvalues)
    | "PL" -> pname, One (color_of_string pvalue)

    (* Node annotation *)
    | "C" | "N" -> pname, One (Text pvalue)
    | "DM" | "GB" | "GW" | "HO" | "UC" -> pname, One (double_of_string pvalue)
    | "V"  -> pname, One (real_of_string pvalue)

    (* Move annotation *)
    | "BM" | "TE" -> pname, One (double_of_string pvalue)
    | "DO" | "IT" -> pname, One Empty

    (* Markup *)
    | "AR" | "LN" -> pname, List (List.map (compose_of_string ~f:point_of_string) pvalues)
    | "CR" | "DD" -> pname, List (List.map point_of_string pvalues)
    | "LB" -> pname, List (List.map (compose_of_string ~f:point_of_string ~s:text_of_string) pvalues)
    | "MA" | "SL" | "SQ" | "TR" -> pname, List (List.map point_of_string pvalues)

    (* Root *)
    | "AP" -> pname, One (compose_of_string ~f:text_of_string pvalue)
    | "CA" -> pname, One (Text pvalue)
    | "FF" -> pname, One (number_of_string ~range:(1,4) pvalue)
    | "GM" -> pname, One (number_of_string ~range:(1,16) pvalue)
    | "ST" -> pname, One (number_of_string ~range:(0,3) pvalue)
    | "SZ" -> pname,
      (try One (compose_of_string ~f:number_of_string pvalue)
       with Invalid_argument _ -> One (number_of_string pvalue))

    (* Game Info *)
    | "AN" | "BR" | "BT" | "CP" | "DT" | "EV" | "GN" | "GC" | "ON"
    | "OT" | "PB" | "PC" | "PW" | "RE" | "RO" | "RU" | "SO" | "US"
    | "WR" | "WT" -> pname, One (Text pvalue)
    | "TM" -> pname, One (real_of_string pvalue)

    (* Timing *)
    | "BL" | "WL" -> pname, One (real_of_string pvalue)
    | "OB" | "OW" -> pname, One (number_of_string pvalue)

    (* Go specific *)
    | "HA" -> pname, One (number_of_string pvalue)
    | "KM" -> pname, One (real_of_string pvalue)
    | "TB" | "TW" -> pname, List (List.map point_of_string pvalues)

    (* Misc *)
    | "FG" -> pname, (match pvalues with [] -> One Empty | _ ->
      List (List.map (compose_of_string ~f:point_of_string ~s:text_of_string) pvalues))
    | "PM" -> pname, One (number_of_string pvalue)
    | "VW" -> pname, List (List.map point_of_string pvalues)

    (* Unknown *)
    | oth -> oth, One (Text pvalue)

# 150 "lib/parser.ml"

let rec _menhir_goto_nonempty_list_gametree_ : _menhir_env -> 'ttv_tail -> _menhir_state -> 'tv_nonempty_list_gametree_ -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
    match _menhir_s with
    | MenhirState10 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : (('freshtv77 * _menhir_state) * _menhir_state * 'tv_sequence) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
        ((assert (not _menhir_env._menhir_error);
        let _tok = _menhir_env._menhir_token in
        match _tok with
        | RPAR ->
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : (('freshtv73 * _menhir_state) * _menhir_state * 'tv_sequence) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let _menhir_env = _menhir_discard _menhir_env in
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : (('freshtv71 * _menhir_state) * _menhir_state * 'tv_sequence) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let (((_menhir_stack, _menhir_s), _, (seq : 'tv_sequence)), _, (gt : 'tv_nonempty_list_gametree_)) = _menhir_stack in
            let _v : 'tv_gametree = 
# 132 "lib/parser.mly"
                                          ( Node (seq, gt) )
# 172 "lib/parser.ml"
             in
            _menhir_goto_gametree _menhir_env _menhir_stack _menhir_s _v) : 'freshtv72)) : 'freshtv74)
        | _ ->
            assert (not _menhir_env._menhir_error);
            _menhir_env._menhir_error <- true;
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : (('freshtv75 * _menhir_state) * _menhir_state * 'tv_sequence) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
            _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv76)) : 'freshtv78)
    | MenhirState14 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : ('freshtv81 * _menhir_state * 'tv_gametree) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : ('freshtv79 * _menhir_state * 'tv_gametree) * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
        ((let ((_menhir_stack, _menhir_s, (x : 'tv_gametree)), _, (xs : 'tv_nonempty_list_gametree_)) = _menhir_stack in
        let _v : 'tv_nonempty_list_gametree_ = 
# 223 "<standard.mly>"
    ( x :: xs )
# 191 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_gametree_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv80)) : 'freshtv82)
    | MenhirState0 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv95 * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
        ((assert (not _menhir_env._menhir_error);
        let _tok = _menhir_env._menhir_token in
        match _tok with
        | EOF ->
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv91 * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv89 * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let (_menhir_stack, _menhir_s, (col : 'tv_nonempty_list_gametree_)) = _menhir_stack in
            let _v : (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 209 "lib/parser.ml"
            ) = 
# 128 "lib/parser.mly"
                      ( (col:collection) )
# 213 "lib/parser.ml"
             in
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv87) = _menhir_stack in
            let (_menhir_s : _menhir_state) = _menhir_s in
            let (_v : (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 221 "lib/parser.ml"
            )) = _v in
            ((let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv85) = Obj.magic _menhir_stack in
            let (_menhir_s : _menhir_state) = _menhir_s in
            let (_v : (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 229 "lib/parser.ml"
            )) = _v in
            ((let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv83) = Obj.magic _menhir_stack in
            let (_menhir_s : _menhir_state) = _menhir_s in
            let ((_1 : (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 237 "lib/parser.ml"
            )) : (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 241 "lib/parser.ml"
            )) = _v in
            (Obj.magic _1 : 'freshtv84)) : 'freshtv86)) : 'freshtv88)) : 'freshtv90)) : 'freshtv92)
        | _ ->
            assert (not _menhir_env._menhir_error);
            _menhir_env._menhir_error <- true;
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv93 * _menhir_state * 'tv_nonempty_list_gametree_) = Obj.magic _menhir_stack in
            ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
            _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv94)) : 'freshtv96)
    | _ ->
        _menhir_fail ()

and _menhir_goto_gametree : _menhir_env -> 'ttv_tail -> _menhir_state -> 'tv_gametree -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
    let (_menhir_env : _menhir_env) = _menhir_env in
    let (_menhir_stack : 'freshtv69 * _menhir_state * 'tv_gametree) = Obj.magic _menhir_stack in
    ((assert (not _menhir_env._menhir_error);
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | LPAR ->
        _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState14
    | EOF | RPAR ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv67 * _menhir_state * 'tv_gametree) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, (x : 'tv_gametree)) = _menhir_stack in
        let _v : 'tv_nonempty_list_gametree_ = 
# 221 "<standard.mly>"
    ( [ x ] )
# 271 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_gametree_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv68)
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState14) : 'freshtv70)

and _menhir_goto_nonempty_list_node_ : _menhir_env -> 'ttv_tail -> _menhir_state -> 'tv_nonempty_list_node_ -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    match _menhir_s with
    | MenhirState1 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv61) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_node_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv59) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let ((seq : 'tv_nonempty_list_node_) : 'tv_nonempty_list_node_) = _v in
        ((let _v : 'tv_sequence = 
# 135 "lib/parser.mly"
              ( (seq:sequence) )
# 294 "lib/parser.ml"
         in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv57) = _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_sequence) = _v in
        ((let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : ('freshtv55 * _menhir_state) * _menhir_state * 'tv_sequence) = Obj.magic _menhir_stack in
        ((assert (not _menhir_env._menhir_error);
        let _tok = _menhir_env._menhir_token in
        match _tok with
        | LPAR ->
            _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState10
        | RPAR ->
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : ('freshtv53 * _menhir_state) * _menhir_state * 'tv_sequence) = Obj.magic _menhir_stack in
            let (_menhir_s : _menhir_state) = MenhirState10 in
            ((let _menhir_env = _menhir_discard _menhir_env in
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : ('freshtv51 * _menhir_state) * _menhir_state * 'tv_sequence) = Obj.magic _menhir_stack in
            let (_ : _menhir_state) = _menhir_s in
            ((let ((_menhir_stack, _menhir_s), _, (seq : 'tv_sequence)) = _menhir_stack in
            let _v : 'tv_gametree = 
# 131 "lib/parser.mly"
                           ( Leaf seq )
# 320 "lib/parser.ml"
             in
            _menhir_goto_gametree _menhir_env _menhir_stack _menhir_s _v) : 'freshtv52)) : 'freshtv54)
        | _ ->
            assert (not _menhir_env._menhir_error);
            _menhir_env._menhir_error <- true;
            _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState10) : 'freshtv56)) : 'freshtv58)) : 'freshtv60)) : 'freshtv62)
    | MenhirState17 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv65 * _menhir_state * 'tv_node) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_node_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv63 * _menhir_state * 'tv_node) = Obj.magic _menhir_stack in
        let (_ : _menhir_state) = _menhir_s in
        let ((xs : 'tv_nonempty_list_node_) : 'tv_nonempty_list_node_) = _v in
        ((let (_menhir_stack, _menhir_s, (x : 'tv_node)) = _menhir_stack in
        let _v : 'tv_nonempty_list_node_ = 
# 223 "<standard.mly>"
    ( x :: xs )
# 340 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_node_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv64)) : 'freshtv66)
    | _ ->
        _menhir_fail ()

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

and _menhir_goto_nonempty_list_property_ : _menhir_env -> 'ttv_tail -> _menhir_state -> 'tv_nonempty_list_property_ -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    match _menhir_s with
    | MenhirState7 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv39 * _menhir_state * 'tv_property) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_property_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv37 * _menhir_state * 'tv_property) = Obj.magic _menhir_stack in
        let (_ : _menhir_state) = _menhir_s in
        let ((xs : 'tv_nonempty_list_property_) : 'tv_nonempty_list_property_) = _v in
        ((let (_menhir_stack, _menhir_s, (x : 'tv_property)) = _menhir_stack in
        let _v : 'tv_nonempty_list_property_ = 
# 223 "<standard.mly>"
    ( x :: xs )
# 367 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_property_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv38)) : 'freshtv40)
    | MenhirState2 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv49 * _menhir_state) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_property_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv47 * _menhir_state) = Obj.magic _menhir_stack in
        let (_ : _menhir_state) = _menhir_s in
        let ((pl : 'tv_nonempty_list_property_) : 'tv_nonempty_list_property_) = _v in
        ((let (_menhir_stack, _menhir_s) = _menhir_stack in
        let _v : 'tv_node = 
# 138 "lib/parser.mly"
                      ( (pl:node) )
# 383 "lib/parser.ml"
         in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv45) = _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_node) = _v in
        ((let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv43 * _menhir_state * 'tv_node) = Obj.magic _menhir_stack in
        ((assert (not _menhir_env._menhir_error);
        let _tok = _menhir_env._menhir_token in
        match _tok with
        | SEMI ->
            _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState17
        | LPAR | RPAR ->
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv41 * _menhir_state * 'tv_node) = Obj.magic _menhir_stack in
            ((let (_menhir_stack, _menhir_s, (x : 'tv_node)) = _menhir_stack in
            let _v : 'tv_nonempty_list_node_ = 
# 221 "<standard.mly>"
    ( [ x ] )
# 404 "lib/parser.ml"
             in
            _menhir_goto_nonempty_list_node_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv42)
        | _ ->
            assert (not _menhir_env._menhir_error);
            _menhir_env._menhir_error <- true;
            _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState17) : 'freshtv44)) : 'freshtv46)) : 'freshtv48)) : 'freshtv50)
    | _ ->
        _menhir_fail ()

and _menhir_goto_nonempty_list_PROPCONTENT_ : _menhir_env -> 'ttv_tail -> _menhir_state -> 'tv_nonempty_list_PROPCONTENT_ -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    match _menhir_s with
    | MenhirState4 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv25 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 422 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_PROPCONTENT_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv23 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 430 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        let (_ : _menhir_state) = _menhir_s in
        let ((xs : 'tv_nonempty_list_PROPCONTENT_) : 'tv_nonempty_list_PROPCONTENT_) = _v in
        ((let (_menhir_stack, _menhir_s, (x : (
# 120 "lib/parser.mly"
      (string)
# 437 "lib/parser.ml"
        ))) = _menhir_stack in
        let _v : 'tv_nonempty_list_PROPCONTENT_ = 
# 223 "<standard.mly>"
    ( x :: xs )
# 442 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_PROPCONTENT_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv24)) : 'freshtv26)
    | MenhirState3 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv35 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 450 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_nonempty_list_PROPCONTENT_) = _v in
        ((let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv33 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 458 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        let (_ : _menhir_state) = _menhir_s in
        let ((vl : 'tv_nonempty_list_PROPCONTENT_) : 'tv_nonempty_list_PROPCONTENT_) = _v in
        ((let (_menhir_stack, _menhir_s, (name : (
# 120 "lib/parser.mly"
      (string)
# 465 "lib/parser.ml"
        ))) = _menhir_stack in
        let _v : 'tv_property = 
# 141 "lib/parser.mly"
                                    ( property_of_tuple name vl )
# 470 "lib/parser.ml"
         in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv31) = _menhir_stack in
        let (_menhir_s : _menhir_state) = _menhir_s in
        let (_v : 'tv_property) = _v in
        ((let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv29 * _menhir_state * 'tv_property) = Obj.magic _menhir_stack in
        ((assert (not _menhir_env._menhir_error);
        let _tok = _menhir_env._menhir_token in
        match _tok with
        | PROPNAME _v ->
            _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState7 _v
        | LPAR | RPAR | SEMI ->
            let (_menhir_env : _menhir_env) = _menhir_env in
            let (_menhir_stack : 'freshtv27 * _menhir_state * 'tv_property) = Obj.magic _menhir_stack in
            ((let (_menhir_stack, _menhir_s, (x : 'tv_property)) = _menhir_stack in
            let _v : 'tv_nonempty_list_property_ = 
# 221 "<standard.mly>"
    ( [ x ] )
# 491 "lib/parser.ml"
             in
            _menhir_goto_nonempty_list_property_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv28)
        | _ ->
            assert (not _menhir_env._menhir_error);
            _menhir_env._menhir_error <- true;
            _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState7) : 'freshtv30)) : 'freshtv32)) : 'freshtv34)) : 'freshtv36)
    | _ ->
        _menhir_fail ()

and _menhir_run4 : _menhir_env -> 'ttv_tail -> _menhir_state -> (
# 120 "lib/parser.mly"
      (string)
# 504 "lib/parser.ml"
) -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
    let _menhir_env = _menhir_discard _menhir_env in
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | PROPCONTENT _v ->
        _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v
    | LPAR | PROPNAME _ | RPAR | SEMI ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv21 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 518 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, (x : (
# 120 "lib/parser.mly"
      (string)
# 523 "lib/parser.ml"
        ))) = _menhir_stack in
        let _v : 'tv_nonempty_list_PROPCONTENT_ = 
# 221 "<standard.mly>"
    ( [ x ] )
# 528 "lib/parser.ml"
         in
        _menhir_goto_nonempty_list_PROPCONTENT_ _menhir_env _menhir_stack _menhir_s _v) : 'freshtv22)
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState4

and _menhir_run3 : _menhir_env -> 'ttv_tail -> _menhir_state -> (
# 120 "lib/parser.mly"
      (string)
# 539 "lib/parser.ml"
) -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s _v ->
    let _menhir_stack = (_menhir_stack, _menhir_s, _v) in
    let _menhir_env = _menhir_discard _menhir_env in
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | PROPCONTENT _v ->
        _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState3 _v
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState3

and _menhir_run2 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s ->
    let _menhir_stack = (_menhir_stack, _menhir_s) in
    let _menhir_env = _menhir_discard _menhir_env in
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | PROPNAME _v ->
        _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState2 _v
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState2

and _menhir_errorcase : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s ->
    match _menhir_s with
    | MenhirState17 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv3 * _menhir_state * 'tv_node) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv4)
    | MenhirState14 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv5 * _menhir_state * 'tv_gametree) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv6)
    | MenhirState10 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : ('freshtv7 * _menhir_state) * _menhir_state * 'tv_sequence) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv8)
    | MenhirState7 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv9 * _menhir_state * 'tv_property) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv10)
    | MenhirState4 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv11 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 594 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv12)
    | MenhirState3 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv13 * _menhir_state * (
# 120 "lib/parser.mly"
      (string)
# 603 "lib/parser.ml"
        )) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s, _) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv14)
    | MenhirState2 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv15 * _menhir_state) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv16)
    | MenhirState1 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv17 * _menhir_state) = Obj.magic _menhir_stack in
        ((let (_menhir_stack, _menhir_s) = _menhir_stack in
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s) : 'freshtv18)
    | MenhirState0 ->
        let (_menhir_env : _menhir_env) = _menhir_env in
        let (_menhir_stack : 'freshtv19) = Obj.magic _menhir_stack in
        (raise _eRR : 'freshtv20)

and _menhir_run1 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =
  fun _menhir_env _menhir_stack _menhir_s ->
    let _menhir_stack = (_menhir_stack, _menhir_s) in
    let _menhir_env = _menhir_discard _menhir_env in
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | SEMI ->
        _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState1
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState1

and _menhir_discard : _menhir_env -> _menhir_env =
  fun _menhir_env ->
    let lexer = _menhir_env._menhir_lexer in
    let lexbuf = _menhir_env._menhir_lexbuf in
    let _tok = lexer lexbuf in
    {
      _menhir_lexer = lexer;
      _menhir_lexbuf = lexbuf;
      _menhir_token = _tok;
      _menhir_error = false;
    }

and collection : (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (
# 123 "lib/parser.mly"
       (Sgftypes.collection)
# 650 "lib/parser.ml"
) =
  fun lexer lexbuf ->
    let _menhir_env = {
      _menhir_lexer = lexer;
      _menhir_lexbuf = lexbuf;
      _menhir_token = Obj.magic ();
      _menhir_error = false;
    } in
    Obj.magic (let (_menhir_env : _menhir_env) = _menhir_env in
    let (_menhir_stack : 'freshtv1) = ((), _menhir_env._menhir_lexbuf.Lexing.lex_curr_p) in
    ((let _menhir_env = _menhir_discard _menhir_env in
    let _tok = _menhir_env._menhir_token in
    match _tok with
    | LPAR ->
        _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState0
    | _ ->
        assert (not _menhir_env._menhir_error);
        _menhir_env._menhir_error <- true;
        _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState0) : 'freshtv2))

# 269 "<standard.mly>"
  

# 674 "lib/parser.ml"