AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let _composite u1 u2 = if 0x1100 <= u1 && u1 <= 0x1112 then begin if u2 < 0x1161 \|\| 0x1175 < u2 then ux_none else let l = u1 - H . lbase in let v = u2 - H . vbase in H . sbase + l * H . ncount + v * H . tcount end else if 0xAC00 <= u1 && u1 <= 0xD788 && ( u1 - 0x0AC00 ) mod H . tcount = 0 then begin if u2 < 0x11A8 \|\| u2 > 0x11C3 then ux_none else ( u1 + u2 - H . tbase ) end else match compose_prop u1 with \| [ ] \|\| -> ux_none \| a -> let len = Array . length a / 2 in let i = ref 0 in try while ( ! i < len ) do if a . ( ! i * 2 ) = u2 then raise Exit else incr i ; done ; ux_none with Exit -> ( a . ( ! i * 2 + 1 ) )
let composite u1 u2 = let u = _composite ( Uchar . to_int u1 ) ( Uchar . to_int u2 ) in if u = ux_none then None else Some ( Uchar . unsafe_of_int u )
type form = [ ` NFC \| ` NFD \| ` NFKC \| ` NFKD ]
type t = { form : form ; compat : bool ; compose : bool ; boundary : int -> bool ; mutable state : state ; mutable uc : [ ` Uchar of Uchar . t ] ; mutable acc : int array ; mutable first : int ; mutable last : int ; mutable is_end : bool ; }
let create_acc ( ) = Array . make 35 ux_none
let create form = let boundary , compat , compose = match form with \| ` NFC -> nfc_boundary , false , true \| ` NFD -> nfd_boundary , false , false \| ` NFKC -> nfkc_boundary , true , true \| ` NFKD -> nfkd_boundary , true , false in { form = ( form :> form ) ; compat ; compose ; boundary ; state = Start ; uc = u_dumb ; acc = create_acc ( ) ; first = 0 ; last = - 1 ; is_end = false }
let get_u n = let ` Uchar u = n . uc in Uchar . to_int u
let acc_empty n = n . first > n . last
let form n = n . form
let copy n = { n with acc = Array . copy n . acc }
let reset n = n . state <- Start ; n . uc <- u_dumb ; n . acc <- create_acc ( ) ; n . first <- 0 ; n . last <- - 1 ; n . is_end <- false
let grow_acc n = let len = Array . length n . acc in let acc ' = Array . make ( 2 * len ) ux_none in Array . blit n . acc 0 acc ' 0 len ; n . acc <- acc '
let ordered_add n u = n . last <- n . last + 1 ; if n . last = Array . length n . acc then grow_acc n ; let c = _ccc u in if c = 0 then n . acc . ( n . last ) <- u else begin let i = ref ( n . last - 1 ) in while ( ! i >= 0 && _ccc ( n . acc . ( ! i ) ) > c ) do n . acc . ( ! i + 1 ) <- n . acc . ( ! i ) ; decr i ; done ; n . acc . ( ! i + 1 ) <- u end
let rec add n u = if 0xAC00 <= u && u <= 0xD7A3 then begin let sindex = u - H . sbase in let l = H . lbase + ( sindex / H . ncount ) in let v = H . vbase + ( sindex mod H . ncount ) / H . tcount in let t = H . tbase + ( sindex mod H . tcount ) in if t = H . tbase then ( ordered_add n l ; ordered_add n v ) else ( ordered_add n l ; ordered_add n v ; ordered_add n t ) end else begin match decomp_prop u with \| [ ] \|\| -> ordered_add n u \| d -> if d_compatibility d . ( 0 ) && not n . compat then ordered_add n u else begin add n ( _d_uchar d . ( 0 ) ) ; for i = 1 to Array . length d - 1 do add n d . ( i ) done end end
let compose n = let rec loop ~ last_starter ~ prev_ccc i = if i > n . last then ( ) else let ccc_i = _ccc n . acc . ( i ) in let u_comp = _composite n . acc . ( last_starter ) n . acc . ( i ) in match ( u_comp = ux_none \|\| ( ccc_i = 0 && last_starter <> i - 1 ) ) with \| true -> let last_starter = if ccc_i = 0 then i else last_starter in loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) \| false -> match prev_ccc <> 0 && prev_ccc >= ccc_i with \| true -> loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) \| false -> n . acc . ( last_starter ) <- u_comp ; Array . blit n . acc ( i + 1 ) n . acc i ( n . last - i ) ; n . last <- n . last - 1 ; let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 ) in let last_starter = n . first in let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 )
let flush_next n = let ret = ` Uchar ( Uchar . unsafe_of_int n . acc . ( n . first ) ) in if n . first = n . last then ( n . first <- 0 ; n . last <- - 1 ) else ( n . first <- n . first + 1 ) ; ret
let flush_start n = if n . compose then compose n ; flush_next n
let add n = function let u = Uchar . to_int u in begin match n . state with \| Boundary -> if n . boundary u then ( let prev = n . uc in n . uc <- uc ; ( prev :> ret ) ) else ( n . state <- Acc ; add n ( get_u n ) ; add n u ; ` Await ) \| Acc -> if n . boundary u then ( n . state <- Flush ; n . uc <- uc ; flush_start n ) else ( add n u ; ` Await ) \| Start -> if n . boundary u then ( n . state <- Boundary ; n . uc <- uc ; ` Await ) else ( n . state <- Acc ; add n u ; ` Await ) \| Flush -> err_exp_await uc \| End -> err_ended uc end begin match n . state with \| Flush -> if not ( acc_empty n ) then flush_next n else if n . is_end then ( n . state <- End ; ` End ) else ( n . state <- Boundary ; ` Await ) \| Start \| Boundary \| Acc -> ` Await \| End -> ` End end n . is_end <- true ; begin match n . state with \| Boundary -> n . state <- End ; ( n . uc :> ret ) \| Acc -> n . state <- Flush ; flush_start n \| Start -> n . state <- End ; ` End \| Flush -> err_exp_await ` End \| End -> err_ended ` End end
let string_X ppf s = Format . pp_open_vbox ppf 1 ; string ppf " " " ; \ for i = 0 to String . length s - 1 do if i mod 16 = 0 && i > 0 then pf ppf " \\@\ n " ; pf ppf " \\ x % 02x " ( Char . code s . [ i ] ) done ; string ppf " " " ; \ Format . pp_close_box ppf ( )
let string_XN ppf = function " " -> string ppf " snil " \| x -> string_X ppf x
let semi ppf ( ) = string ppf " ; " ; sp ppf ( )
let iter i ( ? sep = sp ) pp ppf x = let fst = ref true in i ( fun v -> ( if ! fst then fst := false else sep ppf ( ) ) ; pp ppf v ) x
let as_array i pp ppf = pf ppf " [ @< 2 [ >\|% a ] ] " \|@ ( iter i ~ sep : semi pp )
let array pp = as_array Array . iter pp
let array_N pp ppf = function [ ] \|\| -> string ppf " nil " \| x -> array pp ppf x
module R = struct type _ record = \| [ ] : unit record \| ( ) :: : ( string * ( Format . formatter -> ' a -> unit ) ) * ' b record -> ( ' a -> ' b ) record end
let record record ppf = let field name pp_v ppf v = pf ppf " [ @< 1 >% s =@ % a ] " @ name pp_v v in let open R in let rec go : type a . ( unit -> unit ) -> a R . record -> a = fun k -> function \| [ ] -> pf ppf " [ @< 2 { > % a } ] " @ ( fun _ -> k ) ( ) \| [ name , pp_v ] -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ) [ ] \| ( name , pp_v ) :: record -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ; semi ppf ( ) ) record in go ignore record
type ' a t = { default : ' a ; l0 : ' a array array array }
let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == nil then m . default else Array . unsafe_get l2 ( u land l2_mask )
let create default = { default ; l0 = Array . make l0_size nil }
let set m u v = if v = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size nil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == nil then m . l0 . ( i ) . ( j ) <- Array . make l2_size m . default ; m . l0 . ( i ) . ( j ) . ( u land l2_mask ) <- v
let size v_size m = match m . l0 with let size = ref ( 3 + v_size m . default + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with \| [ ] \|\| -> ( ) \| l1 -> size := ! size + ( 1 + Array . length l1 ) ; for j = 0 to Array . length l1 - 1 do match l1 . ( j ) with \| [ ] \|\| -> ( ) \| l2 -> size := ! size + ( 1 + Array . length l2 ) ; for k = 0 to Array . length l2 - 1 do size := ! size + v_size l2 . ( k ) done ; done ; done ; ! size
let dump pp_v ppf m = let open Uunf_fmt in record [ " default " , pp_v ; " l0 " , pp_v \|> array_N \|> array_N \|> array ] ppf m . default m . l0
type t = { default : bool ; l0 : string array array }
let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code ( String . unsafe_get l2 byte_num ) in byte land ( 1 lsl bit_num ) > 0
let create default = { default ; l0 = Array . make l0_size nil }
let set m u b = let l2_make m = Bytes . make l2_size ( if m . default then ' \ xFF ' else ' \ x00 ' ) in if b = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code m . l0 . ( i ) . ( j ) . [ byte_num ] in let new_byte = if b then ( Char . unsafe_chr ( byte lor ( 1 lsl bit_num ) ) ) else ( Char . unsafe_chr ( byte land lnot ( 1 lsl bit_num ) ) ) in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) byte_num new_byte
let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with \| [ ] \|\| -> ( ) \| l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size
let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0
let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , bool ; " l0 " , pp_v \|> array_N \|> array ] ppf m . default m . l0
let dump = dump_pp pp_v
type t = { default : int ; l0 : string array array }
let get m u = let l1 = Array . get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else Char . code ( String . unsafe_get l2 ( u land l2_mask ) )
let create default = { default ; l0 = Array . make l0_size nil }
let set m u byte = let l2_make m = Bytes . make l2_size ( Char . chr m . default ) in if byte = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) k ( Char . unsafe_chr byte )
let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with \| [ ] \|\| -> ( ) \| l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size
let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0
let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , int ; " l0 " , pp_v \|> array_N \|> array ] ppf m . default m . l0
let dump = dump_pp pp_v
let invalid_encode ( ) = invalid_arg " expected ` Await encode "
let invalid_bounds j l = invalid_arg ( Printf . sprintf " invalid bounds ( index % d , length % d ) " j l )
let unsafe_byte s j = Char . code ( Bytes . unsafe_get s j )
let unsafe_set_byte s j byte = Bytes . unsafe_set s j ( Char . unsafe_chr byte )
let u_bom = Uchar . unsafe_of_int 0xFEFF
let u_rep = Uchar . unsafe_of_int 0xFFFD
type encoding = [ ` UTF_8 \| ` UTF_16 \| ` UTF_16BE \| ` UTF_16LE ]
type decoder_encoding = [ encoding \| ` US_ASCII \| ` ISO_8859_1 ]
let encoding_of_string s = match String . uppercase_ascii s with Some ` US_ASCII Some ` ISO_8859_1
let malformed s j l = ` Malformed ( Bytes . sub_string s j l )
let malformed_pair be hi s j l = let bs1 = Bytes . ( sub s j l ) in let bs0 = Bytes . create 2 in let j0 , j1 = if be then ( 0 , 1 ) else ( 1 , 0 ) in unsafe_set_byte bs0 j0 ( hi lsr 8 ) ; unsafe_set_byte bs0 j1 ( hi land 0xFF ) ; ` Malformed Bytes . ( unsafe_to_string ( cat bs0 bs1 ) )
let r_us_ascii s j = let b0 = unsafe_byte s j in if b0 <= 127 then ` Uchar ( Uchar . unsafe_of_int b0 ) else malformed s j 1
let r_iso_8859_1 s j = ` Uchar ( Uchar . unsafe_of_int @@ unsafe_byte s j )
let utf_8_len = [ \| 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 4 ; 4 ; 4 ; 4 ; 4 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ] \|
let r_utf_8 s j l = let uchar c = ` Uchar ( Uchar . unsafe_of_int c ) in match l with \| 1 -> uchar ( unsafe_byte s j ) \| 2 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in if b1 lsr 6 != 0b10 then malformed s j l else uchar ( ( ( b0 land 0x1F ) lsl 6 ) lor ( b1 land 0x3F ) ) \| 3 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in let b2 = unsafe_byte s ( j + 2 ) in let c = ( ( b0 land 0x0F ) lsl 12 ) lor ( ( b1 land 0x3F ) lsl 6 ) lor ( b2 land 0x3F ) in if b2 lsr 6 != 0b10 then malformed s j l else begin match b0 with \| 0xE0 -> if b1 < 0xA0 \|\| 0xBF < b1 then malformed s j l else uchar c \| 0xED -> if b1 < 0x80 \|\| 0x9F < b1 then malformed s j l else uchar c \| _ -> if b1 lsr 6 != 0b10 then malformed s j l else uchar c end \| 4 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in let b2 = unsafe_byte s ( j + 2 ) in let b3 = unsafe_byte s ( j + 3 ) in let c = ( ( ( b0 land 0x07 ) lsl 18 ) lor ( ( b1 land 0x3F ) lsl 12 ) lor ( ( b2 land 0x3F ) lsl 6 ) lor ( b3 land 0x3F ) ) in if b3 lsr 6 != 0b10 \|\| b2 lsr 6 != 0b10 then malformed s j l else begin match b0 with \| 0xF0 -> if b1 < 0x90 \|\| 0xBF < b1 then malformed s j l else uchar c \| 0xF4 -> if b1 < 0x80 \|\| 0x8F < b1 then malformed s j l else uchar c \| _ -> if b1 lsr 6 != 0b10 then malformed s j l else uchar c end \| _ -> assert false
let r_utf_16 s j0 j1 = let b0 = unsafe_byte s j0 in let b1 = unsafe_byte s j1 in let u = ( b0 lsl 8 ) lor b1 in if u < 0xD800 \|\| u > 0xDFFF then ` Uchar ( Uchar . unsafe_of_int u ) else if u > 0xDBFF then malformed s ( min j0 j1 ) 2 else ` Hi u
let r_utf_16_lo hi s j0 j1 = let b0 = unsafe_byte s j0 in let b1 = unsafe_byte s j1 in let lo = ( b0 lsl 8 ) lor b1 in if lo < 0xDC00 \|\| lo > 0xDFFF then malformed_pair ( j0 < j1 ) hi s ( min j0 j1 ) 2 else ` Uchar ( Uchar . unsafe_of_int ( ( ( ( hi land 0x3FF ) lsl 10 ) lor ( lo land 0x3FF ) ) + 0x10000 ) )
let r_encoding s j l = let some i = if i < l then Some ( unsafe_byte s ( j + i ) ) else None in match ( some 0 ) , ( some 1 ) , ( some 2 ) with \| Some 0xEF , Some 0xBB , Some 0xBF -> ` UTF_8 ` BOM \| Some 0xFE , Some 0xFF , _ -> ` UTF_16BE ` BOM \| Some 0xFF , Some 0xFE , _ -> ` UTF_16LE ` BOM \| Some 0x00 , Some p , _ when p > 0 -> ` UTF_16BE ( ` ASCII p ) \| Some p , Some 0x00 , _ when p > 0 -> ` UTF_16LE ( ` ASCII p ) \| Some u , _ , _ when utf_8_len . ( u ) <> 0 -> ` UTF_8 ` Decode \| Some _ , Some _ , _ -> ` UTF_16BE ` Decode \| Some _ , None , None -> ` UTF_8 ` Decode \| None , None , None -> ` UTF_8 ` End \| None , Some _ , _ -> assert false \| Some _ , None , Some _ -> assert false \| None , None , Some _ -> assert false
type src = [ ` Channel of in_channel \| ` String of string \| ` Manual ]
type nln = [ ` ASCII of Uchar . t \| ` NLF of Uchar . t \| ` Readline of Uchar . t ]
type decode = [ ` Await \| ` End \| ` Malformed of string \| ` Uchar of Uchar . t ]
let pp_decode ppf = function let l = String . length bs in pp ppf " [ ` @ Malformed ( " ; if l > 0 then pp ppf " % 02X " ( Char . code ( bs . [ 0 ] ) ) ; for i = 1 to l - 1 do pp ppf " % 02X " ( Char . code ( bs . [ i ] ) ) done ; pp ppf " ) ] " @
type decoder = { src : src ; mutable encoding : decoder_encoding ; nln : nln option ; nl : Uchar . t ; mutable i : Bytes . t ; mutable i_pos : int ; mutable i_max : int ; t : Bytes . t ; mutable t_len : int ; mutable t_need : int ; mutable removed_bom : bool ; mutable last_cr : bool ; mutable line : int ; mutable col : int ; mutable byte_count : int ; mutable count : int ; mutable pp : decoder -> [ ` Malformed of string \| ` Uchar of Uchar . t ] -> decode ; mutable k : decoder -> decode }
let i_rem d = d . i_max - d . i_pos + 1
let eoi d = d . i <- Bytes . empty ; d . i_pos <- 0 ; d . i_max <- min_int
let src d s j l = if ( j < 0 \|\| l < 0 \|\| j + l > Bytes . length s ) then invalid_bounds j l else if ( l = 0 ) then eoi d else ( d . i <- s ; d . i_pos <- j ; d . i_max <- j + l - 1 )
let refill k d = match d . src with let rc = input ic d . i 0 ( Bytes . length d . i ) in ( src d d . i 0 rc ; k d )
let t_need d need = d . t_len <- 0 ; d . t_need <- need
let rec t_fill k d = let blit d l = unsafe_blit d . i d . i_pos d . t d . t_len l ; d . i_pos <- d . i_pos + l ; d . t_len <- d . t_len + l ; in let rem = i_rem d in if rem < 0 then k d else let need = d . t_need - d . t_len in if rem < need then ( blit d rem ; refill ( t_fill k ) d ) else ( blit d need ; k d )
let ret k v byte_count d = d . k <- k ; d . byte_count <- d . byte_count + byte_count ; d . pp d v
let rec decode_us_ascii d = let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_us_ascii d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 1 ; ret decode_us_ascii ( r_us_ascii d . i j ) 1 d
let rec decode_iso_8859_1 d = let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_iso_8859_1 d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 1 ; ret decode_iso_8859_1 ( r_iso_8859_1 d . i j ) 1 d
let rec t_decode_utf_8 d = if d . t_len < d . t_need then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ret decode_utf_8 ( r_utf_8 d . t 0 d . t_len ) d . t_len d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_8 d ) else let need = unsafe_array_get utf_8_len ( unsafe_byte d . i d . i_pos ) in if rem < need then ( t_need d need ; t_fill t_decode_utf_8 d ) else let j = d . i_pos in if need = 0 then ( d . i_pos <- d . i_pos + 1 ; ret decode_utf_8 ( malformed d . i j 1 ) 1 d ) else ( d . i_pos <- d . i_pos + need ; ret decode_utf_8 ( r_utf_8 d . i j need ) need d )
let rec t_decode_utf_16be_lo hi d = let bcount = d . t_len + 2 in if d . t_len < d . t_need then ret decode_utf_16be ( malformed_pair true hi d . t 0 d . t_len ) bcount d else ret decode_utf_16be ( r_utf_16_lo hi d . t 0 1 ) bcount d if d . t_len < d . t_need then ret decode_utf_16be ( malformed d . t 0 d . t_len ) d . t_len d else decode_utf_16be_lo ( r_utf_16 d . t 0 1 ) d let rem = i_rem d in if rem < 2 then ( t_need d 2 ; t_fill ( t_decode_utf_16be_lo hi ) d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; ret decode_utf_16be ( r_utf_16_lo hi d . i j ( j + 1 ) ) 4 d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_16be d ) else if rem < 2 then ( t_need d 2 ; t_fill t_decode_utf_16be d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; decode_utf_16be_lo ( r_utf_16 d . i j ( j + 1 ) ) d
let rec t_decode_utf_16le_lo hi d = let bcount = d . t_len + 2 in if d . t_len < d . t_need then ret decode_utf_16le ( malformed_pair false hi d . t 0 d . t_len ) bcount d else ret decode_utf_16le ( r_utf_16_lo hi d . t 1 0 ) bcount d if d . t_len < d . t_need then ret decode_utf_16le ( malformed d . t 0 d . t_len ) d . t_len d else decode_utf_16le_lo ( r_utf_16 d . t 1 0 ) d let rem = i_rem d in if rem < 2 then ( t_need d 2 ; t_fill ( t_decode_utf_16le_lo hi ) d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; ret decode_utf_16le ( r_utf_16_lo hi d . i ( j + 1 ) j ) 4 d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_16le d ) else if rem < 2 then ( t_need d 2 ; t_fill t_decode_utf_16le d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; decode_utf_16le_lo ( r_utf_16 d . i ( j + 1 ) j ) d
let guessed_utf_8 d = let b3 d = let b3 = unsafe_byte d . t 2 in match utf_8_len . ( b3 ) with \| 0 -> ret decode_utf_8 ( malformed d . t 2 1 ) 1 d \| n -> d . t_need <- n ; d . t_len <- 1 ; unsafe_set_byte d . t 0 b3 ; t_fill t_decode_utf_8 d in let b2 d = let b2 = unsafe_byte d . t 1 in let b3 = if d . t_len > 2 then b3 else decode_utf_8 in match utf_8_len . ( b2 ) with \| 0 -> ret b3 ( malformed d . t 1 1 ) 1 d \| 1 -> ret b3 ( r_utf_8 d . t 1 1 ) 1 d \| n -> d . t_need <- n ; unsafe_set_byte d . t 0 b2 ; if ( d . t_len < 3 ) then d . t_len <- 1 else ( d . t_len <- 2 ; unsafe_set_byte d . t 1 ( unsafe_byte d . t 2 ) ; ) ; t_fill t_decode_utf_8 d in let b1 = unsafe_byte d . t 0 in let b2 = if d . t_len > 1 then b2 else decode_utf_8 in match utf_8_len . ( b1 ) with \| 0 -> ret b2 ( malformed d . t 0 1 ) 1 d \| 1 -> ret b2 ( r_utf_8 d . t 0 1 ) 1 d \| 2 -> if d . t_len < 2 then ret decode_utf_8 ( malformed d . t 0 1 ) 1 d else if d . t_len < 3 then ret decode_utf_8 ( r_utf_8 d . t 0 2 ) 2 d else ret b3 ( r_utf_8 d . t 0 2 ) 2 d \| 3 -> if d . t_len < 3 then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ret decode_utf_8 ( r_utf_8 d . t 0 3 ) 3 d \| 4 -> if d . t_len < 3 then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ( d . t_need <- 4 ; t_fill t_decode_utf_8 d ) \| n -> assert false
let guessed_utf_16 d be v = let decode_utf_16 , t_decode_utf_16 , t_decode_utf_16_lo , j0 , j1 = if be then decode_utf_16be , t_decode_utf_16be , t_decode_utf_16be_lo , 0 , 1 else decode_utf_16le , t_decode_utf_16le , t_decode_utf_16le_lo , 1 , 0 in let b3 k d = if d . t_len < 3 then decode_utf_16 d else begin d . t_need <- 2 ; d . t_len <- 1 ; unsafe_set_byte d . t 0 ( unsafe_byte d . t 2 ) ; t_fill k d end in match v with \| ` BOM -> ret ( b3 t_decode_utf_16 ) ( ` Uchar u_bom ) 2 d \| ` ASCII u -> ret ( b3 t_decode_utf_16 ) ( ` Uchar ( Uchar . unsafe_of_int u ) ) 2 d \| ` Decode -> match r_utf_16 d . t j0 j1 with \| ` Malformed _ \| ` Uchar _ as v -> ret ( b3 t_decode_utf_16 ) v 2 d \| ` Hi hi -> if d . t_len < 3 then ret decode_utf_16 ( malformed_pair be hi Bytes . empty 0 0 ) d . t_len d else ( b3 ( t_decode_utf_16_lo hi ) ) d
let guess_encoding d = let setup d = match r_encoding d . t 0 d . t_len with \| ` UTF_8 r -> d . encoding <- ` UTF_8 ; d . k <- decode_utf_8 ; begin match r with \| ` BOM -> ret decode_utf_8 ( ` Uchar u_bom ) 3 d \| ` Decode -> guessed_utf_8 d \| ` End -> ` End end \| ` UTF_16BE r -> d . encoding <- ` UTF_16BE ; d . k <- decode_utf_16be ; guessed_utf_16 d true r \| ` UTF_16LE r -> d . encoding <- ` UTF_16LE ; d . k <- decode_utf_16le ; guessed_utf_16 d false r in ( t_need d 3 ; t_fill setup d )
let nline d = d . col <- 0 ; d . line <- d . line + 1
let ncol d = d . col <- d . col + 1
let ncount d = d . count <- d . count + 1
let cr d b = d . last_cr <- b
let pp_remove_bom utf16 pp d = function match Uchar . to_int u with \| 0xFEFF -> if utf16 then ( d . encoding <- ` UTF_16BE ; d . k <- decode_utf_16be ) ; d . removed_bom <- true ; d . pp <- pp ; d . k d \| 0xFFFE when utf16 -> d . encoding <- ` UTF_16LE ; d . k <- decode_utf_16le ; d . removed_bom <- true ; d . pp <- pp ; d . k d \| _ -> d . removed_bom <- false ; d . pp <- pp ; d . pp d v
let pp_nln_none d = function match Uchar . to_int u with \| 0x000A -> let last_cr = d . last_cr in cr d false ; ncount d ; if last_cr then v else ( nline d ; v ) \| 0x000D -> cr d true ; ncount d ; nline d ; v \| ( 0x0085 \| 0x000C \| 0x2028 \| 0x2029 ) -> cr d false ; ncount d ; nline d ; v \| _ -> cr d false ; ncount d ; ncol d ; v
let pp_nln_readline d = function match Uchar . to_int u with \| 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) \| 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl \| ( 0x0085 \| 0x000C \| 0x2028 \| 0x2029 ) -> cr d false ; ncount d ; nline d ; ` Uchar d . nl \| _ -> cr d false ; ncount d ; ncol d ; v
let pp_nln_nlf d = function match Uchar . to_int u with \| 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) \| 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl \| 0x0085 -> cr d false ; ncount d ; nline d ; ` Uchar d . nl \| ( 0x000C \| 0x2028 \| 0x2029 ) -> cr d false ; ncount d ; nline d ; v \| _ -> cr d false ; ncount d ; ncol d ; v
let pp_nln_ascii d = function match Uchar . to_int u with \| 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) \| 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl \| ( 0x0085 \| 0x000C \| 0x2028 \| 0x2029 ) -> cr d false ; ncount d ; nline d ; v \| _ -> cr d false ; ncount d ; ncol d ; v
let decoder ? nln ? encoding src = let pp , nl = match nln with \| None -> pp_nln_none , Uchar . unsafe_of_int 0x000A \| Some ( ` ASCII nl ) -> pp_nln_ascii , nl \| Some ( ` NLF nl ) -> pp_nln_nlf , nl \| Some ( ` Readline nl ) -> pp_nln_readline , nl in let encoding , k = match encoding with \| None -> ` UTF_8 , guess_encoding \| Some e -> ( e :> decoder_encoding ) , decode_fun e in let i , i_pos , i_max = match src with \| ` Manual -> Bytes . empty , 1 , 0 \| ` Channel _ -> Bytes . create io_buffer_size , 1 , 0 \| ` String s -> Bytes . unsafe_of_string s , 0 , String . length s - 1 in { src = ( src :> src ) ; encoding ; nln = ( nln :> nln option ) ; nl ; i ; i_pos ; i_max ; t = Bytes . create 4 ; t_len = 0 ; t_need = 0 ; removed_bom = false ; last_cr = false ; line = 1 ; col = 0 ; byte_count = 0 ; count = 0 ; pp = pp_remove_bom ( encoding = ` UTF_16 ) pp ; k }
let decode d = d . k d
let decoder_line d = d . line
let decoder_col d = d . col

let _composite u1 u2 = if 0x1100 <= u1 && u1 <= 0x1112 then begin if u2 < 0x1161 || 0x1175 < u2 then ux_none else let l = u1 - H . lbase in let v = u2 - H . vbase in H . sbase + l * H . ncount + v * H . tcount end else if 0xAC00 <= u1 && u1 <= 0xD788 && ( u1 - 0x0AC00 ) mod H . tcount = 0 then begin if u2 < 0x11A8 || u2 > 0x11C3 then ux_none else ( u1 + u2 - H . tbase ) end else match compose_prop u1 with | [ ] || -> ux_none | a -> let len = Array . length a / 2 in let i = ref 0 in try while ( ! i < len ) do if a . ( ! i * 2 ) = u2 then raise Exit else incr i ; done ; ux_none with Exit -> ( a . ( ! i * 2 + 1 ) )

let composite u1 u2 = let u = _composite ( Uchar . to_int u1 ) ( Uchar . to_int u2 ) in if u = ux_none then None else Some ( Uchar . unsafe_of_int u )

type form = [ ` NFC | ` NFD | ` NFKC | ` NFKD ]

type t = { form : form ; compat : bool ; compose : bool ; boundary : int -> bool ; mutable state : state ; mutable uc : [ ` Uchar of Uchar . t ] ; mutable acc : int array ; mutable first : int ; mutable last : int ; mutable is_end : bool ; }

