text
stringlengths 0
601k
|
|---|
let of_string s = let buf = Buffer . create ( ) in Buffer . add_string buf s ; Buffer . contents buf |
let rec to_string t = match t with | Leaf ( s , _ ) _ -> s | Node ( _ , _ , l , _ , r ) r -> Zed_string . append ( to_string l ) l ( to_string r ) r |
module Text = struct type t = rope let get = get let init = init let length = length type index = Zip . t let look _ zip = fst ( Zip . next zip ) zip let nth rope idx = Zip . make_f rope idx let next _ zip = Zip . move 1 zip let prev _ zip = Zip . move ( - 1 ) 1 zip let out_of_range _ zip = Zip . at_eos zip let iter = iter let compare = compare let first rope = Zip . make_f rope 0 let last rope = Zip . make_b rope 1 let move _ zip delta = Zip . move delta zip let compare_index _ zip1 zip2 = Zip . offset zip1 - Zip . offset zip2 module Buf = struct type buf = Buffer . t let create _ = Buffer . create ( ) let contents = Buffer . contents let clear = Buffer . reset let reset = Buffer . reset let add_char = Buffer . add_uChar let add_string = Buffer . add_rope let add_buffer buf buf ' = add_string buf ( Buffer . contents buf ' ) buf ' end end |
module Text_core = struct include Text let get t i = Zed_char . core ( get t i ) i let init = init_from_uChars let look _ zip = Zed_char . core ( fst ( Zip . next zip ) zip ) zip let iter f = iter ( fun c -> f ( Zed_char . core c ) c ) c end |
module Text_raw = struct type t = rope type index = Zip_raw . t let get = get_raw let init = init_from_uChars let length = length let look _ zip = fst ( Zip_raw . next zip ) zip let iter f = iter ( fun c -> f ( Zed_char . core c ) c ) c let nth rope idx = Zip_raw . make_f rope idx let next _ zip = Zip_raw . move 1 zip let prev _ zip = Zip_raw . move ( - 1 ) 1 zip let out_of_range _ zip = Zip_raw . at_eos zip let iter = iter let compare = compare let first rope = Zip_raw . make_f rope 0 let last rope = Zip_raw . make_b rope 1 let move _ zip delta = Zip_raw . move delta zip let compare_index _ zip1 zip2 = Zip_raw . offset zip1 - Zip_raw . offset zip2 module Buf = struct type buf = Buffer . t let create _ = Buffer . create ( ) let contents = Buffer . contents let clear = Buffer . reset let reset = Buffer . reset let add_char = Buffer . add_uChar let add_string = Buffer . add_rope let add_buffer buf buf ' = add_string buf ( Buffer . contents buf ' ) buf ' end end |
let fail str pos msg = raise ( Invalid ( InvalidPrintf . sprintf " at position % d : % s " pos msg , str ) str ) str |
module Zed_string0 = struct type seg_width = { start : int ; len : int ; width : int ; } type all_width = { len : int ; width : int ; } type width = ( all_width , seg_width ) seg_width result type t = Zed_utf8 . t let aval_width = function | Ok { len = _ ; width } width -> width | Error { start = _ ; len = _ ; width } width -> width let bytes str = String . length str let size str = Zed_utf8 . length str let copy t = t let unsafe_next str ofs = let str_len = String . length str in let rec skip str ofs = if ofs >= str_len then str_len else let chr , next = Zed_utf8 . unsafe_extract_next str ofs in if Zed_char . is_combining_mark chr then skip str next else ofs in if ofs < 0 || ofs >= String . length str then raise Out_of_bounds else let chr , next = Zed_utf8 . unsafe_extract_next str ofs in if Zed_char . is_printable chr then skip str next else next let next_ofs str ofs = let str_len = String . length str in let rec skip str ofs = if ofs >= str_len then str_len else let chr , next = Zed_utf8 . unsafe_extract_next str ofs in if Zed_char . is_combining_mark chr then skip str next else ofs in if ofs < 0 || ofs >= String . length str then raise Out_of_bounds else let chr , next = Zed_utf8 . unsafe_extract_next str ofs in if Zed_char . is_printable_core chr then skip str next else if Zed_char . is_combining_mark chr then fail str ofs " individual combining marks encountered " else next let length str = let eos = String . length str in let rec length len ofs = if ofs < eos then length ( len + 1 ) 1 ( unsafe_next str ofs ) ofs else len in length 0 0 let unsafe_prev str ofs = let rec skip str ofs = if ofs = 0 then ofs else let chr , prev = Zed_utf8 . unsafe_extract_prev str ofs in if Zed_char . is_combining_mark chr then skip str prev else prev in if ofs <= 0 || ofs > String . length str then raise Out_of_bounds else let chr , prev = Zed_utf8 . extract_prev str ofs in if Zed_char . is_combining_mark chr then skip str prev else prev let prev_ofs str ofs = let rec skip str ofs = if ofs = 0 then ofs else let chr , prev = Zed_utf8 . unsafe_extract_prev str ofs in if Zed_char . is_combining_mark chr then skip str prev else prev in if ofs <= 0 || ofs > String . length str then raise Out_of_bounds else let chr , prev = Zed_utf8 . extract_prev str ofs in if Zed_char . is_combining_mark chr then let prev = skip str prev in if prev = 0 then if Zed_char . is_printable_core ( Zed_utf8 . unsafe_extract str 0 ) 0 then prev else fail str 0 " individual combining marks encountered " else let chr , next = Zed_utf8 . unsafe_extract_next str prev in match Zed_char . prop_uChar chr with | Printable 0 | Other | Null -> fail str next " individual combining marks encountered " | _ -> prev else prev let rec move_l str ofs len = if len = 0 then ofs else if ofs >= String . length str then raise Out_of_bounds else move_l str ( unsafe_next str ofs ) ofs ( len - 1 ) 1 let move_b str ofs len = let rec move str ofs len = if len = 0 then ofs else if ofs < 0 then raise Out_of_bounds else move str ( unsafe_prev str ofs ) ofs ( len - 1 ) 1 in if ofs < 0 || ofs > String . length str then raise Out_of_bounds else move str ofs len let rec move_l_raw str ofs len = if len = 0 then ofs else if ofs >= String . length str then raise Out_of_bounds else move_l_raw str ( Zed_utf8 . unsafe_next str ofs ) ofs ( len - 1 ) 1 let move_b_raw str ofs len = let rec move str ofs len = if len = 0 then ofs else if ofs < 0 then raise Out_of_bounds else move str ( Zed_utf8 . unsafe_prev str ofs ) ofs ( len - 1 ) 1 in if ofs < 0 || ofs > String . length str then raise Out_of_bounds else move str ofs len let extract str ofs = let next = next_ofs str ofs in Zed_char . unsafe_of_utf8 ( String . sub str ofs ( next - ofs ) ofs ) ofs let extract_next str ofs = let next = next_ofs str ofs in ( Zed_char . unsafe_of_utf8 ( String . sub str ofs ( next - ofs ) ofs ) ofs , next ) next let extract_prev str ofs = let prev = prev_ofs str ofs in ( Zed_char . unsafe_of_utf8 ( String . sub str prev ( ofs - prev ) prev ) prev , prev ) prev let to_raw_list str = Zed_utf8 . explode str let to_raw_array str = Array . of_list ( to_raw_list str ) str type index = int let get str idx = if idx < 0 then raise Out_of_bounds else extract str ( move_l str 0 idx ) idx let get_raw = Zed_utf8 . get let empty ( ) = " " let width_ofs ( ? start = 0 ) 0 ? num str = let str_len = String . length str in let rec calc w idx ofs = if ofs < str_len then let chr , next = extract_next str ofs in let chr_width = Zed_char . width chr in if chr_width > 0 then calc ( w + chr_width ) chr_width ( idx + 1 ) 1 next else Error { start ; len = idx - start ; width = w } else Ok { len = idx - start ; width = w } in let calc_num num w idx ofs = let rec calc n w idx ofs = if ofs < str_len && n > 0 then let chr , next = extract_next str ofs in let chr_width = Zed_char . width chr in if chr_width > 0 then calc ( n - 1 ) 1 ( w + chr_width ) chr_width ( idx + 1 ) 1 next else Error { start ; len = idx - start ; width = w } else Ok { len = idx - start ; width = w } in calc num w idx ofs in match num with | Some num -> calc_num num 0 start start | None -> calc 0 start start let width ( ? start = 0 ) 0 ? num str = let ofs = move_l str 0 start in width_ofs ~ start : ofs ? num str let explode str = let str_len = String . length str in let rec aux acc str ofs = if ofs > 0 then let chr , prev = extract_prev str ofs in aux ( chr :: acc ) acc str prev else acc in if str_len > 0 then aux [ ] str str_len else [ ] let rev_explode str = let str_len = String . length str in let rec aux acc ofs = if ofs < str_len then let chr , next = extract_next str ofs in aux ( chr :: acc ) acc next else [ ] in if str_len > 0 then aux [ ] 0 else [ ] let unsafe_explode str = let str_len = String . length str in let rec aux acc str ofs = if ofs > 0 then let chr , prev = extract_prev str ofs in aux ( chr :: acc ) acc str prev else acc in if str_len > 0 then aux [ ] str str_len else [ ] let unsafe_rev_explode str = let str_len = String . length str in let rec aux acc ofs = if ofs < str_len then let chr , next = extract_next str ofs in aux ( chr :: acc ) acc next else [ ] in if str_len > 0 then aux [ ] 0 else [ ] let implode chars = String . concat " " ( List . map Zed_char . to_utf8 chars ) chars let init len ( f : int -> Zed_char . t ) t = let rec create acc n = if n > 0 then create ( ( f ( n - 1 ) 1 ) 1 :: acc ) acc ( n - 1 ) 1 else acc in implode ( create [ ] len ) len let init_from_uChars len f = match len with | 0 -> empty ( ) | len when len > 0 -> let rec create acc n = if n > 0 then create ( ( f ( n - 1 ) 1 ) 1 :: acc ) acc ( n - 1 ) 1 else acc in let uChars = create [ ] len in let zChars , _ = Zed_char . zChars_of_uChars uChars in implode zChars | _ -> raise ( Invalid_argument " Zed_string0 . init_from_uChars ) " let unsafe_of_uChars uChars = match uChars with | [ ] -> " " | _ -> String . concat " " ( List . map Zed_utf8 . singleton uChars ) uChars let of_uChars uChars = match uChars with | [ ] -> " " , [ ] | fst :: _ -> if Zed_char . is_combining_mark fst then ( " " , uChars ) uChars else ( uChars |> List . map Zed_utf8 . singleton |> String . concat " " , [ ] ) let unsafe_append s1 s2 = s1 ^ s2 let append s1 s2 = let validate_s2 ( ) = let s2_first = Zed_utf8 . unsafe_extract s2 0 in if Zed_char . is_combining_mark s2_first then fail s2 0 " individual combining marks encountered " else s2 in if s1 = " " then validate_s2 ( ) else if s2 = " " then s1 else let ( s1_last , _ ) _ = extract_prev s1 ( bytes s1 ) s1 in if Zed_char ( . is_printable_core ( core s1_last ) s1_last ) s1_last then unsafe_append s1 s2 else unsafe_append s1 ( validate_s2 ( ) ) external id : ' a -> ' a = " % identity " let unsafe_of_utf8 : string -> t = id let of_utf8 : string -> t = fun str -> if String . length str = 0 then " " else if Zed_char . is_combining_mark ( Zed_utf8 . extract str 0 ) 0 then fail str 0 " individual combining marks encountered " else unsafe_of_utf8 str let to_utf8 : t -> string = id let for_all p str = List . for_all p ( explode str ) str let check_range t n = n >= 0 && n <= length t let look str ofs = Zed_utf8 . extract str ofs let nth t n = if check_range t n then n else raise ( Invalid_argument " Zed_string . nth ) " let next t n = let n = n + 1 in if check_range t n then n else raise ( Invalid_argument " Zed_string . next ) " let prev t n = let n = n - 1 in if check_range t n then n else raise ( Invalid_argument " Zed_string . prev ) " let out_of_range t n = n < 0 || n >= length t let iter f str = List . iter f ( explode str ) str let rev_iter f str = List . iter f ( rev_explode str ) str let fold f str acc = let rec aux f chars acc = match chars with | [ ] -> acc | chr :: tl -> aux f tl ( f chr acc ) acc in aux f ( explode str ) str acc let rev_fold f str acc = let rec aux f chars acc = match chars with | [ ] -> acc | chr :: tl -> aux f tl ( f chr acc ) acc in aux f ( rev_explode str ) str acc let map f str = implode ( List . map f ( explode str ) str ) str let rev_map f str = implode ( List . map f ( rev_explode str ) str ) str let compare str1 str2 = Zed_utils . list_compare ~ compare : Zed_char . compare_raw ( explode str1 ) str1 ( explode str2 ) str2 let first ( _ : t ) t = 0 let last t = max ( length t - 1 ) 1 0 let move t i n = if n >= 0 then move_l t i n else move_b t i n let move_raw t i n = if n >= 0 then move_l_raw t i n else move_b_raw t i n let compare_index ( _ : t ) t i j = pervasives_compare i j let sub_ofs ~ ofs ~ len s = if ofs < 0 || len < 0 || ofs > bytes s - len then invalid_arg " Zed_string . sub " else String . sub s ofs len let sub ~ pos ~ len s = if pos < 0 || len < 0 || pos > length s - len then invalid_arg " Zed_string . sub " else let ofs_start = move_l s 0 pos in let ofs_end = move_l s ofs_start len in String . sub s ofs_start ( ofs_end - ofs_start ) ofs_start let after s i = let len = length s in if i < len then sub ~ pos : i ~ len ( : len - i ) i s else empty ( ) let rec unsafe_sub_equal str ofs sub ofs_sub = if ofs_sub = String . length sub then true else ( String . unsafe_get str ofs = String . unsafe_get sub ofs_sub ) ofs_sub && unsafe_sub_equal str ( ofs + 1 ) 1 sub ( ofs_sub + 1 ) 1 let starts_with ~ prefix str = if String . length prefix > String . length str then false else unsafe_sub_equal str 0 prefix 0 let make len c = implode ( Array . to_list ( Array . make len c ) c ) c let ends_with ~ suffix str = Zed_utf8 . ends_with str suffix module Buf0 = struct type buf = Buffer . t let create n = Buffer . create n let contents b = Buffer . contents b let clear b = Buffer . clear b let reset b = Buffer . reset b let length b = length ( contents b ) b let add_zChar b zChar = Buffer . add_string b ( Zed_char . to_utf8 zChar ) zChar let add_uChar b uChar = Buffer . add_string b ( Zed_utf8 . singleton uChar ) uChar let add_string b s = Buffer . add_string b s let add_buffer b1 b2 = Buffer . add_buffer b1 b2 end module US0 ( US0US : UnicodeString . Type ) Type = struct module Convert = Zed_utils . Convert ( ConvertUS ) ConvertUS let of_t t = Zed_utf8 . explode t |> Convert . of_list let to_t us = let first = US . first us and last = US . last us in let length = US . length us in let rec create acc i = if US . compare_index us i first >= 0 then create ( US . look us i :: acc ) acc ( US . prev us i ) i else acc in let uChars = if length > 0 then create [ ] last else [ ] in of_uChars uChars let to_t_exn us = let t , _ = to_t us in t end end |
module US_Core = struct include Zed_string0 let get str i = Zed_char . core ( get str i ) i let init = init_from_uChars let iter f str = iter ( fun zChar -> f ( Zed_char . core zChar ) zChar ) zChar str let compare str1 str2 = Zed_utils . list_compare ~ compare : Zed_char . compare_core ( explode str1 ) str1 ( explode str2 ) str2 let to_list str = explode str |> List . map Zed_char . core let to_array str = to_list str |> Array . of_list module US ( USUS : UnicodeString . Type ) Type = struct module Convert = Zed_utils . Convert ( ConvertUS ) ConvertUS let of_t t = ( explode t ) t |> List . map Zed_char . core |> Convert . of_list end module Buf = struct include Buf0 let add_char = add_uChar end end |
module US_Raw = struct type t = Zed_string0 . t let get = Zed_string0 . get_raw let init = Zed_string0 . init_from_uChars let length = Zed_utf8 . length type index = int let check_range t n = n >= 0 && n < Zed_string0 . size t let out_of_range str ofs = ofs < 0 || ofs >= String . length str let look str ofs = Zed_utf8 . extract str ofs let nth str idx = Zed_string0 . move_l str 0 idx let next = Zed_utf8 . next let prev = Zed_utf8 . prev let first _ = 0 let last str = Zed_utf8 . prev str ( String . length str ) str let move = Zed_string0 . move_raw let compare_index _str = pervasives_compare let iter f str = List . iter f ( Zed_utf8 . explode str ) str let compare str1 str2 = Zed_utils . list_compare ~ compare : UChar . compare ( Zed_utf8 . explode str1 ) str1 ( Zed_utf8 . explode str2 ) str2 module US = Zed_string0 . US0 module Buf = struct include Zed_string0 . Buf0 let add_char = add_uChar end end |
let fail str pos msg = raise ( Invalid ( InvalidPrintf . sprintf " at position % d : % s " pos msg , str ) str ) str |
let byte str i = Char . code ( String . unsafe_get str i ) i |
let set_byte str i n = Bytes . unsafe_set str i ( Char . unsafe_chr n ) n |
type check_result = | Correct of int | Message of string |
let next_error s i = let len = String . length s in let rec main i ulen = if i = len then ( i , ulen , ) " " else let ch = String . unsafe_get s i in match ch with | ' \ x00 ' . . ' \ x7f ' -> main ( i + 1 ) 1 ( ulen + 1 ) 1 | ' \ xc0 ' . . ' \ xdf ' -> if i + 1 >= len then ( i , ulen , " premature end of UTF8 sequence ) " else begin let byte1 = Char . code ( String . unsafe_get s ( i + 1 ) 1 ) 1 in if byte1 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if ( ( Char . code ch land 0x1f ) 0x1f lsl 6 ) 6 lor ( byte1 land 0x3f ) 0x3f < 0x80 then ( i , ulen , " overlong UTF8 sequence ) " else main ( i + 2 ) 2 ( ulen + 1 ) 1 end | ' \ xe0 ' . . ' \ xef ' -> if i + 2 >= len then ( i , ulen , " premature end of UTF8 sequence ) " else begin let byte1 = Char . code ( String . unsafe_get s ( i + 1 ) 1 ) 1 and byte2 = Char . code ( String . unsafe_get s ( i + 2 ) 2 ) 2 in if byte1 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if byte2 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if ( ( Char . code ch land 0x0f ) 0x0f lsl 12 ) 12 lor ( ( byte1 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte2 land 0x3f ) 0x3f < 0x800 then ( i , ulen , " overlong UTF8 sequence ) " else main ( i + 3 ) 3 ( ulen + 1 ) 1 end | ' \ xf0 ' . . ' \ xf7 ' -> if i + 3 >= len then ( i , ulen , " premature end of UTF8 sequence ) " else begin let byte1 = Char . code ( String . unsafe_get s ( i + 1 ) 1 ) 1 and byte2 = Char . code ( String . unsafe_get s ( i + 2 ) 2 ) 2 and byte3 = Char . code ( String . unsafe_get s ( i + 3 ) 3 ) 3 in if byte1 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if byte2 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if byte3 land 0xc0 != 0x80 then ( i , ulen , " malformed UTF8 sequence ) " else if ( ( Char . code ch land 0x07 ) 0x07 lsl 18 ) 18 lor ( ( byte1 land 0x3f ) 0x3f lsl 12 ) 12 lor ( ( byte2 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte3 land 0x3f ) 0x3f < 0x10000 then ( i , ulen , " overlong UTF8 sequence ) " else main ( i + 4 ) 4 ( ulen + 1 ) 1 end | _ -> ( i , ulen , " invalid start of UTF8 sequence ) " in main i 0 |
let check str = let ofs , len , msg = next_error str 0 in if ofs = String . length str then Correct len else Message ( Printf . sprintf " at position % d : % s " ofs msg ) msg |
let validate str = let ofs , len , msg = next_error str 0 in if ofs = String . length str then len else fail str ofs msg |
let unsafe_next str ofs = match String . unsafe_get str ofs with | ' \ x00 ' . . ' \ x7f ' -> ofs + 1 | ' \ xc0 ' . . ' \ xdf ' -> if ofs + 2 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ofs + 2 | ' \ xe0 ' . . ' \ xef ' -> if ofs + 3 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ofs + 3 | ' \ xf0 ' . . ' \ xf7 ' -> if ofs + 4 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ofs + 4 | _ -> fail str ofs " invalid start of UTF - 8 sequence " |
let unsafe_prev str ofs = match String . unsafe_get str ( ofs - 1 ) 1 with | ' \ x00 ' . . ' \ x7f ' -> ofs - 1 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 2 then match String . unsafe_get str ( ofs - 2 ) 2 with | ' \ xc0 ' . . ' \ xdf ' -> ofs - 2 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 3 then match String . unsafe_get str ( ofs - 3 ) 3 with | ' \ xe0 ' . . ' \ xef ' -> ofs - 3 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 4 then match String . unsafe_get str ( ofs - 4 ) 4 with | ' \ xf0 ' . . ' \ xf7 ' -> ofs - 4 | _ -> fail str ( ofs - 4 ) 4 " invalid start of UTF - 8 sequence " else fail str ( ofs - 3 ) 3 " invalid start of UTF - 8 string " | _ -> fail str ( ofs - 3 ) 3 " invalid middle of UTF - 8 sequence " else fail str ( ofs - 2 ) 2 " invaild start of UTF - 8 string " | _ -> fail str ( ofs - 2 ) 2 " invalid middle of UTF - 8 sequence " else fail str ( ofs - 1 ) 1 " invalid start of UTF - 8 string " | _ -> fail str ( ofs - 1 ) 1 " invalid end of UTF - 8 sequence " |
let unsafe_extract str ofs = let ch = String . unsafe_get str ofs in match ch with | ' \ x00 ' . . ' \ x7f ' -> UChar . of_char ch | ' \ xc0 ' . . ' \ xdf ' -> if ofs + 2 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else UChar . of_int ( ( ( Char . code ch land 0x1f ) 0x1f lsl 6 ) 6 lor ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f ) 0x3f | ' \ xe0 ' . . ' \ xef ' -> if ofs + 3 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else UChar . of_int ( ( ( Char . code ch land 0x0f ) 0x0f lsl 12 ) 12 lor ( ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte str ( ofs + 2 ) 2 land 0x3f ) 0x3f ) 0x3f | ' \ xf0 ' . . ' \ xf7 ' -> if ofs + 4 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else UChar . of_int ( ( ( Char . code ch land 0x07 ) 0x07 lsl 18 ) 18 lor ( ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f lsl 12 ) 12 lor ( ( byte str ( ofs + 2 ) 2 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte str ( ofs + 3 ) 3 land 0x3f ) 0x3f ) 0x3f | _ -> fail str ofs " invalid start of UTF - 8 sequence " |
let unsafe_extract_next str ofs = let ch = String . unsafe_get str ofs in match ch with | ' \ x00 ' . . ' \ x7f ' -> ( UChar . of_char ch , ofs + 1 ) 1 | ' \ xc0 ' . . ' \ xdf ' -> if ofs + 2 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ( UChar . of_int ( ( ( Char . code ch land 0x1f ) 0x1f lsl 6 ) 6 lor ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f ) 0x3f , ofs + 2 ) 2 | ' \ xe0 ' . . ' \ xef ' -> if ofs + 3 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ( UChar . of_int ( ( ( Char . code ch land 0x0f ) 0x0f lsl 12 ) 12 lor ( ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte str ( ofs + 2 ) 2 land 0x3f ) 0x3f ) 0x3f , ofs + 3 ) 3 | ' \ xf0 ' . . ' \ xf7 ' -> if ofs + 4 > String . length str then fail str ofs " unterminated UTF - 8 sequence " else ( UChar . of_int ( ( ( Char . code ch land 0x07 ) 0x07 lsl 18 ) 18 lor ( ( byte str ( ofs + 1 ) 1 land 0x3f ) 0x3f lsl 12 ) 12 lor ( ( byte str ( ofs + 2 ) 2 land 0x3f ) 0x3f lsl 6 ) 6 lor ( byte str ( ofs + 3 ) 3 land 0x3f ) 0x3f ) 0x3f , ofs + 4 ) 4 | _ -> fail str ofs " invalid start of UTF - 8 sequence " |
let unsafe_extract_prev str ofs = let ch1 = String . unsafe_get str ( ofs - 1 ) 1 in match ch1 with | ' \ x00 ' . . ' \ x7f ' -> ( UChar . of_char ch1 , ofs - 1 ) 1 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 2 then let ch2 = String . unsafe_get str ( ofs - 2 ) 2 in match ch2 with | ' \ xc0 ' . . ' \ xdf ' -> ( UChar . of_int ( ( ( Char . code ch2 land 0x1f ) 0x1f lsl 6 ) 6 lor ( Char . code ch1 land 0x3f ) 0x3f ) 0x3f , ofs - 2 ) 2 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 3 then let ch3 = String . unsafe_get str ( ofs - 3 ) 3 in match ch3 with | ' \ xe0 ' . . ' \ xef ' -> ( UChar . of_int ( ( ( Char . code ch3 land 0x0f ) 0x0f lsl 12 ) 12 lor ( ( Char . code ch2 land 0x3f ) 0x3f lsl 6 ) 6 lor ( Char . code ch1 land 0x3f ) 0x3f ) 0x3f , ofs - 3 ) 3 | ' \ x80 ' . . ' \ xbf ' -> if ofs >= 4 then let ch4 = String . unsafe_get str ( ofs - 4 ) 4 in match ch4 with | ' \ xf0 ' . . ' \ xf7 ' -> ( UChar . of_int ( ( ( Char . code ch4 land 0x07 ) 0x07 lsl 18 ) 18 lor ( ( Char . code ch3 land 0x3f ) 0x3f lsl 12 ) 12 lor ( ( Char . code ch2 land 0x3f ) 0x3f lsl 6 ) 6 lor ( Char . code ch1 land 0x3f ) 0x3f ) 0x3f , ofs - 4 ) 4 | _ -> fail str ( ofs - 4 ) 4 " invalid start of UTF - 8 sequence " else fail str ( ofs - 3 ) 3 " invalid start of UTF - 8 string " | _ -> fail str ( ofs - 3 ) 3 " invalid middle of UTF - 8 sequence " else fail str ( ofs - 2 ) 2 " invaild start of UTF - 8 string " | _ -> fail str ( ofs - 2 ) 2 " invalid middle of UTF - 8 sequence " else fail str ( ofs - 1 ) 1 " invalid start of UTF - 8 string " | _ -> fail str ( ofs - 1 ) 1 " invalid end of UTF - 8 sequence " |
let rec move_l str ofs len = if len = 0 then ofs else if ofs = String . length str then raise Out_of_bounds else move_l str ( unsafe_next str ofs ) ofs ( len - 1 ) 1 |
let unsafe_sub str ofs len = let res = Bytes . create len in String . unsafe_blit str ofs res 0 len ; Bytes . unsafe_to_string res |
let singleton char = let code = UChar . code char in Bytes . unsafe_to_string @@ if code < 0x80 then begin let s = Bytes . create 1 in set_byte s 0 code ; s end else if code <= 0x800 then begin let s = Bytes . create 2 in set_byte s 0 ( ( code lsr 6 ) 6 lor 0xc0 ) 0xc0 ; set_byte s 1 ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ; s end else if code <= 0x10000 then begin let s = Bytes . create 3 in set_byte s 0 ( ( code lsr 12 ) 12 lor 0xe0 ) 0xe0 ; set_byte s 1 ( ( ( code lsr 6 ) 6 land 0x3f ) 0x3f lor 0x80 ) 0x80 ; set_byte s 2 ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ; s end else if code <= 0x10ffff then begin let s = Bytes . create 4 in set_byte s 0 ( ( code lsr 18 ) 18 lor 0xf0 ) 0xf0 ; set_byte s 1 ( ( ( code lsr 12 ) 12 land 0x3f ) 0x3f lor 0x80 ) 0x80 ; set_byte s 2 ( ( ( code lsr 6 ) 6 land 0x3f ) 0x3f lor 0x80 ) 0x80 ; set_byte s 3 ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ; s end else invalid_arg " Zed_utf8 . singleton " |
let make n code = let str = singleton code in let len = String . length str in let res = Bytes . create ( n * len ) len in let ofs = ref 0 in for _ = 1 to n do String . unsafe_blit str 0 res ! ofs len ; ofs := ! ofs + len done ; Bytes . unsafe_to_string res |
let init n f = let buf = Buffer . create n in for i = 0 to n - 1 do Buffer . add_string buf ( singleton ( f i ) i ) i done ; Buffer . contents buf |
let rev_init n f = let buf = Buffer . create n in for i = n - 1 downto 0 do Buffer . add_string buf ( singleton ( f i ) i ) i done ; Buffer . contents buf |
let rec length_rec str ofs len = if ofs = String . length str then len else length_rec str ( unsafe_next str ofs ) ofs ( len + 1 ) 1 |
let length str = length_rec str 0 0 |
let rec compare_rec str1 ofs1 str2 ofs2 = if ofs1 = String . length str1 then if ofs2 = String . length str2 then 0 else - 1 else if ofs2 = String . length str2 then 1 else let code1 , ofs1 = unsafe_extract_next str1 ofs1 and code2 , ofs2 = unsafe_extract_next str2 ofs2 in let d = UChar . code code1 - UChar . code code2 in if d <> 0 then d else compare_rec str1 ofs1 str2 ofs2 |
let compare str1 str2 = compare_rec str1 0 str2 0 |
let get str idx = if idx < 0 then raise Out_of_bounds else unsafe_extract str ( move_l str 0 idx ) idx |
let sub str idx len = if idx < 0 || len < 0 then raise Out_of_bounds else let ofs1 = move_l str 0 idx in let ofs2 = move_l str ofs1 len in unsafe_sub str ofs1 ( ofs2 - ofs1 ) ofs1 |
let break str idx = if idx < 0 then raise Out_of_bounds else let ofs = move_l str 0 idx in ( unsafe_sub str 0 ofs , unsafe_sub str ofs ( String . length str - ofs ) ofs ) ofs |
let before str idx = if idx < 0 then raise Out_of_bounds else let ofs = move_l str 0 idx in unsafe_sub str 0 ofs |
let after str idx = if idx < 0 then raise Out_of_bounds else let ofs = move_l str 0 idx in unsafe_sub str ofs ( String . length str - ofs ) ofs |
let concat3 a b c = let lena = String . length a and lenb = String . length b and lenc = String . length c in let res = Bytes . create ( lena + lenb + lenc ) lenc in String . unsafe_blit a 0 res 0 lena ; String . unsafe_blit b 0 res lena lenb ; String . unsafe_blit c 0 res ( lena + lenb ) lenb lenc ; Bytes . unsafe_to_string res |
let insert str idx sub = let a , b = break str idx in concat3 a sub b |
let remove str idx len = if idx < 0 || len < 0 then raise Out_of_bounds else let ofs1 = move_l str 0 idx in let ofs2 = move_l str ofs1 len in unsafe_sub str 0 ofs1 ^ unsafe_sub str ofs2 ( String . length str - ofs2 ) ofs2 |
let replace str idx len repl = if idx < 0 || len < 0 then raise Out_of_bounds else let ofs1 = move_l str 0 idx in let ofs2 = move_l str ofs1 len in concat3 ( unsafe_sub str 0 ofs1 ) ofs1 repl ( unsafe_sub str ofs2 ( String . length str - ofs2 ) ofs2 ) ofs2 |
let rec rev_rec ( res : Bytes . t ) t str ofs_src ofs_dst = if ofs_src = String . length str then Bytes . unsafe_to_string res else begin let ofs_src ' = unsafe_next str ofs_src in let len = ofs_src ' - ofs_src in let ofs_dst = ofs_dst - len in String . unsafe_blit str ofs_src res ofs_dst len ; rev_rec res str ofs_src ' ofs_dst end |
let rev str = let len = String . length str in rev_rec ( Bytes . create len ) len str 0 len |
let concat sep l = match l with | [ ] -> " " | x :: l -> let sep_len = String . length sep in let len = List . fold_left ( fun len str -> len + sep_len + String . length str ) str ( String . length x ) x l in let res = Bytes . create len in String . unsafe_blit x 0 res 0 ( String . length x ) x ; ignore ( List . fold_left ( fun ofs str -> String . unsafe_blit sep 0 res ofs sep_len ; let ofs = ofs + sep_len in let len = String . length str in String . unsafe_blit str 0 res ofs len ; ofs + len ) len ( String . length x ) x l ) l ; Bytes . unsafe_to_string res |
let rev_concat sep l = match l with | [ ] -> " " | x :: l -> let sep_len = String . length sep in let len = List . fold_left ( fun len str -> len + sep_len + String . length str ) str ( String . length x ) x l in let res = Bytes . create len in let ofs = len - String . length x in String . unsafe_blit x 0 res ofs ( String . length x ) x ; ignore ( List . fold_left ( fun ofs str -> let ofs = ofs - sep_len in String . unsafe_blit sep 0 res ofs sep_len ; let len = String . length str in let ofs = ofs - len in String . unsafe_blit str 0 res ofs len ; ofs ) ofs ofs l ) l ; Bytes . unsafe_to_string res |
let rec explode_rec str ofs acc = if ofs = 0 then acc else let x , ofs = unsafe_extract_prev str ofs in explode_rec str ofs ( x :: acc ) acc |
let explode str = explode_rec str ( String . length str ) str [ ] |
let rec rev_explode_rec str ofs acc = if ofs = String . length str then acc else let x , ofs = unsafe_extract_next str ofs in rev_explode_rec str ofs ( x :: acc ) acc |
let rev_explode str = rev_explode_rec str 0 [ ] |
let implode l = let l = List . map singleton l in let len = List . fold_left ( fun len str -> len + String . length str ) str 0 l in let res = Bytes . create len in ignore ( List . fold_left ( fun ofs str -> let len = String . length str in String . unsafe_blit str 0 res ofs len ; ofs + len ) len 0 l ) l ; Bytes . unsafe_to_string res |
let rev_implode l = let l = List . map singleton l in let len = List . fold_left ( fun len str -> len + String . length str ) str 0 l in let res = Bytes . create len in ignore ( List . fold_left ( fun ofs str -> let len = String . length str in let ofs = ofs - len in String . unsafe_blit str 0 res ofs len ; ofs ) ofs len l ) l ; Bytes . unsafe_to_string res |
let rec iter_rec f str ofs = if ofs = String . length str then ( ) else begin let chr , ofs = unsafe_extract_next str ofs in f chr ; iter_rec f str ofs end |
let iter f str = iter_rec f str 0 |
let rec rev_iter_rec f str ofs = if ofs = 0 then ( ) else begin let chr , ofs = unsafe_extract_prev str ofs in f chr ; rev_iter_rec f str ofs end |
let rev_iter f str = rev_iter_rec f str ( String . length str ) str |
let rec fold_rec f str ofs acc = if ofs = String . length str then acc else begin let chr , ofs = unsafe_extract_next str ofs in fold_rec f str ofs ( f chr acc ) acc end |
let fold f str acc = fold_rec f str 0 acc |
let rec rev_fold_rec f str ofs acc = if ofs = 0 then acc else begin let chr , ofs = unsafe_extract_prev str ofs in rev_fold_rec f str ofs ( f chr acc ) acc end |
let rev_fold f str acc = rev_fold_rec f str ( String . length str ) str acc |
let rec map_rec buf f str ofs = if ofs = String . length str then Buffer . contents buf else begin let chr , ofs = unsafe_extract_next str ofs in Buffer . add_string buf ( singleton ( f chr ) chr ) chr ; map_rec buf f str ofs end |
let map f str = map_rec ( Buffer . create ( String . length str ) str ) str f str 0 |
let rec map_concat_rec buf f str ofs = if ofs = String . length str then Buffer . contents buf else begin let chr , ofs = unsafe_extract_next str ofs in Buffer . add_string buf ( f chr ) chr ; map_concat_rec buf f str ofs end |
let map_concat f str = map_concat_rec ( Buffer . create ( String . length str ) str ) str f str 0 |
let rec rev_map_rec buf f str ofs = if ofs = 0 then Buffer . contents buf else begin let chr , ofs = unsafe_extract_prev str ofs in Buffer . add_string buf ( singleton ( f chr ) chr ) chr ; rev_map_rec buf f str ofs end |
let rev_map f str = rev_map_rec ( Buffer . create ( String . length str ) str ) str f str ( String . length str ) str |
let rec rev_map_concat_rec buf f str ofs = if ofs = 0 then Buffer . contents buf else begin let chr , ofs = unsafe_extract_prev str ofs in Buffer . add_string buf ( f chr ) chr ; rev_map_concat_rec buf f str ofs end |
let rev_map_concat f str = rev_map_concat_rec ( Buffer . create ( String . length str ) str ) str f str ( String . length str ) str |
let rec filter_rec buf f str ofs = if ofs = String . length str then Buffer . contents buf else begin let chr , ofs = unsafe_extract_next str ofs in if f chr then Buffer . add_string buf ( singleton chr ) chr ; filter_rec buf f str ofs end |
let filter f str = filter_rec ( Buffer . create ( String . length str ) str ) str f str 0 |
let rec rev_filter_rec buf f str ofs = if ofs = 0 then Buffer . contents buf else begin let chr , ofs = unsafe_extract_prev str ofs in if f chr then Buffer . add_string buf ( singleton chr ) chr ; rev_filter_rec buf f str ofs end |
let rev_filter f str = rev_filter_rec ( Buffer . create ( String . length str ) str ) str f str ( String . length str ) str |
let rec filter_map_rec buf f str ofs = if ofs = String . length str then Buffer . contents buf else begin let chr , ofs = unsafe_extract_next str ofs in ( match f chr with | Some chr -> Buffer . add_string buf ( singleton chr ) chr | None -> ( ) ) ; filter_map_rec buf f str ofs end |
let filter_map f str = filter_map_rec ( Buffer . create ( String . length str ) str ) str f str 0 |
let rec filter_map_concat_rec buf f str ofs = if ofs = String . length str then Buffer . contents buf else begin let chr , ofs = unsafe_extract_next str ofs in ( match f chr with | Some txt -> Buffer . add_string buf txt | None -> ( ) ) ; filter_map_concat_rec buf f str ofs end |
let filter_map_concat f str = filter_map_concat_rec ( Buffer . create ( String . length str ) str ) str f str 0 |
let rec rev_filter_map_rec buf f str ofs = if ofs = 0 then Buffer . contents buf else begin let chr , ofs = unsafe_extract_prev str ofs in ( match f chr with | Some chr -> Buffer . add_string buf ( singleton chr ) chr | None -> ( ) ) ; rev_filter_map_rec buf f str ofs end |
let rev_filter_map f str = rev_filter_map_rec ( Buffer . create ( String . length str ) str ) str f str ( String . length str ) str |
let rec rev_filter_map_concat_rec buf f str ofs = if ofs = 0 then Buffer . contents buf else begin let chr , ofs = unsafe_extract_prev str ofs in ( match f chr with | Some txt -> Buffer . add_string buf txt | None -> ( ) ) ; rev_filter_map_concat_rec buf f str ofs end |
let rev_filter_map_concat f str = rev_filter_map_concat_rec ( Buffer . create ( String . length str ) str ) str f str ( String . length str ) str |
let rec for_all_rec f str ofs = if ofs = String . length str then true else let chr , ofs = unsafe_extract_next str ofs in f chr && for_all_rec f str ofs |
let for_all f str = for_all_rec f str 0 |
let rec exists_rec f str ofs = if ofs = String . length str then false else let chr , ofs = unsafe_extract_next str ofs in f chr || exists_rec f str ofs |
let exists f str = exists_rec f str 0 |
let rec count_rec f str ofs n = if ofs = String . length str then n else let chr , ofs = unsafe_extract_next str ofs in count_rec f str ofs ( if f chr then n + 1 else n ) n |
let count f str = count_rec f str 0 0 |
let rec unsafe_sub_equal str ofs sub ofs_sub = if ofs_sub = String . length sub then true else ( String . unsafe_get str ofs = String . unsafe_get sub ofs_sub ) ofs_sub && unsafe_sub_equal str ( ofs + 1 ) 1 sub ( ofs_sub + 1 ) 1 |
let rec contains_rec str sub ofs = if ofs + String . length sub > String . length str then false else unsafe_sub_equal str ofs sub 0 || contains_rec str sub ( unsafe_next str ofs ) ofs |
let contains str sub = contains_rec str sub 0 |
let starts_with str prefix = if String . length prefix > String . length str then false else unsafe_sub_equal str 0 prefix 0 |
let ends_with str suffix = let ofs = String . length str - String . length suffix in if ofs < 0 then false else unsafe_sub_equal str ofs suffix 0 |
let rec lfind predicate str ofs = if ofs = String . length str then ofs else let chr , ofs ' = unsafe_extract_next str ofs in if predicate chr then lfind predicate str ofs ' else ofs |
let rec rfind predicate str ofs = if ofs = 0 then 0 else let chr , ofs ' = unsafe_extract_prev str ofs in if predicate chr then rfind predicate str ofs ' else ofs |
let spaces = UCharInfo . load_property_tbl ` White_Space |
let is_space ch = UCharTbl . Bool . get spaces ch |
let strip ( ? predicate = is_space ) is_space str = let lofs = lfind predicate str 0 and rofs = rfind predicate str ( String . length str ) str in if lofs < rofs then unsafe_sub str lofs ( rofs - lofs ) lofs else " " |
let lstrip ( ? predicate = is_space ) is_space str = let lofs = lfind predicate str 0 in unsafe_sub str lofs ( String . length str - lofs ) lofs |
let rstrip ( ? predicate = is_space ) is_space str = let rofs = rfind predicate str ( String . length str ) str in unsafe_sub str 0 rofs |
let lchop = function | " " -> " " | str -> let ofs = unsafe_next str 0 in unsafe_sub str ofs ( String . length str - ofs ) ofs |
let rchop = function | " " -> " " | str -> let ofs = unsafe_prev str ( String . length str ) str in unsafe_sub str 0 ofs |
let add buf char = let code = UChar . code char in if code < 0x80 then Buffer . add_char buf ( Char . unsafe_chr code ) code else if code <= 0x800 then begin Buffer . add_char buf ( Char . unsafe_chr ( ( code lsr 6 ) 6 lor 0xc0 ) 0xc0 ) 0xc0 ; Buffer . add_char buf ( Char . unsafe_chr ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 end else if code <= 0x10000 then begin Buffer . add_char buf ( Char . unsafe_chr ( ( code lsr 12 ) 12 lor 0xe0 ) 0xe0 ) 0xe0 ; Buffer . add_char buf ( Char . unsafe_chr ( ( ( code lsr 6 ) 6 land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 ; Buffer . add_char buf ( Char . unsafe_chr ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 end else if code <= 0x10ffff then begin Buffer . add_char buf ( Char . unsafe_chr ( ( code lsr 18 ) 18 lor 0xf0 ) 0xf0 ) 0xf0 ; Buffer . add_char buf ( Char . unsafe_chr ( ( ( code lsr 12 ) 12 land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 ; Buffer . add_char buf ( Char . unsafe_chr ( ( ( code lsr 6 ) 6 land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 ; Buffer . add_char buf ( Char . unsafe_chr ( ( code land 0x3f ) 0x3f lor 0x80 ) 0x80 ) 0x80 end else invalid_arg " Zed_utf8 . add " |
let extract str ofs = if ofs < 0 || ofs >= String . length str then raise Out_of_bounds else unsafe_extract str ofs |
Subsets and Splits