Source file dhcp_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | WORD of (
# 52 "lib/dhcp_parser.mly"
       (string)
# 15 "lib/dhcp_parser.ml"
  )
    | SUBNET
    | STRING of (
# 32 "lib/dhcp_parser.mly"
       (string)
# 21 "lib/dhcp_parser.ml"
  )
    | SCOLON
    | ROUTERS
    | RBRACKET
    | RANGE
    | OPTION
    | NETMASK
    | MAXLEASETIME
    | MACADDR of (
# 31 "lib/dhcp_parser.mly"
       (Macaddr.t)
# 33 "lib/dhcp_parser.ml"
  )
    | LBRACKET
    | IP of (
# 30 "lib/dhcp_parser.mly"
       (Ipaddr.V4.t)
# 39 "lib/dhcp_parser.ml"
  )
    | INTEGER of (
# 42 "lib/dhcp_parser.mly"
       (int)
# 44 "lib/dhcp_parser.ml"
  )
    | HOST
    | HARDWARE
    | FIXEDADDRESS
    | ETHERNET
    | EOF
    | DOMAINNAMESERVERS
    | DOMAINNAME
    | DEFAULTLEASETIME
    | COMMA
  
end

include MenhirBasics

# 17 "lib/dhcp_parser.mly"
  
  type statement =
    | Range of Ipaddr.V4.t * Ipaddr.V4.t
    | Dhcp_option of Dhcp_wire.dhcp_option
    | Hw_eth of Macaddr.t
    | Fixed_addr of Ipaddr.V4.t
    | Default_lease_time of int32
    | Max_lease_time of int32

  let choke s = invalid_arg s