let create_acc ( ) = Array . make 35 ux_none

let create form = let boundary , compat , compose = match form with | ` NFC -> nfc_boundary , false , true | ` NFD -> nfd_boundary , false , false | ` NFKC -> nfkc_boundary , true , true | ` NFKD -> nfkd_boundary , true , false in { form = ( form :> form ) ; compat ; compose ; boundary ; state = Start ; uc = u_dumb ; acc = create_acc ( ) ; first = 0 ; last = - 1 ; is_end = false }

let get_u n = let ` Uchar u = n . uc in Uchar . to_int u

let acc_empty n = n . first > n . last

let form n = n . form

let copy n = { n with acc = Array . copy n . acc }

let reset n = n . state <- Start ; n . uc <- u_dumb ; n . acc <- create_acc ( ) ; n . first <- 0 ; n . last <- - 1 ; n . is_end <- false

let grow_acc n = let len = Array . length n . acc in let acc ' = Array . make ( 2 * len ) ux_none in Array . blit n . acc 0 acc ' 0 len ; n . acc <- acc '

let ordered_add n u = n . last <- n . last + 1 ; if n . last = Array . length n . acc then grow_acc n ; let c = _ccc u in if c = 0 then n . acc . ( n . last ) <- u else begin let i = ref ( n . last - 1 ) in while ( ! i >= 0 && _ccc ( n . acc . ( ! i ) ) > c ) do n . acc . ( ! i + 1 ) <- n . acc . ( ! i ) ; decr i ; done ; n . acc . ( ! i + 1 ) <- u end

let rec add n u = if 0xAC00 <= u && u <= 0xD7A3 then begin let sindex = u - H . sbase in let l = H . lbase + ( sindex / H . ncount ) in let v = H . vbase + ( sindex mod H . ncount ) / H . tcount in let t = H . tbase + ( sindex mod H . tcount ) in if t = H . tbase then ( ordered_add n l ; ordered_add n v ) else ( ordered_add n l ; ordered_add n v ; ordered_add n t ) end else begin match decomp_prop u with | [ ] || -> ordered_add n u | d -> if d_compatibility d . ( 0 ) && not n . compat then ordered_add n u else begin add n ( _d_uchar d . ( 0 ) ) ; for i = 1 to Array . length d - 1 do add n d . ( i ) done end end

let compose n = let rec loop ~ last_starter ~ prev_ccc i = if i > n . last then ( ) else let ccc_i = _ccc n . acc . ( i ) in let u_comp = _composite n . acc . ( last_starter ) n . acc . ( i ) in match ( u_comp = ux_none || ( ccc_i = 0 && last_starter <> i - 1 ) ) with | true -> let last_starter = if ccc_i = 0 then i else last_starter in loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) | false -> match prev_ccc <> 0 && prev_ccc >= ccc_i with | true -> loop ~ last_starter ~ prev_ccc : ccc_i ( i + 1 ) | false -> n . acc . ( last_starter ) <- u_comp ; Array . blit n . acc ( i + 1 ) n . acc i ( n . last - i ) ; n . last <- n . last - 1 ; let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 ) in let last_starter = n . first in let prev_ccc = _ccc n . acc . ( last_starter ) in loop ~ last_starter ~ prev_ccc ( last_starter + 1 )

let flush_next n = let ret = ` Uchar ( Uchar . unsafe_of_int n . acc . ( n . first ) ) in if n . first = n . last then ( n . first <- 0 ; n . last <- - 1 ) else ( n . first <- n . first + 1 ) ; ret

