text stringlengths 12 786k |
|---|
let get_count r = S . value r . count |
let counter r = r . counter |
let get_counter r = S . value r . counter |
let set_counter r v = r . set_counter v |
let add_counter r v = r . set_counter ( S . value r . counter + v ) v |
let add r x = if S . value r . recording then begin r . tmp_macro <- x :: r . tmp_macro ; r . set_count ( S . value r . count + 1 ) 1 end |
let contents r = r . macro |
module Core = struct module Re = URe . Make ( MakeZed_rope . Text_core ) Text_core type t = Re . compiled_regexp type match_result = ( Re . index * Re . index ) index option array option let compile = Re . compile let convert_success arr = Array . map ( function | Some sub -> let _rope , ... |
module Raw = struct module Re = URe . Make ( MakeZed_rope . Text_raw ) Text_raw type t = Re . compiled_regexp type match_result = ( Re . index * Re . index ) index option array option let compile = Re . compile let convert_success arr = Array . map ( function | Some sub -> let _rope , z... |
type t = | Leaf of Zed_string . t * ( int * int ) int | Node of int * ( int * int ) int * t * ( int * int ) int * t |
let empty ( ) = Leaf ( Zed_string . empty ( ) , ( 0 , 0 ) 0 ) 0 |
let length = function | Leaf ( Leaf_ , ( len , _ ) _ ) _ -> len | Node ( Node_ , ( len_l , _ ) _ , _ , ( len_r , _ ) _ , _ ) _ -> len_l + len_r |
let size = function | Leaf ( Leaf_ , ( _ , size ) size ) size -> size | Node ( Node_ , ( _ , size_l ) size_l , _ , ( _ , size_r ) size_r , _ ) _ -> size_l + size_r |
let depth = function | Leaf _ -> 0 | Node ( Noded , _ , _ , _ , _ ) _ -> d |
let is_empty = function | Leaf ( Leaf_ , ( 0 , 0 ) 0 ) 0 -> true | _ -> false |
let rec trim_hd t = match t with | Leaf ( str , ( l , _ ) _ ) _ -> let hd , _ = Zed_string . extract_next str 0 in let hd = hd |> Zed_char . to_utf8 |> Zed_string . unsafe_of_utf8 in let after = Zed_string . after str 1 in let size = Zed_string . size after in ( Leaf ( after , ( ... |
let append_cm t cm = let size = Zed_string . size cm in let rec append_cm t = match t with | Leaf ( str , ( l , s ) s ) s -> Leaf ( Zed_string . append str cm , ( l , s + size ) size ) size | Node ( d , ( ll , sl ) sl , l , ( lr , sr ) sr , r ) r -> Node ( d ... |
let rec make_fibo acc a b = let c = a + b in if c < b then acc else make_fibo ( c :: acc ) acc b c |
let fibo = let l = make_fibo [ 1 ; 1 ; 0 ] 0 1 1 in let n = List . length l in let fibo = Array . make n 0 in let rec loop i = function | [ ] -> fibo | x :: l -> fibo ( . i ) i <- x ; loop ( i - 1 ) 1 l in loop ( n - 1 ) 1 l |
let unsafe_concat rope1 rope2 = match rope1 , rope2 with | Leaf ( Leaf_ , ( 0 , _ ) _ ) _ , _ -> rope2 | _ , Leaf ( Leaf_ , ( 0 , _ ) _ ) _ -> rope1 | _ -> Node ( Node 1 + max ( depth rope1 ) rope1 ( depth rope2 ) rope2 , ( length rope1 , size rope1 ) ... |
let rec insert_to_forest forest acc idx = let acc = unsafe_concat forest ( . idx ) idx acc in if length acc < fibo ( . idx + 1 ) 1 then forest ( . idx ) idx <- acc else begin forest ( . idx ) idx <- empty ( ) ; insert_to_forest forest acc ( idx + 1 ) 1 end |
let rec concat_forest_until forest acc idx rope = if length rope < fibo ( . idx + 1 ) 1 then insert_to_forest forest ( unsafe_concat acc rope ) rope idx else begin let acc = unsafe_concat forest ( . idx ) idx acc in forest ( . idx ) idx <- empty ( ) ; concat_forest_until forest acc ( ... |
let rec balance_rec forest rope = match rope with | Leaf _ -> concat_forest_until forest ( empty ( ) ) 2 rope | Node ( Node_depth , _len_l , rope_l , _len_r , rope_r ) rope_r -> balance_rec forest rope_l ; balance_rec forest rope_r |
let rec concat_forest forest acc idx = if idx = max_depth then acc else concat_forest forest ( unsafe_concat forest ( . idx ) idx acc ) acc ( idx + 1 ) 1 |
let balance rope = match length rope with | 0 | 1 -> rope | len when len >= fibo ( . depth rope + 2 ) 2 -> rope | _len -> let forest = Array . make max_depth ( empty ( ) ) in balance_rec forest rope ; concat_forest forest ( empty ( ) ) 2 |
let rec unsafe_get idx rope = match rope with | Leaf ( Leaftext , _ ) _ -> Zed_string . get text idx | Node ( Node_ , ( len_l , _ ) _ , rope_l , _len_r , rope_r ) rope_r -> if idx < len_l then unsafe_get idx rope_l else unsafe_get ( idx - len_l ) len_l rope_r |
let get rope idx = if idx < 0 || idx >= length rope then raise Out_of_bounds else unsafe_get idx rope |
let rec unsafe_get_raw idx rope = match rope with | Leaf ( Leaftext , _ ) _ -> Zed_string . get_raw text idx | Node ( Node_ , ( _ , size_l ) size_l , rope_l , _len_r , rope_r ) rope_r -> if idx < size_l then unsafe_get_raw idx rope_l else unsafe_get_raw ( idx - size_l ) size_l ro... |
let get_raw rope idx = if idx < 0 || idx >= size rope then raise Out_of_bounds else unsafe_get_raw idx rope |
let append rope1 rope2 = let len_12_comb = if length rope1 > 0 && length rope2 > 0 then Zed_char . is_combining_mark ( Zed_char . core ( get rope2 0 ) 0 ) 0 else false in let len12 l1 l2 = if len_12_comb then l1 + l2 - 1 else l1 + l2 in match rope1 , rope2 with | Leaf ( Leaf_ , ( 0 ,... |
let concat sep l = let rec loop acc = function | [ ] -> acc | x :: l -> loop ( append ( append acc sep ) sep x ) x l in match l with | [ ] -> empty ( ) | x :: l -> loop x l |
let rec unsafe_sub rope idx len = match rope with | Leaf ( Leaftext , _ ) _ -> let str = Zed_string . sub ~ pos : idx ~ len text in let size = Zed_string . size str in Leaf ( Leafstr , ( len , size ) size ) size | Node ( Node_ , ( len_l , _ ) _ , rope_l , ( len_r , _ ... |
let sub rope idx len = if idx < 0 || len < 0 || idx + len > length rope then raise Out_of_bounds else unsafe_sub rope idx len |
let make length char = if length < max_leaf_size then Leaf ( LeafZed_string . make length char , ( length , length ) length ) length else begin let text = Zed_string . make max_leaf_size char in let chunk = Leaf ( Leaftext , ( max_leaf_size , max_leaf_size ) max_leaf_size ) max_leaf_size ... |
let singleton ch = Leaf ( LeafZed_string . make 1 ch , ( 1 , 1 ) 1 ) 1 |
let break rope pos = let len = length rope in if pos < 0 || pos > len then raise Out_of_bounds ; ( unsafe_sub rope 0 pos , unsafe_sub rope pos ( len - pos ) pos ) pos |
let before rope pos = sub rope 0 pos |
let after rope pos = sub rope pos ( length rope - pos ) pos |
let insert rope pos sub = let before , after = break rope pos in append before ( append sub after ) after |
let remove rope pos len = append ( sub rope 0 pos ) pos ( sub rope ( pos + len ) len ( length rope - pos - len ) len ) len |
let replace rope pos len repl = append ( sub rope 0 pos ) pos ( append repl ( sub rope ( pos + len ) len ( length rope - pos - len ) len ) len ) len |
let insert_uChar rope pos ch = let open CamomileLibraryDefault . Camomile in if UChar . code ch = 0 then rope else if Zed_char . is_combining_mark ch then if length rope = 0 then failwith " inserting an individual combining mark " else if pos = 0 then failwith " inserting an individual combining mark " ... |
let lchop = function | Leaf ( Leaf_ , ( 0 , _ ) _ ) _ -> empty ( ) | rope -> sub rope 1 ( length rope - 1 ) 1 |
let rchop = function | Leaf ( Leaf_ , ( 0 , _ ) _ ) _ -> empty ( ) | rope -> sub rope 0 ( length rope - 1 ) 1 |
let rec iter f = function | Leaf ( Leaftext , _ ) _ -> Zed_string . iter f text | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> iter f rope_l ; iter f rope_r |
let rec rev_iter f = function | Leaf ( Leaftext , _ ) _ -> Zed_string . rev_iter f text | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> rev_iter f rope_r ; rev_iter f rope_l |
let rec fold f rope acc = match rope with | Leaf ( Leaftext , _ ) _ -> Zed_string . fold f text acc | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> fold f rope_r ( fold f rope_l acc ) acc |
let rec rev_fold f rope acc = match rope with | Leaf ( Leaftext , _ ) _ -> Zed_string . rev_fold f text acc | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> rev_fold f rope_l ( rev_fold f rope_r acc ) acc |
let rec map f = function | Leaf ( Leaftxt , len ) len -> Leaf ( LeafZed_string . map f txt , len ) len | Node ( Nodedepth , length_l , rope_l , length_r , rope_r ) rope_r -> let rope_l ' = map f rope_l in let rope_r ' = map f rope_r in Node ( Nodedepth , length_l , rope_l ' ... |
let rec rev_map f = function | Leaf ( Leaftxt , len ) len -> Leaf ( LeafZed_string . rev_map f txt , len ) len | Node ( Nodedepth , length_l , rope_l , length_r , rope_r ) rope_r -> let rope_l ' = rev_map f rope_l in let rope_r ' = rev_map f rope_r in Node ( Nodedepth , length_r... |
let rec iter_leaf f = function | Leaf ( Leaftext , _ ) _ -> f text | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> iter_leaf f rope_l ; iter_leaf f rope_r |
let rec rev_iter_leaf f = function | Leaf ( Leaftext , _ ) _ -> f text | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> rev_iter_leaf f rope_r ; rev_iter_leaf f rope_l |
let rec fold_leaf f rope acc = match rope with | Leaf ( Leaftext , _ ) _ -> f text acc | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> fold_leaf f rope_r ( fold_leaf f rope_l acc ) acc |
let rec rev_fold_leaf f rope acc = match rope with | Leaf ( Leaftext , _ ) _ -> f text acc | Node ( Node_ , _ , rope_l , _ , rope_r ) rope_r -> rev_fold_leaf f rope_l ( rev_fold_leaf f rope_r acc ) acc |
let rec cmp_loop str1 ofs1 str2 ofs2 rest1 rest2 = if ofs1 = Zed_string . bytes str1 then match rest1 with | [ ] -> if ofs2 = Zed_string . length str2 && rest2 = [ ] then 0 else - 1 | rope1 :: rest1 -> cmp_search1 rope1 str2 ofs2 rest1 rest2 else if ofs2 = Zed_string . bytes str2 then match res... |
let rec cmp_init rope1 rope2 rest1 = match rope1 with | Leaf ( Leafstr1 , _ ) _ -> cmp_search2 rope2 str1 0 rest1 [ ] | Node ( Node_ , _ , rope1_l , _ , rope1_r ) rope1_r -> cmp_init rope1_l rope2 ( rope1_r :: rest1 ) rest1 |
let compare r1 r2 = cmp_init r1 r2 [ ] |
let equal r1 r2 = length r1 = length r2 && compare r1 r2 = 0 |
module Zip = struct type rope_zipper = { str : Zed_string . t ; ofs : int ; leaf : t ; rest_b : t list ; rest_f : t list ; } type t = { idx : int ; pos : int ; zip : rope_zipper ; } let rec make_rec ofs rope pos rest_b rest_f = match rope with | Leaf ( Leafstr , _ ) _ -> ... |
module Zip_raw = struct type rope_zipper = { str : Zed_string . t ; ofs : int ; leaf : t ; rest_b : t list ; rest_f : t list ; } type t = { idx : int ; pos : int ; zip : rope_zipper ; } let rec make_f_rec ofs rope pos rest_b rest_f = match rope with | Leaf ( Leafstr , _ ) _... |
module Buffer = struct type t = { mutable acc : rope ; mutable buf : Zed_string . Buf . buf ; mutable idx : int ; } let create ( ) = { acc = empty ( ) ; buf = Zed_string . Buf . create 1024 ; idx = 0 ; } let add buffer x = if buffer . idx = max_leaf_size then begin let str... |
let init n f = let buf = Buffer . create ( ) in for i = 0 to n - 1 do Buffer . add buf ( f i ) i done ; Buffer . contents buf |
let init_from_uChars len f = match len with | 0 -> empty ( ) | len when len > 0 -> let rec create n = if n > 0 then f ( len - n ) n :: create ( n - 1 ) 1 else [ ] in let uChars = create len in let zChars , _ = Zed_char . zChars_of_uChars uChars in let buf = Buffer . create ( ) ... |
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 _ zi... |
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 ... |
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 -> ... |
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 ( ex... |
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 lo... |
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 +... |
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 o... |
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 | ' \ x... |
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 ( ( ( ... |
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 " el... |
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 i... |
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 (... |
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 ... |
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 ) ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.