# 73 "lib/dhcp_parser.ml"

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

  | MenhirState06 : (('s, _menhir_box_main) _menhir_cell1_OPTION, _menhir_box_main) _menhir_state
    (** State 06.
        Stack shape : OPTION.
        Start symbol: main. *)

  | MenhirState08 : (('s, _menhir_box_main) _menhir_cell1_IP, _menhir_box_main) _menhir_state
    (** State 08.
        Stack shape : IP.
        Start symbol: main. *)

  | MenhirState12 : (('s, _menhir_box_main) _menhir_cell1_OPTION, _menhir_box_main) _menhir_state
    (** State 12.
        Stack shape : OPTION.
        Start symbol: main. *)

  | MenhirState31 : (('s, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_state
    (** State 31.
        Stack shape : statement.
        Start symbol: main. *)

  | MenhirState32 : ((('s, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_cell1_statements, _menhir_box_main) _menhir_state
    (** State 32.
        Stack shape : statement statements.
        Start symbol: main. *)

  | MenhirState37 : (('s, _menhir_box_main) _menhir_cell1_SUBNET _menhir_cell0_IP _menhir_cell0_IP, _menhir_box_main) _menhir_state
    (** State 37.
        Stack shape : SUBNET IP IP.
        Start symbol: main. *)

  | MenhirState38 : ((('s, _menhir_box_main) _menhir_cell1_SUBNET _menhir_cell0_IP _menhir_cell0_IP, _menhir_box_main) _menhir_cell1_statements, _menhir_box_main) _menhir_state
    (** State 38.
        Stack shape : SUBNET IP IP statements.
        Start symbol: main. *)

  | MenhirState41 : (('s, _menhir_box_main) _menhir_cell1_HOST _menhir_cell0_WORD, _menhir_box_main) _menhir_state
    (** State 41.
        Stack shape : HOST WORD.
        Start symbol: main. *)

  | MenhirState44 : (('s, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_state
    (** State 44.
        Stack shape : statement.
        Start symbol: main. *)

  | MenhirState48 : (('s, _menhir_box_main) _menhir_cell1_host, _menhir_box_main) _menhir_state
    (** State 48.
        Stack shape : host.
        Start symbol: main. *)

  | MenhirState50 : (((('s, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_cell1_statements, _menhir_box_main) _menhir_cell1_subnet, _menhir_box_main) _menhir_state
    (** State 50.
        Stack shape : statement statements subnet.
        Start symbol: main. *)

  | MenhirState53 : ((('s, _menhir_box_main) _menhir_cell1_subnet, _menhir_box_main) _menhir_cell1_subnet, _menhir_box_main) _menhir_state
    (** State 53.
        Stack shape : subnet subnet.
        Start symbol: main. *)


and ('s, 'r) _menhir_cell1_host = 
  | MenhirCell1_host of 's * ('s, 'r) _menhir_state * (Ast.host)

and ('s, 'r) _menhir_cell1_statement = 
  | MenhirCell1_statement of 's * ('s, 'r) _menhir_state * (statement)

and ('s, 'r) _menhir_cell1_statements = 
  | MenhirCell1_statements of 's * ('s, 'r) _menhir_state * (statement list)

and ('s, 'r) _menhir_cell1_subnet = 
  | MenhirCell1_subnet of 's * ('s, 'r) _menhir_state * (Ast.subnet)

and ('s, 'r) _menhir_cell1_HOST = 
  | MenhirCell1_HOST of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_IP = 
  | MenhirCell1_IP of 's * ('s, 'r) _menhir_state * (
# 30 "lib/dhcp_parser.mly"
       (Ipaddr.V4.t)
# 161 "lib/dhcp_parser.ml"
)

and 's _menhir_cell0_IP = 
  | MenhirCell0_IP of 's * (
# 30 "lib/dhcp_parser.mly"
       (Ipaddr.V4.t)
# 168 "lib/dhcp_parser.ml"
)

and ('s, 'r) _menhir_cell1_OPTION = 
  | MenhirCell1_OPTION of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_SUBNET = 
  | MenhirCell1_SUBNET of 's * ('s, 'r) _menhir_state

and 's _menhir_cell0_WORD = 
  | MenhirCell0_WORD of 's * (
# 52 "lib/dhcp_parser.mly"
       (string)
# 181 "lib/dhcp_parser.ml"
)

and _menhir_box_main = 
  | MenhirBox_main of (Ast.t) [@@unboxed]

let _menhir_action_01 =
  fun hostname statements ->
    (
# 161 "lib/dhcp_parser.mly"
                                                                       (
  let () = List.iter (function
      | Range _ -> choke "Range is invalid in host context"
      | _ -> ())
      statements
  in
  let options = Util.filter_map (function
      | Dhcp_option o -> Some o
      | _ -> None)
      statements
  in
  let fixed_addr = Util.find_map (function
      | Fixed_addr fa -> Some fa
      | _ -> None)
      statements
  in
  let hw_addr = Util.find_map (function
      | Hw_eth he -> Some he
      | _ -> None)
      statements
  in
  let hw_addr =
    Util.some_or_f hw_addr
                   (fun () -> choke "Missing hardware ethernet statement." )
  in
  { Ast.hostname; options; fixed_addr; hw_addr }
)
# 218 "lib/dhcp_parser.ml"
     : (Ast.host))

let _menhir_action_02 =
  fun () ->
    (
# 157 "lib/dhcp_parser.mly"
                ( [] )
# 226 "lib/dhcp_parser.ml"
     : (Ast.host list))

let _menhir_action_03 =
  fun host hosts ->
    (
# 158 "lib/dhcp_parser.mly"
                               ( host :: hosts )
# 234 "lib/dhcp_parser.ml"
     : (Ast.host list))

let _menhir_action_04 =
  fun ip ->
    (
# 95 "lib/dhcp_parser.mly"
            ( [ip] )
# 242 "lib/dhcp_parser.ml"
     : (Ipaddr.V4.t list))

let _menhir_action_05 =
  fun ip ips ->
    (
# 96 "lib/dhcp_parser.mly"
                              ( ip :: ips )
# 250 "lib/dhcp_parser.ml"
     : (Ipaddr.V4.t list))

let _menhir_action_06 =
  fun s ss sub subs ->
    (
# 58 "lib/dhcp_parser.mly"
                                                                      (
  let statements = s :: ss in
  let subnets = sub :: subs in
  (* Now extract the options from the statements *)
  let () = List.iter (function
      | Dhcp_option o -> ()
      | Default_lease_time t -> ()
      | Max_lease_time t -> ()
      | _ -> choke "Only dhcp options and default|max-lease-time \
                    are allowed in the global section")
      statements
  in
  let options = Util.filter_map (function
      | Dhcp_option o -> Some o
      | _ -> None)
      statements
  in
  let default_lease_time =
    match (Util.find_map (function
        | Default_lease_time t -> Some t
        | _ -> None)
        statements)
    with | Some time -> time
         | None -> Int32.of_int (60 * 60 * 60) (* 1h *)
  in
  let max_lease_time =
    match (Util.find_map (function
        | Max_lease_time t -> Some t
        | _ -> None)
        statements)
    with | Some time -> time
         | None -> Int32.of_int (60 * 60 * 60 * 24) (* 24h *)
  in
  { Ast.subnets; options; default_lease_time; max_lease_time }
)
# 292 "lib/dhcp_parser.ml"
     : (Ast.t))

let _menhir_action_07 =
  fun v ->
    (
# 103 "lib/dhcp_parser.mly"
                                           ( Dhcp_option (Dhcp_wire.Domain_name v))
# 300 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_08 =
  fun ips ->
    (
# 104 "lib/dhcp_parser.mly"
                                                 ( Dhcp_option (Dhcp_wire.Dns_servers ips) )
# 308 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_09 =
  fun ips ->
    (
# 105 "lib/dhcp_parser.mly"
                                       ( Dhcp_option (Dhcp_wire.Routers ips) )
# 316 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_10 =
  fun v1 v2 ->
    (
# 106 "lib/dhcp_parser.mly"
                                    (
  if Int32.compare (Ipaddr.V4.to_int32 v1) (Ipaddr.V4.to_int32 v2) >= 0 then
    choke "Invalid `range` statement, must be `low high`";
  Range (v1, v2)
  )
# 328 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_11 =
  fun mac ->
    (
# 111 "lib/dhcp_parser.mly"
                                              ( Hw_eth mac )
# 336 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_12 =
  fun v ->
    (
# 112 "lib/dhcp_parser.mly"
                                 ( Fixed_addr v )
# 344 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_13 =
  fun v ->
    (
# 113 "lib/dhcp_parser.mly"
                                          ( Default_lease_time (Int32.of_int v) )
# 352 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_14 =
  fun v ->
    (
# 114 "lib/dhcp_parser.mly"
                                      ( Max_lease_time (Int32.of_int v) )
# 360 "lib/dhcp_parser.ml"
     : (statement))

let _menhir_action_15 =
  fun () ->
    (
# 99 "lib/dhcp_parser.mly"
                ( [] )
# 368 "lib/dhcp_parser.ml"
     : (statement list))

let _menhir_action_16 =
  fun s ss ->
    (
# 100 "lib/dhcp_parser.mly"
                                   ( s :: (List.rev ss) )
# 376 "lib/dhcp_parser.ml"
     : (statement list))

let _menhir_action_17 =
  fun hosts ip mask statements ->
    (
# 122 "lib/dhcp_parser.mly"
                                                   (
  let network = Ipaddr.V4.Prefix.of_netmask mask ip in
  (* Catch statements that don't make sense in a subnet *)
  let () = List.iter (function
      | Hw_eth _ | Fixed_addr _ ->
        choke "`hardware` and `fixed-address` belong to `host` context, not subnet"
      | _ -> ())
      statements
  in
  (* First find the range statement, XXX ignoring if multiple *)
  let range = Util.find_map (function
      | Range (v1, v2) -> Some (v1, v2)
      | _ -> None)
      statements |> (function
      | Some (v1, v2) -> (v1, v2)
      | None -> choke ("Missing `range` statement for subnet " ^
                       (Ipaddr.V4.to_string ip)))
  in
  let options = Util.filter_map (function
      | Dhcp_option o -> Some o
      | _ -> None)
      statements
  in
  let default_lease_time =
    (Util.find_map (function Default_lease_time t -> Some t | _ -> None)
        statements)
  in
  let max_lease_time =
    (Util.find_map (function Max_lease_time t -> Some t | _ -> None)
        statements)
  in
  { Ast.network; range = Some range; options; hosts; default_lease_time; max_lease_time }
)
# 416 "lib/dhcp_parser.ml"
     : (Ast.subnet))

let _menhir_action_18 =
  fun () ->
    (
# 117 "lib/dhcp_parser.mly"
                ( [] )
# 424 "lib/dhcp_parser.ml"
     : (Ast.subnet list))

let _menhir_action_19 =
  fun sub subs ->
    (
# 118 "lib/dhcp_parser.mly"
                                 ( sub :: (List.rev subs) )
# 432 "lib/dhcp_parser.ml"
     : (Ast.subnet list))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | COMMA ->
        "COMMA"
    | DEFAULTLEASETIME ->
        "DEFAULTLEASETIME"
    | DOMAINNAME ->
        "DOMAINNAME"
    | DOMAINNAMESERVERS ->
        "DOMAINNAMESERVERS"
    | EOF ->
        "EOF"
    | ETHERNET ->
        "ETHERNET"
    | FIXEDADDRESS ->
        "FIXEDADDRESS"
    | HARDWARE ->
        "HARDWARE"
    | HOST ->
        "HOST"
    | INTEGER _ ->
        "INTEGER"
    | IP _ ->
        "IP"
    | LBRACKET ->
        "LBRACKET"
    | MACADDR _ ->
        "MACADDR"
    | MAXLEASETIME ->
        "MAXLEASETIME"
    | NETMASK ->
        "NETMASK"
    | OPTION ->
        "OPTION"
    | RANGE ->
        "RANGE"
    | RBRACKET ->
        "RBRACKET"
    | ROUTERS ->
        "ROUTERS"
    | SCOLON ->
        "SCOLON"
    | STRING _ ->
        "STRING"
    | SUBNET ->
        "SUBNET"
    | WORD _ ->
        "WORD"

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_51 : type  ttv_stack. (((ttv_stack, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_cell1_statements, _menhir_box_main) _menhir_cell1_subnet -> _ -> _menhir_box_main =
    fun _menhir_stack _v ->
      let MenhirCell1_subnet (_menhir_stack, _, sub) = _menhir_stack in
      let MenhirCell1_statements (_menhir_stack, _, ss) = _menhir_stack in
      let MenhirCell1_statement (_menhir_stack, _, s) = _menhir_stack in
      let subs = _v in
      let _v = _menhir_action_06 s ss sub subs in
      MenhirBox_main _v
  
  let rec _menhir_run_54 : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_subnet, _menhir_box_main) _menhir_cell1_subnet -> _ -> _menhir_box_main =
    fun _menhir_stack _v ->
      let MenhirCell1_subnet (_menhir_stack, _menhir_s, sub) = _menhir_stack in
      let subs = _v in
      let _v = _menhir_action_19 sub subs in
      _menhir_goto_subnets _menhir_stack _v _menhir_s
  
  and _menhir_goto_subnets : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_subnet as 'stack) -> _ -> ('stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState53 ->
          _menhir_run_54 _menhir_stack _v
      | MenhirState50 ->
          _menhir_run_51 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  let rec _menhir_run_01 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | IP _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IP _v_0 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SCOLON ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (v2, v1) = (_v_0, _v) in
                  let _v = _menhir_action_10 v1 v2 in
                  _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_statement : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState31 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState44 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState41 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_44 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_statement (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RANGE ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | OPTION ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | MAXLEASETIME ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | HARDWARE ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | FIXEDADDRESS ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | DEFAULTLEASETIME ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState44
      | HOST | RBRACKET | SUBNET ->
          let _v_0 = _menhir_action_15 () in
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_05 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ROUTERS ->
          let _menhir_stack = MenhirCell1_OPTION (_menhir_stack, _menhir_s) in
          let _menhir_s = MenhirState06 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IP _v ->
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | DOMAINNAMESERVERS ->
          let _menhir_stack = MenhirCell1_OPTION (_menhir_stack, _menhir_s) in
          let _menhir_s = MenhirState12 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IP _v ->
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | DOMAINNAME ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | STRING _v ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SCOLON ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let v = _v in
                  let _v = _menhir_action_07 v in
                  _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_07 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_IP (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState08 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IP _v ->
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | SCOLON ->
          let ip = _v in
          let _v = _menhir_action_04 ip in
          _menhir_goto_ips _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_ips : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState12 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState06 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState08 ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_13 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_OPTION -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_OPTION (_menhir_stack, _menhir_s) = _menhir_stack in
      let ips = _v in
      let _v = _menhir_action_08 ips in
      _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_10 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_OPTION -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_OPTION (_menhir_stack, _menhir_s) = _menhir_stack in
      let ips = _v in
      let _v = _menhir_action_09 ips in
      _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_09 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_IP -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_IP (_menhir_stack, _menhir_s, ip) = _menhir_stack in
      let ips = _v in
      let _v = _menhir_action_05 ip ips in
      _menhir_goto_ips _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_18 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INTEGER _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SCOLON ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let v = _v in
              let _v = _menhir_action_14 v in
              _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_21 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ETHERNET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MACADDR _v ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SCOLON ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let mac = _v in
                  let _v = _menhir_action_11 mac in
                  _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_25 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | IP _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SCOLON ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let v = _v in
              let _v = _menhir_action_12 v in
              _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_28 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INTEGER _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SCOLON ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let v = _v in
              let _v = _menhir_action_13 v in
              _menhir_goto_statement _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_45 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_statement -> _ -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_statement (_menhir_stack, _menhir_s, s) = _menhir_stack in
      let ss = _v in
      let _v = _menhir_action_16 s ss in
      _menhir_goto_statements _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_statements : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState44 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState41 ->
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState37 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_32 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_42 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_HOST _menhir_cell0_WORD -> _ -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_WORD (_menhir_stack, hostname) = _menhir_stack in
          let MenhirCell1_HOST (_menhir_stack, _menhir_s) = _menhir_stack in
          let statements = _v in
          let _v = _menhir_action_01 hostname statements in
          let _menhir_stack = MenhirCell1_host (_menhir_stack, _menhir_s, _v) in
          (match (_tok : MenhirBasics.token) with
          | HOST ->
              _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState48
          | RBRACKET ->
              let _v_0 = _menhir_action_02 () in
              _menhir_run_49 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_39 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_HOST (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WORD _v ->
          let _menhir_stack = MenhirCell0_WORD (_menhir_stack, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LBRACKET ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RANGE ->
                  _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | OPTION ->
                  _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | MAXLEASETIME ->
                  _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | HARDWARE ->
                  _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | FIXEDADDRESS ->
                  _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | DEFAULTLEASETIME ->
                  _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState41
              | RBRACKET ->
                  let _v_0 = _menhir_action_15 () in
                  _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_49 : type  ttv_stack. (ttv_stack, _menhir_box_main) _menhir_cell1_host -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_host (_menhir_stack, _menhir_s, host) = _menhir_stack in
      let hosts = _v in
      let _v = _menhir_action_03 host hosts in
      _menhir_goto_hosts _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_hosts : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState48 ->
          _menhir_run_49 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState38 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_46 : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_SUBNET _menhir_cell0_IP _menhir_cell0_IP, _menhir_box_main) _menhir_cell1_statements -> _ -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_statements (_menhir_stack, _, statements) = _menhir_stack in
      let MenhirCell0_IP (_menhir_stack, mask) = _menhir_stack in
      let MenhirCell0_IP (_menhir_stack, ip) = _menhir_stack in
      let MenhirCell1_SUBNET (_menhir_stack, _menhir_s) = _menhir_stack in
      let hosts = _v in
      let _v = _menhir_action_17 hosts ip mask statements in
      _menhir_goto_subnet _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_subnet : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState53 ->
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState50 ->
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState32 ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_53 : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_subnet as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_subnet (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SUBNET ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState53
      | EOF ->
          let _v_0 = _menhir_action_18 () in
          _menhir_run_54 _menhir_stack _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_33 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_SUBNET (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | IP _v ->
          let _menhir_stack = MenhirCell0_IP (_menhir_stack, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NETMASK ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | IP _v_0 ->
                  let _menhir_stack = MenhirCell0_IP (_menhir_stack, _v_0) in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | LBRACKET ->
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RANGE ->
                          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | OPTION ->
                          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | MAXLEASETIME ->
                          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | HARDWARE ->
                          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | FIXEDADDRESS ->
                          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | DEFAULTLEASETIME ->
                          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
                      | HOST | RBRACKET ->
                          let _v_1 = _menhir_action_15 () in
                          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState37 _tok
                      | _ ->
                          _eRR ())
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_38 : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_SUBNET _menhir_cell0_IP _menhir_cell0_IP as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_statements (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | HOST ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState38
      | RBRACKET ->
          let _v_0 = _menhir_action_02 () in
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_50 : type  ttv_stack. (((ttv_stack, _menhir_box_main) _menhir_cell1_statement, _menhir_box_main) _menhir_cell1_statements as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_subnet (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SUBNET ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | EOF ->
          let _v_0 = _menhir_action_18 () in
          _menhir_run_51 _menhir_stack _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_32 : type  ttv_stack. ((ttv_stack, _menhir_box_main) _menhir_cell1_statement as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_statements (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SUBNET ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState32
      | _ ->
          _eRR ()
  
  and _menhir_run_31 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_main) _menhir_state -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_statement (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RANGE ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | OPTION ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | MAXLEASETIME ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | HARDWARE ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | FIXEDADDRESS ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | DEFAULTLEASETIME ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState31
      | SUBNET ->
          let _v_0 = _menhir_action_15 () in
          _menhir_run_32 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState31 _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState00 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RANGE ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPTION ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | MAXLEASETIME ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | HARDWARE ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | FIXEDADDRESS ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | DEFAULTLEASETIME ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
end

let main =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_main v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v