let flush_start n = if n . compose then compose n ; flush_next n

let add n = function let u = Uchar . to_int u in begin match n . state with | Boundary -> if n . boundary u then ( let prev = n . uc in n . uc <- uc ; ( prev :> ret ) ) else ( n . state <- Acc ; add n ( get_u n ) ; add n u ; ` Await ) | Acc -> if n . boundary u then ( n . state <- Flush ; n . uc <- uc ; flush_start n ) else ( add n u ; ` Await ) | Start -> if n . boundary u then ( n . state <- Boundary ; n . uc <- uc ; ` Await ) else ( n . state <- Acc ; add n u ; ` Await ) | Flush -> err_exp_await uc | End -> err_ended uc end begin match n . state with | Flush -> if not ( acc_empty n ) then flush_next n else if n . is_end then ( n . state <- End ; ` End ) else ( n . state <- Boundary ; ` Await ) | Start | Boundary | Acc -> ` Await | End -> ` End end n . is_end <- true ; begin match n . state with | Boundary -> n . state <- End ; ( n . uc :> ret ) | Acc -> n . state <- Flush ; flush_start n | Start -> n . state <- End ; ` End | Flush -> err_exp_await ` End | End -> err_ended ` End end

let string_X ppf s = Format . pp_open_vbox ppf 1 ; string ppf " " " ; \ for i = 0 to String . length s - 1 do if i mod 16 = 0 && i > 0 then pf ppf " \\@\ n " ; pf ppf " \\ x % 02x " ( Char . code s . [ i ] ) done ; string ppf " " " ; \ Format . pp_close_box ppf ( )

let string_XN ppf = function " " -> string ppf " snil " | x -> string_X ppf x

let semi ppf ( ) = string ppf " ; " ; sp ppf ( )

let iter i ( ? sep = sp ) pp ppf x = let fst = ref true in i ( fun v -> ( if ! fst then fst := false else sep ppf ( ) ) ; pp ppf v ) x

let as_array i pp ppf = pf ppf " [ @< 2 [ >|% a ] ] " |@ ( iter i ~ sep : semi pp )

let array pp = as_array Array . iter pp

let array_N pp ppf = function [ ] || -> string ppf " nil " | x -> array pp ppf x

module R = struct type _ record = | [ ] : unit record | ( ) :: : ( string * ( Format . formatter -> ' a -> unit ) ) * ' b record -> ( ' a -> ' b ) record end

let record record ppf = let field name pp_v ppf v = pf ppf " [ @< 1 >% s =@ % a ] " @ name pp_v v in let open R in let rec go : type a . ( unit -> unit ) -> a R . record -> a = fun k -> function | [ ] -> pf ppf " [ @< 2 { > % a } ] " @ ( fun _ -> k ) ( ) | [ name , pp_v ] -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ) [ ] | ( name , pp_v ) :: record -> fun v -> go ( fun ( ) -> k ( ) ; field name pp_v ppf v ; semi ppf ( ) ) record in go ignore record

type ' a t = { default : ' a ; l0 : ' a array array array }

let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == nil then m . default else Array . unsafe_get l2 ( u land l2_mask )

let create default = { default ; l0 = Array . make l0_size nil }

let set m u v = if v = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size nil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == nil then m . l0 . ( i ) . ( j ) <- Array . make l2_size m . default ; m . l0 . ( i ) . ( j ) . ( u land l2_mask ) <- v

let size v_size m = match m . l0 with let size = ref ( 3 + v_size m . default + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + ( 1 + Array . length l1 ) ; for j = 0 to Array . length l1 - 1 do match l1 . ( j ) with | [ ] || -> ( ) | l2 -> size := ! size + ( 1 + Array . length l2 ) ; for k = 0 to Array . length l2 - 1 do size := ! size + v_size l2 . ( k ) done ; done ; done ; ! size

let dump pp_v ppf m = let open Uunf_fmt in record [ " default " , pp_v ; " l0 " , pp_v |> array_N |> array_N |> array ] ppf m . default m . l0

type t = { default : bool ; l0 : string array array }

let get m u = let l1 = Array . unsafe_get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code ( String . unsafe_get l2 byte_num ) in byte land ( 1 lsl bit_num ) > 0

let create default = { default ; l0 = Array . make l0_size nil }

let set m u b = let l2_make m = Bytes . make l2_size ( if m . default then ' \ xFF ' else ' \ x00 ' ) in if b = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in let byte_num = k lsr 3 in let bit_num = k land 7 in let byte = Char . code m . l0 . ( i ) . ( j ) . [ byte_num ] in let new_byte = if b then ( Char . unsafe_chr ( byte lor ( 1 lsl bit_num ) ) ) else ( Char . unsafe_chr ( byte land lnot ( 1 lsl bit_num ) ) ) in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) byte_num new_byte

let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size

let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0

let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , bool ; " l0 " , pp_v |> array_N |> array ] ppf m . default m . l0

let dump = dump_pp pp_v

type t = { default : int ; l0 : string array array }

let get m u = let l1 = Array . get m . l0 ( u lsr l0_shift ) in if l1 == nil then m . default else let l2 = Array . unsafe_get l1 ( u lsr l1_shift land l1_mask ) in if l2 == snil then m . default else Char . code ( String . unsafe_get l2 ( u land l2_mask ) )

let create default = { default ; l0 = Array . make l0_size nil }

let set m u byte = let l2_make m = Bytes . make l2_size ( Char . chr m . default ) in if byte = m . default then ( ) else let i = u lsr l0_shift in if m . l0 . ( i ) == nil then m . l0 . ( i ) <- Array . make l1_size snil ; let j = u lsr l1_shift land l1_mask in if m . l0 . ( i ) . ( j ) == snil then m . l0 . ( i ) . ( j ) <- Bytes . unsafe_to_string ( l2_make m ) ; let k = u land l2_mask in Bytes . set ( Bytes . unsafe_of_string m . l0 . ( i ) . ( j ) ) k ( Char . unsafe_chr byte )

let size m = match m . l0 with let size = ref ( 3 + 1 + Array . length l0 ) in for i = 0 to Array . length l0 - 1 do match l0 . ( i ) with | [ ] || -> ( ) | l1 -> size := ! size + 1 + Array . length l1 ; for j = 0 to Array . length l1 - 1 do size := ! size + 1 + ( ( String . length l1 . ( j ) * 8 ) / Sys . word_size ) done ; done ; ! size

let iter_blobs i m = Array . ( iter ( iter i ) ) m . l0

let dump_pp pp_v ppf m = let open Uunf_fmt in record [ " default " , int ; " l0 " , pp_v |> array_N |> array ] ppf m . default m . l0

let dump = dump_pp pp_v

let invalid_encode ( ) = invalid_arg " expected ` Await encode "

