Datasets:
AllenGeng
/
ocamlgithub

Dataset card Data Studio Files Community
text
stringlengths
12
786k
let ceil_div a b = 1 + ( a - 1 ) / b
let _BRANCHING = 1 lsl _BITS
let _SKIP_SIZE = _BRANCHING - ceil_div _EXTRA_STEPS 2
let check_depth = let max_depth = if Sys . int_size = 31 then 6 else 12 in fun d -> if d > max_depth then failwith " clarity - vector - too - large "
type ' a t = | Leaf of ' a array | R_node of int array * ' a t array | B_node of ' a t array
let depth x = let rec loop : type a . int -> a t -> int = fun a -> function | Leaf _ -> a | R_node ( _ , n ) | B_node n -> assert ( Arr . len n > 0 ) ; loop ( a + 1 ) ( Arr . get n 0 ) in loop 0 x
let rec length = function | Leaf x -> Arr . len x | R_node ( i , v ) -> assert ( Arr . len i = Arr . len v ) ; Arr . get i ( Arr . len i - 1 ) | B_node v as node -> assert ( Arr . len v > 0 ) ; let d = depth node in check_depth d ; let item_sz = 1 lsl ( d * _BITS ) in item_sz * ( Arr . len v - 1 ) + length ( Arr . get v ( Arr . len v - 1 ) )
let update_lengths = function | Leaf _ | B_node _ -> ( ) | R_node ( is , vs ) -> assert ( Arr . len is = Arr . len vs ) ; let sum = ref 0 in for i = 0 to Arr . len vs - 1 do sum := ! sum + length ( Arr . get vs i ) ; Arr . set is i ! sum done
let mk_rnode arr = let res = R_node ( Arr . make ( Arr . len arr ) 0 , arr ) in update_lengths res ; res
let rr_search : int array -> int -> int -> int * int = fun sizes depth idx -> assert ( Arr . len sizes > 0 ) ; assert ( idx <= Arr . get sizes ( Arr . len sizes - 1 ) ) ; check_depth depth ; let start = idx lsr ( _BITS * depth ) in assert ( start < Arr . len sizes ) ; let rec loop n = assert ( n < Arr . len sizes ) ; let sz = Arr . get sizes n in if sz > idx then n else loop ( n + 1 ) in let slot = loop start in let new_idx = if slot = 0 then idx else idx - Arr . get sizes ( slot - 1 ) in slot , new_idx
let radix_search : int -> int -> int * int = fun depth idx -> check_depth depth ; let shift = _BITS * depth in let slot = idx lsr shift in slot , idx - slot lsl shift
let max_nodes_allowed subnodes = _EXTRA_STEPS + ( subnodes - 1 ) / _BRANCHING + 1
let empty = Leaf [ ] ||
let get_leaf = function | Leaf x -> x | _ -> assert false
let get_rnode = function | R_node ( i , v ) -> i , v | B_node v -> let sizes = Arr . make ( Arr . len v ) 0 in update_lengths ( R_node ( sizes , v ) ) ; sizes , v | _ -> assert false
let get_bnode = function | B_node x -> x | _ -> assert false
let node_len : type a . a t -> int = function | Leaf x -> Arr . len x | R_node ( _ , x ) | B_node x -> Arr . len x
module Concatenation = struct let assign_subnode_lengths : type a . a t AP . t -> int AP . t -> unit = fun src dst -> let dst_idx = ref 0 in let src_idx = ref 0 in let size = ref 0 in let not_done = let need = AP . len src - AP . len dst in fun ( ) -> let need = if ! size = 0 then need else need + 1 in let diff = ! src_idx - ! dst_idx in assert ( diff <= need ) ; diff <> need in let get ( ) = assert ( ! src_idx < AP . len src ) ; let res = AP . get src ! src_idx in incr src_idx ; res in let push ( i : int ) = assert ( ! dst_idx < AP . len dst ) ; match ( ) with | _ when i >= _SKIP_SIZE && ! size = 0 -> incr dst_idx | _ when ! size + i > _BRANCHING && ! size < _SKIP_SIZE -> AP . set dst ! dst_idx _BRANCHING ; incr dst_idx ; size := ! size + i - _BRANCHING | _ when ! size + i > _BRANCHING -> AP . set dst ! dst_idx ! size ; incr dst_idx ; size := i | _ -> size := ! size + i in while not_done ( ) do push ( node_len ( get ( ) ) ) done ; if ! size <> 0 then begin AP . set dst ! dst_idx ! size ; incr dst_idx end let copy_subnode_data : type a . a t AP . t -> a t AP . t -> int AP . t -> unit = fun ( lnodes , _ as src_v ) dst_v lengths -> let ( copy_to_node : a t -> int -> a t -> int -> int -> unit ) , ( new_node : int -> a t ) = assert ( Arr . len lnodes > 0 ) ; match Arr . get lnodes 0 with | Leaf x -> assert ( Arr . len x > 0 ) ; ( fun src src_off dst -> Arr . blit ( get_leaf src ) src_off ( get_leaf dst ) ) , fun n -> Leaf ( Arr . make n ( Arr . get x 0 ) ) | node -> let l , x = get_rnode node in assert ( Arr . len l = Arr . len x ) ; assert ( Arr . len x > 0 ) ; ( fun src src_off dst -> let dst_ = snd ( get_rnode dst ) in let src_ = snd ( get_rnode src ) in Arr . blit src_ src_off dst_ ) , fun n -> R_node ( Arr . make n ( Arr . get l 0 ) , Arr . make n ( Arr . get x 0 ) ) in let src_idx = ref 0 in let src_off = ref 0 in for i = 0 to AP . len lengths - 1 do let new_len = AP . get lengths i in if new_len = 0 then ( assert ( ! src_off = 0 ) ; AP . set dst_v i ( AP . get src_v ! src_idx ) ; incr src_idx ; ) else ( let nn = new_node new_len in let rec loop = function | n when n = new_len -> ( ) | nn_off -> let src_node = AP . get src_v ! src_idx in let sz = min ( new_len - nn_off ) ( node_len src_node - ! src_off ) in copy_to_node src_node ! src_off nn nn_off sz ; src_off := ! src_off + sz ; if ! src_off = node_len src_node then ( src_off := 0 ; incr src_idx ) ; loop ( nn_off + sz ) in loop 0 ; AP . set dst_v i nn ) done let compute_indices : type a . a t array -> int array -> int array -> unit = fun xv xi lengths -> assert ( Arr . len xv = Arr . len xi ) ; assert ( Arr . len xv = Arr . len lengths ) ; let sum = ref 0 in for i = 0 to Arr . len lengths - 1 do let len = Arr . get lengths i in let node = Arr . get xv i in if len <> 0 then update_lengths node ; sum := ! sum + length node ; Arr . set xi i ! sum done let merge : ' a t -> ' a t -> ' a t = fun l r -> let _ , lv = get_rnode l in let _ , rv = get_rnode r in assert ( Arr . len lv > 0 ) ; let nodes = Arr . len lv + Arr . len rv in let subnodes = let sum a x = a + node_len x in Arr . foldl sum ( Arr . foldl sum 0 lv ) rv in let max_nodes = max_nodes_allowed subnodes in if max_nodes >= nodes then mk_rnode ( if node_len r = 0 then [ | l ] | else [ | l ; r ] ) | else begin let len_l , len_r = if max_nodes <= _BRANCHING then max_nodes , 0 else _BRANCHING , max_nodes - _BRANCHING in let length_l = Arr . make len_l 0 in let length_r = Arr . make len_r 0 in let lengths = length_l , length_r in assign_subnode_lengths ( lv , rv ) lengths ; let node_l = Arr . make len_l empty in let node_r = Arr . make len_r empty in let new_nodes = node_l , node_r in copy_subnode_data ( lv , rv ) new_nodes lengths ; compute_indices node_l length_l length_l ; compute_indices node_r length_r length_r ; let lres = R_node ( fst lengths , fst new_nodes ) in let res = if len_r = 0 then [ | lres ] | else let rres = R_node ( snd lengths , snd new_nodes ) in [ | lres ; rres ] | in mk_rnode res end let leftmost = function | R_node ( _ , x ) | B_node x -> Arr . get x 0 | Leaf _ -> assert false let rightmost = function | R_node ( _ , x ) | B_node x -> Arr . get x ( Arr . len x - 1 ) | Leaf _ -> assert false let rec append_same : type a . a t -> a t -> int -> a t = fun l r n -> assert ( depth l = n ) ; assert ( depth r = n ) ; match n with | 0 -> assert ( node_len l > 0 ) ; assert ( node_len r > 0 ) ; ( match l , r with | Leaf _ , Leaf _ -> ( ) | _ -> assert false ) ; mk_rnode [ | l ; r ] | | 1 -> merge l r | n -> let _ , lv = get_rnode l in let _ , rv = get_rnode r in assert ( Arr . len lv > 0 ) ; assert ( Arr . len rv > 0 ) ; let intermediate = append_same ( rightmost l ) ( leftmost r ) ( n - 1 ) in let _ , iv = get_rnode intermediate in let overall = node_len l + node_len r - 2 + node_len intermediate in let ll , lr = if overall > _BRANCHING then _BRANCHING , overall - _BRANCHING else overall , 0 in let lnode = Arr . make ll empty in let rnode = Arr . make lr empty in let ap = lnode , rnode in let idx = ref 0 in for i = 0 to Arr . len lv - 2 do AP . set ap ! idx ( Arr . get lv i ) ; incr idx done ; for i = 0 to Arr . len iv - 1 do AP . set ap ! idx ( Arr . get iv i ) ; incr idx done ; for i = 1 to Arr . len rv - 1 do AP . set ap ! idx ( Arr . get rv i ) ; incr idx done ; let l = R_node ( Arr . make ll 0 , lnode ) in let r = R_node ( Arr . make lr 0 , rnode ) in update_lengths l ; update_lengths r ; merge l r let append : type a . a t -> a t -> a t = fun l r -> match l , r with | Leaf [ ] , || x | x , Leaf [ ] || -> x | _ -> let dl = depth l in let dr = depth r in let rec add_layers x = function | 0 -> x | n -> add_layers ( mk_rnode [ | x ] ) | ( n - 1 ) in let res = match ( ) with | _ when dl = dr -> append_same l r dl | _ when dl < dr -> append_same ( add_layers l ( dr - dl ) ) r dr | _ -> append_same l ( add_layers r ( dl - dr ) ) dl in match res with | R_node ( _ , vs ) when Arr . len vs = 1 -> Arr . get vs 0 | _ -> res end
let cons x v = append ( Leaf [ | x ] ) | v
let snoc v x = append v ( Leaf [ | x ] ) |
let check_bounds n index = let size = length n in if size - 1 < index || index < 0 then raise ( Out_of_bounds { index ; size } )
let get : type a . a t -> int -> a = fun n i -> check_bounds n i ; let rec loop n i = function | 0 -> Arr . get ( get_leaf n ) i | d -> begin match n with | Leaf _ -> assert false | R_node ( is , vs ) -> let slot , new_i = rr_search is d i in loop ( Arr . get vs slot ) new_i ( d - 1 ) | B_node vs -> let slot , new_i = radix_search d i in loop ( Arr . get vs slot ) new_i ( d - 1 ) end in loop n i ( depth n )
let update : type a . a t -> int -> a -> a t = fun n i x -> check_bounds n i ; let rec loop n i = function | 0 -> let res = Arr . copy ( get_leaf n ) in Arr . set res i x ; Leaf res | d -> begin match n with | Leaf _ -> assert false | R_node ( is , vs ) -> let slot , new_i = rr_search is d i in let upd = loop ( Arr . get vs slot ) new_i ( d - 1 ) in let res = Arr . copy vs in Arr . set res slot upd ; R_node ( is , res ) | B_node vs -> let slot , new_i = radix_search d i in let upd = loop ( Arr . get vs slot ) new_i ( d - 1 ) in let res = Arr . copy vs in Arr . set res slot upd ; B_node res end in loop n i ( depth n )
let split_at : type a . a t -> int -> a t * a t = fun n i -> let size = length n in if i < 0 then raise ( Out_of_bounds { index = i ; size } ) ; let rec loop n i = function | 0 -> begin match i with | 0 -> None , Some n | i when node_len n = i -> Some n , None | i -> let a = get_leaf n in let al = Arr . make i ( Arr . get a 0 ) in let ar = Arr . make ( Arr . len a - i ) ( Arr . get a i ) in Arr . blit a 1 al 1 ( i - 1 ) ; Arr . blit a ( i + 1 ) ar 1 ( Arr . len a - i - 1 ) ; Some ( Leaf al ) , Some ( Leaf ar ) end | d -> begin match n with | Leaf _ -> assert false | node when i = 0 -> None , Some node | node when i >= length node -> Some node , None | node -> let is , vs = get_rnode node in assert ( Arr . len is = Arr . len vs ) ; assert ( Arr . len is > 0 ) ; let slot , new_i = rr_search is d i in let l , r = loop ( Arr . get vs slot ) new_i ( d - 1 ) in let len_l = if l = None then slot else slot + 1 in let len_r = Arr . len vs - if r = None then slot + 1 else slot in let nl = Some ( let lv = Arr . make len_l ( Arr . get vs 0 ) in for j = 1 to slot - 1 do Arr . set lv j ( Arr . get vs j ) done ; begin match l with | None -> ( ) | Some x -> Arr . set lv slot x end ; mk_rnode lv ) in let nr = Some ( let rv = Arr . make len_r ( Arr . get vs 0 ) in begin match r with | None -> for j = 0 to len_r - 1 do Arr . set rv j ( Arr . get vs ( j + slot ) ) done | Some x -> Arr . set rv 0 x ; for j = 1 to len_r - 1 do Arr . set rv j ( Arr . get vs ( j + slot ) ) done end ; mk_rnode rv ) in nl , nr end in let l , r = loop n i ( depth n ) in let get = function | Some x -> x | None -> empty in get l , get r
let take : type a . a t -> int -> a t = fun n i -> let sz = length n in fst ( split_at n ( if i > sz then sz else i ) )
let drop : type a . a t -> int -> a t = fun n i -> let sz = length n in snd ( split_at n ( if i > sz then sz else i ) )
let rec iter f = function | Leaf x -> Arr . iter f x | R_node ( _ , x ) | B_node x -> Arr . iter ( iter f ) x
module Builder = struct type ' a vector = ' a t type ' a chunk = { mutable cnt : int ; vec : ' a vector } type ' a t = ' a chunk list ref let copy : ' a t -> ' a t = fun x -> match ! x with | [ ] -> ref [ ] | { cnt ; vec } :: t -> ref ( { cnt = cnt ; vec = vec } :: t ) let rec push_node n ( x : ' a t ) : unit = match ! x with | [ ] -> x := [ { cnt = 1 ; vec = B_node ( Arr . make _BRANCHING n ) } ] | { cnt ; vec = B_node arr } as h :: _ when cnt < _BRANCHING -> Arr . set arr cnt n ; h . cnt <- cnt + 1 | { cnt ; vec } :: t -> assert ( cnt = _BRANCHING ) ; let tail = ref t in push_node vec tail ; x := { cnt = 1 ; vec = B_node ( Arr . make _BRANCHING n ) } :: ! tail let put ( x : ' a t ) e : unit = match ! x with | [ ] -> x := [ { cnt = 1 ; vec = Leaf ( Arr . make _BRANCHING e ) } ] | { cnt ; vec = Leaf arr } as h :: _ when cnt < _BRANCHING -> Arr . set arr cnt e ; h . cnt <- cnt + 1 | { cnt ; vec } :: t -> assert ( cnt = _BRANCHING ) ; let tail = ref t in push_node vec tail ; x := { cnt = 1 ; vec = Leaf ( Arr . make _BRANCHING e ) } :: ! tail let rec result ( x : ' a t ) : ' a vector = let realloc_array a n = assert ( Arr . len a > n ) ; let res = Arr . make n ( Arr . get a 0 ) in for i = 1 to n - 1 do Arr . set res i ( Arr . get a i ) done ; res in let realloc = function | { cnt ; vec } when cnt = _BRANCHING -> vec | { cnt ; vec = Leaf x } -> Leaf ( realloc_array x cnt ) | { cnt ; vec = B_node x } -> B_node ( realloc_array x cnt ) | _ -> assert false in match ! x with | [ ] -> empty | [ x ] -> realloc x | h :: t -> let tail = ref t in push_node ( realloc h ) tail ; result tail let empty ( ) = ref [ ] let clear b = b := [ ] end
let init : type a . int -> ( int -> a ) -> a t = fun l f -> let b = Builder . empty ( ) in for i = 1 to l do Builder . put b ( f i ) done ; Builder . result b type nonrec ' a t = ' a t let pure x = Leaf [ | x ] | let bind f x = let b = Builder . empty ( ) in iter ( fun y -> iter ( Builder . put b ) ( f y ) ) x ; Builder . result b let ap f x = if f = empty then empty else let x = x ( ) in let b = Builder . empty ( ) in iter ( fun f -> iter ( Builder . put b % f ) x ) f ; Builder . result b let map f x = ap ( pure f ) ( const x ) end ) type nonrec ' a t = ' a t let rec foldl f a = function | Leaf x -> Arr . foldl f a x | R_node ( _ , x ) | B_node x -> Arr . foldl ( foldl f ) a x let rec foldr f a = function | Leaf x -> Arr . foldr f a x | R_node ( _ , x ) | B_node x -> Arr . foldr ( fun x a -> foldr f a x ) a x end )
let rec foldr ' f a = function | Leaf x -> Arr . foldr ' f a x | R_node ( _ , x ) | B_node x -> Arr . foldr ' ( fun x a -> foldr ' f a x ) a x
let to_list x = foldr ' Clarity_list . _Cons [ ] x
let of_list x = let b = Builder . empty ( ) in Clarity_list . iter ( Builder . put b ) x ; Builder . result b type nonrec ' a t = ' a t let align_as both left right a b = let la = length a in let lb = length b in let build = Builder . empty ( ) in for i = 0 to min la lb - 1 do Builder . put build ( both ( get a i ) ( get b i ) ) done ; if la > lb then for i = lb to la - 1 do Builder . put build @@ left ( get a i ) done else if la < lb then for i = la to lb - 1 do Builder . put build @@ right ( get b i ) done ; Builder . result build end )
module A3 ( A : Applicative . Basic3 ) = Traversable . Make3 ( struct type nonrec ' a t = ' a t type ( ' u , ' v , ' a ) f = ( ' u , ' v , ' a ) A . t module Ap = Applicative . Make3 ( A ) let traverse f x = let cf x l = let open ! Ap in ap ( map ( fun h t -> h :: t ) ( f x ) ) l in let ls = foldr cf ( defer Ap . pure [ ] ) x in Ap . map of_list ls let traverse_ f = foldr ( Ap . discard_left % f ) ( defer Ap . pure ( ) ) end )
module A2 ( A : Applicative . Basic2 ) = A3 ( struct type ( _ , ' p , ' a ) t = ( ' p , ' a ) A . t include ( A : Applicative . Basic2 with type ( ' p , ' a ) t := ( ' p , ' a ) A . t ) end )
module A ( A : Applicative . Basic ) = A2 ( struct type ( _ , ' a ) t = ' a A . t include ( A : Applicative . Basic with type ' a t := ' a A . t ) end )
module M3 ( M : Monad . Basic3 ) = struct include A3 ( M ) let foldr_m f a l = let g k x z = M . bind k ( f x z ) in foldl g M . pure l a let foldl_m f a l = let g x k z = M . bind ( fun x -> k ( ) x ) ( f z x ) in foldr g ( const M . pure ) l a end
module M2 ( M : Monad . Basic2 ) = M3 ( struct type ( _ , ' p , ' a ) t = ( ' p , ' a ) M . t include ( M : Monad . Basic2 with type ( ' p , ' a ) t := ( ' p , ' a ) M . t ) end )
module M ( M : Monad . Basic ) = M2 ( struct type ( _ , ' a ) t = ' a M . t include ( M : Monad . Basic with type ' a t := ' a M . t ) end )
module type Vector_base = sig type t type elt type index val fold_index : ( index -> elt -> ' a ) -> ( ' a -> index -> elt -> ' a ) -> t -> ' a val fold_index_2 : ( index -> elt -> elt -> ' a ) -> ( ' a -> index -> elt -> elt -> ' a ) -> t -> t -> ' a val map : ( index -> elt -> elt ) -> t -> t end
module Vect2 = struct type t = float * float type elt = float type index = Fst | Snd let fold_index init f ( fst , snd ) = f ( init Fst fst ) Snd snd let fold_index_2 init f ( fst1 , snd1 ) ( fst2 , snd2 ) = f ( init Fst fst1 fst2 ) Snd snd1 snd2 let map f ( fst , snd ) = ( f Fst fst , f Snd snd ) end
module Vect3 = struct type t = float * float * float type elt = float type index = Fst | Snd | Trd let fold_index init f ( fst , snd , trd ) = f ( f ( init Fst fst ) Snd snd ) Trd trd let fold_index_2 init f ( fst1 , snd1 , trd1 ) ( fst2 , snd2 , trd2 ) = f ( f ( init Fst fst1 fst2 ) Snd snd1 snd2 ) Trd trd1 trd2 let map f ( fst , snd , trd ) = ( f Fst fst , f Snd snd , f Trd trd ) end
module Vect2_record = struct type t = { x : float ; y : float } type elt = float type index = X | Y let fold_index init f { x ; y } = f ( init X x ) Y y let fold_index_2 init f v1 v2 = f ( init X v1 . x v2 . x ) Y v1 . y v2 . y let map f { x ; y } = { x = f X x ; y = f Y y } end
module Vect3_record = struct type t = { x : float ; y : float ; z : float } type elt = float type index = X | Y | Z let fold_index init f { x ; y ; z } = f ( f ( init X x ) Y y ) Z z let fold_index_2 init f v1 v2 = f ( f ( init X v1 . x v2 . x ) Y v1 . y v2 . y ) Z v1 . z v2 . z let map f { x ; y ; z } = { x = f X x ; y = f Y y ; z = f Z z } end
module Vect_array = struct type t = float array type elt = float type index = int let fold_index init f a = if Array . length a = 0 then invalid_arg " fold_index " ; let r = ref ( init 0 ( Array . unsafe_get a 0 ) ) in for i = 1 to Array . length a - 1 do r := f ! r i ( Array . unsafe_get a i ) done ; ! r let fold_index_2 init f v1 v2 = if Array . length v1 = 0 || Array . length v2 = 0 || Array . length v1 <> Array . length v2 then invalid_arg " fold_index " ; let r = ref ( init 0 ( Array . unsafe_get v1 0 ) ( Array . unsafe_get v2 0 ) ) in for i = 1 to Array . length v1 - 1 do r := f ! r i ( Array . unsafe_get v1 i ) ( Array . unsafe_get v2 i ) done ; ! r let map = Array . mapi end
module Vector_operations ( V : Vector_base with type elt = float ) = struct type elt = V . elt type t = V . t let norm v = let sum_sq = V . fold_index ( fun _ elt -> elt . * elt ) ( fun acc _ elt -> acc . + elt . * elt ) v in sqrt sum_sq let scale s v = V . map ( fun _ x -> x . * s ) v let dot v1 v2 = V . fold_index_2 ( fun _ f1 f2 -> f1 . * f2 ) ( fun acc _ f1 f2 -> acc . + f1 . * f2 ) v1 v2 let are_orthogonal v1 v2 = dot v1 v2 = 0 . end
type step = { obs : Tensor . t ; reward : Tensor . t ; is_done : Tensor . t }
type t = { envs : Pytypes . pyobject ; np : Pytypes . pyobject }
let create str ~ num_processes = if not ( Py . is_initialized ( ) ) then ( Py . add_python_path " examples / reinforcement - learning " ; Py . initialize ( ) ) ; let wrappers = Py . import " atari_wrappers " in let envs = Py . Module . get_function wrappers " make " [ | Py . String . of_string str ; Py . Int . of_int num_processes ] | in let np = Py . import " numpy " in { envs ; np }
let to_tensor t np_array = let np_array = Py . Module . get_function t . np " ascontiguousarray " [ | np_array ] | in Py . Object . call_method np_array " astype " [ | Py . Module . get t . np " float32 " ] | |> Numpy . to_bigarray Float32 C_layout |> Tensor . of_bigarray |> Tensor . to_type ~ type_ ( : T Float )
let reset t = let reset_fn = Py . Object . get_attr_string t . envs " reset " in Py . Callable . to_function ( Option . value_exn reset_fn ) [ ] || |> to_tensor t
let step t ~ actions = let v = Py . Object . call_method t . envs " step " [ | Py . List . of_list_map Py . Int . of_int actions ] | in let obs , reward , is_done , _ = Py . Tuple . to_tuple4 v in { obs = to_tensor t obs ; reward = to_tensor t reward ; is_done = to_tensor t is_done }
let action_space t = let action_space = Option . value_exn ( Py . Object . get_attr_string t . envs " action_space " ) in Option . value_exn ( Py . Object . get_attr_string action_space " n " ) |> Py . Int . to_int
module type ResizeType = sig type t val null : t end
module type S = sig type elt type t val length : t -> int val compact : t -> unit val singleton : elt -> t val empty : unit -> t val make : int -> t val init : int -> ( int -> elt ) -> t val is_empty : t -> bool val of_sub_array : elt array -> int -> int -> t val unsafe_internal_array : t -> elt array val reserve : t -> int -> unit val push : t -> elt -> unit val delete : t -> int -> unit val pop : t -> unit val get_last_and_pop : t -> elt val delete_range : t -> int -> int -> unit val get_and_delete_range : t -> int -> int -> t val clear : t -> unit val reset : t -> unit val to_list : t -> elt list val of_list : elt list -> t val to_array : t -> elt array val of_array : elt array -> t val copy : t -> t val reverse_in_place : t -> unit val iter : t -> ( elt -> unit ) -> unit val iteri : t -> ( int -> elt -> unit ) -> unit val iter_range : t -> from : int -> to_ : int -> ( elt -> unit ) -> unit val iteri_range : t -> from : int -> to_ : int -> ( int -> elt -> unit ) -> unit val map : ( elt -> elt ) -> t -> t val mapi : ( int -> elt -> elt ) -> t -> t val map_into_array : ( elt -> ' f ) -> t -> ' f array val map_into_list : ( elt -> ' f ) -> t -> ' f list val fold_left : ( ' f -> elt -> ' f ) -> ' f -> t -> ' f val fold_right : ( elt -> ' g -> ' g ) -> t -> ' g -> ' g val filter : ( elt -> bool ) -> t -> t val inplace_filter : ( elt -> bool ) -> t -> unit val inplace_filter_with : ( elt -> bool ) -> cb_no ( : elt -> ' a -> ' a ) -> ' a -> t -> ' a val inplace_filter_from : int -> ( elt -> bool ) -> t -> unit val equal : ( elt -> elt -> bool ) -> t -> t -> bool val get : t -> int -> elt val unsafe_get : t -> int -> elt val last : t -> elt val capacity : t -> int val exists : ( elt -> bool ) -> t -> bool val sub : t -> int -> int -> t end
let err_argv = " argv array must have at least one element "
let err_not_opt = " Option argument without name "
let err_not_pos = " Positional argument with a name "
let err_help s = " Term error , help requested for unknown command " ^ s
let err_empty_list = " Empty list "
let err_incomplete_enum = " Incomplete enumeration for the type "
let err_doc_string s = str " Variable substitution failed on documentation fragment ` % s ' " s
let rev_compare n n ' = compare n ' n
let str_of_pp pp v = pp Format . str_formatter v ; Format . flush_str_formatter ( )
let quote s = str " ` % s ' " s
let alts_str ( ? quoted = true ) alts = let quote = if quoted then quote else ( fun s -> s ) in match alts with | [ ] -> invalid_arg err_empty_list | [ a ] -> ( quote a ) | [ a ; b ] -> str " either % s or % s " ( quote a ) ( quote b ) | alts -> let rev_alts = List . rev alts in str " one of % s or % s " ( String . concat " , " ( List . rev_map quote ( List . tl rev_alts ) ) ) ( quote ( List . hd rev_alts ) )
let pr_white_str spaces ppf s = let left = ref 0 and right = ref 0 and len = String . length s in let flush ( ) = Format . pp_print_string ppf ( String . sub s ! left ( ! right - ! left ) ) ; incr right ; left := ! right ; in while ( ! right <> len ) do if s . [ ! right ] = ' \ n ' then ( flush ( ) ; Format . pp_force_newline ppf ( ) ) else if spaces && s . [ ! right ] = ' ' then ( flush ( ) ; Format . pp_print_space ppf ( ) ) else incr right ; done ; if ! left <> len then flush ( )
let pr_text = pr_white_str true
let pr_lines = pr_white_str false
let pr_to_temp_file pr v = try let exec = Filename . basename Sys . argv . ( 0 ) in let file , oc = Filename . open_temp_file exec " out " in let ppf = Format . formatter_of_out_channel oc in pr ppf v ; Format . pp_print_flush ppf ( ) ; close_out oc ; at_exit ( fun ( ) -> try Sys . remove file with Sys_error e -> ( ) ) ; Some file
let levenshtein_distance s t = let minimum a b c = min a ( min b c ) in let m = String . length s in let n = String . length t in let d = Array . make_matrix ( m + 1 ) ( n + 1 ) 0 in for i = 0 to m do d . ( i ) . ( 0 ) <- i done ; for j = 0 to n do d . ( 0 ) . ( j ) <- j done ; for j = 1 to n do for i = 1 to m do if s . [ i - 1 ] = t . [ j - 1 ] then d . ( i ) . ( j ) <- d . ( i - 1 ) . ( j - 1 ) else d . ( i ) . ( j ) <- minimum ( d . ( i - 1 ) . ( j ) + 1 ) ( d . ( i ) . ( j - 1 ) + 1 ) ( d . ( i - 1 ) . ( j - 1 ) + 1 ) done ; done ; d . ( m ) . ( n )
let suggest s candidates = let add ( min , acc ) name = let d = levenshtein_distance s name in if d = min then min , ( name :: acc ) else if d < min then d , [ name ] else min , acc in let dist , suggs = List . fold_left add ( max_int , [ ] ) candidates in if dist < 3 then suggs else [ ]
module Trie : sig type ' a t val empty : ' a t val is_empty : ' a t -> bool val add : ' a t -> string -> ' a -> ' a t val find : ' a t -> string -> [ ` Ok of ' a | ` Ambiguous | ` Not_found ] val ambiguities : ' a t -> string -> string list val of_list : ( string * ' a ) list -> ' a t module Cmap = Map . Make ( Char ) type ' a value = | Pre of ' a | Key of ' a | Amb | Nil type ' a t = { v : ' a value ; succs : ' a t Cmap . t } let empty = { v = Nil ; succs = Cmap . empty } let is_empty t = t = empty let add t k d = let rec aux t k len i d pre_d = if i = len then { v = Key d ; succs = t . succs } else let v = match t . v with | Amb | Pre _ -> Amb | Key _ as v -> v | Nil -> pre_d in let succs = let t ' = try Cmap . find k . [ i ] t . succs with Not_found -> empty in Cmap . add k . [ i ] ( aux t ' k len ( i + 1 ) d pre_d ) t . succs in { v ; succs } in aux t k ( String . length k ) 0 d ( Pre d ) let find_node t k = let rec aux t k len i = if i = len then t else aux ( Cmap . find k . [ i ] t . succs ) k len ( i + 1 ) in aux t k ( String . length k ) 0 let find t k = try match ( find_node t k ) . v with | Key v | Pre v -> ` Ok v | Amb -> ` Ambiguous | Nil -> ` Not_found with Not_found -> ` Not_found let ambiguities t p = try let t = find_node t p in match t . v with | Key _ | Pre _ | Nil -> [ ] | Amb -> let add_char s c = s ^ ( String . make 1 c ) in let rem_char s = String . sub s 0 ( ( String . length s ) - 1 ) in let to_list m = Cmap . fold ( fun k t acc -> ( k , t ) :: acc ) m [ ] in let rec aux acc p = function | ( ( c , t ) :: succs ) :: rest -> let p ' = add_char p c in let acc ' = match t . v with | Pre _ | Amb -> acc | Key _ -> ( p ' :: acc ) | Nil -> assert false in aux acc ' p ' ( ( to_list t . succs ) :: succs :: rest ) | [ ] :: [ ] -> acc | [ ] :: rest -> aux acc ( rem_char p ) rest | [ ] -> assert false in aux [ ] p ( to_list t . succs :: [ ] ) with Not_found -> [ ] let of_list l = List . fold_left ( fun t ( s , v ) -> add t s v ) empty l end
type env_info = { env_var : string ; env_doc : string ; env_docs : string ; }
type absence = | Error | Val of string Lazy . t
type opt_kind = | Flag | Opt | Opt_vopt of string
type pos_kind = | All | Nth of bool * int | Left of bool * int | Right of bool * int
type arg_info = { id : int ; absent : absence ; env_info : env_info option ; doc : string ; docv : string ; docs : string ; p_kind : pos_kind ; o_kind : opt_kind ; o_names : string list ; o_all : bool ; }
let arg_id = let c = ref 0 in fun ( ) -> let id = ! c in incr c ; if id > ! c then assert false else id
let is_opt a = a . o_names <> [ ]
let is_pos a = a . o_names = [ ]
module Amap = Map . Make ( struct type t = arg_info let compare a a ' = compare a . id a ' . id end )
type arg = | O of ( int * string * ( string option ) ) list | P of string list
type cmdline = arg Amap . t
type man_block = [ | ` S of string | ` P of string | ` Pre of string | ` I of string * string | ` Noblank ]
type term_info = { name : string ; version : string option ; tdoc : string ; tdocs : string ; sdocs : string ; man : man_block list ; }
type eval_info = { term : term_info * arg_info list ; main : term_info * arg_info list ; choices : ( term_info * arg_info list ) list ; env : string -> string option }
let eval_kind ei = if ei . choices = [ ] then ` Simple else if ( fst ei . term ) == ( fst ei . main ) then ` M_main else ` M_choice
module Manpage = struct type title = string * int * string * string * string type block = man_block type t = title * block list let p_indent = 7 let l_indent = 4 let escape subst esc buf s = let subst s = let len = String . length s in if not ( len > 1 && s . [ 1 ] = ' , ' ) then ( subst s ) else if len = 2 then " " else esc s . [ 0 ] ( String . sub s 2 ( len - 2 ) ) in try Buffer . clear buf ; Buffer . add_substitute buf subst s ; let s = Buffer . contents buf in Buffer . clear buf ; Buffer . add_substitute buf subst s ; Buffer . contents buf with Not_found -> invalid_arg ( err_doc_string s ) let pr_tokens ( ? groff = false ) ppf s = let is_space = function ' ' | ' \ n ' | ' \ r ' | ' \ t ' -> true | _ -> false in let len = String . length s in let i = ref 0 in try while ( true ) do while ( ! i < len && is_space s . [ ! i ] ) do incr i done ; let start = ! i in if start = len then raise Exit ; while ( ! i < len && not ( is_space s . [ ! i ] ) && not ( s . [ ! i ] = ' ' ) ) - do incr i done ; pr_str ppf ( String . sub s start ( ! i - start ) ) ; if ! i = len then raise Exit ; if s . [ ! i ] = ' ' - then ( incr i ; if groff then pr_str ppf " " \\- else pr_char ppf ' ' ) ; - if ( ! i < len && is_space s . [ ! i ] ) then ( if groff then pr_char ppf ' ' else Format . pp_print_space ppf ( ) ) done with Exit -> ( ) let plain_esc c s = match c with ' g ' -> " " | _ -> s let pr_indent ppf c = for i = 1 to c do pr_char ppf ' ' done let pr_plain_blocks subst ppf ts = let buf = Buffer . create 1024 in let escape t = escape subst plain_esc buf t in let pr_tokens ppf t = pr_tokens ppf ( escape t ) in let rec aux = function | [ ] -> ( ) | t :: ts -> begin match t with | ` Noblank -> ( ) | ` P s -> pr ppf " % a [ @% a ] , " @@ pr_indent p_indent pr_tokens s | ` S s -> pr ppf " [ @% a ] " @ pr_tokens s | ` Pre s -> pr ppf " % a [ @% a ] , " @@ pr_indent p_indent pr_lines ( escape s ) | ` I ( label , s ) -> let label = escape label in let ll = String . length label in pr ppf " [ @% a [ @% a ] " @ pr_indent p_indent pr_tokens label ; if s = " " then ( ) else if ll < l_indent then pr ppf " % a [ @% a ] ] , " @@@ pr_indent ( l_indent - ll ) pr_tokens s else pr ppf " @\ n % a [ @% a ] ] , " @@@ pr_indent ( p_indent + l_indent ) pr_tokens s end ; begin match ts with | ` Noblank :: ts -> aux ts | ts -> Format . pp_print_cut ppf ( ) ; aux ts end in aux ts let pr_plain_page subst ppf ( _ , text ) = pr ppf " [ @< v >% a ] " @ ( pr_plain_blocks subst ) text let groff_esc c s = match c with | ' i ' -> ( str " \\ fI % s \\ fR " s ) | ' b ' -> ( str " \\ fB % s \\ fR " s ) | ' p ' -> " " | _ -> s let pr_groff_lines ppf s = let left = ref 0 and right = ref 0 and len = String . length s in let flush ( ) = Format . pp_print_string ppf ( String . sub s ! left ( ! right - ! left ) ) ; incr right ; left := ! right ; in while ( ! right <> len ) do if s . [ ! right ] = ' \ n ' then ( flush ( ) ; Format . pp_force_newline ppf ( ) ) else if s . [ ! right ] = ' ' - then ( flush ( ) ; pr_str ppf " " ) \\- else incr right ; done ; if ! left <> len then flush ( ) let pr_groff_blocks subst ppf text = let buf = Buffer . create 1024 in let escape t = escape subst groff_esc buf t in let pr_tokens ppf t = pr_tokens ~ groff : true ppf ( escape t ) in let pr_block = function | ` P s -> pr ppf " @\ n . P @\ n % a " pr_tokens s | ` Pre s -> pr ppf " @\ n . P @\ n . nf @\ n % a @\ n . fi " pr_groff_lines ( escape s ) | ` S s -> pr ppf " @\ n . SH % a " pr_tokens s | ` Noblank -> pr ppf " @\ n . sp - 1 " | ` I ( l , s ) -> pr ppf " @\ n . TP 4 @\ n % a @\ n % a " pr_tokens l pr_tokens s in List . iter pr_block text let pr_groff_page subst ppf ( ( n , s , a1 , a2 , a3 ) , t ) = pr ppf " . " \\\ Pipe this output to groff - man - Tutf8 | less @\ n \ . " \\\@\ n \ . TH " \% s " \ % d " \% s " \ " \% s " \ " \% s " \@\ n \ . " \\\ Disable hyphenation and ragged - right @\ n \ . nh @\ n \ . ad l \ % a " @? n s a1 a2 a3 ( pr_groff_blocks subst ) t let find_cmd cmds = let test , null = match Sys . os_type with | " Win32 " -> " where " , " NUL " | _ -> " type " , " / dev / null " in let cmd c = Sys . command ( str " % s % s 1 >% s 2 >% s " test c null null ) = 0 in try Some ( List . find cmd cmds ) with Not_found -> None let pr_to_pager print ppf v = let pager = let cmds = [ " less " ; " more " ] in let cmds = try ( Sys . getenv " PAGER " ) :: cmds with Not_found -> cmds in let cmds = try ( Sys . getenv " MANPAGER " ) :: cmds with Not_found -> cmds in find_cmd cmds in match pager with | None -> print ` Plain ppf v | Some pager -> let cmd = match ( find_cmd [ " groff " ; " nroff " ] ) with | None -> begin match pr_to_temp_file ( print ` Plain ) v with | None -> None | Some f -> Some ( str " % s < % s " pager f ) end | Some c -> begin match pr_to_temp_file ( print ` Groff ) v with | None -> None | Some f -> let xroff = if c = " groff " then c ^ " - Tascii - P - c " else c in Some ( str " % s - man < % s | % s " xroff f pager ) end in match cmd with | None -> print ` Plain ppf v | Some cmd -> if ( Sys . command cmd ) <> 0 then print ` Plain ppf v let rec print ( ? subst = fun x -> x ) fmt ppf page = match fmt with | ` Pager -> pr_to_pager ( print ~ subst ) ppf page | ` Plain -> pr_plain_page subst ppf page | ` Groff -> pr_groff_page subst ppf page end
module Help = struct let invocation ( ? sep = ' ' ) ei = match eval_kind ei with | ` Simple | ` M_main -> ( fst ei . main ) . name | ` M_choice -> str " % s % c % s " ( fst ei . main ) . name sep ( fst ei . term ) . name let title ei = let prog = String . capitalize ( fst ei . main ) . name in let name = String . uppercase ( invocation ~ sep ' ' :- ei ) in let left_footer = prog ^ match ( fst ei . main ) . version with | None -> " " | Some v -> str " % s " v in let center_header = str " % s Manual " prog in name , 1 , " " , left_footer , center_header let name_section ei = let tdoc d = if d = " " then " " else ( str " - % s " d ) in [ ` S " NAME " ; ` P ( str " % s % s " ( invocation ~ sep ' ' :- ei ) ( tdoc ( fst ei . term ) . tdoc ) ) ; ] let synopsis ei = match eval_kind ei with | ` M_main -> str " ( $ b , % s ) ( $ i , COMMAND ) . . . " ( invocation ei ) | ` Simple | ` M_choice -> let rev_cmp ( p , _ ) ( p ' , _ ) = match p ' , p with | p , All -> - 1 | All , p -> 1 | Left _ , Right _ -> - 1 | Right _ , Left _ -> 1 | Left ( false , k ) , Nth ( false , k ' ) | Nth ( false , k ) , Nth ( false , k ' ) | Nth ( false , k ) , Right ( false , k ' ) -> if k <= k ' then - 1 else 1 | Nth ( false , k ) , Left ( false , k ' ) | Right ( false , k ) , Nth ( false , k ' ) -> if k >= k ' then 1 else - 1 | Left ( true , k ) , Nth ( true , k ' ) | Nth ( true , k ) , Nth ( true , k ' ) | Nth ( true , k ) , Right ( true , k ' ) -> if k >= k ' then - 1 else 1 | Nth ( true , k ) , Left ( true , k ' ) | Right ( true , k ) , Nth ( true , k ' ) -> if k <= k ' then 1 else - 1 | p , p ' -> compare p p ' in let rec format_pos acc = function | a :: al -> if is_opt a then format_pos acc al else let v = if a . docv = " " then " ( $ i , ARG ) " else str " ( $ i , % s ) " a . docv in let v = if a . absent = Error then str " % s " v else str " [ % s ] " v in let v = v ^ match a . p_kind with Nth _ -> " " | _ -> " . . . " in format_pos ( ( a . p_kind , v ) :: acc ) al | [ ] -> acc in let args = List . sort rev_cmp ( format_pos [ ] ( snd ei . term ) ) in let args = String . concat " " ( List . rev_map snd args ) in str " ( $ b , % s ) [ ( $ i , OPTION ) ] . . . % s " ( invocation ei ) args let get_synopsis_section ei = let rec extract_synopsis syn = function | ` S _ :: _ as man -> List . rev syn , man | block :: rest -> extract_synopsis ( block :: syn ) rest | [ ] -> List . rev syn , [ ] in match ( fst ei . term ) . man with | ` S " SYNOPSIS " as s :: rest -> extract_synopsis [ s ] rest | man -> [ ` S " SYNOPSIS " ; ` P ( synopsis ei ) ; ] , man let or_env a = match a . env_info with | None -> " " | Some v -> str " or ( $ i , % s ) env " v . env_var let make_arg_label a = if is_pos a then str " ( $ i , % s ) " a . docv else let fmt_name var = match a . o_kind with | Flag -> fun n -> str " ( $ b , % s ) % s " n ( or_env a ) | Opt -> fun n -> if String . length n > 2 then str " ( $ b , % s ) ( =$ i , % s ) " n var else str " ( $ b , % s ) ( $ i , % s ) " n var | Opt_vopt _ -> fun n -> if String . length n > 2 then str " ( $ b , % s ) [ ( =$ i , % s ) ] " n var else str " ( $ b , % s ) [ ( $ i , % s ) ] " n var in let var = if a . docv = " " then " VAL " else a . docv in let names = List . sort compare a . o_names in let s = String . concat " , " ( List . rev_map ( fmt_name var ) names ) in s let arg_info_substs ~ buf a doc = let subst = function | " docv " -> str " ( $ i , % s ) " a . docv | " opt " when is_opt a -> let k = String . lowercase ( List . hd ( List . sort compare a . o_names ) ) in str " ( $ b , % s ) " k | " env " when a . env_info <> None -> begin match a . env_info with | None -> assert false | Some v -> str " ( $ i , % s ) " v . env_var end | s -> str " ( $% s ) " s in try Buffer . clear buf ; Buffer . add_substitute buf subst doc ; Buffer . contents buf with Not_found -> invalid_arg ( err_doc_string doc ) let make_arg_items ei = let buf = Buffer . create 200 in let cmp a a ' = let c = compare a . docs a ' . docs in if c <> 0 then c else match is_opt a , is_opt a ' with | true , true -> let key names = let k = String . lowercase ( List . hd ( List . sort rev_compare names ) ) in if k . [ 1 ] = ' ' - then String . sub k 1 ( String . length k - 1 ) else k in compare ( key a . o_names ) ( key a ' . o_names ) | false , false -> compare ( String . lowercase a . docv ) ( String . lowercase a ' . docv ) | true , false -> - 1 | false , true -> 1 in let format a = let absent = match a . absent with | Error -> " " | Val v -> match Lazy . force v with | " " -> " " | v -> str " absent =% s % s " v ( or_env a ) in let optvopt = match a . o_kind with | Opt_vopt v -> str " default =% s " v | _ -> " " in let argvdoc = match optvopt , absent with | " " , " " -> " " | s , " " | " " , s -> str " ( % s ) " s | s , s ' -> str " ( % s ) ( % s ) " s s ' in ( a . docs , ` I ( make_arg_label a ^ argvdoc , ( arg_info_substs ~ buf a a . doc ) ) ) in let is_arg_item a = not ( is_pos a && ( a . docv = " " || a . doc = " " ) ) in let l = List . sort cmp ( List . filter is_arg_item ( snd ei . term ) ) in List . rev_map format l let make_env_items_rev ei = let buf = Buffer . create 200 in let cmp a a ' = let e ' = match a ' . env_info with None -> assert false | Some a ' -> a ' in let e = match a . env_info with None -> assert false | Some a -> a in let c = compare e . env_docs e ' . env_docs in if c <> 0 then c else compare e . env_var e ' . env_var in let format a = let e = match a . env_info with None -> assert false | Some a -> a in ( e . env_docs , ` I ( str " ( $ i , % s ) " e . env_var , arg_info_substs ~ buf a e . env_doc ) ) in let is_env_item a = a . env_info <> None in let l = List . sort cmp ( List . filter is_env_item ( snd ei . term ) ) in List . rev_map format l let make_cmd_items ei = match eval_kind ei with | ` Simple | ` M_choice -> [ ] | ` M_main -> let add_cmd acc ( ti , _ ) = ( ti . tdocs , ` I ( ( str " ( $ b , % s ) " ti . name ) , ti . tdoc ) ) :: acc in List . sort rev_compare ( List . fold_left add_cmd [ ] ei . choices ) let text ei = let rec merge_items acc to_insert mark il = function | ` S s as sec :: ts -> let acc = List . rev_append to_insert acc in let acc = if mark then sec :: ` Orphan_mark :: acc else sec :: acc in let to_insert , il = List . partition ( fun ( n , _ ) -> n = s ) il in let to_insert = List . rev_map ( fun ( _ , i ) -> i ) to_insert in let to_insert = ( to_insert :> [ ` Orphan_mark | Manpage . block ] list ) in merge_items acc to_insert ( s = " DESCRIPTION " ) il ts | t :: ts -> let t = ( t :> [ ` Orphan_mark | Manpage . block ] ) in merge_items ( t :: acc ) to_insert mark il ts | [ ] -> let acc = List . rev_append to_insert acc in ( if mark then ` Orphan_mark :: acc else acc ) , il in let rec merge_orphans acc orphans = function | ` Orphan_mark :: ts -> let rec merge acc s = function | [ ] -> ( ` S s ) :: acc | ( s ' , i ) :: ss -> let i = ( i :> Manpage . block ) in if s = s ' then merge ( i :: acc ) s ss else merge ( i :: ( ` S s ) :: acc ) s ' ss in let acc = match orphans with | [ ] -> acc | ( s , _ ) :: _ -> merge acc s orphans in merge_orphans acc [ ] ts | ( # Manpage . block as e ) :: ts -> merge_orphans ( e :: acc ) orphans ts | [ ] -> acc in let cmds = make_cmd_items ei in let args = make_arg_items ei in let envs_rev = make_env_items_rev ei in let items_rev = List . rev_append cmds ( List . rev_append args envs_rev ) in let cmp ( s , _ ) ( s ' , _ ) = match s , s with | " ENVIRONMENT VARIABLES " , _ -> 1 | s , " ENVIRONMENT VARIABLES " -> - 1 | s , s ' -> compare s s ' in let items = List . rev ( List . stable_sort cmp items_rev ) in let synopsis , man = get_synopsis_section ei in let rev_text , orphans = merge_items [ ` Orphan_mark ] [ ] false items man in synopsis @ merge_orphans [ ] orphans rev_text let ei_subst ei = function | " tname " -> ( fst ei . term ) . name | " mname " -> ( fst ei . main ) . name | s -> str " ( $% s ) " s let man ei = title ei , ( name_section ei ) @ ( text ei ) let print fmt ppf ei = Manpage . print ~ subst ( : ei_subst ei ) fmt ppf ( man ei ) let pr_synopsis ppf ei = pr ppf " [ @% s ] " @ ( Manpage . escape ( ei_subst ei ) Manpage . plain_esc ( Buffer . create 100 ) ( synopsis ei ) ) let pr_version ppf ei = match ( fst ei . main ) . version with | None -> assert false | Some v -> pr ppf " [ @% a ] . " @@ pr_text v end
module Err = struct let invalid kind s exp = str " invalid % s % s , % s " kind ( quote s ) exp let invalid_val = invalid " value " let no kind s = str " no % s % s " ( quote s ) kind let not_dir s = str " % s is not a directory " ( quote s ) let is_dir s = str " % s is a directory " ( quote s ) let element kind s exp = str " invalid element in % s ( ` % s ' ) : % s " kind s exp let sep_miss sep s = invalid_val s ( str " missing a ` % c ' separator " sep ) let unknown kind ( ? hints = [ ] ) v = let did_you_mean s = str " , did you mean % s " ? s in let hints = match hints with [ ] -> " . " | hs -> did_you_mean ( alts_str hs ) in str " unknown % s % s % s " kind ( quote v ) hints let ambiguous kind s ambs = str " % s % s ambiguous and could be % s " kind ( quote s ) ( alts_str ambs ) let pos_excess excess = str " too many arguments , don ' t know what to do with % s " ( String . concat " , " ( List . map quote excess ) ) let flag_value f v = str " option % s is a flag , it cannot take the argument % s " ( quote f ) ( quote v ) let opt_value_missing f = str " option % s needs an argument " ( quote f ) let opt_parse_value f e = str " option % s : % s " ( quote f ) e let env_parse_value var e = str " environment variable % s : % s " ( quote var ) e let opt_repeated f f ' = if f = f ' then str " option % s cannot be repeated " ( quote f ) else str " options % s and % s cannot be present at the same time " ( quote f ) ( quote f ' ) let pos_parse_value a e = if a . docv = " " then e else match a . p_kind with | Nth _ -> str " % s argument : % s " a . docv e | _ -> str " % s . . . arguments : % s " a . docv e let arg_missing a = if is_opt a then let rec long_name = function | n :: l -> if ( String . length n ) > 2 || l = [ ] then n else long_name l | [ ] -> assert false in str " required option % s is missing " ( long_name a . o_names ) else if a . docv = " " then str " a required argument is missing " else str " required argument % s is missing " a . docv let print ppf ei e = pr ppf " % s : [ @% a ] . " @@ ( fst ei . main ) . name pr_text e let pr_backtrace err ei e bt = let bt = let len = String . length bt in if len > 0 then String . sub bt 0 ( len - 1 ) else bt in pr err " % s : [ @ internal error , uncaught exception :@\ n % a ] . " @@ ( fst ei . main ) . name pr_lines ( str " % s \ n % s " ( Printexc . to_string e ) bt ) let pr_try_help ppf ei = let exec = Help . invocation ei in let main = ( fst ei . main ) . name in if exec = main then pr ppf " [ @< 2 > Try ` % s -- help ' for more information . ] " @ exec else pr ppf " [ @< 2 > Try ` % s -- help ' or ` % s -- help ' for more information . ] " @ exec main let pr_usage ppf ei e = pr ppf " [ @< v >% s : [ @% a ] , [ @@@ Usage : [ @% a ] ] , @@@% a ] . " @@ ( fst ei . main ) . name pr_text e Help . pr_synopsis ei pr_try_help ei end
module Cmdline : sig exception Error of string val choose_term : term_info -> ( term_info * ' a ) list -> string list -> term_info * string list val create : ? peek_opts : bool -> arg_info list -> string list -> cmdline val opt_arg : cmdline -> arg_info -> ( int * string * ( string option ) ) list val pos_arg : cmdline -> arg_info -> string list exception Error of string let opt_arg cl a = match try Amap . find a cl with Not_found -> assert false with O l -> l | _ -> assert false let pos_arg cl a = match try Amap . find a cl with Not_found -> assert false with P l -> l | _ -> assert false let choose_term ti choices = function | [ ] -> ti , [ ] | maybe :: args ' as args -> if String . length maybe > 1 && maybe . [ 0 ] = ' ' - then ti , args else let index = let add acc ( choice , _ ) = Trie . add acc choice . name choice in List . fold_left add Trie . empty choices in match Trie . find index maybe with | ` Ok choice -> choice , args ' | ` Not_found -> let all = Trie . ambiguities index " " in let hints = suggest maybe all in raise ( Error ( Err . unknown " command " ~ hints maybe ) ) | ` Ambiguous -> let ambs = List . sort compare ( Trie . ambiguities index maybe ) in raise ( Error ( Err . ambiguous " command " maybe ambs ) ) let arg_info_indexes al = let rec aux opti posi cl = function | a :: l -> if is_pos a then aux opti ( a :: posi ) ( Amap . add a ( P [ ] ) cl ) l else let add t name = Trie . add t name a in aux ( List . fold_left add opti a . o_names ) posi ( Amap . add a ( O [ ] ) cl ) l | [ ] -> opti , posi , cl in aux Trie . empty [ ] Amap . empty al let parse_opt_arg s = let l = String . length s in if s . [ 1 ] <> ' ' - then if l = 2 then s , None else String . sub s 0 2 , Some ( String . sub s 2 ( l - 2 ) ) else try let i = String . index s ' ' = in String . sub s 0 i , Some ( String . sub s ( i + 1 ) ( l - i - 1 ) ) with Not_found -> s , None let parse_args ~ peek_opts opti cl args = let rec aux k opti cl pargs = function | [ ] -> cl , ( List . rev pargs ) | " " -- :: args -> cl , ( List . rev_append pargs args ) | s :: args -> let is_opt s = String . length s > 1 && s . [ 0 ] = ' ' - in let is_short_opt s = String . length s = 2 && s . [ 0 ] = ' ' - in if not ( is_opt s ) then aux ( k + 1 ) opti cl ( s :: pargs ) args else let name , value = parse_opt_arg s in match Trie . find opti name with | ` Ok a -> let value , args = match value , a . o_kind with | Some v , Flag when is_short_opt name -> None , ( " " - ^ v ) :: args | Some v , _ -> value , args | None , Flag -> value , args | None , _ -> match args with | v :: rest -> if is_opt v then None , args else Some v , rest | [ ] -> None , args in let arg = O ( ( k , name , value ) :: opt_arg cl a ) in aux ( k + 1 ) opti ( Amap . add a arg cl ) pargs args | ` Not_found when peek_opts -> aux ( k + 1 ) opti cl pargs args | ` Not_found -> let hints = if String . length s <= 2 then [ ] else let short_opt , long_opt = if s . [ 1 ] <> ' ' - then s , Printf . sprintf " -% s " s else String . sub s 1 ( String . length s - 1 ) , s in let short_opt , _ = parse_opt_arg short_opt in let long_opt , _ = parse_opt_arg long_opt in let all = Trie . ambiguities opti " " - in match List . mem short_opt all , suggest long_opt all with | false , [ ] -> [ ] | false , l -> l | true , [ ] -> [ short_opt ] | true , l -> if List . mem short_opt l then l else short_opt :: l in raise ( Error ( Err . unknown " option " ~ hints name ) ) | ` Ambiguous -> let ambs = List . sort compare ( Trie . ambiguities opti name ) in raise ( Error ( Err . ambiguous " option " name ambs ) ) in aux 0 opti cl [ ] args let process_pos_args posi cl pargs = if pargs = [ ] then cl else let rec take n acc l = if n = 0 then List . rev acc else take ( n - 1 ) ( List . hd l :: acc ) ( List . tl l ) in let rec aux pargs last cl max_spec = function | a :: al -> let arg , max_spec = match a . p_kind with | All -> P pargs , last | Nth ( rev , k ) -> let k = if rev then last - k else k in let max_spec = max k max_spec in if k < 0 || k > last then P [ ] , max_spec else P ( [ List . nth pargs k ] ) , max_spec | Left ( rev , k ) -> let k = if rev then last - k else k in let max_spec = max k max_spec in if k <= 0 || k > last then P [ ] , max_spec else P ( take k [ ] pargs ) , max_spec | Right ( rev , k ) -> let k = if rev then last - k else k in if k < 0 || k >= last then P [ ] , last else P ( List . rev ( take ( last - k ) [ ] ( List . rev pargs ) ) ) , last in aux pargs last ( Amap . add a arg cl ) max_spec al | [ ] -> cl , max_spec in let last = List . length pargs - 1 in let cl , max_spec = aux pargs last cl ( - 1 ) posi in if last <= max_spec then cl else let excess = List . rev ( take ( last - max_spec ) [ ] ( List . rev pargs ) ) in raise ( Error ( Err . pos_excess excess ) ) let create ( ? peek_opts = false ) al args = let opti , posi , cl = arg_info_indexes al in let cl , pargs = parse_args ~ peek_opts opti cl args in if peek_opts then cl else process_pos_args posi cl pargs end
module Arg = struct type ' a parser = string -> [ ` Ok of ' a | ` Error of string ] type ' a printer = Format . formatter -> ' a -> unit type ' a converter = ' a parser * ' a printer type env = env_info type ' a arg_converter = ( eval_info -> cmdline -> ' a ) type ' a t = arg_info list * ' a arg_converter type info = arg_info let env_var ( ? docs = " ENVIRONMENT VARIABLES " ) ( ? doc = " See option ( $ opt ) . " ) env_var = { env_var = env_var ; env_doc = doc ; env_docs = docs } let ( & ) f x = f x let parse_error e = raise ( Cmdline . Error e ) let some ( ? none = " " ) ( parse , print ) = ( fun s -> match parse s with ` Ok v -> ` Ok ( Some v ) | ` Error _ as e -> e ) , ( fun ppf v -> match v with None -> pr_str ppf none | Some v -> print ppf v ) let info ? docs ( ? docv = " " ) ( ? doc = " " ) ? env names = let dash n = if String . length n = 1 then " " - ^ n else " " -- ^ n in let docs = match docs with | None -> if names = [ ] then " ARGUMENTS " else " OPTIONS " | Some s -> s in { id = arg_id ( ) ; absent = Val ( lazy " " ) ; env_info = env ; doc = doc ; docv = docv ; docs = docs ; p_kind = All ; o_kind = Flag ; o_names = List . rev_map dash names ; o_all = false ; } let env_bool_parse s = match String . lowercase s with | " " | " false " | " no " | " n " | " 0 " -> ` Ok false | " true " | " yes " | " y " | " 1 " -> ` Ok true | s -> ` Error ( Err . invalid_val s ( alts_str [ " true " ; " yes " ; " false " ; " no " ] ) ) let parse_to_list parser s = match parser s with | ` Ok v -> ` Ok [ v ] | ` Error _ as e -> e let try_env ei a parse ~ absent = match a . env_info with | None -> absent | Some env -> match ei . env env . env_var with | None -> absent | Some v -> match parse v with | ` Ok v -> v | ` Error e -> parse_error ( Err . env_parse_value env . env_var e ) let flag a = if is_pos a then invalid_arg err_not_opt else let convert ei cl = match Cmdline . opt_arg cl a with | [ ] -> try_env ei a env_bool_parse ~ absent : false | [ _ , _ , None ] -> true | [ _ , f , Some v ] -> parse_error ( Err . flag_value f v ) | ( _ , f , _ ) :: ( _ , g , _ ) :: _ -> parse_error ( Err . opt_repeated f g ) in [ a ] , convert let flag_all a = if is_pos a then invalid_arg err_not_opt else let a = { a with o_all = true } in let convert ei cl = match Cmdline . opt_arg cl a with | [ ] -> try_env ei a ( parse_to_list env_bool_parse ) ~ absent [ ] : | l -> let truth ( _ , f , v ) = match v with | None -> true | Some v -> parse_error ( Err . flag_value f v ) in List . rev_map truth l in [ a ] , convert let vflag v l = let convert _ cl = let rec aux fv = function | ( v , a ) :: rest -> begin match Cmdline . opt_arg cl a with | [ ] -> aux fv rest | [ _ , f , None ] -> begin match fv with | None -> aux ( Some ( f , v ) ) rest | Some ( g , _ ) -> parse_error ( Err . opt_repeated g f ) end | [ _ , f , Some v ] -> parse_error ( Err . flag_value f v ) | ( _ , f , _ ) :: ( _ , g , _ ) :: _ -> parse_error ( Err . opt_repeated g f ) end | [ ] -> match fv with None -> v | Some ( _ , v ) -> v in aux None l in let flag ( _ , a ) = if is_pos a then invalid_arg err_not_opt else a in List . rev_map flag l , convert let vflag_all v l = let convert _ cl = let rec aux acc = function | ( fv , a ) :: rest -> begin match Cmdline . opt_arg cl a with | [ ] -> aux acc rest | l -> let fval ( k , f , v ) = match v with | None -> ( k , fv ) | Some v -> parse_error ( Err . flag_value f v ) in aux ( List . rev_append ( List . rev_map fval l ) acc ) rest end | [ ] -> if acc = [ ] then v else List . rev_map snd ( List . sort rev_compare acc ) in aux [ ] l in let flag ( _ , a ) = if is_pos a then invalid_arg err_not_opt else { a with o_all = true } in List . rev_map flag l , convert let parse_opt_value parse f v = match parse v with | ` Ok v -> v | ` Error e -> parse_error ( Err . opt_parse_value f e ) let opt ? vopt ( parse , print ) v a = if is_pos a then invalid_arg err_not_opt else let a = { a with absent = Val ( lazy ( str_of_pp print v ) ) ; o_kind = match vopt with | None -> Opt | Some dv -> Opt_vopt ( str_of_pp print dv ) } in let convert ei cl = match Cmdline . opt_arg cl a with | [ ] -> try_env ei a parse ~ absent : v | [ _ , f , Some v ] -> parse_opt_value parse f v | [ _ , f , None ] -> begin match vopt with | None -> parse_error ( Err . opt_value_missing f ) | Some optv -> optv end | ( _ , f , _ ) :: ( _ , g , _ ) :: _ -> parse_error ( Err . opt_repeated g f ) in [ a ] , convert let opt_all ? vopt ( parse , print ) v a = if is_pos a then invalid_arg err_not_opt else let a = { a with absent = Val ( lazy " " ) ; o_all = true ; o_kind = match vopt with | None -> Opt | Some dv -> Opt_vopt ( str_of_pp print dv ) } in let convert ei cl = match Cmdline . opt_arg cl a with | [ ] -> try_env ei a ( parse_to_list parse ) ~ absent : v | l -> let parse ( k , f , v ) = match v with | Some v -> ( k , parse_opt_value parse f v ) | None -> match vopt with | None -> parse_error ( Err . opt_value_missing f ) | Some dv -> ( k , dv ) in List . rev_map snd ( List . sort rev_compare ( List . rev_map parse l ) ) in [ a ] , convert let parse_pos_value parse a v = match parse v with | ` Ok v -> v | ` Error e -> parse_error ( Err . pos_parse_value a e ) let pos ( ? rev = false ) k ( parse , print ) v a = if is_opt a then invalid_arg err_not_pos else let a = { a with p_kind = Nth ( rev , k ) ; absent = Val ( lazy ( str_of_pp print v ) ) } in let convert ei cl = match Cmdline . pos_arg cl a with | [ ] -> try_env ei a parse ~ absent : v | [ v ] -> parse_pos_value parse a v | _ -> assert false in [ a ] , convert let pos_list kind ( parse , _ ) v a = if is_opt a then invalid_arg err_not_pos else let a = { a with p_kind = kind } in let convert ei cl = match Cmdline . pos_arg cl a with | [ ] -> try_env ei a ( parse_to_list parse ) ~ absent : v | l -> List . rev ( List . rev_map ( parse_pos_value parse a ) l ) in [ a ] , convert let pos_all c v a = pos_list All c v a let pos_left ( ? rev = false ) k = pos_list ( Left ( rev , k ) ) let pos_right ( ? rev = false ) k = pos_list ( Right ( rev , k ) ) let absent_error al = List . rev_map ( fun a -> { a with absent = Error } ) al let value a = a let required ( al , convert ) = let al = absent_error al in let convert ei cl = match convert ei cl with | Some v -> v | None -> parse_error ( Err . arg_missing ( List . hd al ) ) in al , convert let non_empty ( al , convert ) = let al = absent_error al in let convert ei cl = match convert ei cl with | [ ] -> parse_error ( Err . arg_missing ( List . hd al ) ) | l -> l in al , convert let last ( al , convert ) = let convert ei cl = match convert ei cl with | [ ] -> parse_error ( Err . arg_missing ( List . hd al ) ) | l -> List . hd ( List . rev l ) in al , convert let bool = ( fun s -> try ` Ok ( bool_of_string s ) with Invalid_argument _ -> ` Error ( Err . invalid_val s ( alts_str [ " true " ; " false " ] ) ) ) , Format . pp_print_bool let char = ( fun s -> if String . length s = 1 then ` Ok s . [ 0 ] else ` Error ( Err . invalid_val s " expected a character " ) ) , pr_char let parse_with t_of_str exp s = try ` Ok ( t_of_str s ) with Failure _ -> ` Error ( Err . invalid_val s exp ) let int = parse_with int_of_string " expected an integer " , Format . pp_print_int let int32 = parse_with Int32 . of_string " expected a 32 - bit integer " , ( fun ppf -> pr ppf " % ld " ) let int64 = parse_with Int64 . of_string " expected a 64 - bit integer " , ( fun ppf -> pr ppf " % Ld " ) let nativeint = parse_with Nativeint . of_string " expected a processor - native integer " , ( fun ppf -> pr ppf " % nd " ) let float = parse_with float_of_string " expected a floating point number " , Format . pp_print_float let string = ( fun s -> ` Ok s ) , pr_str let enum sl = if sl = [ ] then invalid_arg err_empty_list else let t = Trie . of_list sl in let parse s = match Trie . find t s with | ` Ok _ as r -> r | ` Ambiguous -> let ambs = List . sort compare ( Trie . ambiguities t s ) in ` Error ( Err . ambiguous " enum value " s ambs ) | ` Not_found -> let alts = List . rev ( List . rev_map ( fun ( s , _ ) -> s ) sl ) in ` Error ( Err . invalid_val s ( " expected " ^ ( alts_str alts ) ) ) in let print ppf v = let sl_inv = List . rev_map ( fun ( s , v ) -> ( v , s ) ) sl in try pr_str ppf ( List . assoc v sl_inv ) with Not_found -> invalid_arg err_incomplete_enum in parse , print let file = ( fun s -> if Sys . file_exists s then ` Ok s else ` Error ( Err . no " file or directory " s ) ) , pr_str let dir = ( fun s -> if Sys . file_exists s then if Sys . is_directory s then ` Ok s else ` Error ( Err . not_dir s ) else ` Error ( Err . no " directory " s ) ) , pr_str let non_dir_file = ( fun s -> if Sys . file_exists s then if not ( Sys . is_directory s ) then ` Ok s else ` Error ( Err . is_dir s ) else ` Error ( Err . no " file " s ) ) , pr_str let split_and_parse sep parse s = let parse sub = match parse sub with | ` Error e -> failwith e | ` Ok v -> v in let rec split accum j = let i = try String . rindex_from s j sep with Not_found -> - 1 in if ( i = - 1 ) then let p = String . sub s 0 ( j + 1 ) in if p <> " " then parse p :: accum else accum else let p = String . sub s ( i + 1 ) ( j - i ) in let accum ' = if p <> " " then parse p :: accum else accum in split accum ' ( i - 1 ) in split [ ] ( String . length s - 1 ) let list ( ? sep = ' , ' ) ( parse , pr_e ) = let parse s = try ` Ok ( split_and_parse sep parse s ) with | Failure e -> ` Error ( Err . element " list " s e ) in let rec print ppf = function | v :: l -> pr_e ppf v ; if ( l <> [ ] ) then ( pr_char ppf sep ; print ppf l ) | [ ] -> ( ) in parse , print let array ( ? sep = ' , ' ) ( parse , pr_e ) = let parse s = try ` Ok ( Array . of_list ( split_and_parse sep parse s ) ) with | Failure e -> ` Error ( Err . element " array " s e ) in let print ppf v = let max = Array . length v - 1 in for i = 0 to max do pr_e ppf v . ( i ) ; if i <> max then pr_char ppf sep done in parse , print let split_left sep s = try let i = String . index s sep in let len = String . length s in Some ( ( String . sub s 0 i ) , ( String . sub s ( i + 1 ) ( len - i - 1 ) ) ) with Not_found -> None let pair ( ? sep = ' , ' ) ( pa0 , pr0 ) ( pa1 , pr1 ) = let parser s = match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v0 , v1 ) -> match pa0 v0 , pa1 v1 with | ` Ok v0 , ` Ok v1 -> ` Ok ( v0 , v1 ) | ` Error e , _ | _ , ` Error e -> ` Error ( Err . element " pair " s e ) in let printer ppf ( v0 , v1 ) = pr ppf " % a % c % a " pr0 v0 sep pr1 v1 in parser , printer let t2 = pair let t3 ( ? sep = ' , ' ) ( pa0 , pr0 ) ( pa1 , pr1 ) ( pa2 , pr2 ) = let parse s = match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v0 , s ) -> match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v1 , v2 ) -> match pa0 v0 , pa1 v1 , pa2 v2 with | ` Ok v0 , ` Ok v1 , ` Ok v2 -> ` Ok ( v0 , v1 , v2 ) | ` Error e , _ , _ | _ , ` Error e , _ | _ , _ , ` Error e -> ` Error ( Err . element " triple " s e ) in let print ppf ( v0 , v1 , v2 ) = pr ppf " % a % c % a % c % a " pr0 v0 sep pr1 v1 sep pr2 v2 in parse , print let t4 ( ? sep = ' , ' ) ( pa0 , pr0 ) ( pa1 , pr1 ) ( pa2 , pr2 ) ( pa3 , pr3 ) = let parse s = match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v0 , s ) -> match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v1 , s ) -> match split_left sep s with | None -> ` Error ( Err . sep_miss sep s ) | Some ( v2 , v3 ) -> match pa0 v0 , pa1 v1 , pa2 v2 , pa3 v3 with | ` Ok v1 , ` Ok v2 , ` Ok v3 , ` Ok v4 -> ` Ok ( v1 , v2 , v3 , v4 ) | ` Error e , _ , _ , _ | _ , ` Error e , _ , _ | _ , _ , ` Error e , _ | _ , _ , _ , ` Error e -> ` Error ( Err . element " quadruple " s e ) in let print ppf ( v0 , v1 , v2 , v3 ) = pr ppf " % a % c % a % c % a % c % a " pr0 v0 sep pr1 v1 sep pr2 v2 sep pr3 v3 in parse , print let doc_quote = quote let doc_alts = alts_str let doc_alts_enum ? quoted enum = alts_str ? quoted ( List . map fst enum ) end
module Term = struct type info = term_info type ' + a t = arg_info list * ( eval_info -> cmdline -> ' a ) type ' a result = [ | ` Ok of ' a | ` Error of [ ` Parse | ` Term | ` Exn ] | ` Version | ` Help ] exception Term of [ ` Help of [ ` Pager | ` Plain | ` Groff ] * string option | ` Error of bool * string ] let info ( ? sdocs = " OPTIONS " ) ( ? man = [ ] ) ( ? docs = " COMMANDS " ) ( ? doc = " " ) ? version name = { name = name ; version = version ; tdoc = doc ; tdocs = docs ; sdocs = sdocs ; man = man } let name ti = ti . name let const v = [ ] , ( fun _ _ -> v ) let pure = const let app ( al , f ) ( al ' , v ) = List . rev_append al al ' , fun ei cl -> ( f ei cl ) ( v ei cl ) let ( $ ) = app type ' a ret = [ ` Help of [ ` Pager | ` Plain | ` Groff ] * string option | ` Error of ( bool * string ) | ` Ok of ' a ] let ret ( al , v ) = al , fun ei cl -> match v ei cl with | ` Ok v -> v | ` Error ( u , e ) -> raise ( Term ( ` Error ( u , e ) ) ) | ` Help h -> raise ( Term ( ` Help h ) ) let main_name = [ ] , ( fun ei _ -> ( fst ei . main ) . name ) let choice_names = [ ] , fun ei _ -> List . rev_map ( fun e -> ( fst e ) . name ) ei . choices let man_format = let fmts = [ " pager " , ` Pager ; " groff " , ` Groff ; " plain " , ` Plain ] in let doc = " Show output in format ( $ docv ) ( pager , plain or groff ) . " in Arg . ( value & opt ( enum fmts ) ` Pager & info [ " man - format " ] ~ docv " : FMT " ~ doc ) let remove_exec argv = try List . tl ( Array . to_list argv ) with Failure _ -> invalid_arg err_argv let add_std_opts ei = let docs = ( fst ei . term ) . sdocs in let args , v_lookup = if ( fst ei . main ) . version = None then [ ] , None else let ( a , lookup ) = Arg . flag ( Arg . info [ " version " ] ~ docs ~ doc " : Show version information . " ) in a , Some lookup in let args , h_lookup = let ( a , lookup ) = let fmt = Arg . enum [ " pager " , ` Pager ; " groff " , ` Groff ; " plain " , ` Plain ] in let doc = " Show this help in format ( $ docv ) ( pager , plain or groff ) . " in let a = Arg . info [ " help " ] ~ docv " : FMT " ~ docs ~ doc in Arg . opt ~ vopt ( : Some ` Pager ) ( Arg . some fmt ) None a in List . rev_append a args , lookup in h_lookup , v_lookup , { ei with term = ( fst ei . term ) , List . rev_append args ( snd ei . term ) } let eval_term help err ei f args = let help_arg , vers_arg , ei = add_std_opts ei in try let cl = Cmdline . create ( snd ei . term ) args in match help_arg ei cl , vers_arg with | Some fmt , _ -> Help . print fmt help ei ; ` Help | None , Some v_arg when v_arg ei cl -> Help . pr_version help ei ; ` Version | _ -> ` Ok ( f ei cl ) with | Cmdline . Error e -> Err . pr_usage err ei e ; ` Error ` Parse | Term ( ` Error ( usage , e ) ) -> if usage then Err . pr_usage err ei e else Err . print err ei e ; ` Error ` Term | Term ( ` Help ( fmt , cmd ) ) -> let ei = match cmd with | Some cmd -> let cmd = try List . find ( fun ( i , _ ) -> i . name = cmd ) ei . choices with Not_found -> invalid_arg ( err_help cmd ) in { ei with term = cmd } | None -> { ei with term = ei . main } in let _ , _ , ei = add_std_opts ei in Help . print fmt help ei ; ` Help let env_default v = try Some ( Sys . getenv v ) with Not_found -> None let eval ( ? help = Format . std_formatter ) ( ? err = Format . err_formatter ) ( ? catch = true ) ( ? env = env_default ) ( ? argv = Sys . argv ) ( ( al , f ) , ti ) = let term = ti , al in let ei = { term = term ; main = term ; choices = [ ] ; env = env } in try eval_term help err ei f ( remove_exec argv ) with | e when catch -> Err . pr_backtrace err ei e ( Printexc . get_backtrace ( ) ) ; ` Error ` Exn let eval_choice ( ? help = Format . std_formatter ) ( ? err = Format . err_formatter ) ( ? catch = true ) ( ? env = env_default ) ( ? argv = Sys . argv ) ( ( ( al , f ) as t ) , ti ) choices = let ei_choices = List . rev_map ( fun ( ( al , _ ) , ti ) -> ti , al ) choices in let main = ( ti , al ) in let ei = { term = main ; main = main ; choices = ei_choices ; env = env } in try let chosen , args = Cmdline . choose_term ti ei_choices ( remove_exec argv ) in let find_chosen ( _ , ti ) = ti = chosen in let ( al , f ) , _ = List . find find_chosen ( ( t , ti ) :: choices ) in let ei = { ei with term = ( chosen , al ) } in eval_term help err ei f args with | Cmdline . Error e -> Err . pr_usage err ei e ; ` Error ` Parse | e when catch -> Err . pr_backtrace err ei e ( Printexc . get_backtrace ( ) ) ; ` Error ` Exn let eval_peek_opts ( ? version_opt = false ) ( ? env = env_default ) ( ? argv = Sys . argv ) ( al , f ) = let args = remove_exec argv in let version = if version_opt then Some " dummy " else None in let term = info ? version " dummy " , al in let ei = { term = term ; main = term ; choices = [ ] ; env = env } in let help_arg , vers_arg , ei = add_std_opts ei in try let cl = Cmdline . create ~ peek_opts : true ( snd ei . term ) args in match help_arg ei cl , vers_arg with | Some fmt , _ -> ( try ( Some ( f ei cl ) , ` Help ) with e -> None , ` Help ) | None , Some v_arg when v_arg ei cl -> ( try ( Some ( f ei cl ) , ` Version ) with e -> None , ` Version ) | _ -> let v = f ei cl in Some v , ` Ok v with | Cmdline . Error _ -> None , ( ` Error ` Parse ) | Term _ -> None , ( ` Error ` Term ) | e -> None , ( ` Error ` Exn ) end
module List = struct include List let map f l = List . rev_map f l |> List . rev let rev_split l = let rec inner xs ys = function | ( x , y ) :: xys -> inner ( x :: xs ) ( y :: ys ) xys | [ ] -> ( xs , ys ) in inner [ ] [ ] l let split l = rev_split ( List . rev l ) end
type wrap = [ | ` Wrap_atoms | ` Always_wrap | ` Never_wrap | ` Force_breaks | ` Force_breaks_rec | ` No_breaks ]
type label_break = [ | ` Auto | ` Always | ` Always_rec | ` Never ]
type style = { tag_open : string ; tag_close : string }
type atom_param = { atom_style : style_name option ; }
let atom = { atom_style = None }
type list_param = { space_after_opening : bool ; space_after_separator : bool ; space_before_separator : bool ; separators_stick_left : bool ; space_before_closing : bool ; stick_to_label : bool ; align_closing : bool ; wrap_body : wrap ; indent_body : int ; list_style : style_name option ; opening_style : style_name option ; body_style : style_name option ; separator_style : style_name option ; closing_style : style_name option ; }