text stringlengths 12 786k |
|---|
let cleanup_types ( ) = List . iter ( fun ( ty , desc ) -> ty . desc <- desc ) ! saved_desc ; List . iter ( fun r -> r := None ) ! saved_kinds ; saved_desc := [ ] ; saved_kinds := [ ] ; new_kinds := [ ] |
let rec mark_type ty = let ty = repr ty in if ty . level >= lowest_level then begin ty . level <- pivot_level - ty . level ; iter_type_expr mark_type ty end |
let mark_type_node ty = let ty = repr ty in if ty . level >= lowest_level then begin ty . level <- pivot_level - ty . level ; end |
let mark_type_params ty = iter_type_expr mark_type ty |
let rec unmark_type ty = let ty = repr ty in if ty . level < lowest_level then begin ty . level <- pivot_level - ty . level ; iter_type_expr unmark_type ty end |
let unmark_type_decl decl = List . iter unmark_type decl . type_params ; begin match decl . type_kind with Type_abstract -> ( ) | Type_variant cstrs -> List . iter ( fun ( c , tl ) -> List . iter unmark_type tl ) cstrs | Type_record ( lbls , rep ) -> List . iter ( fun ( c , ... |
let unmark_class_signature sign = unmark_type sign . cty_self ; Vars . iter ( fun l ( m , v , t ) -> unmark_type t ) sign . cty_vars |
let rec unmark_class_type = function Tcty_constr ( p , tyl , cty ) -> List . iter unmark_type tyl ; unmark_class_type cty | Tcty_signature sign -> unmark_class_signature sign | Tcty_fun ( _ , ty , cty ) -> unmark_type ty ; unmark_class_type cty |
let rec find_expans priv p1 = function Mnil -> None | Mcons ( priv ' , p2 , ty0 , ty , _ ) when priv ' >= priv && Path . same p1 p2 -> Some ty | Mcons ( _ , _ , _ , _ , rem ) -> find_expans priv p1 rem | Mlink { contents = rem } -> find_expans priv p1 rem |
let memo = ref [ ] |
let cleanup_abbrev ( ) = List . iter ( fun abbr -> abbr := Mnil ) ! memo ; memo := [ ] |
let memorize_abbrev mem priv path v v ' = mem := Mcons ( priv , path , v , v ' , ! mem ) ; memo := mem :: ! memo |
let rec forget_abbrev_rec mem path = match mem with Mnil -> assert false | Mcons ( _ , path ' , _ , _ , rem ) when Path . same path path ' -> rem | Mcons ( priv , path ' , v , v ' , rem ) -> Mcons ( priv , path ' , v , v ' , forget_abbrev_rec rem path ) | Mlin... |
let forget_abbrev mem path = try mem := forget_abbrev_rec ! mem path with Exit -> ( ) |
let is_optional l = String . length l > 0 && l . [ 0 ] = ' ' ? |
let label_name l = if is_optional l then String . sub l 1 ( String . length l - 1 ) else l |
let rec extract_label_aux hd l = function [ ] -> raise Not_found | ( l ' , t as p ) :: ls -> if label_name l ' = l then ( l ' , t , List . rev hd , ls ) else extract_label_aux ( p :: hd ) l ls |
let extract_label l ls = extract_label_aux [ ] l ls |
type change = Ctype of type_expr * type_desc | Clevel of type_expr * int | Cname of ( Path . t * type_expr list ) option ref * ( Path . t * type_expr list ) option | Crow of row_field option ref * row_field option | Ckind of field_kind option ref * field_kind option | Ccommu of commutable ref ... |
let undo_change = function Ctype ( ty , desc ) -> ty . desc <- desc | Clevel ( ty , level ) -> ty . level <- level | Cname ( r , v ) -> r := v | Crow ( r , v ) -> r := v | Ckind ( r , v ) -> r := v | Ccommu ( r , v ) -> r := v | Cuniv ( r , v ) -> r := ... |
type changes = Change of change * changes ref | Unchanged | Invalid |
type snapshot = changes ref * int |
let trail = Weak . create 1 |
let last_snapshot = ref 0 |
let log_change ch = match Weak . get trail 0 with None -> ( ) | Some r -> let r ' = ref Unchanged in r := Change ( ch , r ' ) ; Weak . set trail 0 ( Some r ' ) |
let log_type ty = if ty . id <= ! last_snapshot then log_change ( Ctype ( ty , ty . desc ) ) |
let link_type ty ty ' = log_type ty ; ty . desc <- Tlink ty ' |
let set_level ty level = if ty . id <= ! last_snapshot then log_change ( Clevel ( ty , ty . level ) ) ; ty . level <- level |
let set_univar rty ty = log_change ( Cuniv ( rty , ! rty ) ) ; rty := Some ty |
let set_name nm v = log_change ( Cname ( nm , ! nm ) ) ; nm := v |
let set_row_field e v = log_change ( Crow ( e , ! e ) ) ; e := Some v |
let set_kind rk k = log_change ( Ckind ( rk , ! rk ) ) ; rk := Some k |
let set_commu rc c = log_change ( Ccommu ( rc , ! rc ) ) ; rc := c |
let snapshot ( ) = let old = ! last_snapshot in last_snapshot := ! new_id ; match Weak . get trail 0 with Some r -> ( r , old ) | None -> let r = ref Unchanged in Weak . set trail 0 ( Some r ) ; ( r , old ) |
let rec rev_log accu = function Unchanged -> accu | Invalid -> assert false | Change ( ch , next ) -> let d = ! next in next := Invalid ; rev_log ( ch :: accu ) d |
let backtrack ( changes , old ) = match ! changes with Unchanged -> last_snapshot := old | Invalid -> failwith " Btype . backtrack " | Change _ as change -> cleanup_abbrev ( ) ; let backlog = rev_log [ ] change in List . iter undo_change backlog ; changes := Unchanged ; last_snaps... |
module Shared = struct type t = { buf : Bytes . t ; mutable pos : int ; pos_end : int ; } let of_bytes buf = { buf ; pos = 0 ; pos_end = Bytes . length buf } let of_bytes_sub buf ~ pos ~ pos_end = { buf ; pos ; pos_end } let remaining b = b . pos_end - b . pos external bs... |
module Write = struct include Shared let rec write_fully fd buf pos pos_end = if pos = pos_end then ( ) else let written = Unix . write fd buf pos ( pos_end - pos ) in write_fully fd buf ( pos + written ) pos_end let write_fd fd b = write_fully fd b . buf 0 b . pos let put_raw_8 b i v = Bytes... |
module Read = struct include Shared let rec read_into fd buf off = if off = Bytes . length buf then { buf ; pos = 0 ; pos_end = off } else begin assert ( 0 <= off && off <= Bytes . length buf ) ; let n = Unix . read fd buf off ( Bytes . length buf - off ) in if n = 0 then { buf... |
let ( ) = Printexc . register_printer ( function | Write . Overflow n -> Some ( " Buffer overflow at position " ^ string_of_int n ) | Read . Underflow n -> Some ( " Buffer underflow at position " ^ string_of_int n ) | _ -> None ) |
type t = { mutable buffer : bytes ; mutable position : int ; mutable length : int ; initial_buffer : bytes } |
let create n = let n = if n < 1 then 1 else n in let n = if n > Sys . max_string_length then Sys . max_string_length else n in let s = Bytes . create n in { buffer = s ; position = 0 ; length = n ; initial_buffer = s } |
let contents b = Bytes . sub_string b . buffer 0 b . position |
let to_bytes b = Bytes . sub b . buffer 0 b . position |
let sub b ofs len = if ofs < 0 || len < 0 || ofs > b . position - len then invalid_arg " Buffer . sub " else Bytes . sub_string b . buffer ofs len |
let blit src srcoff dst dstoff len = if len < 0 || srcoff < 0 || srcoff > src . position - len || dstoff < 0 || dstoff > ( Bytes . length dst ) - len then invalid_arg " Buffer . blit " else Bytes . unsafe_blit src . buffer srcoff dst dstoff len |
let nth b ofs = if ofs < 0 || ofs >= b . position then invalid_arg " Buffer . nth " else Bytes . unsafe_get b . buffer ofs |
let length b = b . position |
let clear b = b . position <- 0 |
let reset b = b . position <- 0 ; b . buffer <- b . initial_buffer ; b . length <- Bytes . length b . buffer |
let resize b more = let old_pos = b . position in let old_len = b . length in let new_len = ref old_len in while old_pos + more > ! new_len do new_len := 2 * ! new_len done ; if ! new_len > Sys . max_string_length then begin if old_pos + more <= Sys . max_string_length then new_len := Sys . ... |
let add_char b c = let pos = b . position in if pos >= b . length then resize b 1 ; Bytes . unsafe_set b . buffer pos c ; b . position <- pos + 1 let add_utf_8_uchar b u = match Uchar . to_int u with | u when u < 0 -> assert false | u when u <= 0x007F -> add_char b ( Char . unsafe_ch... |
let add_substring b s offset len = if offset < 0 || len < 0 || offset > String . length s - len then invalid_arg " Buffer . add_substring / add_subbytes " ; let new_position = b . position + len in if new_position > b . length then resize b len ; Bytes . unsafe_blit_string s offset b . ... |
let add_subbytes b s offset len = add_substring b ( Bytes . unsafe_to_string s ) offset len |
let add_string b s = let len = String . length s in let new_position = b . position + len in if new_position > b . length then resize b len ; Bytes . unsafe_blit_string s 0 b . buffer b . position len ; b . position <- new_position |
let add_bytes b s = add_string b ( Bytes . unsafe_to_string s ) |
let add_buffer b bs = add_subbytes b bs . buffer 0 bs . position |
let really_input_up_to ic buf ofs len = let rec loop ic buf ~ already_read ~ ofs ~ to_read = if to_read = 0 then already_read else begin let r = input ic buf ofs to_read in if r = 0 then already_read else begin let already_read = already_read + r in let ofs = ofs + r in let to_read = to_read - r in loop... |
let unsafe_add_channel_up_to b ic len = if b . position + len > b . length then resize b len ; let n = really_input_up_to ic b . buffer b . position len in assert ( b . position + n <= b . length ) ; b . position <- b . position + n ; n |
let add_channel b ic len = if len < 0 || len > Sys . max_string_length then invalid_arg " Buffer . add_channel " ; let n = unsafe_add_channel_up_to b ic len in if n < len then raise End_of_file ; ( ) |
let output_buffer oc b = output oc b . buffer 0 b . position |
let closing = function | ' ( ' -> ' ) ' | ' { ' -> ' } ' | _ -> assert false |
let advance_to_closing opening closing k s start = let rec advance k i lim = if i >= lim then raise Not_found else if s . [ i ] = opening then advance ( k + 1 ) ( i + 1 ) lim else if s . [ i ] = closing then if k = 0 then i else advance ( k - 1 ) ( i + 1 ) lim else advance k (... |
let advance_to_non_alpha s start = let rec advance i lim = if i >= lim then lim else match s . [ i ] with | ' a ' . . ' z ' | ' A ' . . ' Z ' | ' 0 ' . . ' 9 ' | ' _ ' -> advance ( i + 1 ) lim | _ -> i in advance start ( String . length s ) |
let find_ident s start lim = if start >= lim then raise Not_found else match s . [ start ] with | ' ( ' | ' { ' as c -> let new_start = start + 1 in let stop = advance_to_closing c ( closing c ) 0 s new_start in String . sub s new_start ( stop - start - 1 ) , stop + 1 | _ ... |
let add_substitute b f s = let lim = String . length s in let rec subst previous i = if i < lim then begin match s . [ i ] with | ' ' $ as current when previous = ' ' \\ -> add_char b current ; subst ' ' ( i + 1 ) | ' ' $ -> let j = i + 1 in let ident , next_i = find_id... |
let truncate b len = if len < 0 || len > length b then invalid_arg " Buffer . truncate " else b . position <- len |
let to_seq b = let rec aux i ( ) = if i >= b . position then Seq . Nil else let x = Bytes . unsafe_get b . buffer i in Seq . Cons ( x , aux ( i + 1 ) ) in aux 0 |
let to_seqi b = let rec aux i ( ) = if i >= b . position then Seq . Nil else let x = Bytes . unsafe_get b . buffer i in Seq . Cons ( ( i , x ) , aux ( i + 1 ) ) in aux 0 |
let add_seq b seq = Seq . iter ( add_char b ) seq |
let of_seq i = let b = create 32 in add_seq b i ; b |
let add_int8 b x = let new_position = b . position + 1 in if new_position > b . length then resize b 1 ; unsafe_set_int8 b . buffer b . position x ; b . position <- new_position |
let add_int16_ne b x = let new_position = b . position + 2 in if new_position > b . length then resize b 2 ; unsafe_set_int16 b . buffer b . position x ; b . position <- new_position |
let add_int32_ne b x = let new_position = b . position + 4 in if new_position > b . length then resize b 4 ; unsafe_set_int32 b . buffer b . position x ; b . position <- new_position |
let add_int64_ne b x = let new_position = b . position + 8 in if new_position > b . length then resize b 8 ; unsafe_set_int64 b . buffer b . position x ; b . position <- new_position |
let add_int16_le b x = add_int16_ne b ( if Sys . big_endian then swap16 x else x ) |
let add_int16_be b x = add_int16_ne b ( if Sys . big_endian then x else swap16 x ) |
let add_int32_le b x = add_int32_ne b ( if Sys . big_endian then swap32 x else x ) |
let add_int32_be b x = add_int32_ne b ( if Sys . big_endian then x else swap32 x ) |
let add_int64_le b x = add_int64_ne b ( if Sys . big_endian then swap64 x else x ) |
let add_int64_be b x = add_int64_ne b ( if Sys . big_endian then x else swap64 x ) |
type t = A of t * t | B ; ; |
type t2 = C of ( t2 * t2 ) | D ; ; |
type ' a t3 = S of ' a | T ; ; |
let A ( b , B ) = A ( B , B ) ; ; |
let f ( A ( B , B ) ) = ( ) ; ; |
let f B ( A ( B , B ) ) = ( ) ; ; |
let ( D , d ) = ( D , D ) ; ; |
let ( C ( D , d ) ) = ( C ( D , D ) ) ; ; function |
let Some a = Some 42 ; ; |
let Some a :: y = [ Some 42 ] ; ; |
let Some a , b = Some 42 , 43 ; ; |
let ( Some a ) , b = Some 42 , 43 ; ; |
let Some a as b = let _ = b = 42 in Some 42 ; ; |
let Some a | Some a = Some 42 ; ; |
let x , y as r = 1 , 2 ; ; |
let ( ( x , y ) as r ) = ( 1 , 2 ) ; ; |
type top = Top of ( int * int ) ; ; |
let rec f x y = ( ) ; ; |
let rec next line pos0 = ( ) in ( ) ; ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.