let invalid_bounds j l = invalid_arg ( Printf . sprintf " invalid bounds ( index % d , length % d ) " j l )

let unsafe_byte s j = Char . code ( Bytes . unsafe_get s j )

let unsafe_set_byte s j byte = Bytes . unsafe_set s j ( Char . unsafe_chr byte )

let u_bom = Uchar . unsafe_of_int 0xFEFF

let u_rep = Uchar . unsafe_of_int 0xFFFD

type encoding = [ ` UTF_8 | ` UTF_16 | ` UTF_16BE | ` UTF_16LE ]

type decoder_encoding = [ encoding | ` US_ASCII | ` ISO_8859_1 ]

let encoding_of_string s = match String . uppercase_ascii s with Some ` US_ASCII Some ` ISO_8859_1

let malformed s j l = ` Malformed ( Bytes . sub_string s j l )

let malformed_pair be hi s j l = let bs1 = Bytes . ( sub s j l ) in let bs0 = Bytes . create 2 in let j0 , j1 = if be then ( 0 , 1 ) else ( 1 , 0 ) in unsafe_set_byte bs0 j0 ( hi lsr 8 ) ; unsafe_set_byte bs0 j1 ( hi land 0xFF ) ; ` Malformed Bytes . ( unsafe_to_string ( cat bs0 bs1 ) )

