text stringlengths 0 601k |
|---|
let name_of_action x = let rec loop a b = if a = b then raise Not_found else let c = ( a + b ) b / 2 in let action , name = Array . unsafe_get actions_to_names c in match compare x action with | d when d < 0 -> loop a c | d when d > 0 -> loop ( c + 1 ) 1 b | _ -> name in let open Printf in let param_action_to_str name ... |
module type S = sig type event type + ' a t val empty : ' a t val add : event list -> ' a -> ' a t -> ' a t val remove : event list -> ' a t -> ' a t val fold : ( event list -> ' a -> ' b -> ' b ) ' b -> ' a t -> ' b -> ' b val bindings : ' a t -> ( event list * ' a ) ' a list type ' a resolver type ' a pack val pack :... |
module Make ( Event : Map . OrderedType ) OrderedType = struct type event = Event . t module Event_map = Map . Make ( Event ) Event type ' a t = ' a node Event_map . t and ' a node = | Set of ' a t | Val of ' a let empty = Event_map . empty let rec add events value set = match events with | [ ] -> invalid_arg " Zed_inp... |
type line = { length : int ; width : int ; width_info : int array ; } |
type t = | String of line | Return | Concat of t * t * int * int * int |
let empty_line ( ) = { length = 0 ; width = 0 ; width_info = [ ] || } |
let length = function | String line -> line . length | Return -> 1 | Concat ( Concat_ , _ , len , _ , _ ) _ -> len |
let count = function | String _ -> 0 | Return -> 1 | Concat ( Concat_ , _ , _ , count , _ ) _ -> count |
let depth = function | String _ | Return -> 0 | Concat ( Concat_ , _ , _ , _ , d ) d -> d |
let empty = String ( empty_line ( ) ) |
let unsafe_width ( ? tolerant = false ) false set idx len = let start = idx and len_all = len and acc = if tolerant then fun a b -> ( ) + ( if a < 0 then 1 else a ) a ( if b < 0 then 1 else b ) b else ( ) + in let rec unsafe_width set idx len = if len = 0 then Ok 0 else match set with | Return -> Error ( start + len_al... |
let width ( ? tolerant = false ) false set idx len = if idx < 0 || len < 0 || idx + len > length set then raise Out_of_bounds else unsafe_width ~ tolerant set idx len |
let force_width set idx len = let acc a b = ( ) + ( if a < 0 then 1 else a ) a ( if b < 0 then 1 else b ) b in let rec force_width set idx len = if len = 0 then 0 else match set with | Return -> 0 | String line -> Array . fold_left acc 0 ( Array . sub line . width_info idx len ) len | Concat ( set1 , set2 , _ , _ , _ )... |
let rec line_index_rec set ofs acc = match set with | String _ -> acc | Return -> if ofs = 0 then acc else acc + 1 | Concat ( Concats1 , s2 , _ , _ , _ ) _ -> let len1 = length s1 in if ofs < len1 then line_index_rec s1 ofs acc else line_index_rec s2 ( ofs - len1 ) len1 ( acc + count s1 ) s1 |
let line_index set ofs = if ofs < 0 || ofs > length set then raise Out_of_bounds else line_index_rec set ofs 0 |
let rec line_start_rec set idx acc = match set with | String _ -> acc | Return -> if idx = 0 then acc else acc + 1 | Concat ( Concats1 , s2 , _ , _ , _ ) _ -> let count1 = count s1 in if idx <= count1 then line_start_rec s1 idx acc else line_start_rec s2 ( idx - count1 ) count1 ( acc + length s1 ) s1 |
let line_start set idx = if idx < 0 || idx > count set then raise Out_of_bounds else line_start_rec set idx 0 |
let line_stop set idx = if idx = count set then length set else line_start set ( idx + 1 ) 1 - 1 |
let line_length set idx = line_stop set idx - line_start set idx |
let concat set1 set2 = Concat ( Concat set1 , set2 , length set1 + length set2 , count set1 + count set2 , 1 + max ( depth set1 ) set1 ( depth set2 ) set2 ) set2 |
let append_line l1 l2 = { length = l1 . length + l2 . length ; width = l1 . width + l2 . width ; width_info = Array . append l1 . width_info l2 . width_info } |
let append set1 set2 = match set1 , set2 with | String { length = 0 ; _ } _ , _ -> set2 | _ , String { length = 0 ; _ } _ -> set1 | String l1 , String l2 -> String ( append_line l1 l2 ) l2 | String l1 , Concat ( ConcatString l2 , set , len , count , h ) h -> Concat ( ConcatString ( append_line l1 l2 ) l2 , set , len + ... |
let rec unsafe_sub set idx len = match set with | String line -> let length = len in let width_info = Array . sub line . width_info idx length in let width = Array . fold_left ( ) + 0 width_info in String { length ; width ; width_info } | Return -> if len = 1 then Return else String ( empty_line ( ) ) | Concat ( Concat... |
let sub set idx len = if idx < 0 || len < 0 || idx + len > length set then raise Out_of_bounds else unsafe_sub set idx len |
let break set ofs = let len = length set in if ofs < 0 || ofs > len then raise Out_of_bounds else ( unsafe_sub set 0 ofs , unsafe_sub set ofs ( len - ofs ) ofs ) ofs |
let insert set ofs set ' = let set1 , set2 = break set ofs in append set1 ( append set ' set2 ) set2 |
let remove set ofs len = append ( sub set 0 ofs ) ofs ( sub set ( ofs + len ) len ( length set - ofs - len ) len ) len |
let replace set ofs len repl = append ( sub set 0 ofs ) ofs ( append repl ( sub set ( ofs + len ) len ( length set - ofs - len ) len ) len ) len |
let of_rope rope = let calc_widths widths = let width_info = widths |> List . rev |> Array . of_list in let width = Array . fold_left ( ) + 0 width_info in ( width , width_info ) width_info in let rec loop zip ( length , widths ) widths acc = if Zed_rope . Zip . at_eos zip then let width , width_info = calc_widths widt... |
let get_idx_by_width set row column = let start = line_start set row in let stop = line_stop set row in let rec get idx acc_width = if acc_width >= column || idx >= stop then idx else let curr_width = force_width set idx 1 in if acc_width + curr_width > column then idx else get ( idx + 1 ) 1 ( acc_width + curr_width ) ... |
type ' a t = { recording : bool signal ; set_recording : bool -> unit ; mutable tmp_macro : ' a list ; mutable macro : ' a list ; count : int signal ; set_count : int -> unit ; counter : int signal ; set_counter : int -> unit ; } |
let create macro = let recording , set_recording = S . create false in let count , set_count = S . create 0 in let counter , set_counter = S . create 0 in { recording ; set_recording ; macro ; tmp_macro = [ ] ; count ; set_count ; counter ; set_counter ; } |
let recording r = r . recording |
let get_recording r = S . value r . recording |
let set_recording r state = match state with | true -> r . tmp_macro <- [ ] ; r . set_recording true ; r . set_count 0 ; r . set_counter 0 | false -> if S . value r . recording then begin r . macro <- List . rev r . tmp_macro ; r . tmp_macro <- [ ] ; r . set_recording false ; r . set_count 0 end |
let cancel r = if S . value r . recording then begin r . tmp_macro <- [ ] ; r . set_recording false ; r . set_count 0 end |
let count r = r . count |
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 , zip1 , zip2 = Re . SubText . co... |
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 , zip1 , zip2 = Re . SubText . conte... |
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 , ( l - 1 , size ) size ) size , hd ) hd | N... |
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 , ( ll , sl ) sl , l , ( lr , sr + size ) size , append_cm r ... |
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 ) rope1 , rope1 , ( length rope2 , size rope2 ) rope2 , rope2 ) rope2 |
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 ( idx + 1 ) 1 rope end |
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 rope_r |
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 , _ ) _ ) _ , _ -> rope2 | _ , Leaf (... |
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 , _ ) _ , rope_r ) rope_r -> if len = len_l + len_r then... |
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 in let rec loop acc n = if n = ... |
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 " else let pos = i... |
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 ' , length_r , rope_r ' ) rope_r ' |
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 , rope_r ' , length_l , rope_l ' ) rope_... |
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 rest2 with | [ ] -> 1 | rope... |
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 , _ ) _ -> { idx = Zed_string . move str 0 pos ; pos = pos ... |
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 , _ ) _ -> { idx = Zed_string . move_raw str 0 pos ; ... |
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 = Zed_string . Buf . contents buffer . buf in ... |
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 ( ) in List . iter ( Buffer . add buf ) buf zC... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.