Datasets:

AllenGeng

/

ocamlgithub

like 0

type ' a pattern = | Pany | Por of ' a pattern * ' a pattern | Pconstr of ' a * ' a pattern list

module type SIG = sig type tag val compare : tag -> tag -> int val arity : tag -> int val is_complete : tag list -> bool val not_in : tag list -> tag type pattern_ast val inject : pattern_ast -> tag pattern val eject : tag pattern -> pattern_ast end

module PATTERN_CHECKER = functor ( S : SIG ) -> struct module SSet = Set . Make ( struct type t = S . tag let compare = S . compare end ) let uniq l = SSet . elements ( List . fold_right SSet . add l SSet . empty ) let is_complete sigma = S . is_complete ( uniq sigma ) let not_in sigma = S . not_in ( uniq sigma ) let rec head_constrs h = match h with | Pconstr ( c , q ) -> [ ( c , List . length q ) ] | Por ( l , r ) -> head_constrs l @ head_constrs r | Pany -> [ ] let rec matS c ar p = let vecS pv = match pv with | [ ] -> assert false | Pconstr ( c ' , r ' ) :: pv ' -> if S . compare c c ' = 0 then [ r ' @ pv ' ] else [ ] | Pany :: pv ' -> [ repeat ar Pany @ pv ' ] | Por ( t1 , t2 ) :: pv ' -> matS c ar [ t1 :: pv ' ; t2 :: pv ' ] in List . concat ( List . map vecS p ) let rec matD p = let vecD pv = match pv with | Pconstr _ :: _ -> [ ] | Pany :: pv ' -> [ pv ' ] | Por ( t1 , t2 ) :: pv ' -> matD [ t1 :: pv ' ; t2 :: pv ' ] | _ -> assert false in List . concat ( List . map vecD p ) let rec algU p q = match ( p , q ) with | ( [ ] , _ ) -> true | ( _ :: _ , [ ] ) -> false | ( h :: t , Pconstr ( c , r ) :: q ' ) -> let p ' = matS c ( List . length r ) p in algU p ' ( r @ q ' ) | ( h :: t , Por ( r1 , r2 ) :: q ' ) -> algU p ( r1 :: q ' ) || algU p ( r2 :: q ' ) | ( h :: t , Pany :: q ' ) -> let sigma = List . concat ( List . map ( fun v -> head_constrs ( List . hd v ) ) p ) in let algU_constr ( c_k , ar_k ) = let p ' = matS c_k ar_k p in algU p ' ( repeat ar_k Pany @ q ' ) in let sigma_used = List . exists algU_constr sigma in sigma_used || ( if not ( is_complete ( List . map fst sigma ) ) then algU ( matD p ) q ' else false ) type ' a trivec = { p : ' a patt_vec ; q : ' a patt_vec ; r : ' a patt_vec } and ' a trimat = ' a trivec list let rec trimatS c arity mv = let filter_line l = match l . p with | Pconstr ( c ' , t ) :: p ' -> if S . compare c c ' = 0 then [ { l with p = t @ p ' } ] else [ ] | Pany :: p ' -> [ { l with p = repeat arity Pany @ p ' } ] | Por ( t1 , t2 ) :: p ' -> trimatS c arity [ { l with p = t1 :: p ' } ; { l with p = t2 :: p ' } ] | _ -> assert false in List . concat ( List . map filter_line mv ) let shift1 l = match l . p with | p :: p ' -> { l with p = p ' ; q = p :: l . q } | _ -> assert false let shift2 l = match l . p with | p :: p ' -> { l with p = p ' ; r = p :: l . r } | _ -> assert false let simple_union e e ' = match ( e , e ' ) with | ( Some l , Some l ' ) -> Some ( l @ l ' ) | ( None , _ ) | ( _ , None ) -> None let union r1 r2 e ' e ' ' = match ( e ' , e ' ' ) with | ( Some [ ] , Some [ ] ) -> Some [ ] | ( None , None ) -> None | ( Some [ ] , None ) -> Some [ r2 ] | ( None , Some [ ] ) -> Some [ r1 ] | ( Some [ ] , Some ( _ :: _ ) ) -> e ' ' | ( Some ( _ :: _ ) , Some [ ] ) -> e ' | ( None , Some ( ( _ :: _ ) as t ) ) -> Some ( r1 :: t ) | ( Some ( ( _ :: _ ) as t ) , None ) -> Some ( r2 :: t ) | ( Some ( ( _ :: _ ) as t ' ) , Some ( ( _ :: _ ) as t ' ' ) ) -> Some ( t ' @ t ' ' ) let rec algU ' m v = match v . p with | Pconstr ( c , t ) :: p ' -> algU ' ( trimatS c ( List . length t ) m ) { v with p = t @ p ' } | Pany :: _ -> algU ' ( List . map shift1 m ) ( shift1 v ) | Por _ :: _ -> algU ' ( List . map shift2 m ) ( shift2 v ) | [ ] -> begin match v . r with | [ ] -> let qm = List . map ( fun l -> l . q ) m in if algU qm v . q then Some [ ] else None | _ :: _ -> let rec compute_Ej j = begin match List . nth v . r ( j - 1 ) with | Por ( t1 , t2 ) -> let f l = let r_j = keep l . r j and r_woj = drop l . r j in { p = [ r_j ] ; q = r_woj @ l . q ; r = [ ] } in let rv_woj = drop v . r j in let m ' = List . map f m in let m ' ' = m ' @ [ { p = [ t1 ] ; q = drop v . r j @ v . q ; r = [ ] } ] in let r1 = algU ' m ' { p = [ t1 ] ; q = rv_woj @ v . q ; r = [ ] } and r2 = algU ' m ' ' { p = [ t2 ] ; q = rv_woj @ v . q ; r = [ ] } in union t1 t2 r1 r2 | _ -> assert false end in let j_list = range 1 ( List . length ( List . hd m ) . r ) in let computed_Ej = List . map compute_Ej j_list in List . fold_left simple_union ( Some [ ] ) computed_Ej end let rec algI m n = match ( m , n ) with | ( [ ] , 0 ) -> Some [ ] | ( [ ] :: _ , 0 ) -> None | ( m , n ) -> let sigma = List . concat ( List . map ( fun v -> head_constrs ( List . hd v ) ) m ) in let sigma_c = List . map fst sigma in let default = if is_complete sigma_c then None else algI ( matD m ) ( n - 1 ) in begin match default with | Some p -> begin match sigma with | [ ] -> Some ( Pany :: p ) | _ :: _ -> let c ' = not_in sigma_c in Some ( Pconstr ( c ' , repeat ( S . arity c ' ) Pany ) :: p ) end | None -> let rec traverse_sigma sigma = match sigma with | [ ] -> None | ( c , ar ) :: sigma ' -> let res = algI ( matS c ar m ) ( ar + n - 1 ) in begin match res with | None -> traverse_sigma sigma ' | Some v -> let ( r , p ) = separate ar v in Some ( Pconstr ( c , r ) :: p ) end in traverse_sigma sigma end type result = { not_matched : S . pattern_ast option ; redundant_patterns : S . pattern_ast list ; } let check m = let m ' = List . map ( fun v -> [ S . inject v ] ) m in match m ' with | [ ] -> invalid_arg " check " | v :: _ -> { not_matched = begin let n = List . length v in match algI m ' n with | None -> None | Some [ p ] -> Some ( S . eject p ) | _ -> assert false end ; redundant_patterns = begin let make_trivec v = { p = v ; q = [ ] ; r = [ ] } in let make_trimat m = List . map make_trivec m in let check_line ( m , red ) v = let r = algU ' ( make_trimat m ) ( make_trivec v ) in ( m @ [ v ] , match r with | Some [ ] -> red | Some r -> List . map S . eject r @ red | None -> List . map S . eject v @ red ) in let ( _ , red ) = List . fold_left check_line ( [ ( List . hd m ' ) ] , [ ] ) ( List . tl m ' ) in red ; end } end

let header_in_file = let open Zconfig in " The Zelus compiler , version " ^ version ^ " " - ^ subversion ^ " \ n \ ( " ^ date ^ " ) "

module S = Set . Make ( struct type t = string let compare = compare end )

module Env = Map . Make ( struct type t = string let compare = compare end )

let default_used_modules = ref [ name_of_stdlib_module ]

let load_path = ref ( [ standard_lib ] )

let set_stdlib p = load_path := [ p ]

let locate_stdlib ( ) = Printf . printf " % s \ n " standard_lib

let show_version ( ) = let open Zconfig in Printf . printf " The Zelus compiler , version % s -% s ( % s ) \ n " version subversion date ; Printf . printf " Std lib : " ; locate_stdlib ( ) ; Printf . printf " \ n " ; ( )

let simulation_node = ref None

let set_simulation_node ( n : string ) = simulation_node := Some ( n )

let outname = ref None

let set_outname ( n : string ) = outname := Some ( n )

let node_outname = ref None

let set_node_outname ( n : string ) = node_outname := Some ( n )

let number_of_checks = ref 0

let set_check ( n : int ) = number_of_checks := n

let sampling_period = ref 0 . 0

let set_sampling_period p = sampling_period := p

let inlining_level = ref 10

let set_inlining_level l = inlining_level := l

let inline_all = ref false

let dzero = ref false

let verbose = ref false

let vverbose = ref false

let print_types = ref false

let print_causality_types = ref false

let print_initialization_types = ref false

let typeonly = ref false

let use_gtk = ref false

let no_stdlib = ref false

let no_causality = ref false

let no_initialisation = ref false

let no_opt = ref false

let no_deadcode = ref false

let no_simplify_causality_type = ref false

let no_reduce = ref false

let no_warning = ref false

let zsign = ref false

let with_copy = ref false

let use_rif = ref false

let build_deps = ref false

let lmm_nodes = ref S . empty

let set_lmm_nodes ( n : string ) = lmm_nodes := S . add n ! lmm_nodes object val mutable counter = 0 method name = counter <- counter + 1 ; counter method reset = counter <- 0 method init i = counter <- i end

let symbol = new name_generator object val mutable counter = 0 val mutable assoc_table : ( int * string ) list = [ ] method name var = try List . assq var assoc_table with not_found -> let n = f counter in counter <- counter + 1 ; assoc_table <- ( var , n ) :: assoc_table ; n method reset = counter <- 0 ; assoc_table <- [ ] end

let int_to_letter bound i = if i < 26 then String . make 1 ( Char . chr ( i + bound ) ) else String . make 1 ( Char . chr ( ( i mod 26 ) + bound ) ) ^ string_of_int ( i / 26 )

let int_to_alpha i = int_to_letter 97 i

let binding_level = ref 0

let top_binding_level ( ) = ! binding_level = 0

let push_binding_level ( ) = binding_level := ! binding_level + 1

let pop_binding_level ( ) = binding_level := ! binding_level - 1 ; assert ( ! binding_level > generic )

let reset_binding_level ( ) = binding_level := 0

let optional f acc = function | None -> acc | Some x -> f acc x

let optional_unit f acc = function | None -> ( ) | Some x -> f acc x

let optional_map f = function | None -> None | Some ( x ) -> Some ( f x )

let optional_with_map f acc = function | None -> None , acc | Some ( x ) -> let x , acc = f acc x in Some ( x ) , acc

let optional_get = function | Some x -> x | None -> assert false

let rec iter f = function | [ ] -> [ ] | x :: l -> let y = f x in y :: iter f l

let fold f l = List . rev ( List . fold_left f [ ] l )

let from i = let rec fromrec acc i = match i with | 0 -> acc | _ -> fromrec ( i :: acc ) ( i - 1 ) in fromrec [ ] i

let map_fold f acc l = let rec maprec acc = function | [ ] -> [ ] , acc | x :: l -> let y , acc = f acc x in let l , acc = maprec acc l in y :: l , acc in maprec acc l

let rec firsts = function | [ ] -> assert false | [ p ] -> [ ] , p | p :: l -> let head , tail = firsts l in p :: head , tail

module State = struct type ' a t = | Empty | Cons of ' a * ' a t | Par of ' a t * ' a t let singleton x = Cons ( x , Empty ) let cons x s = Cons ( x , s ) let seq s1 s2 = match s1 , s2 with | ( Empty , s ) | ( s , Empty ) -> s | _ -> Seq ( s1 , s2 ) let par s1 s2 = match s1 , s2 with | ( Empty , s ) | ( s , Empty ) -> s | _ -> Par ( s1 , s2 ) let empty = Empty let is_empty s = ( s = empty ) let rec fold f s acc = match s with | Empty -> acc | Cons ( x , l ) -> f x ( fold f l acc ) | Par ( l1 , l2 ) -> fold f l1 ( fold f l2 acc ) | Seq ( l1 , l2 ) -> fold f l1 ( fold f l2 acc ) let list acc s = fold ( fun l ls -> l :: ls ) s acc let cons_list xs s = List . fold_left ( fun s x -> Cons ( x , s ) ) s ( List . rev xs ) let rec map f s = match s with | Empty -> Empty | Cons ( x , l ) -> Cons ( f x , map f l ) | Par ( l1 , l2 ) -> Par ( map f l1 , map f l2 ) | Seq ( l1 , l2 ) -> Seq ( map f l1 , map f l2 ) let rec iter f s = match s with | Empty -> ( ) | Cons ( x , l ) -> ( f x ; iter f l ) | Par ( l1 , l2 ) | Seq ( l1 , l2 ) -> ( iter f l1 ; iter f l2 ) let rec partition f s = match s with | Empty -> Empty , Empty | Cons ( x , l ) -> let left , right = partition f l in if f x then Cons ( x , left ) , right else left , Cons ( x , right ) | Par ( l1 , l2 ) -> let left1 , right1 = partition f l1 in let left2 , right2 = partition f l2 in Par ( left1 , left2 ) , Par ( right1 , right2 ) | Seq ( l1 , l2 ) -> let left1 , right1 = partition f l1 in let left2 , right2 = partition f l2 in Seq ( left1 , left2 ) , Seq ( right1 , right2 ) let fprint_t fprint_v ff s = let rec print ff s = Format . fprintf ff " [ @< hov >% a ] " @ print s end

let internal_error message printer input = Format . eprintf " [ @ Internal error ( % s ) . @ % a . ] " @@ message printer input ; raise Error

module Context = struct type t external create : unit -> t = " caml_zmq_new " external terminate : t -> unit = " caml_zmq_term " type int_option = | ZMQ_IO_THREADS | ZMQ_MAX_SOCKETS | ZMQ_IPV6 external set_int_option : t -> int_option -> int -> unit = " caml_zmq_ctx_set_int_option " external get_int_option : t -> int_option -> int = " caml_zmq_ctx_get_int_option " let get_io_threads ctx = get_int_option ctx ZMQ_IO_THREADS let set_io_threads ctx = set_int_option ctx ZMQ_IO_THREADS let get_max_sockets ctx = get_int_option ctx ZMQ_MAX_SOCKETS let set_max_sockets ctx = set_int_option ctx ZMQ_MAX_SOCKETS let get_ipv6 ctx = ( get_int_option ctx ZMQ_IPV6 ) ZMQ_IPV6 == 1 let set_ipv6 ctx has_ipv6 = set_int_option ctx ZMQ_IPV6 ( if has_ipv6 then 1 else 0 ) 0 end

module Msg = struct open Bigarray type t type bigstring = ( char , int8_unsigned_elt , c_layout ) c_layout Array1 . t external native_init_data : bigstring -> int -> int -> t = " caml_zmq_msg_init_data " let init_data ( ? offset = 0 ) 0 ? length buf = let length = let max_possible = Array1 . dim buf - offset in match length with | Some l -> min l max_possible | None -> max_possible in native_init_data buf offset length external size : t -> int = " caml_zmq_msg_size " external unsafe_data : t -> bigstring = " caml_zmq_msg_data " let copy_data msg = let data = unsafe_data msg in let copy = Array1 . create char c_layout ( Array1 . dim data ) data in Array1 . blit data copy ; copy external close : t -> unit = " caml_zmq_msg_close " external gets : t -> string -> string = " caml_zmq_msg_gets " end

module Socket = struct open Stdint type + ' a t type ' a kind = int let pair = 0 let pub = 1 let sub = 2 let req = 3 let rep = 4 let dealer = 5 let router = 6 let pull = 7 let push = 8 let xpub = 9 let xsub = 10 let stream = 11 external create : Context . t -> ' a kind -> ' a t = " caml_zmq_socket " external close : ' a t -> unit = " caml_zmq_close " external connect : ' a t -> string -> unit = " caml_zmq_connect " external disconnect : ' a t -> string -> unit = " caml_zmq_disconnect " external bind : ' a t -> string -> unit = " caml_zmq_bind " external unbind : ' a t -> string -> unit = " caml_zmq_unbind " external native_recv : ' a t -> bool -> string = " caml_zmq_recv " let recv ( ? block = true ) true socket = native_recv socket block external native_send : ' a t -> string -> bool -> bool -> unit = " caml_zmq_send " let send ( ? block = true ) true ( ? more = false ) false socket message = native_send socket message block more external native_recv_msg : ' a t -> bool -> Msg . t = " caml_zmq_recv_msg " let recv_msg ( ? block = true ) true socket = native_recv_msg socket block external native_send_msg : ' a t -> Msg . t -> bool -> bool -> unit = " caml_zmq_send_msg " let send_msg ( ? block = true ) true ( ? more = false ) false socket message = native_send_msg socket message block more type int64_option = | ZMQ_MAXMSGSIZE external set_int64_option : ' a t -> int64_option -> int64 -> unit = " caml_zmq_set_int64_option " external get_int64_option : ' a t -> int64_option -> int64 = " caml_zmq_get_int64_option " type uint64_option = | ZMQ_AFFINITY external set_uint64_option : ' a t -> uint64_option -> Uint64 . t -> unit = " caml_zmq_set_uint64_option " external get_uint64_option : ' a t -> uint64_option -> Uint64 . t = " caml_zmq_get_uint64_option " type string_option = | ZMQ_IDENTITY | ZMQ_SUBSCRIBE | ZMQ_UNSUBSCRIBE | ZMQ_LAST_ENDPOINT | ZMQ_TCP_ACCEPT_FILTER | ZMQ_PLAIN_USERNAME | ZMQ_PLAIN_PASSWORD | ZMQ_CURVE_PUBLICKEY | ZMQ_CURVE_SECRETKEY | ZMQ_CURVE_SERVERKEY | ZMQ_ZAP_DOMAIN external set_string_option : ' a t -> string_option -> string -> unit = " caml_zmq_set_string_option " external get_string_option : ' a t -> string_option -> int -> string = " caml_zmq_get_string_option " [ @@@ warning " - 37 ] " type int_option = | ZMQ_RATE | ZMQ_RECOVERY_IVL | ZMQ_SNDBUF | ZMQ_RCVBUF | ZMQ_RCVMORE | ZMQ_EVENTS | ZMQ_TYPE | ZMQ_LINGER | ZMQ_RECONNECT_IVL | ZMQ_BACKLOG | ZMQ_RECONNECT_IVL_MAX | ZMQ_SNDHWM | ZMQ_RCVHWM | ZMQ_MULTICAST_HOPS | ZMQ_RCVTIMEO | ZMQ_SNDTIMEO | ZMQ_IPV6 | ZMQ_ROUTER_MANDATORY | ZMQ_TCP_KEEPALIVE | ZMQ_TCP_KEEPALIVE_CNT | ZMQ_TCP_KEEPALIVE_IDLE | ZMQ_TCP_KEEPALIVE_INTVL | ZMQ_IMMEDIATE | ZMQ_XPUB_VERBOSE | ZMQ_MECHANISM | ZMQ_PLAIN_SERVER | ZMQ_CURVE_SERVER | ZMQ_PROBE_ROUTER | ZMQ_REQ_CORRELATE | ZMQ_REQ_RELAXED | ZMQ_CONFLATE [ @@@ warning " + 37 ] " external set_int_option : ' a t -> int_option -> int -> unit = " caml_zmq_set_int_option " external get_int_option : ' a t -> int_option -> int = " caml_zmq_get_int_option " let validate_string_length min max str msg = match String . length str with | n when n < min -> invalid_arg msg | n when n > max -> invalid_arg msg | _ -> ( ) let set_max_message_size socket size = set_int64_option socket ZMQ_MAXMSGSIZE ( Int64 . of_int size ) size let get_max_message_size socket = Int64 . to_int ( get_int64_option socket ZMQ_MAXMSGSIZE ) ZMQ_MAXMSGSIZE let set_affinity socket size = set_uint64_option socket ZMQ_AFFINITY ( Uint64 . of_int size ) size let get_affinity socket = Uint64 . to_int ( get_uint64_option socket ZMQ_AFFINITY ) ZMQ_AFFINITY let set_identity socket identity = validate_string_length 1 255 identity " set_identity " ; set_string_option socket ZMQ_IDENTITY identity let maximal_buffer_length = 255 let curve_z85_buffer_length = 41 let get_identity socket = get_string_option socket ZMQ_IDENTITY maximal_buffer_length let subscribe socket topic = set_string_option socket ZMQ_SUBSCRIBE topic let unsubscribe socket topic = set_string_option socket ZMQ_UNSUBSCRIBE topic let get_last_endpoint socket = get_string_option socket ZMQ_LAST_ENDPOINT maximal_buffer_length let set_tcp_accept_filter socket filter = set_string_option socket ZMQ_TCP_ACCEPT_FILTER filter let set_rate socket rate = set_int_option socket ZMQ_RATE rate let get_rate socket = get_int_option socket ZMQ_RATE let set_recovery_interval socket interval = set_int_option socket ZMQ_RECOVERY_IVL interval let get_recovery_interval socket = get_int_option socket ZMQ_RECOVERY_IVL let set_send_buffer_size socket size = set_int_option socket ZMQ_SNDBUF size let get_send_buffer_size socket = get_int_option socket ZMQ_SNDBUF let set_receive_buffer_size socket size = set_int_option socket ZMQ_RCVBUF size let get_receive_buffer_size socket = get_int_option socket ZMQ_RCVBUF let has_more socket = get_int_option socket ZMQ_RCVMORE != 0 let set_linger_period socket period = set_int_option socket ZMQ_LINGER period let get_linger_period socket = get_int_option socket ZMQ_LINGER let set_reconnect_interval socket interval = set_int_option socket ZMQ_RECONNECT_IVL interval let get_reconnect_interval socket = get_int_option socket ZMQ_RECONNECT_IVL let set_connection_backlog socket backlog = set_int_option socket ZMQ_BACKLOG backlog let get_connection_backlog socket = get_int_option socket ZMQ_BACKLOG let set_reconnect_interval_max socket interval = set_int_option socket ZMQ_RECONNECT_IVL_MAX interval let get_reconnect_interval_max socket = get_int_option socket ZMQ_RECONNECT_IVL_MAX let set_send_high_water_mark socket mark = set_int_option socket ZMQ_SNDHWM mark let get_send_high_water_mark socket = get_int_option socket ZMQ_SNDHWM let set_receive_high_water_mark socket mark = set_int_option socket ZMQ_RCVHWM mark let get_receive_high_water_mark socket = get_int_option socket ZMQ_RCVHWM let set_multicast_hops socket hops = set_int_option socket ZMQ_MULTICAST_HOPS hops let get_multicast_hops socket = get_int_option socket ZMQ_MULTICAST_HOPS let set_receive_timeout socket timeout = set_int_option socket ZMQ_RCVTIMEO timeout let get_receive_timeout socket = get_int_option socket ZMQ_RCVTIMEO let set_send_timeout socket timeout = set_int_option socket ZMQ_SNDTIMEO timeout let get_send_timeout socket = get_int_option socket ZMQ_SNDTIMEO let set_ipv6 socket flag = let value = match flag with true -> 1 | false -> 0 in set_int_option socket ZMQ_IPV6 value let get_ipv6 socket = match get_int_option socket ZMQ_IPV6 with | 0 -> false | _ -> true let set_router_mandatory socket flag = let value = match flag with true -> 1 | false -> 0 in set_int_option socket ZMQ_ROUTER_MANDATORY value let get_router_mandatory socket = match get_int_option socket ZMQ_ROUTER_MANDATORY with | 0 -> false | _ -> true let set_tcp_keepalive socket flag = let value = match flag with | ` Default -> - 1 | ` Value false -> 0 | ` Value true -> 1 in set_int_option socket ZMQ_TCP_KEEPALIVE value let get_tcp_keepalive socket = match get_int_option socket ZMQ_TCP_KEEPALIVE with | - 1 -> ` Default | 0 -> ` Value false | _ -> ` Value true let set_tcp_keepalive_idle socket flag = let value = match flag with | ` Default -> - 1 | ` Value n when n <= 0 -> invalid_arg " set_tcp_keepalive_idle " | ` Value n -> n in set_int_option socket ZMQ_TCP_KEEPALIVE_IDLE value let get_tcp_keepalive_idle socket = match get_int_option socket ZMQ_TCP_KEEPALIVE_IDLE with | - 1 -> ` Default | n when n <= 0 -> assert false | n -> ` Value n let set_tcp_keepalive_interval socket flag = let value = match flag with | ` Default -> - 1 | ` Value n when n <= 0 -> invalid_arg " set_tcp_keepalive_interval " | ` Value n -> n in set_int_option socket ZMQ_TCP_KEEPALIVE_INTVL value let get_tcp_keepalive_interval socket = match get_int_option socket ZMQ_TCP_KEEPALIVE_INTVL with | - 1 -> ` Default | n when n <= 0 -> assert false | n -> ` Value n let set_tcp_keepalive_count socket flag = let value = match flag with | ` Default -> - 1 | ` Value n when n <= 0 -> invalid_arg " set_tcp_keepalive_count " | ` Value n -> n in set_int_option socket ZMQ_TCP_KEEPALIVE_CNT value let get_tcp_keepalive_count socket = match get_int_option socket ZMQ_TCP_KEEPALIVE_CNT with | - 1 -> ` Default | n when n <= 0 -> assert false | n -> ` Value n let set_immediate socket flag = let value = match flag with | true -> 1 | false -> 0 in set_int_option socket ZMQ_IMMEDIATE value let get_immediate socket = match get_int_option socket ZMQ_IMMEDIATE with | 0 -> false | _ -> true let set_xpub_verbose socket flag = let value = match flag with | true -> 1 | false -> 0 in set_int_option socket ZMQ_XPUB_VERBOSE value let set_probe_router socket flag = set_int_option socket ZMQ_PROBE_ROUTER ( if flag then 1 else 0 ) 0 let set_req_correlate socket flag = set_int_option socket ZMQ_REQ_CORRELATE ( if flag then 1 else 0 ) 0 let set_req_relaxed socket flag = set_int_option socket ZMQ_REQ_RELAXED ( if flag then 1 else 0 ) 0 let set_plain_server socket flag = set_int_option socket ZMQ_PLAIN_SERVER ( if flag then 1 else 0 ) 0 let set_curve_server socket flag = set_int_option socket ZMQ_CURVE_SERVER ( if flag then 1 else 0 ) 0 let set_plain_username socket = set_string_option socket ZMQ_PLAIN_USERNAME let get_plain_username socket = get_string_option socket ZMQ_PLAIN_USERNAME maximal_buffer_length let set_plain_password socket = set_string_option socket ZMQ_PLAIN_PASSWORD let get_plain_password socket = get_string_option socket ZMQ_PLAIN_PASSWORD maximal_buffer_length let validate_curve_key_length str msg = match String . length str with | 32 | 40 -> ( ) | _ -> invalid_arg msg let get_curve_publickey socket = get_string_option socket ZMQ_CURVE_PUBLICKEY curve_z85_buffer_length let set_curve_publickey socket str = validate_curve_key_length str " set_curve_publickey " ; set_string_option socket ZMQ_CURVE_PUBLICKEY str let get_curve_secretkey socket = get_string_option socket ZMQ_CURVE_SECRETKEY curve_z85_buffer_length let set_curve_secretkey socket str = validate_curve_key_length str " set_curve_secretkey " ; set_string_option socket ZMQ_CURVE_SECRETKEY str let get_curve_serverkey socket = get_string_option socket ZMQ_CURVE_SERVERKEY curve_z85_buffer_length let set_curve_serverkey socket str = validate_curve_key_length str " set_curve_serverkey " ; set_string_option socket ZMQ_CURVE_SERVERKEY str let get_mechanism socket = match get_int_option socket ZMQ_MECHANISM with | 0 -> ` Null | 1 -> ` Plain | 2 -> ` Curve | _ -> assert false let set_zap_domain socket = set_string_option socket ZMQ_ZAP_DOMAIN let get_zap_domain socket = get_string_option socket ZMQ_ZAP_DOMAIN maximal_buffer_length let set_conflate socket flag = set_int_option socket ZMQ_CONFLATE ( if flag then 1 else 0 ) 0 external get_fd : ' a t -> Unix . file_descr = " caml_zmq_get_fd " type event = No_event | Poll_in | Poll_out | Poll_in_out | Poll_error external events : ' a t -> event = " caml_zmq_get_events " let recv_all_wrapper ( f : ? block : bool -> _ t -> _ ) _ = let rec loop socket accu = if has_more socket then loop socket ( f socket :: accu ) accu else accu in fun ? block socket -> let first = f ? block socket in List . rev ( loop socket [ first ] first ) first let send_all_wrapper ( f : ? block : bool -> ? more : bool -> _ t -> _ -> unit ) unit = let rec send_all_inner_loop socket message = match message with | [ ] -> ( ) | hd :: [ ] -> f socket hd | hd :: tl -> f ~ more : true socket hd ; send_all_inner_loop socket tl in fun ? block socket message -> match message with | [ ] -> ( ) | hd :: [ ] -> f ? block ~ more : false socket hd | hd :: tl -> f ? block ~ more : true socket hd ; send_all_inner_loop socket tl let recv_all ? block socket = recv_all_wrapper recv ? block socket let send_all ? block socket message = send_all_wrapper send ? block socket message let recv_msg_all ? block socket = recv_all_wrapper recv_msg ? block socket let send_msg_all ? block socket message = send_all_wrapper send_msg ? block socket message end

module Proxy = struct external zmq_proxy2 : ' a Socket . t -> ' b Socket . t -> unit = " caml_zmq_proxy2 " external zmq_proxy3 : ' a Socket . t -> ' b Socket . t -> ' c Socket . t -> unit = " caml_zmq_proxy3 " let create ? capture frontend backend = match capture with | Some capture -> zmq_proxy3 frontend backend capture | None -> zmq_proxy2 frontend backend end

module Poll = struct type t type poll_event = In | Out | In_out type ' a poll_mask = ( ' a Socket . t * poll_event ) poll_event let mask_in_out t = ( t :> [ ` Pair ` | Pub ` | Sub ` | Req ` | Rep ` | Dealer ` | Router ` | Pull ` | Push ` | Xsub ` | Xpub ` | Stream ] Stream Socket . t ) , In_out let mask_in t = ( t :> [ ` Pair ` | Pub ` | Sub ` | Req ` | Rep ` | Dealer ` | Router ` | Pull ` | Push ` | Xsub ` | Xpub ` | Stream ] Stream Socket . t ) , In let mask_out t = ( t :> [ ` Pair ` | Pub ` | Sub ` | Req ` | Rep ` | Dealer ` | Router ` | Pull ` | Push ` | Xsub ` | Xpub ` | Stream ] Stream Socket . t ) , Out external mask_of : ' a poll_mask array -> t = " caml_zmq_poll_of_pollitem_array " external of_masks : ' a poll_mask array -> t = " caml_zmq_poll_of_pollitem_array " external native_poll : t -> int -> poll_event option array = " caml_zmq_poll " let poll ( ? timeout = - 1 ) 1 items = native_poll items timeout end

module Monitor = struct type t = string type address = string type error_no = int type error_text = string type event = | Connected of address * Unix . file_descr | Connect_delayed of address | Connect_retried of address * int | Listening of address * Unix . file_descr | Bind_failed of address * error_no * error_text | Accepted of address * Unix . file_descr | Accept_failed of address * error_no * error_text | Closed of address * Unix . file_descr | Close_failed of address * error_no * error_text | Disconnected of address * Unix . file_descr | Monitor_stopped of address | Handshake_failed_no_detail of address | Handshake_succeeded of address | Handshake_failed_protocol of address * int | Handshake_failed_auth of address * int external socket_monitor : ' a Socket . t -> string -> unit = " caml_zmq_socket_monitor " let create socket = let socket_id = Hashtbl . hash ( Socket . get_fd socket ) socket in let address = Printf . sprintf " inproc :// _socket_monitor -% d -% x . % x " ( Unix . getpid ( ) ) socket_id ( Random . bits ( ) ) in socket_monitor socket address ; address let connect ctx t = let s = Socket . create ctx Socket . pair in Socket . connect s t ; s external decode_monitor_event : string -> string -> event = " caml_decode_monitor_event " let recv ? block socket = let event = Socket . recv ? block socket in assert ( Socket . has_more socket ) socket ; let addr = Socket . recv ~ block : false socket in decode_monitor_event event addr let get_peer_address fd = try let sockaddr = Unix . getpeername fd in let domain = match Unix . domain_of_sockaddr sockaddr with | Unix . PF_UNIX -> " unix " | Unix . PF_INET -> " tcp " | Unix . PF_INET6 -> " tcp6 " in match sockaddr with | Unix . ADDR_UNIX s -> Printf . sprintf " % s ://% s " domain s ; | Unix . ADDR_INET ( addr , port ) port -> Printf . sprintf " % s ://% s :% d " domain ( Unix . string_of_inet_addr addr ) addr port with | Unix . Unix_error _ -> " unknown " let internal_string_of_event push_address pop_address = function | Connected ( addr , fd ) fd -> Printf . sprintf " Connect : % s . peer % s " addr ( push_address fd ) fd | Connect_delayed addr -> Printf . sprintf " Connect delayed : % s " addr | Connect_retried ( addr , interval ) interval -> Printf . sprintf " Connect retried : % s - % d " addr interval | Listening ( addr , fd ) fd -> Printf . sprintf " Listening : % s - peer % s " addr ( push_address fd ) fd | Bind_failed ( addr , error_no , error_text ) error_text -> Printf . sprintf " Bind failed : % s . % d :% s " addr error_no error_text | Accepted ( addr , fd ) fd -> Printf . sprintf " Accepted : % s . peer % s " addr ( push_address fd ) fd | Accept_failed ( addr , error_no , error_text ) error_text -> Printf . sprintf " Accept failed : % s . % d :% s " addr error_no error_text | Closed ( addr , fd ) fd -> Printf . sprintf " Closed : % s . peer % s " addr ( pop_address fd ) fd | Close_failed ( addr , error_no , error_text ) error_text -> Printf . sprintf " Close failed : % s . % d :% s " addr error_no error_text | Disconnected ( addr , fd ) fd -> Printf . sprintf " Disconnect : % s . peer % s " addr ( pop_address fd ) fd | Monitor_stopped addr -> Printf . sprintf " Monitor_stopped : % s " addr | Handshake_failed_no_detail addr -> Printf . sprintf " Handshake_failed_no_detail : % s " addr | Handshake_succeeded addr -> Printf . sprintf " Handshake_succeeded : % s " addr | Handshake_failed_protocol ( addr , code ) code -> Printf . sprintf " Handshake_failed_protocol : % s - % d " addr code | Handshake_failed_auth ( addr , code ) code -> Printf . sprintf " Handshake_failed_auth : % s - % d " addr code let string_of_event event = internal_string_of_event get_peer_address get_peer_address event let mk_string_of_event ( ) = let state = ref [ ] in let pop_address fd = let rec pop acc = function | [ ] -> ( get_peer_address fd , acc ) acc | ( fd ' , address ) address :: xs when fd ' = fd -> ( address , acc @ xs ) xs | x :: xs -> pop ( x :: acc ) acc xs in let ( address , new_state ) new_state = pop [ ] ! state in state := new_state ; address in let push_address fd = let address = get_peer_address fd in state := ( fd , address ) address :: ! state ; address in internal_string_of_event push_address pop_address end

module Z85 = struct external encode : string -> string = " caml_z85_encode " external decode : string -> string = " caml_z85_decode " end

module Curve = struct external keypair : unit -> string * string = " caml_curve_keypair " end

let zmq_raise e str func_name = let exn = match e with | I_ENOTSUP -> Unix ( . Unix_error ( EOPNOTSUPP , func_name , ) ) " " | I_EPROTONOSUPPORT -> Unix ( . Unix_error ( EPROTONOSUPPORT , func_name , ) ) " " | I_ENOBUFS -> Unix ( . Unix_error ( ENOBUFS , func_name , ) ) " " | I_ENETDOWN -> Unix ( . Unix_error ( ENETDOWN , func_name , ) ) " " | I_EADDRINUSE -> Unix ( . Unix_error ( EADDRINUSE , func_name , ) ) " " | I_EADDRNOTAVAIL -> Unix ( . Unix_error ( EADDRNOTAVAIL , func_name , ) ) " " | I_ECONNREFUSED -> Unix ( . Unix_error ( ECONNREFUSED , func_name , ) ) " " | I_EINPROGRESS -> Unix ( . Unix_error ( EINPROGRESS , func_name , ) ) " " | I_ENOTSOCK -> Unix ( . Unix_error ( ENOTSOCK , func_name , ) ) " " | I_EMSGSIZE -> Unix ( . Unix_error ( EMSGSIZE , func_name , ) ) " " | I_EAFNOSUPPORT -> Unix ( . Unix_error ( EAFNOSUPPORT , func_name , ) ) " " | I_ENETUNREACH -> Unix ( . Unix_error ( ENETUNREACH , func_name , ) ) " " | I_ECONNABORTED -> Unix ( . Unix_error ( ECONNABORTED , func_name , ) ) " " | I_ECONNRESET -> Unix ( . Unix_error ( ECONNRESET , func_name , ) ) " " | I_ENOTCONN -> Unix ( . Unix_error ( ENOTCONN , func_name , ) ) " " | I_ETIMEDOUT -> Unix ( . Unix_error ( ETIMEDOUT , func_name , ) ) " " | I_EHOSTUNREACH -> Unix ( . Unix_error ( EHOSTUNREACH , func_name , ) ) " " | I_ENETRESET -> Unix ( . Unix_error ( ENETRESET , func_name , ) ) " " | I_EFSM -> ZMQ_exception ( EFSM , str ) str | I_ENOCOMPATPROTO -> ZMQ_exception ( ENOCOMPATPROTO , str ) str | I_ETERM -> ZMQ_exception ( ETERM , str ) str | I_EMTHREAD -> ZMQ_exception ( EMTHREAD , str ) str | I_EUNKNOWN -> ZMQ_exception ( EUNKNOWN , str ) str in raise exn

let ( ) = Callback . register " Zmq . zmq_raise " zmq_raise

let debug fmt = Printf . ksprintf ( fun s -> print_endline s ; flush stdout ) stdout fmt

let sleep t = ignore ( ignoreUnix . select [ ] [ ] [ ] ( ( float t ) t . / 1000 . 0 ) 0 ) 0

let dump_events l = let f = function | None -> " None " | Some In -> " In " | Some Out -> " Out " | Some In_out -> " In / Out " in let l = Array . to_list ( Array . map f l ) l in [ " " | ^ ( String . concat " ; " l ) l ^ ] " " |

let test_ctx_options ( ) = let ctx = Context . create ( ) in let test_set_get_int msg setter getter ctx v = let default = getter ctx in setter ctx v ; assert_equal ~ msg ~ printer : string_of_int v ( getter ctx ) ctx ; setter ctx default ; assert_equal ~ msg default ( getter ctx ) ctx ; ( ) in let test_set_get_bool msg setter getter ctx v = let default = getter ctx in setter ctx v ; assert_equal ~ msg ~ printer : string_of_bool v ( getter ctx ) ctx ; setter ctx default ; assert_equal ~ msg default ( getter ctx ) ctx ; ( ) in test_set_get_int " IO threads " set_io_threads get_io_threads ctx 1 ; test_set_get_int " Max sockets " set_max_sockets get_max_sockets ctx 1024 ; test_set_get_bool " IPv6 " Context . set_ipv6 Context . get_ipv6 ctx false ; Context . terminate ctx

let test_socket_options ( ) = let ctx = Context . create ( ) in let socket = create ctx push in let test_set_get_int msg setter getter socket v = let default = getter socket in setter socket v ; assert_equal ~ msg ~ printer : string_of_int v ( getter socket ) socket ; setter socket default ; assert_equal ~ msg default ( getter socket ) socket ; ( ) in let test_set_get_value msg setter getter socket v = let default = getter socket in setter socket v ; assert_equal ~ msg ~ printer ( : function ` Default -> " default " | ` Value n -> string_of_int n ) n v ( getter socket ) socket ; setter socket default ; assert_equal ~ msg default ( getter socket ) socket ; ( ) in test_set_get_int " Highwatermark " set_receive_high_water_mark get_receive_high_water_mark socket 1235 ; test_set_get_int " Affinity " set_affinity get_affinity socket 3 ; test_set_get_int " Receive timeout " set_receive_timeout get_receive_timeout socket 1000 ; test_set_get_value " Tcp keepalive interval " set_tcp_keepalive_interval get_tcp_keepalive_interval socket ( ` Value 1000 ) 1000 ; Socket . close socket ; Context . terminate ctx ; ( )

let test_monitor ( ) = let endpoint = " ipc :// monitor_socket " in let expect_handshake = match Zmq . version ( ) with | ( 4 , n , _ ) _ when n < 3 -> false | ( 3 , _ , _ ) _ -> failwith " Only zmq version 4 or higher is supported " | _ -> true in let assert_event name socket event = let printer x = x in let rec cmp str1 str2 = match String . length str1 <= String . length str2 with | true -> String . sub str2 0 ( String . length str1 ) str1 = str1 | false -> cmp str2 str1 in let rec receive_event ~ end_time = match Zmq . Monitor . recv ~ block : false socket with | event -> Zmq . Monitor . string_of_event event | exception Unix . Unix_error ( Unix_errorUnix . EAGAIN , _ , _ ) _ when end_time > ( Unix . gettimeofday ( ) ) -> sleep 10 ; receive_event ~ end_time | exception Unix . Unix_error ( Unix_errorUnix . EAGAIN , _ , _ ) _ -> " No event received " in let received = receive_event ~ end_time ( : Unix . gettimeofday ( ) . + 1 . 0 ) 0 in assert_equal ~ msg ( : Printf . sprintf " Wrong event received on % s " name ) name ~ printer ~ cmp ( Printf . sprintf " % s : % s " event endpoint ) endpoint received in let ctx = Context . create ( ) in let s1 = Zmq . Socket . create ctx Zmq . Socket . pair in let s2 = Zmq . Socket . create ctx Zmq . Socket . pair in let m1 = let mon_t = Zmq . Monitor . create s1 in Zmq . Monitor . connect ctx mon_t in let m2 = let mon_t = Zmq . Monitor . create s2 in Zmq . Monitor . connect ctx mon_t in Zmq . Socket . bind s1 endpoint ; assert_event " m1 " m1 " Listening " ; Zmq . Socket . connect s2 endpoint ; assert_event " m1 " m1 " Accepted " ; assert_event " m2 " m2 " Connect " ; if ( expect_handshake ) expect_handshake then begin assert_event " m1 " m1 " Handshake_succeeded " ; assert_event " m2 " m2 " Handshake_succeeded " end ; Zmq . Socket . close s1 ; assert_event " m1 " m1 " Closed " ; Zmq . Socket . close s2 ; assert_event " m2 " m2 " Disconnect " ; Zmq . Socket . close m2 ; Zmq . Socket . close m1 ; Context . terminate ctx ; ( )

let test_proxy ( ) = let ctx = Zmq . Context . create ( ) in let pull_endpoint = " inproc :// pull " in let pub_endpoint = " inproc :// pub " in let pull = Zmq . Socket . create ctx pull in let pub = Zmq . Socket . create ctx pub in let proxy ( pull , pub ) pub = Zmq . Socket . bind pull pull_endpoint ; Zmq . Socket . bind pub pub_endpoint ; try Zmq . Proxy . create pull pub ; assert_failure " Proxy . create must raise an exception when completed " with Unix . Unix_error ( Unix . ENOTSOCK , _ , _ ) _ -> ( ) in let _thread = Thread . create proxy ( pull , pub ) pub in sleep 10 ; let sub = let s = Zmq . Socket . create ctx sub in Zmq . Socket . connect s pub_endpoint ; Zmq . Socket . subscribe s " " ; s in let push = let s = Zmq . Socket . create ctx push in Zmq . Socket . connect s pull_endpoint ; s in let msg1 = " Message1 " in let msg2 = " Message2 " in Zmq . Socket . send push msg1 ; Zmq . Socket . send push msg2 ; assert_equal msg1 ( Zmq . Socket . recv sub ) sub ; assert_equal msg2 ( Zmq . Socket . recv sub ) sub ; Zmq . Socket . close sub ; Zmq . Socket . close push ; Zmq . Socket . close pull ; Zmq . Socket . close pub ; Zmq . Context . terminate ctx ; ( )

let test_unix_exceptions = bracket ( fun ( ) -> let ctx = Zmq . Context . create ( ) in let s = Zmq . Socket . create ctx pull in ( ctx , s ) s ) ( fun ( _ , s ) s -> let mask = Zmq . Poll . of_masks [ | s , Zmq . Poll . In ] | in Sys ( . set_signal sigalrm ( Signal_handle ( fun _ -> ( ) ) ) ) ; ignore ( Unix . alarm 1 ) 1 ; assert_raises ~ msg " : Failed to raise EINTR " Unix ( . Unix_error ( Unix_errorEINTR , " zmq_poll " , ) ) " " ( fun _ -> Zmq . Poll . poll ~ timeout : 2000 mask ) mask ; ( ) ) ( fun ( ctx , s ) s -> Zmq . Socket . close s ; Zmq . Context . terminate ctx )

let test_zmq_exception = bracket ( fun ( ) -> let ctx = Zmq . Context . create ( ) in let socket = Zmq . Socket . create ctx req in ( ctx , socket ) socket ) ( fun ( _ , socket ) socket -> assert_raises ( Zmq . ZMQ_exception ( ZMQ_exceptionZmq . EFSM , " Operation cannot be accomplished in current state ) ) " ( fun ( ) -> Zmq . Socket . recv socket ) socket ; ) ( fun ( ctx , socket ) socket -> Zmq . Socket . close socket ; Zmq . Context . terminate ctx ; )

let test_socket_gc ( ) = let sock = let ctx = Zmq . Context . create ( ) in Zmq . Socket . create ctx Zmq . Socket . req in Gc . compact ( ) ; Zmq . Socket . close sock ; Gc . compact ( )

let test_context_gc ( ) = let ctx = let ctx = Zmq . Context . create ( ) in let sock = Zmq . Socket . create ctx Zmq . Socket . pair in Zmq . Socket . connect sock " ipc :// context_gc_socket " ; Zmq . Socket . send sock " test " ; ctx in Gc . compact ( ) ; Zmq . Context . terminate ctx ; ( )

let test_z85 ( ) = let binary = " \ xBB \ x88 \ x47 \ x1D \ x65 \ xE2 \ x65 \ x9B " ^ " \ x30 \ xC5 \ x5A \ x53 \ x21 \ xCE \ xBB \ x5A " ^ " \ xAB \ x2B \ x70 \ xA3 \ x98 \ x64 \ x5C \ x26 " ^ " \ xDC \ xA2 \ xB2 \ xFC \ xB4 \ x3F \ xC5 \ x18 " in let ascii = " Yne @$ w - vo < fVvi ] fVvia < NY6T1ed : M $ fCG [ * IaLV { IaLVhID " in assert_equal ~ printer ( : Printf . sprintf " % S ) " binary ( Zmq . Z85 . decode ascii ) ascii ; assert_equal ~ printer ( : Printf . sprintf " % S ) " ascii ( Zmq . Z85 . encode binary ) binary ; assert_raises ( Invalid_argument " zmq_z85_encode ) " ( fun ( ) -> Zmq . Z85 . encode " 123 ) " ; assert_raises ( Invalid_argument " zmq_z85_decode ) " ( fun ( ) -> Zmq . Z85 . decode " 123 ) " ; ( )

let suite = " zmq test " >::: [ " request reply " >:: ( bracket ( fun ( ) -> let ctx = Zmq . Context . create ( ) in let req = create ctx req in let rep = create ctx rep in ctx , req , rep ) ( fun ( _ , req , rep ) rep -> let endpoint = " inproc :// endpoint " in bind rep endpoint ; connect req endpoint ; send req " request " ; let msg = recv rep in assert_equal " request " msg ; send rep " reply " ; let msg = recv req in assert_equal " reply " msg ) ( fun ( ctx , req , rep ) rep -> close req ; close rep ; Zmq . Context . terminate ctx ) ) ; " request reply ( multi - part ) part " >:: ( bracket ( fun ( ) -> let ctx = Zmq . Context . create ( ) in let req = create ctx req in let rep = create ctx rep in ctx , req , rep ) ( fun ( _ , req , rep ) rep -> let endpoint = " inproc :// endpoint " in bind rep endpoint ; connect req endpoint ; send_all req [ " request " ; " and more ] " ; let msg = recv_all rep in assert_equal [ " request " ; " and more ] " msg ; send_all rep [ " reply " ; " and more ] " ; let msg = recv_all req in assert_equal [ " reply " ; " and more ] " msg ) ( fun ( ctx , req , rep ) rep -> close req ; close rep ; Zmq . Context . terminate ctx ) ) ; " poll " >:: ( bracket ( fun ( ) -> let ctx = Zmq . Context . create ( ) in let req = create ctx req in let rep = create ctx rep in let sub = create ctx sub in ctx , req , rep , sub ) ( fun ( _ , req , rep , sub ) sub -> let endpoint = " inproc :// endpoint " in bind rep endpoint ; connect req endpoint ; subscribe sub " " ; let mask = of_masks [ | Poll . mask_in_out req ; Poll . mask_in_out rep ; Poll . mask_in_out sub ] | in assert_equal [ | Some Out ; None ; None ] | ( poll ~ timeout : 1000 mask ) mask ; send req " request " ; assert_equal [ | None ; Some In ; None ] | ( poll ~ timeout : 1000 mask ) mask ; let msg = recv ~ block : false rep in assert_equal " request " msg ; send rep " reply " ; assert_equal [ | Some In ; None ; None ] | ( poll ~ timeout : 1000 mask ) mask ; let msg = recv req in assert_equal " reply " msg ; ) ( fun ( ctx , req , rep , sub ) sub -> close req ; close rep ; close sub ; Zmq . Context . terminate ctx ; ) ) ; " get / set context options " >:: test_ctx_options ; " get / set socket options " >:: test_socket_options ; " proxy " >:: test_proxy ; " monitor " >:: test_monitor ; " z85 encoding / decoding " >:: test_z85 ; " unix exceptions " >:: test_unix_exceptions ; " zmq exceptions " >:: test_zmq_exception ; ]

module type ZN = sig type t include S . B58_DATA with type t := t include S . ENCODER with type t := t val zero : t val one : t val n : Z . t val ( + ) : t -> t -> t val ( * ) : t -> t -> t val ( - ) : t -> t -> t val ( = ) : t -> t -> bool val of_int : int -> t val of_Z : Z . t -> t val to_Z : t -> Z . t val of_bits_exn : String . t -> t val to_bits : t -> String . t val pow : t -> Z . t -> t val inv : t -> t option end

module type INT = sig val n : Z . t end

module MakeZn ( N : INT ) ( B : sig val b58_prefix : string end ) : ZN = struct type t = Z . t let n = N . n let max_char_length = 2 * Z . numbits n let zero = Z . zero let one = Z . one let of_Z r = Z . ( erem r n ) let to_Z a = a let of_int u = u |> Z . of_int |> of_Z let to_bits h = h |> Zplus . serialize |> fun s -> String . sub s 0 ( String . length s - 1 ) let of_bits_exn bits = if Compare . Int . ( String . length bits > max_char_length ) then failwith " input too long " else let x = Zplus . deserialize bits in if Zplus . ( x < zero || x >= N . n ) then failwith " out of range " else of_Z x let pow a x = Z . powm a Z . ( erem x ( sub n one ) ) n let ( + ) x y = Z . ( erem ( add x y ) n ) let ( * ) x y = Z . ( erem ( mul x y ) n ) let ( - ) x y = Z . ( erem ( sub x y ) n ) let ( = ) x y = Z . equal x y let inv a = Zplus . invert a n let title = Format . sprintf " Znz . Make ( % s ) " ( Z . to_string N . n ) let name = Format . sprintf " An element of Z / nZ for n = % s " ( Z . to_string N . n ) type Base58 . data += Data of t let b58check_encoding = Base58 . register_encoding ~ prefix : B . b58_prefix ~ length : 32 ~ to_raw : to_bits ~ of_raw ( : fun s -> Option . catch ( fun ( ) -> of_bits_exn s ) ) ~ wrap ( : fun x -> Data x ) include Helpers . MakeB58 ( struct type nonrec t = t let name = name let b58check_encoding = b58check_encoding end ) include Helpers . MakeEncoder ( struct type nonrec t = t let name = name let title = title let raw_encoding = Data_encoding . ( conv to_bits of_bits_exn string ) let to_b58check = to_b58check let to_short_b58check = to_short_b58check let of_b58check = of_b58check let of_b58check_opt = of_b58check_opt let of_b58check_exn = of_b58check_exn end ) end

module Stable = struct module Full_data = struct module V1 = struct module Index = struct type t = int let next = Int . succ let prev = Int . pred let before_first_transition = - 1 let to_external t = max 0 t let of_external ( _ : t ) = - 1 include Binable . Of_binable_without_uuid [ @ alert " - legacy " ] ( Int ) ( struct type t = int let to_binable = to_external let of_binable = of_external end ) include Sexpable . Of_sexpable ( Int ) ( struct type t = int let to_sexpable = to_external let of_sexpable = of_external end ) end module Regime = struct type t = { utc_offset_in_seconds : Int63 . Stable . V1 . t ; is_dst : bool ; abbrv : string } [ @@ deriving bin_io , sexp ] end module Leap_second = struct type t = { time_in_seconds_since_epoch : Int63 . Stable . V1 . t ; seconds : int } [ @@ deriving bin_io , sexp ] end module Transition = struct type t = { start_time_in_seconds_since_epoch : Int63 . Stable . V1 . t ; new_regime : Regime . t } [ @@ deriving bin_io , sexp ] end type t = { name : string ; original_filename : string option ; digest : Md5 . As_binary_string . t option ; transitions : Transition . t array ; mutable last_regime_index : Index . t ; default_local_time_type : Regime . t ; leap_seconds : Leap_second . t list } [ @@ deriving bin_io , sexp ] let compare t1 t2 = String . compare t1 . name t2 . name let original_filename zone = zone . original_filename let digest zone = zone . digest module Zone_file : sig val input_tz_file : zonename : string -> filename : string -> t end = struct let bool_of_int i = i <> 0 let input_long_as_int32 = let long = Bytes . create 4 in let int32_of_char chr = Int32 . of_int_exn ( int_of_char chr ) in fun ic -> In_channel . really_input_exn ic ~ buf : long ~ pos : 0 ~ len : 4 ; let sb1 = Int32 . shift_left ( int32_of_char ( Bytes . get long 0 ) ) 24 in let sb2 = Int32 . shift_left ( int32_of_char ( Bytes . get long 1 ) ) 16 in let sb3 = Int32 . shift_left ( int32_of_char ( Bytes . get long 2 ) ) 8 in let sb4 = int32_of_char ( Bytes . get long 3 ) in Int32 . bit_or ( Int32 . bit_or sb1 sb2 ) ( Int32 . bit_or sb3 sb4 ) ; ; let input_long_as_int ic = Int32 . to_int_exn ( input_long_as_int32 ic ) let input_long_as_int63 ic = Int63 . of_int32 ( input_long_as_int32 ic ) let input_long_long_as_int63 ic = let int63_of_char chr = Int63 . of_int_exn ( int_of_char chr ) in let shift c bits = Int63 . shift_left ( int63_of_char c ) bits in let long_long = Bytes . create 8 in In_channel . really_input_exn ic ~ buf : long_long ~ pos : 0 ~ len : 8 ; let result = shift ( Bytes . get long_long 0 ) 56 in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 1 ) 48 ) in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 2 ) 40 ) in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 3 ) 32 ) in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 4 ) 24 ) in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 5 ) 16 ) in let result = Int63 . bit_or result ( shift ( Bytes . get long_long 6 ) 8 ) in let result = Int63 . bit_or result ( int63_of_char ( Bytes . get long_long 7 ) ) in result ; ; let input_list ic ~ len ~ f = let rec loop c lst = if c > 0 then loop ( c - 1 ) ( f ic :: lst ) else List . rev lst in loop len [ ] ; ; let input_array ic ~ len ~ f = Array . of_list ( input_list ic ~ len ~ f ) let input_regime ic = let utc_offset_in_seconds = input_long_as_int63 ic in let is_dst = bool_of_int ( Option . value_exn ( In_channel . input_byte ic ) ) in let abbrv_index = Option . value_exn ( In_channel . input_byte ic ) in let lt abbrv = { Regime . utc_offset_in_seconds ; is_dst ; abbrv } in lt , abbrv_index ; ; let input_abbreviations ic ~ len = let raw_abbrvs = input_list ic ~ len ~ f ( : fun ic -> Option . value_exn ( In_channel . input_char ic ) ) in let buf = Buffer . create len in let _ , indexed_abbrvs = List . fold raw_abbrvs ~ init ( : 0 , Map . Poly . empty ) ~ f ( : fun ( index , abbrvs ) c -> match c with | ' \ 000 ' -> let data = Buffer . contents buf in let next_index = index + String . length data + 1 in let abbrvs = Map . set abbrvs ~ key : index ~ data in Buffer . clear buf ; next_index , abbrvs | c -> Buffer . add_char buf c ; index , abbrvs ) in if Buffer . length buf <> 0 then raise ( Invalid_file_format " missing \ 000 terminating character in input_abbreviations " ) ; indexed_abbrvs ; ; let input_tz_file_gen ~ input_transition ~ input_leap_second ic = let utc_local_count = input_long_as_int ic in let std_wall_count = input_long_as_int ic in let leap_count = input_long_as_int ic in let transition_count = input_long_as_int ic in let type_count = input_long_as_int ic in let abbrv_char_count = input_long_as_int ic in let transition_times = input_list ic ~ f : input_transition ~ len : transition_count in let transition_indices = input_list ic ~ f ( : fun ic -> Option . value_exn ( In_channel . input_byte ic ) ) ~ len : transition_count in let regimes = input_list ic ~ f : input_regime ~ len : type_count in let abbreviations = input_abbreviations ic ~ len : abbrv_char_count in let leap_seconds = input_list ic ~ f : input_leap_second ~ len : leap_count in let _std_wall_indicators = input_array ic ~ len : std_wall_count ~ f ( : fun ic -> bool_of_int ( Option . value_exn ( In_channel . input_byte ic ) ) ) in let _utc_local_indicators = input_array ic ~ len : utc_local_count ~ f ( : fun ic -> bool_of_int ( Option . value_exn ( In_channel . input_byte ic ) ) ) in let regimes = Array . of_list ( List . map regimes ~ f ( : fun ( lt , abbrv_index ) -> let abbrv = Map . find_exn abbreviations abbrv_index in lt abbrv ) ) in let raw_transitions = List . map2_exn transition_times transition_indices ~ f ( : fun time index -> let regime = regimes . ( index ) in time , regime ) in let transitions = let rec make_transitions acc l = match l with | [ ] -> Array . of_list ( List . rev acc ) | ( start_time_in_seconds_since_epoch , new_regime ) :: rest -> make_transitions ( { Transition . start_time_in_seconds_since_epoch ; new_regime } :: acc ) rest in make_transitions [ ] raw_transitions in let default_local_time_type = match Array . find regimes ~ f ( : fun r -> not r . Regime . is_dst ) with | None -> regimes . ( 0 ) | Some ltt -> ltt in fun name ~ original_filename ~ digest -> { name ; original_filename = Some original_filename ; digest = Some digest ; transitions ; last_regime_index = Index . before_first_transition ; default_local_time_type ; leap_seconds } ; ; let input_leap_second_gen ~ input_leap_second ic = let time_in_seconds_since_epoch = input_leap_second ic in let seconds = input_long_as_int ic in { Leap_second . time_in_seconds_since_epoch ; seconds } ; ; let read_header ic = let magic = let buf = Bytes . create 4 in In_channel . really_input_exn ic ~ buf ~ pos : 0 ~ len : 4 ; Bytes . unsafe_to_string ~ no_mutation_while_string_reachable : buf in if not ( String . equal magic " TZif " ) then raise ( Invalid_file_format " magic characters TZif not present " ) ; let version = match In_channel . input_char ic with | Some ' \ 000 ' -> ` V1 | Some ' 2 ' -> ` V2 | Some ' 3 ' -> ` V3 | None -> raise ( Invalid_file_format " expected version , found nothing " ) | Some bad_version -> raise ( Invalid_file_format ( sprintf " version ( % c ) is invalid " bad_version ) ) in In_channel . really_input_exn ic ~ buf ( : Bytes . create 15 ) ~ pos : 0 ~ len : 15 ; version ; ; let input_tz_file_v1 ic = let input_leap_second = input_leap_second_gen ~ input_leap_second : input_long_as_int63 in input_tz_file_gen ~ input_transition : input_long_as_int63 ~ input_leap_second ic ; ; let input_tz_file_v2_or_v3 ~ version ic = let ( _ : string -> original_filename : string -> digest : Md5_lib . t -> t ) = input_tz_file_v1 ic in assert ( [ % compare . equal : [ ` V1 | ` V2 | ` V3 ] ] ( read_header ic ) version ) ; let input_leap_second = input_leap_second_gen ~ input_leap_second : input_long_long_as_int63 in input_tz_file_gen ~ input_transition : input_long_long_as_int63 ~ input_leap_second ic ; ; let input_tz_file ~ zonename ~ filename = try protectx ( In_channel . create filename ) ~ finally : In_channel . close ~ f ( : fun ic -> let make_zone = match read_header ic with | ` V1 -> input_tz_file_v1 ic | ( ` V2 | ` V3 ) as version -> input_tz_file_v2_or_v3 ~ version ic in let digest = Md5 . digest_file_blocking filename in let r = make_zone zonename ~ original_filename : filename ~ digest in r ) with | Invalid_file_format reason -> raise ( Invalid_file_format ( sprintf " % s - % s " filename reason ) ) ; ; end let of_utc_offset ~ hours : offset = assert ( offset >= - 24 && offset <= 24 ) ; let name = if offset = 0 then " UTC " else sprintf " UTC % s % d " ( if offset < 0 then " " - else " " ) + ( abs offset ) in let utc_offset_in_seconds = Int63 . of_int ( offset * 60 * 60 ) in { name ; original_filename = None ; digest = None ; transitions = [ ] || ; last_regime_index = Index . before_first_transition ; default_local_time_type = { Regime . utc_offset_in_seconds ; is_dst = false ; abbrv = name } ; leap_seconds = [ ] } ; ; end end end

let sexp_of_t t = Sexp . Atom t . name

let likely_machine_zones = ref [ " America / New_York " ; " Europe / London " ; " Asia / Hong_Kong " ; " America / Chicago " ] ; ;

let utc = of_utc_offset ~ hours : 0

let name zone = zone . name

let reset_transition_cache t = t . last_regime_index <- Index . before_first_transition

let get_regime_exn t index = if index < 0 then t . default_local_time_type else t . transitions . ( index ) . new_regime ; ;

module Mode = struct type t = | Absolute | Date_and_ofday end