let r_us_ascii s j = let b0 = unsafe_byte s j in if b0 <= 127 then ` Uchar ( Uchar . unsafe_of_int b0 ) else malformed s j 1

let r_iso_8859_1 s j = ` Uchar ( Uchar . unsafe_of_int @@ unsafe_byte s j )

let utf_8_len = [ | 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 1 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 2 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 3 ; 4 ; 4 ; 4 ; 4 ; 4 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ; 0 ] |

let r_utf_8 s j l = let uchar c = ` Uchar ( Uchar . unsafe_of_int c ) in match l with | 1 -> uchar ( unsafe_byte s j ) | 2 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in if b1 lsr 6 != 0b10 then malformed s j l else uchar ( ( ( b0 land 0x1F ) lsl 6 ) lor ( b1 land 0x3F ) ) | 3 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in let b2 = unsafe_byte s ( j + 2 ) in let c = ( ( b0 land 0x0F ) lsl 12 ) lor ( ( b1 land 0x3F ) lsl 6 ) lor ( b2 land 0x3F ) in if b2 lsr 6 != 0b10 then malformed s j l else begin match b0 with | 0xE0 -> if b1 < 0xA0 || 0xBF < b1 then malformed s j l else uchar c | 0xED -> if b1 < 0x80 || 0x9F < b1 then malformed s j l else uchar c | _ -> if b1 lsr 6 != 0b10 then malformed s j l else uchar c end | 4 -> let b0 = unsafe_byte s j in let b1 = unsafe_byte s ( j + 1 ) in let b2 = unsafe_byte s ( j + 2 ) in let b3 = unsafe_byte s ( j + 3 ) in let c = ( ( ( b0 land 0x07 ) lsl 18 ) lor ( ( b1 land 0x3F ) lsl 12 ) lor ( ( b2 land 0x3F ) lsl 6 ) lor ( b3 land 0x3F ) ) in if b3 lsr 6 != 0b10 || b2 lsr 6 != 0b10 then malformed s j l else begin match b0 with | 0xF0 -> if b1 < 0x90 || 0xBF < b1 then malformed s j l else uchar c | 0xF4 -> if b1 < 0x80 || 0x8F < b1 then malformed s j l else uchar c | _ -> if b1 lsr 6 != 0b10 then malformed s j l else uchar c end | _ -> assert false

let r_utf_16 s j0 j1 = let b0 = unsafe_byte s j0 in let b1 = unsafe_byte s j1 in let u = ( b0 lsl 8 ) lor b1 in if u < 0xD800 || u > 0xDFFF then ` Uchar ( Uchar . unsafe_of_int u ) else if u > 0xDBFF then malformed s ( min j0 j1 ) 2 else ` Hi u

let r_utf_16_lo hi s j0 j1 = let b0 = unsafe_byte s j0 in let b1 = unsafe_byte s j1 in let lo = ( b0 lsl 8 ) lor b1 in if lo < 0xDC00 || lo > 0xDFFF then malformed_pair ( j0 < j1 ) hi s ( min j0 j1 ) 2 else ` Uchar ( Uchar . unsafe_of_int ( ( ( ( hi land 0x3FF ) lsl 10 ) lor ( lo land 0x3FF ) ) + 0x10000 ) )

