text
stringlengths 0
601k
|
|---|
let length h = h . size |
let resize indexfun h = let odata = h . data in let osize = Array . length odata in let nsize = osize * 2 in if nsize < Sys . max_array_length then begin let ndata = Array . make nsize [ ] in h . data <- ndata ; let rec insert_bucket = function [ ] -> ( ) | key :: rest -> insert_bucket rest ; let nidx = indexfun h key in ndata . ( nidx ) <- key :: ndata . ( nidx ) in for i = 0 to osize - 1 do insert_bucket odata . ( i ) done end |
let key_index h key = if Obj . size ( Obj . repr h ) >= 3 then ( seeded_hash_param 10 100 h . seed key ) land ( Array . length h . data - 1 ) else ( old_hash_param 10 100 key ) mod ( Array . length h . data ) |
let add h key = let i = key_index h key in let bucket = key :: h . data . ( i ) in h . data . ( i ) <- bucket ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h |
let remove h key = let rec remove_bucket = function | [ ] -> [ ] | k :: next -> if compare k key = 0 then begin h . size <- h . size - 1 ; next end else k :: remove_bucket next in let i = key_index h key in h . data . ( i ) <- remove_bucket h . data . ( i ) |
let rec find_rec key = function | [ ] -> raise Not_found | k :: rest -> if compare key k = 0 then k else find_rec key rest |
let find h key = match h . data . ( key_index h key ) with | [ ] -> raise Not_found | k1 :: rest1 -> if compare key k1 = 0 then k1 else match rest1 with | [ ] -> raise Not_found | k2 :: rest2 -> if compare key k2 = 0 then k2 else match rest2 with | [ ] -> raise Not_found | k3 :: rest3 -> if compare key k3 = 0 then k3 else find_rec key rest3 |
let find_all h key = let rec find_in_bucket = function | [ ] -> [ ] | k :: rest -> if compare k key = 0 then k :: find_in_bucket rest else find_in_bucket rest in find_in_bucket h . data . ( key_index h key ) |
let replace h key = let rec replace_bucket = function | [ ] -> raise Not_found | k :: next -> if compare k key = 0 then k :: next else k :: replace_bucket next in let i = key_index h key in let l = h . data . ( i ) in try h . data . ( i ) <- replace_bucket l with Not_found -> h . data . ( i ) <- key :: l ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h |
let mem h key = let rec mem_in_bucket = function | [ ] -> false | k :: rest -> compare k key = 0 || mem_in_bucket rest in mem_in_bucket h . data . ( key_index h key ) |
let iter f h = let rec do_bucket = function | [ ] -> ( ) | k :: rest -> f k ; do_bucket rest in let d = h . data in for i = 0 to Array . length d - 1 do do_bucket d . ( i ) done |
let fold f h init = let rec do_bucket b accu = match b with [ ] -> accu | k :: rest -> do_bucket rest ( f k accu ) in let d = h . data in let accu = ref init in for i = 0 to Array . length d - 1 do accu := do_bucket d . ( i ) ! accu done ; ! accu |
let find_or_add tbl v = try find tbl v with | Not_found -> add tbl v ; v |
type statistics = { num_bindings : int ; num_buckets : int ; max_bucket_length : int ; bucket_histogram : int array } |
let rec bucket_length accu = function | [ ] -> accu | _ :: rest -> bucket_length ( accu + 1 ) rest |
let stats h = let mbl = Array . fold_left ( fun m b -> max m ( bucket_length 0 b ) ) 0 h . data in let histo = Array . make ( mbl + 1 ) 0 in Array . iter ( fun b -> let l = bucket_length 0 b in histo . ( l ) <- histo . ( l ) + 1 ) h . data ; { num_bindings = h . size ; num_buckets = Array . length h . data ; max_bucket_length = mbl ; bucket_histogram = histo } |
module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end |
module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end |
module type S = sig type key type t val create : int -> t val clear : t -> unit val reset : t -> unit val copy : t -> t val add : t -> key -> unit val remove : t -> key -> unit val find : t -> key -> key val find_all : t -> key -> key list val replace : t -> key -> unit val mem : t -> key -> bool val iter : ( key -> unit ) -> t -> unit val fold : ( key -> ' b -> ' b ) -> t -> ' b -> ' b val length : t -> int val stats : t -> statistics val find_or_add : t -> key -> key end |
module type SeededS = sig type key type t val create : ? random : bool -> int -> t val clear : t -> unit val reset : t -> unit val copy : t -> t val add : t -> key -> unit val remove : t -> key -> unit val find : t -> key -> key val find_all : t -> key -> key list val replace : t -> key -> unit val mem : t -> key -> bool val iter : ( key -> unit ) -> t -> unit val fold : ( key -> ' b -> ' b ) -> t -> ' b -> ' b val length : t -> int val stats : t -> statistics val find_or_add : t -> key -> key end |
module MakeSeeded ( H : SeededHashedType ) : ( SeededS with type key = H . t ) = struct type key = H . t type hashtbl = key t type t = hashtbl let create = create let clear = clear let reset = reset let copy = copy let key_index h key = ( H . hash h . seed key ) land ( Array . length h . data - 1 ) let add h key = let i = key_index h key in let bucket = key :: h . data . ( i ) in h . data . ( i ) <- bucket ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h let remove h key = let rec remove_bucket = function | [ ] -> [ ] | k :: next -> if H . equal k key then begin h . size <- h . size - 1 ; next end else k :: remove_bucket next in let i = key_index h key in h . data . ( i ) <- remove_bucket h . data . ( i ) let rec find_rec key = function | [ ] -> raise Not_found | k :: rest -> if H . equal key k then k else find_rec key rest let find h key = match h . data . ( key_index h key ) with | [ ] -> raise Not_found | k1 :: rest1 -> if H . equal key k1 then k1 else match rest1 with | [ ] -> raise Not_found | k2 :: rest2 -> if H . equal key k2 then k2 else match rest2 with | [ ] -> raise Not_found | k3 :: rest3 -> if H . equal key k3 then k3 else find_rec key rest3 let find_all h key = let rec find_in_bucket = function | [ ] -> [ ] | k :: rest -> if H . equal k key then k :: find_in_bucket rest else find_in_bucket rest in find_in_bucket h . data . ( key_index h key ) let replace h key = let rec replace_bucket = function | [ ] -> raise Not_found | k :: next -> if H . equal k key then key :: next else k :: replace_bucket next in let i = key_index h key in let l = h . data . ( i ) in try h . data . ( i ) <- replace_bucket l with Not_found -> h . data . ( i ) <- key :: l ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h let mem h key = let rec mem_in_bucket = function | [ ] -> false | k :: rest -> H . equal k key || mem_in_bucket rest in mem_in_bucket h . data . ( key_index h key ) let iter = iter let fold = fold let length = length let stats = stats let find_or_add tbl v = try find tbl v with | Not_found -> add tbl v ; v end |
module Make ( H : HashedType ) : ( S with type key = H . t ) = struct include MakeSeeded ( struct type t = H . t let equal = H . equal let hash ( _seed : int ) x = H . hash x end ) let create sz = create ~ random : false sz end |
int -> int -> int -> ' a -> int = " caml_hash " " noalloc " int -> int -> ' a -> int = " caml_hash_univ_param " " noalloc " |
let hash x = seeded_hash_param 10 100 0 x |
let hash_param n1 n2 x = seeded_hash_param n1 n2 0 x |
let seeded_hash seed x = seeded_hash_param 10 100 seed x |
type ( ' a , ' b ) t = { mutable size : int ; mutable data : ( ' a , ' b ) bucketlist array ; mutable seed : int ; initial_size : int ; } Empty | Cons of ' a * ' b * ( ' a , ' b ) bucketlist |
let randomized_default = let params = try Sys . getenv " OCAMLRUNPARAM " with Not_found -> try Sys . getenv " CAMLRUNPARAM " with Not_found -> " " in String . contains params ' R ' |
let randomized = ref randomized_default |
let randomize ( ) = randomized := true |
let prng = lazy ( Random . State . make_self_init ( ) ) |
let rec power_2_above x n = if x >= n then x else if x * 2 > Sys . max_array_length then x else power_2_above ( x * 2 ) n |
let create ( ? random = ! randomized ) initial_size = let s = power_2_above 16 initial_size in let seed = if random then Random . State . bits ( Lazy . force prng ) else 0 in { initial_size = s ; size = 0 ; seed = seed ; data = Array . make s Empty } |
let clear h = h . size <- 0 ; let len = Array . length h . data in for i = 0 to len - 1 do h . data . ( i ) <- Empty done |
let reset h = let len = Array . length h . data in if Obj . size ( Obj . repr h ) < 4 || len = h . initial_size then clear h else begin h . size <- 0 ; h . data <- Array . make h . initial_size Empty end |
let copy h = { h with data = Array . copy h . data } |
let length h = h . size |
let resize indexfun h = let odata = h . data in let osize = Array . length odata in let nsize = osize * 2 in if nsize < Sys . max_array_length then begin let ndata = Array . make nsize Empty in h . data <- ndata ; let rec insert_bucket = function Empty -> ( ) | Cons ( key , data , rest ) -> insert_bucket rest ; let nidx = indexfun h key in a_set ndata nidx @@ Cons ( key , data , a_get ndata nidx ) in for i = 0 to osize - 1 do insert_bucket @@ a_get odata i done end |
let key_index h key = if Obj . size ( Obj . repr h ) >= 3 then ( seeded_hash_param 10 100 h . seed key ) land ( Array . length h . data - 1 ) else ( old_hash_param 10 100 key ) mod ( Array . length h . data ) |
let add h key info = let i = key_index h key in let bucket = Cons ( key , info , a_get h . data i ) in a_set h . data i bucket ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h |
let remove h key = let rec remove_bucket = function | Empty -> Empty | Cons ( k , i , next ) -> if compare k key = 0 then begin h . size <- h . size - 1 ; next end else Cons ( k , i , remove_bucket next ) in let i = key_index h key in a_set h . data i @@ remove_bucket @@ a_get h . data i |
let rec find_rec key = function | Empty -> raise Not_found | Cons ( k , d , rest ) -> if compare key k = 0 then d else find_rec key rest |
let find h key = match a_get h . data @@ key_index h key with | Empty -> raise Not_found | Cons ( k1 , d1 , rest1 ) -> if compare key k1 = 0 then d1 else match rest1 with | Empty -> raise Not_found | Cons ( k2 , d2 , rest2 ) -> if compare key k2 = 0 then d2 else match rest2 with | Empty -> raise Not_found | Cons ( k3 , d3 , rest3 ) -> if compare key k3 = 0 then d3 else find_rec key rest3 |
let find_all h key = let rec find_in_bucket = function | Empty -> [ ] | Cons ( k , d , rest ) -> if compare k key = 0 then d :: find_in_bucket rest else find_in_bucket rest in find_in_bucket @@ a_get h . data @@ key_index h key |
let replace h key info = let rec replace_bucket = function | Empty -> raise Not_found | Cons ( k , i , next ) -> if compare k key = 0 then Cons ( key , info , next ) else Cons ( k , i , replace_bucket next ) in let i = key_index h key in let l = a_get h . data i in try a_set h . data i @@ replace_bucket l with Not_found -> a_set h . data i @@ Cons ( key , info , l ) ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h |
let mem h key = let rec mem_in_bucket = function | Empty -> false | Cons ( k , _d , rest ) -> compare k key = 0 || mem_in_bucket rest in mem_in_bucket @@ a_get h . data @@ key_index h key |
let iter f h = let rec do_bucket = function | Empty -> ( ) | Cons ( k , d , rest ) -> f k d ; do_bucket rest in let d = h . data in for i = 0 to Array . length d - 1 do do_bucket @@ a_get d i done |
let fold f h init = let rec do_bucket b accu = match b with Empty -> accu | Cons ( k , d , rest ) -> do_bucket rest ( f k d accu ) in let d = h . data in let accu = ref init in for i = 0 to Array . length d - 1 do accu := do_bucket ( a_get d i ) ! accu done ; ! accu |
type statistics = { num_bindings : int ; num_buckets : int ; max_bucket_length : int ; bucket_histogram : int array } |
let rec bucket_length accu = function | Empty -> accu | Cons ( _ , _ , rest ) -> bucket_length ( accu + 1 ) rest |
let stats h = let mbl = Array . fold_left ( fun m b -> max m ( bucket_length 0 b ) ) 0 h . data in let histo = Array . make ( mbl + 1 ) 0 in Array . iter ( fun b -> let l = bucket_length 0 b in a_set histo l @@ a_get histo l + 1 ) h . data ; { num_bindings = h . size ; num_buckets = Array . length h . data ; max_bucket_length = mbl ; bucket_histogram = histo } |
module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end |
module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end |
module type S = sig type key type ' a t val create : int -> ' a t val clear : ' a t -> unit val reset : ' a t -> unit val copy : ' a t -> ' a t val add : ' a t -> key -> ' a -> unit val remove : ' a t -> key -> unit val find : ' a t -> key -> ' a val find_all : ' a t -> key -> ' a list val replace : ' a t -> key -> ' a -> unit val mem : ' a t -> key -> bool val iter : ( key -> ' a -> unit ) -> ' a t -> unit val fold : ( key -> ' a -> ' b -> ' b ) -> ' a t -> ' b -> ' b val length : ' a t -> int val stats : ' a t -> statistics end |
module type SeededS = sig type key type ' a t val create : ? random : bool -> int -> ' a t val clear : ' a t -> unit val reset : ' a t -> unit val copy : ' a t -> ' a t val add : ' a t -> key -> ' a -> unit val remove : ' a t -> key -> unit val find : ' a t -> key -> ' a val find_all : ' a t -> key -> ' a list val replace : ' a t -> key -> ' a -> unit val mem : ' a t -> key -> bool val iter : ( key -> ' a -> unit ) -> ' a t -> unit val fold : ( key -> ' a -> ' b -> ' b ) -> ' a t -> ' b -> ' b val length : ' a t -> int val stats : ' a t -> statistics end |
module MakeSeeded ( H : SeededHashedType ) : ( SeededS with type key = H . t ) = struct type key = H . t type ' a hashtbl = ( key , ' a ) t type ' a t = ' a hashtbl let create = create let clear = clear let reset = reset let copy = copy let key_index h key = ( H . hash h . seed key ) land ( Array . length h . data - 1 ) let add h key info = let i = key_index h key in let bucket = Cons ( key , info , a_get h . data i ) in a_set h . data i bucket ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h let remove h key = let rec remove_bucket = function | Empty -> Empty | Cons ( k , i , next ) -> if H . equal k key then begin h . size <- h . size - 1 ; next end else Cons ( k , i , remove_bucket next ) in let i = key_index h key in a_set h . data i @@ remove_bucket @@ a_get h . data i let rec find_rec key = function | Empty -> raise Not_found | Cons ( k , d , rest ) -> if H . equal key k then d else find_rec key rest let find h key = match a_get h . data @@ key_index h key with | Empty -> raise Not_found | Cons ( k1 , d1 , rest1 ) -> if H . equal key k1 then d1 else match rest1 with | Empty -> raise Not_found | Cons ( k2 , d2 , rest2 ) -> if H . equal key k2 then d2 else match rest2 with | Empty -> raise Not_found | Cons ( k3 , d3 , rest3 ) -> if H . equal key k3 then d3 else find_rec key rest3 let find_all h key = let rec find_in_bucket = function | Empty -> [ ] | Cons ( k , d , rest ) -> if H . equal k key then d :: find_in_bucket rest else find_in_bucket rest in find_in_bucket @@ a_get h . data @@ key_index h key let replace h key info = let rec replace_bucket = function | Empty -> raise Not_found | Cons ( k , i , next ) -> if H . equal k key then Cons ( key , info , next ) else Cons ( k , i , replace_bucket next ) in let i = key_index h key in let l = a_get h . data i in try a_set h . data i @@ replace_bucket l with Not_found -> a_set h . data i @@ Cons ( key , info , l ) ; h . size <- h . size + 1 ; if h . size > Array . length h . data lsl 1 then resize key_index h let mem h key = let rec mem_in_bucket = function | Empty -> false | Cons ( k , _d , rest ) -> H . equal k key || mem_in_bucket rest in mem_in_bucket @@ a_get h . data @@ key_index h key let iter = iter let fold = fold let length = length let stats = stats end |
module Make ( H : HashedType ) : ( S with type key = H . t ) = struct include MakeSeeded ( struct type t = H . t let equal = H . equal let hash ( _seed : int ) x = H . hash x end ) let create sz = create ~ random : false sz end |
module type S = sig open Signal . Types val lut : int64 -> signal -> signal val muxcy : signal -> signal -> signal -> signal val inv : signal -> signal val xorcy : signal -> signal -> signal val muxf5 : signal -> signal -> signal -> signal val muxf6 : signal -> signal -> signal -> signal val muxf7 : signal -> signal -> signal -> signal val muxf8 : signal -> signal -> signal -> signal val fdce : signal -> signal -> signal -> signal -> signal val fdpe : signal -> signal -> signal -> signal -> signal val mult_and : signal -> signal -> signal val ram1s : signal -> signal -> signal -> signal -> signal end |
module LutEqn = struct type t = | Gnd | Vdd | Input of int64 | And of t * t | Or of t * t | Xor of t * t | Not of t let i0 = Input ( 0L ) let i1 = Input ( 1L ) let i2 = Input ( 2L ) let i3 = Input ( 3L ) let i4 = Input ( 4L ) let i5 = Input ( 5L ) let gnd = Gnd let vdd = Vdd let ( ) &: a b = And ( a , b ) let ( ) |: a b = Or ( a , b ) let ( ) ^: a b = Xor ( a , b ) let ( ) ~: a = Not ( a ) let ( ) <>: a b = a ^: b let ( ) ==: a b = ~: ( a <>: b ) let ( . ) >> a b = Int64 . shift_right_logical a ( Int64 . to_int b ) let ( . ) << a b = Int64 . shift_left a ( Int64 . to_int b ) let ( . ) & = Int64 . logand let ( . ) | = Int64 . logor let ( . ) ^ = Int64 . logxor let ( . ) ~ = Int64 . lognot let ( . ) + = Int64 . add let eval n v = let n = Int64 . of_int n in let rec eval n = function | Gnd -> 0L | Vdd -> 1L | Input ( a ) -> ( n . >> a ) . & 1L | And ( a , b ) -> ( eval n a ) . & ( eval n b ) | Or ( a , b ) -> ( eval n a ) . | ( eval n b ) | Xor ( a , b ) -> ( eval n a ) . ^ ( eval n b ) | Not ( a ) -> ( . ~ ( eval n a ) ) . & 1L in let rec evaln m w = if m = ( 1L . << n ) then w else evaln ( m . + 1L ) ( ( ( eval m v ) . << m ) . | w ) in evaln 0L 0L end |
module HardCaml_api = struct open Signal . Types open Signal . Comb open Signal . Seq let lut v sel = let n = 1 lsl ( width sel ) in let rec build i = if i = n then [ ] else let d = if Int64 . logand v ( Int64 . shift_left 1L i ) <> 0L then vdd else gnd in d :: build ( i + 1 ) in mux sel ( build 0 ) let muxcy ci di sel = mux2 sel ci di let inv a = ~: a let xorcy ci li = ci ^: li let muxf5 f t s = mux2 s t f let muxf6 f t s = mux2 s t f let muxf7 f t s = mux2 s t f let muxf8 f t s = mux2 s t f let fdce c ce clr d = reg { r_none with reg_clock = c ; reg_reset = clr ; reg_reset_value = gnd } ce d let fdpe c ce pre d = reg { r_none with reg_clock = c ; reg_reset = pre ; reg_reset_value = vdd } ce d let mult_and a b = a &: b let ram1s a d clk we = memory ( 1 lsl ( width a ) ) { r_none with reg_clock = clk } a we d a end |
module Unisim = struct open Utils open Signal . Types open Signal . Comb open Signal . Instantiation module B = Bits . Comb . IntbitsList let inv a = ( inst " INV " [ ] [ " I " , a ] [ " O " , 1 ] ) # o " O " let lut v sel = let w = width sel in let w ' = string_of_int w in let init = ( Int64 . to_string v ) |> B . constd ( 1 lsl w ) |> B . reverse |> B . to_string in ( inst ( " LUT " ^ w ' ) [ " INIT " , ParamString ( init ) ] ( mapi ( fun i b -> " I " ^ string_of_int i , b ) ( bits sel |> List . rev ) ) [ " O " , 1 ] ) # o " O " let muxcy ci di sel = ( inst " MUXCY " [ ] [ " CI " , ci ; " DI " , di ; " S " , sel ] [ " O " , 1 ] ) # o " O " let xorcy ci li = ( inst " XORCY " [ ] [ " CI " , ci ; " LI " , li ] [ " O " , 1 ] ) # o " O " let muxf5 f t s = ( inst " MUXF5 " [ ] [ " I0 " , f ; " I1 " , t ; " S " , s ] [ " O " , 1 ] ) # o " O " let muxf6 f t s = ( inst " MUXF6 " [ ] [ " I0 " , f ; " I1 " , t ; " S " , s ] [ " O " , 1 ] ) # o " O " let muxf7 f t s = ( inst " MUXF7 " [ ] [ " I0 " , f ; " I1 " , t ; " S " , s ] [ " O " , 1 ] ) # o " O " let muxf8 f t s = ( inst " MUXF8 " [ ] [ " I0 " , f ; " I1 " , t ; " S " , s ] [ " O " , 1 ] ) # o " O " let fdce c ce clr d = ( inst " FDCE " [ " INIT " , ParamString ( " 0 " ) ] [ " C " , c ; " CE " , ce ; " CLR " , clr ; " D " , d ] [ " Q " , 1 ] ) # o " Q " let fdpe c ce pre d = ( inst " FDPE " [ " INIT " , ParamString ( " 1 " ) ] [ " C " , c ; " CE " , ce ; " D " , d ; " PRE " , pre ] [ " Q " , 1 ] ) # o " Q " let mult_and a b = ( inst " MULT_AND " [ ] [ " I0 " , a ; " I1 " , b ] [ " LO " , 1 ] ) # o " LO " let ram1s a d clk we = let width = width a in let size = 1 lsl width in let a = mapi ( fun i s -> " A " ^ string_of_int i , s ) ( a |> bits |> List . rev ) in ( inst ( " RAM " ^ string_of_int size ^ " X1S " ) [ " INIT " , ParamString ( bstr_of_int size 0 ) ] ( [ " D " , d ; " WE " , we ; " WCLK " , clk ] @ a ) [ " Q " , 1 ] ) # o " Q " end |
module type T = sig open Signal . Types val x_lut : LutEqn . t -> signal -> signal val x_map : LutEqn . t -> signal list -> signal val x_and : signal -> signal -> signal val x_or : signal -> signal -> signal val x_xor : signal -> signal -> signal val x_not : signal -> signal val x_reduce_carry : bool -> ( LutEqn . t -> LutEqn . t -> LutEqn . t ) -> signal -> signal -> signal -> signal val x_and_reduce : signal -> signal val x_or_reduce : signal -> signal val x_reduce_tree : ( LutEqn . t -> LutEqn . t -> LutEqn . t ) -> signal -> signal val x_add_carry : LutEqn . t -> signal -> signal -> signal -> ( signal * signal ) val x_add : signal -> signal -> signal val x_sub : signal -> signal -> signal val x_mux_add_carry : LutEqn . t -> signal -> signal -> ( signal * signal ) -> signal -> ( signal * signal ) val x_mux_add : signal -> ( signal * signal ) -> signal -> signal val x_mux_sub : signal -> signal -> ( signal * signal ) -> signal val x_eq : signal -> signal -> signal val x_lt : signal -> signal -> signal val x_mux : signal -> signal list -> signal val x_mulu : signal -> signal -> signal val x_muls : signal -> signal -> signal end |
module type LutSize = sig val max_lut : int end |
module Lut4 = struct let max_lut = 4 end |
module Lut6 = struct let max_lut = 6 end |
module XMake ( X : S ) ( L : LutSize ) = struct open Utils open Signal . Types module S = Signal . Comb open S open LutEqn open L let x_lut f s = let i = eval ( width s ) f in X . lut i s let x_map f l = let w = List . hd l |> width in let lut n = x_lut f ( List . map ( fun s -> select s n n ) l |> List . rev |> concat ) in let rec build n = if n = w then [ ] else lut n :: build ( n + 1 ) in concat ( ( build 0 ) |> List . rev ) let x_and a b = x_map ( i0 &: i1 ) [ a ; b ] let x_or a b = x_map ( i0 |: i1 ) [ a ; b ] let x_xor a b = x_map ( i0 ^: i1 ) [ a ; b ] let x_not a = a |> bits |> List . map X . inv |> concat let inputs n = lselect [ i0 ; i1 ; i2 ; i3 ; i4 ; i5 ] 0 ( n - 1 ) let reduce_inputs op n = let args = inputs n in List . fold_left ( fun acc a -> op acc a ) ( List . hd args ) ( List . tl args ) let rec x_reduce_carry inv op mux_din carry_in a = let n = min max_lut ( width a ) in let op ' = reduce_inputs op n in let op ' = if inv then ~: op ' else op ' in let lut = x_lut op ' ( select a ( n - 1 ) 0 ) in let carry_out = X . muxcy carry_in mux_din lut in if n = width a then carry_out else x_reduce_carry inv op mux_din carry_out ( select a ( width a - 1 ) n ) let x_and_reduce a = x_reduce_carry false ( ) &: S . gnd S . vdd a let x_or_reduce a = x_reduce_carry true ( ) |: S . vdd S . gnd a let rec x_reduce_tree op a = let rec level a = let n = min max_lut ( width a ) in let op ' = reduce_inputs op n in let lut = x_lut op ' ( select a ( n - 1 ) 0 ) in if n = width a then lut else level ( select a ( width a - 1 ) n ) @: lut in if width a = 1 then a else x_reduce_tree op ( level a ) let x_xor_reduce a = x_reduce_tree ( ) ^: a let x_add_carry op c a b = let lut c a b = let o = x_lut op ( a @: b ) in let s = X . xorcy c o in let c = X . muxcy c b o in c , s in let r , c = List . fold_left2 ( fun ( r , c ) a b -> let c , s = lut c a b in s :: r , c ) ( [ ] , c ) ( bits a |> List . rev ) ( bits b |> List . rev ) in c , concat r let x_add a b = snd ( x_add_carry ( i0 ^: i1 ) S . gnd a b ) let x_sub a b = snd ( x_add_carry ( ~: ( i0 ^: i1 ) ) S . vdd b a ) let x_mux_add_carry op c x ( a , a ' ) b = let lut op x c ( a , a ' ) b = let o = x_lut op ( x @: b @: a ' @: a ) in let s = X . xorcy c o in let c = X . muxcy c b o in c , s in let zip a b = List . map2 ( fun a b -> a , b ) a b in let r , c = List . fold_left2 ( fun ( r , c ) ( a , a ' ) b -> let c , s = lut op x c ( a , a ' ) b in s :: r , c ) ( [ ] , c ) ( zip ( bits a |> List . rev ) ( bits a ' |> List . rev ) ) ( bits b |> List . rev ) in c , concat r let x_mux_add x ( a , a ' ) b = let add_lut_op = ( ( i0 &: i3 ) |: ( i1 &: ( ~: i3 ) ) ) ^: i2 in snd ( x_mux_add_carry add_lut_op S . gnd x ( a , a ' ) b ) let x_mux_sub x a ( b , b ' ) = let sub_lut_op = ~: ( ( ( i0 &: i3 ) |: ( i1 &: ( ~: i3 ) ) ) ^: i2 ) in snd ( x_mux_add_carry sub_lut_op S . vdd x ( b , b ' ) a ) let x_eq a b = let rec eq l = match l with | [ ] -> [ ] | a :: b :: t -> ~: ( a ^: b ) :: eq t | _ -> failwith " x_eq expecting even length list " in let eq l = List . fold_left ( ) &: vdd ( eq l ) in let eq_lut a b = match width a with | 1 -> x_lut ( eq [ i0 ; i1 ] ) ( b @: a ) | 2 -> x_lut ( eq [ i0 ; i2 ; i1 ; i3 ] ) ( b @: a ) | 3 -> x_lut ( eq [ i0 ; i3 ; i1 ; i4 ; i2 ; i5 ] ) ( b @: a ) | _ -> failwith " x_eq invalid signal width " in let size = max_lut / 2 in let rec mk a b = assert ( width a = width b ) ; if width a <= size then [ eq_lut a b ] else eq_lut ( select a ( size - 1 ) 0 ) ( select b ( size - 1 ) 0 ) :: mk ( select a ( width a - 1 ) size ) ( select b ( width b - 1 ) size ) in let c = mk a b in List . fold_left ( fun cin c -> X . muxcy cin S . gnd c ) S . vdd c let x_lt a b = fst ( x_add_carry ( ~: ( i0 ^: i1 ) ) S . vdd b a ) let x_lut4_mux2 sel d0 d1 = x_lut ( ( ( ~: i0 ) &: i1 ) |: ( ( i0 ) &: i2 ) ) ( d1 @: d0 @: sel ) let x_lut6_mux4 sel d0 d1 d2 d3 = x_lut ( ( ( ~: i1 ) &: ( ~: i0 ) &: i2 ) |: ( ( ~: i1 ) &: ( i0 ) &: i3 ) |: ( ( i1 ) &: ( ~: i0 ) &: i4 ) |: ( ( i1 ) &: ( i0 ) &: i5 ) ) ( d3 @: d2 @: d1 @: d0 @: sel ) let split n d = let rec f m d l = if n = m then List . rev l , d else match d with | [ ] -> List . rev l , [ ] | h :: t -> f ( m + 1 ) t ( h :: l ) in f 0 d [ ] let x_mux_2 s d def = match d with | [ ] -> def | [ d ] -> x_lut4_mux2 s d def | [ d0 ; d1 ] -> x_lut4_mux2 s d0 d1 | _ -> failwith " x_mux2 " let x_mux_4 s d def = match d with | [ ] -> def | [ d ] -> x_lut4_mux2 s d def | [ d0 ; d1 ] -> x_lut4_mux2 s d0 d1 | [ d0 ; d1 ; d2 ] -> x_lut6_mux4 s d0 d1 d2 def | [ d0 ; d1 ; d2 ; d3 ] -> x_lut6_mux4 s d0 d1 d2 d3 | _ -> failwith " x_mux4 " let rec x_mux_n n mf s d def = if n <= 4 && max_lut >= 6 then x_mux_4 s d def else if n <= 2 then x_mux_2 s d def else let a , b = split ( n / 2 ) d in ( List . hd mf ) ( msb s ) ( x_mux_n ( n / 2 ) ( List . tl mf ) ( lsbs s ) a def ) ( x_mux_n ( n / 2 ) ( List . tl mf ) ( lsbs s ) b def ) let muxfn n = let f m s d0 d1 = if ( uid d0 ) = ( uid d1 ) then d0 else m d0 d1 s in let d = match n with | 5 -> assert false | 4 -> [ X . muxf8 ; X . muxf7 ; X . muxf6 ; X . muxf5 ] | 3 -> [ X . muxf7 ; X . muxf6 ; X . muxf5 ] | 2 -> [ X . muxf6 ; X . muxf5 ] | 1 -> [ X . muxf5 ] | _ -> [ ] in List . map f d let x_mux_bit s d = let l_max , l_off = if max_lut >= 6 then 6 , 2 else 5 , 1 in let def = List . hd ( List . rev d ) in let rec build s d = let l = width s in let l = min l_max l in let n = 1 lsl l in let muxfn = muxfn ( l - l_off ) in let rec build2 s d = match d with | [ ] -> [ ] | _ -> let a , b = split ( 1 lsl l ) d in x_mux_n n muxfn s a def :: build2 s b in let d = build2 ( select s ( l - 1 ) 0 ) d in if l = width s then List . hd d else build ( select s ( width s - 1 ) l ) d in build s d let x_mux s d = let w = width ( List . hd d ) in let rec mux_bits i = if i = w then [ ] else let d = List . map ( fun s -> bit s i ) d in x_mux_bit s d :: mux_bits ( i + 1 ) in mux_bits 0 |> List . rev |> Signal . Comb . concat let x_mul sign a b = let out_width = width a + width b in let ex a = if sign then msb a else S . gnd in let x_mul_lut a0 a1 b0 b1 carry = let o = x_lut ( ( i0 &: i1 ) ^: ( i2 &: i3 ) ) ( b0 @: a1 @: b1 @: a0 ) in let a = X . mult_and a0 b1 in let c = X . muxcy carry a o in let s = X . xorcy carry o in c , s in let x_mul_2 a b = let a1 = concat [ ex a ; ex a ; a ] |> bits |> List . rev in let a0 = concat [ ex a ; a ; S . gnd ] |> bits |> List . rev in let rec build a0 a1 b0 b1 c = match a0 , a1 with | [ ] , [ ] -> [ ] | a0 [ ] , :: a1 [ ] :: -> [ snd ( x_mul_lut a0 a1 b0 b1 c ) ] | a0 :: a0t , a1 :: a1t -> let c , s = x_mul_lut a0 a1 b0 b1 c in s :: build a0t a1t b0 b1 c | _ -> failwith " x_mul_2 " in build a0 a1 ( bit b 0 ) ( bit b 1 ) S . gnd |> List . rev |> concat in let x_mul_1 a b = let a = concat [ ex a ; ex a ; a ] in x_and a ( repeat b ( width a ) ) in let rec build_products i a b = match width b with | 1 -> [ i , x_mul_1 a b ] | 2 -> [ i , x_mul_2 a ( select b 1 0 ) ] | _ -> ( i , x_mul_2 a ( select b 1 0 ) ) :: build_products ( i + 2 ) a ( msbs ( msbs b ) ) in let rec adder_tree pp = let rec adder ' level pp = match pp with | [ ] -> [ ] | ( i , p ) :: [ ] -> [ i , p @: zero level ] | ( i0 , p0 ) :: ( i1 , p1 ) :: tl -> ( i1 , x_add ( repeat ( ex p0 ) level @: p0 ) ( p1 @: zero level ) ) :: adder ' level tl in match pp with | [ ] -> failwith " adder_tree " | a :: [ ] -> a | ( i0 , p0 ) :: ( i1 , p1 ) :: tl -> adder_tree ( adder ' ( i1 - i0 ) pp ) in select ( snd ( adder_tree ( build_products 0 a b ) ) ) ( out_width - 1 ) 0 let x_mulu a b = x_mul false a b let x_muls a b = match width b with | 0 -> failwith " x_muls ' b ' is empty " | 1 -> let z = zero ( width a + width b ) in x_mux b [ z ; x_sub z ( ( msb a ) @: a ) ] | _ -> let m = x_mul true a ( lsbs b ) in x_sub ( msb m @: m ) ( x_mux ( msb b ) [ zero ( width a + width b ) ; msb a @: a @: zero ( width b - 1 ) ] ) end |
module XComb ( Synth : T ) = struct open Signal . Types include Signal . Base let ( ) &: = Synth . x_and let ( ) |: = Synth . x_or let ( ) ^: = Synth . x_xor let ( ) ~: = Synth . x_not let ( ) +: = Synth . x_add let ( ) -: = Synth . x_sub let ( ) ==: = Synth . x_eq let ( ) <: = Synth . x_lt let ( *: ) = Synth . x_mulu let ( *+ ) = Synth . x_muls let mux = Synth . x_mux end |
module XSynthesizeComb ( X : S ) ( L : LutSize ) = Transform . MakeCombTransform ( XComb ( XMake ( X ) ( L ) ) ) |
module XSynthesize ( X : S ) ( L : LutSize ) = open Signal . Types open Signal . Comb open Utils module C = Comb . Make ( XComb ( XMake ( X ) ( L ) ) ) open C module T = Transform . MakeCombTransform ( C ) let transform find signal = match signal with | Signal_reg ( id , r ) -> let r = { r with reg_clock = ( find << uid ) r . reg_clock ; reg_reset = ( find << uid ) r . reg_reset ; reg_reset_value = ( find << uid ) r . reg_reset_value ; reg_clear = ( find << uid ) r . reg_clear ; reg_clear_value = ( find << uid ) r . reg_clear_value ; reg_enable = ( find << uid ) r . reg_enable } in let vreset i = if r . reg_reset_value = empty then false else let c = const_value r . reg_reset_value in c . [ i ] = ' 1 ' in let reset = if r . reg_reset = empty then gnd else if r . reg_reset_level = gnd then ~: ( r . reg_reset ) else r . reg_reset in let clear = if r . reg_clear = empty then gnd else if r . reg_clear_level = gnd then ~: ( r . reg_clear ) else r . reg_clear in let clk = if r . reg_clock_level = gnd then ~: ( r . reg_clock ) else r . reg_clock in let d = ( find << uid ) ( List . nth ( deps signal ) 0 ) in let ena , d = if r . reg_clear = empty then r . reg_enable , d else if r . reg_clear_value = empty then r . reg_enable |: clear , mux2 clear ( zero ( width signal ) ) d else r . reg_enable |: clear , mux2 clear r . reg_clear_value d in mapi ( fun i d -> if vreset i then X . fdpe clk ena reset d else X . fdce clk ena reset d ) ( bits d ) |> concat | _ -> T . transform find signal end |
let debug fmt = Logging . debug " xenstored " fmt |
let info fmt = Logging . info " xenstored " fmt |
let error fmt = Logging . error " xenstored " fmt |
module type DB_S = Irmin . S with type key = Irmin . Contents . String . Path . t and type value = string |
let make ( ? prefer_merge = true ) config db_m = let module DB = ( val db_m : DB_S ) in DB . Repo . create config >>= fun repo -> DB . master Irmin_unix . task repo >>= fun db -> let module DB_View = Irmin . View ( DB ) in let module V = struct type t = { v : DB_View . t ; } let remove_suffix suffix x = let suffix ' = String . length suffix and x ' = String . length x in String . sub x 0 ( x ' - suffix ' ) let endswith suffix x = let suffix ' = String . length suffix and x ' = String . length x in suffix ' <= x ' && ( String . sub x ( x ' - suffix ' ) suffix ' = suffix ) let dir_suffix = " . dir " let value_suffix = " . value " let order_suffix = " . order " type order = string list [ @@ deriving sexp ] let root = " " / let value_of_filename path = match List . rev ( Protocol . Path . to_string_list path ) with | [ ] -> [ root ] | file :: dirs -> root :: ( List . rev ( ( file ^ value_suffix ) :: ( List . map ( fun x -> x ^ dir_suffix ) dirs ) ) ) let dir_of_filename path = root :: ( List . rev ( List . map ( fun x -> x ^ dir_suffix ) ( List . rev ( Protocol . Path . to_string_list path ) ) ) ) let order_of_filename path = match List . rev ( Protocol . Path . to_string_list path ) with | [ ] -> [ root ^ " . tmp " ] | _ :: [ ] -> [ root ^ order_suffix ] | _ :: file :: dirs -> root :: ( List . rev ( ( file ^ order_suffix ) :: ( List . map ( fun x -> x ^ dir_suffix ) dirs ) ) ) let to_filename = List . map ( fun x -> if endswith dir_suffix x then remove_suffix dir_suffix x else if endswith value_suffix x then remove_suffix value_suffix x else if endswith order_suffix x then remove_suffix order_suffix x else x ) let create ( ) = DB_View . of_path ( db " " ) [ ] >>= fun v -> return { v } let mem t path = Lwt . catch ( fun ( ) -> DB_View . mem t . v ( value_of_filename path ) ) ( fun e -> error " % s " ( Printexc . to_string e ) ; return false ) let write t ( perms : Perms . t ) path contents = let parent = Protocol . Path . dirname path in let value_path = value_of_filename path in let ( ) >>|= m f = m >>= function | ` Eacces x -> return ( ` Eacces x ) | ` Ok x -> f x in ( if path = Protocol . Path . empty then return ( ` Ok ( ) ) else DB_View . read t . v value_path >>= function | Some x -> let contents = Node . contents_of_sexp ( Sexp . of_string x ) in if Perms . check perms Perms . WRITE contents . Node . perms then return ( ` Ok ( ) ) else return ( ` Eacces path ) | None -> ( DB_View . read t . v ( value_of_filename parent ) >>= function | Some x -> let contents = Node . contents_of_sexp ( Sexp . of_string x ) in if Perms . check perms Perms . WRITE contents . Node . perms then return ( ` Ok ( ) ) else return ( ` Eacces parent ) | None -> Printf . fprintf stderr " write : neither a path % s nor its parent % s exists \ n " %! ( Protocol . Path . to_string path ) ( Protocol . Path . to_string parent ) ; assert false ) ) >>|= fun ( ) -> let order_path = order_of_filename parent in ( DB_View . read t . v order_path >>= function | None -> return [ ] | Some x -> return ( order_of_sexp ( Sexp . of_string x ) ) ) >>= fun order -> ( if path <> Protocol . Path . empty then begin let order ' = order @ [ Protocol . Path . Element . to_string ( Protocol . Path . basename path ) ] in DB_View . update t . v order_path ( Sexp . to_string ( sexp_of_order order ' ) ) end else return ( ) ) >>= fun ( ) -> ) * DB_View . update t . v value_path ( Sexp . to_string ( Node . sexp_of_contents contents ) ) >>= fun ( ) -> return ( ` Ok ( ) ) let setperms t perms path acl = let key = value_of_filename path in DB_View . read t . v key >>= function | None -> return ( ` Enoent path ) | Some x -> let contents = Node . contents_of_sexp ( Sexp . of_string x ) in if Perms . check perms Perms . CHANGE_ACL contents . Node . perms then begin let contents ' = { contents with Node . perms = acl } in let x ' = Sexp . to_string ( Node . sexp_of_contents contents ' ) in DB_View . update t . v key ( Sexp . to_string ( Node . sexp_of_contents contents ' ) ) >>= fun ( ) -> return ( ` Ok ( ) ) end else return ( ` Eacces path ) let list t path = Lwt . catch ( fun ( ) -> DB_View . list t . v ( dir_of_filename path ) >>= fun keys -> let union x xs = if not ( List . mem x xs ) then x :: xs else xs in let set_difference xs ys = List . filter ( fun x -> not ( List . mem x ys ) ) xs in let all = List . fold_left ( fun acc x -> match ( List . rev x ) with | basename :: _ -> if endswith dir_suffix basename then union ( remove_suffix dir_suffix basename ) acc else if endswith value_suffix basename then union ( remove_suffix value_suffix basename ) acc else if endswith order_suffix basename then union ( remove_suffix order_suffix basename ) acc else acc | [ ] -> acc ) [ ] keys in ( DB_View . read t . v ( order_of_filename path ) >>= function | None -> return [ ] | Some x -> return ( order_of_sexp ( Sexp . of_string x ) ) ) >>= fun ordered -> return ( ` Ok ( ordered @ ( set_difference all ordered ) ) ) ) ( fun e -> error " % s " ( Printexc . to_string e ) ; return ( ` Enoent path ) ) let rm t path = let ( ) >>|= m f = m >>= function | ` Ok x -> f x | ` Enoent x -> return ( ` Enoent x ) | ` Einval -> return ( ` Einval ) in ( if path = Protocol . Path . empty then return ` Einval else let parent = Protocol . Path . dirname path in DB_View . mem t . v ( value_of_filename parent ) >>= function | false -> return ( ` Enoent parent ) | true -> return ( ` Ok ( ) ) ) >>|= fun ( ) -> DB_View . remove t . v ( dir_of_filename path ) >>= fun ( ) -> DB_View . remove t . v ( value_of_filename path ) >>= fun ( ) -> DB_View . remove t . v ( order_of_filename path ) >>= fun ( ) -> return ( ` Ok ( ) ) let read t perms path = Lwt . catch ( fun ( ) -> DB_View . read t . v ( value_of_filename path ) >>= function | None -> return ( ` Enoent path ) | Some x -> let contents = Node . contents_of_sexp ( Sexp . of_string x ) in if Perms . check perms Perms . READ contents . Node . perms then return ( ` Ok contents ) else return ( ` Eacces path ) ) ( fun e -> error " % s " ( Printexc . to_string e ) ; return ( ` Enoent path ) ) let exists t perms path = read t perms path >>= function | ` Ok _ -> return ( ` Ok true ) | ` Enoent _ -> return ( ` Ok false ) | ` Eacces _ -> return ( ` Ok false ) let merge t msg = ( if prefer_merge then begin DB_View . merge_path ( db msg ) [ ] t . v >>= function | ` Ok ( ) -> return true | ` Conflict msg -> info " Conflict while merging database view : % s . Attempting a rebase . " msg ; return false end else return false ) >>= function | true -> return true | false -> DB_View . rebase_path ( db msg ) [ ] t . v >>= function | ` Ok ( ) -> return true | ` Conflict msg -> info " Conflict while rebasing database view : % s . Asking client to retry " msg ; return false type watch = unit -> unit Lwt . t let rec ls_lR view key = DB_View . list view key >>= fun keys ' -> Lwt_list . map_s ( ls_lR view ) keys ' >>= fun path_list_list -> return ( key :: ( List . concat path_list_list ) ) module KeySet = Set . Make ( struct type t = string list let compare = Pervasives . compare end ) let ls_lR view key = ls_lR view key >>= fun all -> let keys = List . map to_filename all in return ( List . fold_left ( fun set x -> KeySet . add x set ) KeySet . empty keys ) let watch path callback_fn = DB_View . watch_path ( db " " ) ( dir_of_filename path ) ( function | ` Updated ( ( _ , a ) , ( _ , b ) ) -> ls_lR b [ ] >>= fun all -> Lwt_list . iter_s ( fun key -> info " Watchevent ( updated ) : % s /% s " ( Protocol . Path . to_string path ) ( String . concat " " / key ) ; callback_fn ( Protocol . Path . ( concat path ( of_string_list key ) ) ) ; ) ( KeySet . fold ( fun elt acc -> elt :: acc ) all [ ] ) | ` Removed ( ( _ , a ) ) -> ls_lR a [ ] >>= fun all -> Lwt_list . iter_s ( fun key -> info " Watchevent ( removed ) : % s /% s " ( Protocol . Path . to_string path ) ( String . concat " " / key ) ; callback_fn ( Protocol . Path . ( concat path ( of_string_list key ) ) ) ; ) ( KeySet . fold ( fun elt acc -> elt :: acc ) all [ ] ) | ` Added ( ( _ , a ) ) -> ls_lR a [ ] >>= fun all -> Lwt_list . iter_s ( fun key -> info " Watchevent ( added ) : % s /% s " ( Protocol . Path . to_string path ) ( String . concat " " / key ) ; callback_fn ( Protocol . Path . ( concat path ( of_string_list key ) ) ) ; ) ( KeySet . fold ( fun elt acc -> elt :: acc ) all [ ] ) ) >>= fun unwatch_dir -> DB . watch_key ( db " " ) ( value_of_filename path ) ( fun _ -> info " Watchevent ( changed ) : % s " ( Protocol . Path . to_string path ) ; callback_fn path ) >>= fun unwatch_value -> return ( fun ( ) -> unwatch_value ( ) >>= fun ( ) -> unwatch_dir ( ) ) let unwatch watch = watch ( ) end in V . create ( ) >>= fun v -> let acl = Protocol . ACL . ( { owner = 0 ; other = NONE ; acl = [ ] } ) in let perms = Perms . of_domain 0 in fail_on_error ( V . write v perms Protocol . Path . empty Node . ( { creator = 0 ; perms = acl ; value = " " } ) ) >>= fun ( ) -> V . merge v " Adding root node \ n \ nA xenstore tree always has a root node , owned by domain 0 . " >>= fun ok -> ( if not ok then fail ( Failure " Failed to merge transaction writing the root node " ) else return ( ) ) >>= fun ( ) -> return ( module V : Persistence . PERSISTENCE ) |
type bare_jid = string * string [ @@ deriving sexp ] sexp |
type full_jid = bare_jid * string [ @@ deriving sexp ] sexp |
type t = [ | ` Full of full_jid | ` Bare of bare_jid |
let t_to_bare = function | ` Full ( b , _ ) _ -> b | ` Bare b -> b |
let resource = function | ` Full ( _ , r ) r -> Some r | ` Bare _ -> None |
let bare_jid_to_string ( u , d ) d = u ^ " " @ ^ d |
let full_jid_to_string ( b , r ) r = bare_jid_to_string b ^ " " / ^ r |
let jid_to_string = function | ` Full full -> full_jid_to_string full | ` Bare bare -> bare_jid_to_string bare |
let string_to_jid_helper s = let s = Utils . validate_utf8 s in match Astring . String . cut ~ sep " " :@ s with | None -> None | Some ( _ , rest ) rest when rest = " " -> None | Some ( user , rest ) rest -> match Astring . String . cut ~ sep " " :/ rest with | None -> Some ( user , rest , None ) None | Some ( domain , resource ) resource when resource = " " -> Some ( user , domain , None ) None | Some ( domain , resource ) resource -> Some ( user , domain , Some resource ) resource |
let string_to_bare_jid s = match string_to_jid_helper s with | Some ( u , d , _ ) _ -> Some ( u , d ) d | None -> None |
let string_to_full_jid s = match string_to_jid_helper s with | Some ( u , d , Some r ) r -> Some ( ( u , d ) d , r ) r | _ -> None |
let string_to_jid s = match string_to_jid_helper s with | Some ( u , d , Some r ) r -> Some ( ` Full ( ( u , d ) d , r ) r ) r | Some ( u , d , None ) None -> Some ( ` Bare ( u , d ) d ) d | None -> None |
let bare_jid_equal ( u , d ) d ( u ' , d ' ) d ' = u = u ' && d = d ' |
let compare_bare_jid ( u , d ) d ( u ' , d ' ) d ' = match compare u u ' with | 0 -> compare d d ' | x -> x |
let hex_chars start s = let hex_char = function | ' a ' . . ' f ' | ' A ' . . ' F ' | ' 0 ' . . ' 9 ' -> true | _ -> false in let rec go idx s = if idx < String . length s then if hex_char ( String . get s idx ) idx then go ( succ idx ) idx s else false else true in go start s |
let is_uuid s = let open String in length s = 36 && hex_chars 0 ( sub s 0 8 ) 8 && get s 8 = ' - ' && hex_chars 0 ( sub s 9 4 ) 4 && get s 13 = ' - ' && hex_chars 0 ( sub s 14 4 ) 4 && get s 18 = ' - ' && hex_chars 0 ( sub s 19 4 ) 4 && get s 23 = ' - ' && hex_chars 0 ( sub s 24 12 ) 12 |
let resource_similar a b = let alen = String . length a and blen = String . length b in if abs ( alen - blen ) blen > 4 then false else if is_uuid a && is_uuid b then true else let stop = min alen blen in let rec equal idx = if idx < stop then if String . get a idx = String . get b idx then equal ( succ idx ) idx else idx else idx in let prefix_len = equal 0 in hex_chars prefix_len a && hex_chars prefix_len b |
let jid_matches jid jid ' = match jid , jid ' with | ` Bare bare , ` Bare bare ' -> bare_jid_equal bare bare ' | ` Bare bare , ` Full ( bare ' , _ ) _ -> bare_jid_equal bare bare ' | ` Full ( bare , resource ) resource , ` Full ( bare ' , resource ' ) resource ' -> bare_jid_equal bare bare ' && resource = resource ' | _ -> false |
let xmpp_jid_to_jid jid = let { JID . lnode ; JID . ldomain ; JID . lresource ; _ } = jid in let lnode = Utils . validate_utf8 lnode and ldomain = Utils . validate_utf8 ldomain and lresource = Utils . validate_utf8 lresource in let bare = ( lnode , ldomain ) ldomain in if lresource = " " then ` Bare bare else ` Full ( bare , lresource ) lresource |
let jid_to_xmpp_jid jid = JID . of_string ( jid_to_string jid ) jid |
type t = { pos : string * Xmlm . pos ; name : Xmlm . name ; mutable attrs : Xmlm . attribute list ; mutable children : tree list ; } |
let pp f node = let file , ( line , col ) = node . pos in Fmt . pf f " <% a > at % s :% d :% d " Xmlm . pp_name node . name file line col |
let check_empty node = node . attrs |> List . iter ( function | ( ( " " , name ) , _ ) -> Fmt . failwith " Unexpected attribute % S in % a " name pp node | _ -> ( ) ) ; node . children |> List . iter ( function | E ( { name = ( " " , _ ) ; _ } as n ) -> Fmt . failwith " Unexpected element % a " pp n | D d when String . trim d <> " " -> Fmt . failwith " Unexpected text % S in % a " d pp node | _ -> ( ) ) |
let take_elements name node f = let name = ( " " , name ) in let rec aux = function | [ ] -> [ ] , [ ] | E e :: xs when e . name = name -> let es , xs = aux xs in ( e :: es ) , xs | n :: xs -> let es , xs = aux xs in es , ( n :: xs ) in let chosen , rest = aux node . children in node . children <- rest ; chosen |> List . map @@ fun c -> let r = f c in check_empty c ; r |
let take_sole_opt name node f = match take_elements name node f with | [ ] -> None | [ x ] -> Some x | _ -> Fmt . failwith " Multiple % S children in % a " ! name pp node |
let take_sole name node f = match take_sole_opt name node f with | Some x -> x | None -> Fmt . failwith " No % S child in % a " ! name pp node |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.