let r_encoding s j l = let some i = if i < l then Some ( unsafe_byte s ( j + i ) ) else None in match ( some 0 ) , ( some 1 ) , ( some 2 ) with | Some 0xEF , Some 0xBB , Some 0xBF -> ` UTF_8 ` BOM | Some 0xFE , Some 0xFF , _ -> ` UTF_16BE ` BOM | Some 0xFF , Some 0xFE , _ -> ` UTF_16LE ` BOM | Some 0x00 , Some p , _ when p > 0 -> ` UTF_16BE ( ` ASCII p ) | Some p , Some 0x00 , _ when p > 0 -> ` UTF_16LE ( ` ASCII p ) | Some u , _ , _ when utf_8_len . ( u ) <> 0 -> ` UTF_8 ` Decode | Some _ , Some _ , _ -> ` UTF_16BE ` Decode | Some _ , None , None -> ` UTF_8 ` Decode | None , None , None -> ` UTF_8 ` End | None , Some _ , _ -> assert false | Some _ , None , Some _ -> assert false | None , None , Some _ -> assert false

type src = [ ` Channel of in_channel | ` String of string | ` Manual ]

type nln = [ ` ASCII of Uchar . t | ` NLF of Uchar . t | ` Readline of Uchar . t ]

type decode = [ ` Await | ` End | ` Malformed of string | ` Uchar of Uchar . t ]

let pp_decode ppf = function let l = String . length bs in pp ppf " [ ` @ Malformed ( " ; if l > 0 then pp ppf " % 02X " ( Char . code ( bs . [ 0 ] ) ) ; for i = 1 to l - 1 do pp ppf " % 02X " ( Char . code ( bs . [ i ] ) ) done ; pp ppf " ) ] " @

type decoder = { src : src ; mutable encoding : decoder_encoding ; nln : nln option ; nl : Uchar . t ; mutable i : Bytes . t ; mutable i_pos : int ; mutable i_max : int ; t : Bytes . t ; mutable t_len : int ; mutable t_need : int ; mutable removed_bom : bool ; mutable last_cr : bool ; mutable line : int ; mutable col : int ; mutable byte_count : int ; mutable count : int ; mutable pp : decoder -> [ ` Malformed of string | ` Uchar of Uchar . t ] -> decode ; mutable k : decoder -> decode }

let i_rem d = d . i_max - d . i_pos + 1

let eoi d = d . i <- Bytes . empty ; d . i_pos <- 0 ; d . i_max <- min_int

let src d s j l = if ( j < 0 || l < 0 || j + l > Bytes . length s ) then invalid_bounds j l else if ( l = 0 ) then eoi d else ( d . i <- s ; d . i_pos <- j ; d . i_max <- j + l - 1 )

let refill k d = match d . src with let rc = input ic d . i 0 ( Bytes . length d . i ) in ( src d d . i 0 rc ; k d )

let t_need d need = d . t_len <- 0 ; d . t_need <- need

let rec t_fill k d = let blit d l = unsafe_blit d . i d . i_pos d . t d . t_len l ; d . i_pos <- d . i_pos + l ; d . t_len <- d . t_len + l ; in let rem = i_rem d in if rem < 0 then k d else let need = d . t_need - d . t_len in if rem < need then ( blit d rem ; refill ( t_fill k ) d ) else ( blit d need ; k d )

let ret k v byte_count d = d . k <- k ; d . byte_count <- d . byte_count + byte_count ; d . pp d v

let rec decode_us_ascii d = let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_us_ascii d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 1 ; ret decode_us_ascii ( r_us_ascii d . i j ) 1 d

let rec decode_iso_8859_1 d = let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_iso_8859_1 d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 1 ; ret decode_iso_8859_1 ( r_iso_8859_1 d . i j ) 1 d

let rec t_decode_utf_8 d = if d . t_len < d . t_need then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ret decode_utf_8 ( r_utf_8 d . t 0 d . t_len ) d . t_len d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_8 d ) else let need = unsafe_array_get utf_8_len ( unsafe_byte d . i d . i_pos ) in if rem < need then ( t_need d need ; t_fill t_decode_utf_8 d ) else let j = d . i_pos in if need = 0 then ( d . i_pos <- d . i_pos + 1 ; ret decode_utf_8 ( malformed d . i j 1 ) 1 d ) else ( d . i_pos <- d . i_pos + need ; ret decode_utf_8 ( r_utf_8 d . i j need ) need d )

let rec t_decode_utf_16be_lo hi d = let bcount = d . t_len + 2 in if d . t_len < d . t_need then ret decode_utf_16be ( malformed_pair true hi d . t 0 d . t_len ) bcount d else ret decode_utf_16be ( r_utf_16_lo hi d . t 0 1 ) bcount d if d . t_len < d . t_need then ret decode_utf_16be ( malformed d . t 0 d . t_len ) d . t_len d else decode_utf_16be_lo ( r_utf_16 d . t 0 1 ) d let rem = i_rem d in if rem < 2 then ( t_need d 2 ; t_fill ( t_decode_utf_16be_lo hi ) d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; ret decode_utf_16be ( r_utf_16_lo hi d . i j ( j + 1 ) ) 4 d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_16be d ) else if rem < 2 then ( t_need d 2 ; t_fill t_decode_utf_16be d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; decode_utf_16be_lo ( r_utf_16 d . i j ( j + 1 ) ) d

let rec t_decode_utf_16le_lo hi d = let bcount = d . t_len + 2 in if d . t_len < d . t_need then ret decode_utf_16le ( malformed_pair false hi d . t 0 d . t_len ) bcount d else ret decode_utf_16le ( r_utf_16_lo hi d . t 1 0 ) bcount d if d . t_len < d . t_need then ret decode_utf_16le ( malformed d . t 0 d . t_len ) d . t_len d else decode_utf_16le_lo ( r_utf_16 d . t 1 0 ) d let rem = i_rem d in if rem < 2 then ( t_need d 2 ; t_fill ( t_decode_utf_16le_lo hi ) d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; ret decode_utf_16le ( r_utf_16_lo hi d . i ( j + 1 ) j ) 4 d let rem = i_rem d in if rem <= 0 then ( if rem < 0 then ` End else refill decode_utf_16le d ) else if rem < 2 then ( t_need d 2 ; t_fill t_decode_utf_16le d ) else let j = d . i_pos in d . i_pos <- d . i_pos + 2 ; decode_utf_16le_lo ( r_utf_16 d . i ( j + 1 ) j ) d

let guessed_utf_8 d = let b3 d = let b3 = unsafe_byte d . t 2 in match utf_8_len . ( b3 ) with | 0 -> ret decode_utf_8 ( malformed d . t 2 1 ) 1 d | n -> d . t_need <- n ; d . t_len <- 1 ; unsafe_set_byte d . t 0 b3 ; t_fill t_decode_utf_8 d in let b2 d = let b2 = unsafe_byte d . t 1 in let b3 = if d . t_len > 2 then b3 else decode_utf_8 in match utf_8_len . ( b2 ) with | 0 -> ret b3 ( malformed d . t 1 1 ) 1 d | 1 -> ret b3 ( r_utf_8 d . t 1 1 ) 1 d | n -> d . t_need <- n ; unsafe_set_byte d . t 0 b2 ; if ( d . t_len < 3 ) then d . t_len <- 1 else ( d . t_len <- 2 ; unsafe_set_byte d . t 1 ( unsafe_byte d . t 2 ) ; ) ; t_fill t_decode_utf_8 d in let b1 = unsafe_byte d . t 0 in let b2 = if d . t_len > 1 then b2 else decode_utf_8 in match utf_8_len . ( b1 ) with | 0 -> ret b2 ( malformed d . t 0 1 ) 1 d | 1 -> ret b2 ( r_utf_8 d . t 0 1 ) 1 d | 2 -> if d . t_len < 2 then ret decode_utf_8 ( malformed d . t 0 1 ) 1 d else if d . t_len < 3 then ret decode_utf_8 ( r_utf_8 d . t 0 2 ) 2 d else ret b3 ( r_utf_8 d . t 0 2 ) 2 d | 3 -> if d . t_len < 3 then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ret decode_utf_8 ( r_utf_8 d . t 0 3 ) 3 d | 4 -> if d . t_len < 3 then ret decode_utf_8 ( malformed d . t 0 d . t_len ) d . t_len d else ( d . t_need <- 4 ; t_fill t_decode_utf_8 d ) | n -> assert false

let guessed_utf_16 d be v = let decode_utf_16 , t_decode_utf_16 , t_decode_utf_16_lo , j0 , j1 = if be then decode_utf_16be , t_decode_utf_16be , t_decode_utf_16be_lo , 0 , 1 else decode_utf_16le , t_decode_utf_16le , t_decode_utf_16le_lo , 1 , 0 in let b3 k d = if d . t_len < 3 then decode_utf_16 d else begin d . t_need <- 2 ; d . t_len <- 1 ; unsafe_set_byte d . t 0 ( unsafe_byte d . t 2 ) ; t_fill k d end in match v with | ` BOM -> ret ( b3 t_decode_utf_16 ) ( ` Uchar u_bom ) 2 d | ` ASCII u -> ret ( b3 t_decode_utf_16 ) ( ` Uchar ( Uchar . unsafe_of_int u ) ) 2 d | ` Decode -> match r_utf_16 d . t j0 j1 with | ` Malformed _ | ` Uchar _ as v -> ret ( b3 t_decode_utf_16 ) v 2 d | ` Hi hi -> if d . t_len < 3 then ret decode_utf_16 ( malformed_pair be hi Bytes . empty 0 0 ) d . t_len d else ( b3 ( t_decode_utf_16_lo hi ) ) d

let guess_encoding d = let setup d = match r_encoding d . t 0 d . t_len with | ` UTF_8 r -> d . encoding <- ` UTF_8 ; d . k <- decode_utf_8 ; begin match r with | ` BOM -> ret decode_utf_8 ( ` Uchar u_bom ) 3 d | ` Decode -> guessed_utf_8 d | ` End -> ` End end | ` UTF_16BE r -> d . encoding <- ` UTF_16BE ; d . k <- decode_utf_16be ; guessed_utf_16 d true r | ` UTF_16LE r -> d . encoding <- ` UTF_16LE ; d . k <- decode_utf_16le ; guessed_utf_16 d false r in ( t_need d 3 ; t_fill setup d )

let nline d = d . col <- 0 ; d . line <- d . line + 1

let ncol d = d . col <- d . col + 1

let ncount d = d . count <- d . count + 1

let cr d b = d . last_cr <- b

let pp_remove_bom utf16 pp d = function match Uchar . to_int u with | 0xFEFF -> if utf16 then ( d . encoding <- ` UTF_16BE ; d . k <- decode_utf_16be ) ; d . removed_bom <- true ; d . pp <- pp ; d . k d | 0xFFFE when utf16 -> d . encoding <- ` UTF_16LE ; d . k <- decode_utf_16le ; d . removed_bom <- true ; d . pp <- pp ; d . k d | _ -> d . removed_bom <- false ; d . pp <- pp ; d . pp d v

let pp_nln_readline d = function match Uchar . to_int u with | 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) | 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl | ( 0x0085 | 0x000C | 0x2028 | 0x2029 ) -> cr d false ; ncount d ; nline d ; ` Uchar d . nl | _ -> cr d false ; ncount d ; ncol d ; v

let pp_nln_nlf d = function match Uchar . to_int u with | 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) | 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl | 0x0085 -> cr d false ; ncount d ; nline d ; ` Uchar d . nl | ( 0x000C | 0x2028 | 0x2029 ) -> cr d false ; ncount d ; nline d ; v | _ -> cr d false ; ncount d ; ncol d ; v

let pp_nln_ascii d = function match Uchar . to_int u with | 0x000A -> let last_cr = d . last_cr in cr d false ; if last_cr then d . k d else ( ncount d ; nline d ; ` Uchar d . nl ) | 0x000D -> cr d true ; ncount d ; nline d ; ` Uchar d . nl | ( 0x0085 | 0x000C | 0x2028 | 0x2029 ) -> cr d false ; ncount d ; nline d ; v | _ -> cr d false ; ncount d ; ncol d ; v

let decoder ? nln ? encoding src = let pp , nl = match nln with | None -> pp_nln_none , Uchar . unsafe_of_int 0x000A | Some ( ` ASCII nl ) -> pp_nln_ascii , nl | Some ( ` NLF nl ) -> pp_nln_nlf , nl | Some ( ` Readline nl ) -> pp_nln_readline , nl in let encoding , k = match encoding with | None -> ` UTF_8 , guess_encoding | Some e -> ( e :> decoder_encoding ) , decode_fun e in let i , i_pos , i_max = match src with | ` Manual -> Bytes . empty , 1 , 0 | ` Channel _ -> Bytes . create io_buffer_size , 1 , 0 | ` String s -> Bytes . unsafe_of_string s , 0 , String . length s - 1 in { src = ( src :> src ) ; encoding ; nln = ( nln :> nln option ) ; nl ; i ; i_pos ; i_max ; t = Bytes . create 4 ; t_len = 0 ; t_need = 0 ; removed_bom = false ; last_cr = false ; line = 1 ; col = 0 ; byte_count = 0 ; count = 0 ; pp = pp_remove_bom ( encoding = ` UTF_16 ) pp ; k }

let decode d = d . k d

let decoder_line d = d . line

let decoder_col d = d . col