text
stringlengths 0
601k
|
|---|
let env = Hashtbl . create 8 |
let shell_set = ref " " |
let suppress_failure = ref false |
let last_status = ref 0 |
let export k v = Hashtbl . replace env k ( Some v ) v |
let set opts = shell_set := opts |
let unset k = Hashtbl . replace env k None |
let getenv_default var default = try Sys . getenv var with Not_found -> default |
let q = Printf . sprintf " " \% s " " \ |
let ql = map q |
let split_char_bounded str ~ on ~ max = let open String in if str = " " then [ ] else if max = 1 then [ str ] str else let rec loop offset tokens = if tokens = max - 1 then [ sub str offset ( length str - offset ) offset ] offset else try let index = index_from str offset on in if index = offset then ( " " :: loop ( offset + 1 ) 1 ( tokens + 1 ) 1 ) 1 else let token = String . sub str offset ( index - offset ) offset in token ( :: loop ( index + 1 ) 1 ( tokens + 1 ) 1 ) 1 with Not_found -> [ sub str offset ( length str - offset ) offset ] offset in loop 0 0 |
let split_char_unbounded_no_trailer str ~ on = let open String in if str = " " then [ ] else let rec loop acc offset = try begin let index = rindex_from str offset on in if index = offset then loop acc ( index - 1 ) 1 else let token = sub str ( index + 1 ) 1 ( offset - index ) index in loop ( token :: acc ) acc ( index - 1 ) 1 end with Not_found -> ( sub str 0 ( offset + 1 ) 1 ) 1 :: acc in loop [ ] ( length str - 1 ) 1 |
let some = function " " -> None | x -> Some x |
let list = split_char_unbounded_no_trailer ~ on : ' ' |
let lines = let rm_trailing_CR s = let len = String . length s in if len > 0 && s [ . len - 1 ] 1 = ' \ r ' then String . sub s 0 ( len - 1 ) 1 else s in fun str -> let l = split_char_unbounded_no_trailer ~ on : ' \ n ' str in List . map rm_trailing_CR l |
let pair s = match split_char_bounded s ~ on : ' : ' ~ max : 2 with | [ ] -> ( " " , None ) None | [ x ] x -> ( x , None ) None | x :: y :: _ -> ( x , Some y ) y |
let fuzzy_bool_of_string s = match String . lowercase s with | " false " | " 0 " -> false | _ -> true |
let echo fmt = Printf . ksprintf print_endline fmt |
let is_space = function ' ' | ' \ 012 ' | ' \ n ' | ' \ r ' | ' \ t ' -> true | _ -> false |
let trim s = let open String in let len = length s in let i = ref 0 in while ! i < len && is_space ( unsafe_get s ! i ) i do incr i done ; let j = ref ( len - 1 ) 1 in while ! j >= ! i && is_space ( unsafe_get s ! j ) j do decr j done ; if ! j >= ! i then sub s ! i ( ! j - ! i + 1 ) 1 else " " |
let escape_unprintable s = let must_not_escape = ref true in let i = ref 0 in while ! i < String . length s && ! must_not_escape do if s [ . ! i ] i < ' ' then must_not_escape := false ; incr i done ; if ! must_not_escape then s else ( let b = Buffer . create ( String . length s + 8 ) 8 in for i = 0 to String . length s - 1 do if s [ . i ] i < ' ' then Buffer . add_string b ( Char . escaped s [ . i ] i ) i else Buffer . add_char b s [ . i ] i done ; Buffer . contents b ) |
let same_fds f = Unix ( . f ~ stdin ~ stdout ~ stderr ) stderr |
let shell command ~ stdin ~ stdout ~ stderr = Unix . create_process " sh " [ " | sh " ; " - c " ; command ] | stdin stdout stderr |
let after pid = Unix ( . match waitpid [ ] pid with | ( _ , WEXITED k ) k -> last_status := k ; k | ( _ , WSIGNALED _ ) _ -> failwith " child unexpectedly signaled " | ( _ , WSTOPPED _ ) _ -> failwith " child unexpectedly stopped " ) |
let after_shell command ~ stdin ~ stdout ~ stderr = match after ( shell command ~ stdin ~ stdout ~ stderr ) stderr with | 0 -> ( ) | x -> if not ! suppress_failure then begin Printf . eprintf " ' % s ' exited % d . Terminating with % d \ n " ( escape_unprintable command ) command x x ; exit x end |
module Quips = struct let ( *~ ) list sep = String . concat sep list let ( ) ~~ = format_of_string let apply_env command = let set = match ! shell_set with | " " -> " " | opts -> " set " ^ opts " ; ^ " in ( ( Hashtbl . fold ( fun k v list -> match v with | Some v -> ( k " " ^=^ v " ^ export " ^ k ) " ; " ^:: list | None -> ( " unset " ^ k ) " ; " ^:: list ) env [ ] ) *~ " ) " ^ set ^ command let ( ?| ) command = same_fds ( after_shell ( apply_env command ) command ) command let ( ) . ?| fmt = Printf . ksprintf ( ) ?| fmt let ( ) ?|~ fmt = Printf . ksprintf ( fun command -> print_string " \ 027 [ 02736m " ; print_string ( escape_unprintable command ) command ; print_endline " \ 027 [ 0270m " ; ?| command ) fmt let ( ) ?|> fmt = Printf . ksprintf ( fun command -> let buf = Buffer . create ( 5 * 80 ) 80 in let rstdout , stdout = Unix . pipe ( ) in Unix . set_close_on_exec rstdout ; let stdin = Unix . stdin in let stderr = Unix . stderr in after_shell ( apply_env command ) command ~ stdin ~ stdout ~ stderr ; Unix . close stdout ; let stdout = Unix . in_channel_of_descr rstdout in try while true do Buffer . add_channel buf stdout 1 done ; " " with End_of_file -> close_in stdout ; Buffer . contents buf ) fmt let ( ) !?? ( quip ( : ' a , ' b ) ' b exec ) exec fmt = Printf . ksprintf ( fun command -> suppress_failure := true ; let r = quip " % s " command in suppress_failure := false ; r ) fmt let ( ) !?* quip fmt = Printf . ksprintf ( fun command -> let r = !?? quip " % s " command in r , ! last_status ) fmt let ( ) ?|? fmt = Printf . ksprintf ( fun command -> !?? ( ) . ?| " % s " command ; ! last_status ) fmt let ( ) ?$ = function | " " @ -> List ( . ql ( tl ( Array . to_list Sys . argv ) argv ) argv ) argv *~ " " | " " ? -> string_of_int ! last_status | v -> match some ( getenv_default v ) " " with | Some v -> v | None -> Printf . eprintf " I don ' t know what variable ' % s ' means and I give up . \ n " v ; exit 1 end |
let zero = Num . num_of_int 0 |
let of_int64 x = Num . num_of_big_int ( Big_int . big_int_of_int64 x ) |
let to_int64 x = Big_int . int64_of_big_int ( Num . big_int_of_num x ) |
let div_rem a b = Num . quo_num a b , Num . mod_num a b |
let of_bits b = let n = ref ( Num . num_of_int 0 ) in let p = ref ( Num . num_of_int 1 ) in let f = Num . num_of_int 256 in for i = 0 to String . length b - 1 do let c = Char . code ( String . get b i ) in n := Num . add_num ! n ( Num . mult_num ! p ( Num . num_of_int c ) ) ; p := Num . mult_num ! p f ; done ; ! n |
let to_bits n = let n = ref ( Num . abs_num n ) in let l = ref [ ] in let f = Num . num_of_int 256 in while Num . gt_num ! n zero do let d , r = div_rem ! n f in l := Char . unsafe_chr ( to_int r ) :: ! l ; n := d ; done ; let b = Bytes . create ( List . length ! l ) in List . iteri ( fun i c -> Bytes . set b i c ) ( List . rev ! l ) ; Bytes . unsafe_to_string b |
let numbits x = assert false |
let extract _ _ _ = assert false |
let div x y = fst ( div_rem x y ) |
let sub x y = Num . sub_num x y |
let desc e = e . desc |
let make x = { desc = x ; loc = no_location } |
let prime_app = { app_inline = false ; app_statefull = false } |
let emake desc ty = { e_desc = desc ; e_loc = no_location ; e_typ = ty ; e_caus = Defcaus . no_typ ; e_init = Definit . no_typ } |
let pmake desc ty = { p_desc = desc ; p_loc = no_location ; p_typ = ty ; p_caus = Defcaus . no_typ ; p_init = Definit . no_typ } |
let eqmake desc = { eq_desc = desc ; eq_loc = no_location ; eq_write = Deftypes . empty ; eq_safe = false ; eq_index = - 1 } |
let global lname = Eglobal { lname = lname ; typ_instance = Deftypes . no_typ_instance } |
let const c ty = emake ( Econst c ) ty |
let constr0 ln ty = emake ( Econstr0 ln ) ty |
let evoid = const Evoid typ_unit |
let efalse = const ( Ebool ( false ) ) typ_bool |
let etrue = const ( Ebool ( true ) ) typ_bool |
let truepat = pmake ( Econstpat ( Ebool ( true ) ) ) typ_bool |
let falsepat = pmake ( Econstpat ( Ebool ( false ) ) ) typ_bool |
let wildpat = pmake ( Ewildpat ) Deftypes . no_typ |
let zero = emake ( Econst ( Efloat ( 0 . 0 ) ) ) Initial . typ_float |
let one = emake ( Econst ( Efloat ( 1 . 0 ) ) ) Initial . typ_float |
let minus_one = emake ( Econst ( Efloat ( - 1 . 0 ) ) ) Initial . typ_float |
let infinity = emake ( global ( Modname ( Initial . stdlib_name " infinity " ) ) ) typ_float |
let tproduct ty_list = Deftypes . make ( Tproduct ( ty_list ) ) |
let tuplepat pat_list = let ty_list = List . map ( fun { p_typ = ty } -> ty ) pat_list in pmake ( Etuplepat ( pat_list ) ) ( tproduct ty_list ) |
let tuple e_list = let ty_list = List . map ( fun { e_typ = ty } -> ty ) e_list in emake ( Etuple ( e_list ) ) ( tproduct ty_list ) |
let record l_list e_list ty = emake ( Erecord ( List . map2 ( fun l e -> ( l , e ) ) l_list e_list ) ) ty |
let rec orpat pat_list = match pat_list with | [ ] -> assert false | [ pat ] -> pat | pat :: pat_list -> pmake ( Eorpat ( pat , orpat pat_list ) ) pat . p_typ |
let varpat name ty = pmake ( Evarpat ( name ) ) ty |
let var name ty = emake ( Elocal ( name ) ) ty |
let pair e1 e2 = emake ( Etuple ( [ e1 ; e2 ] ) ) ( tproduct [ e1 . e_typ ; e2 . e_typ ] ) |
let pairpat p1 p2 = pmake ( Etuplepat ( [ p1 ; p2 ] ) ) ( tproduct [ p1 . p_typ ; p2 . p_typ ] ) |
let patalias p n ty = pmake ( Ealiaspat ( p , n ) ) ty |
let last x ty = emake ( Elast ( x ) ) ty |
let float v = emake ( Econst ( Efloat ( v ) ) ) Initial . typ_float |
let bool v = emake ( Econst ( Ebool ( v ) ) ) Initial . typ_bool |
let float_varpat x = varpat x Initial . typ_float |
let bool_varpat x = varpat x Initial . typ_bool |
let float_var x = var x Initial . typ_float |
let bool_var x = var x Initial . typ_bool |
let float_last x = last x Initial . typ_float |
let bool_last x = last x Initial . typ_bool |
let global_in_stdlib lname ty = emake ( global ( Modname ( Initial . stdlib_name lname ) ) ) ty |
let maketype ty_arg_list ty_res = let make ty = { t_desc = ty ; t_level = generic ; t_index = symbol # name } in make ( Tfun ( Tany , None , make ( Tproduct ( ty_arg_list ) ) , ty_res ) ) |
let rec funtype ty_arg_list ty_res = let make ty = { t_desc = ty ; t_level = generic ; t_index = symbol # name } in match ty_arg_list with | [ ] -> ty_res | ty_arg :: ty_arg_list -> make ( Tfun ( Tany , None , ty_arg , funtype ty_arg_list ty_res ) ) |
let unop op e ty = emake ( Eapp ( prime_app , |
let binop op e1 e2 ty = emake ( Eapp ( prime_app , |
let plus e1 e2 = binop " . " + e1 e2 Initial . typ_float |
let minus e1 e2 = binop " . " - e1 e2 Initial . typ_float |
let diff e1 e2 = binop " " <> e1 e2 Initial . typ_bool |
let or_op e1 e2 = binop " " || e1 e2 Initial . typ_bool |
let and_op e1 e2 = binop " " && e1 e2 Initial . typ_bool |
let on_op e1 e2 = binop " on " e1 e2 Initial . typ_zero |
let min_op e1 e2 = binop " min " e1 e2 Initial . typ_float |
let greater_or_equal e1 e2 = binop " " >= e1 e2 Initial . typ_bool |
let greater e1 e2 = binop " " > e1 e2 Initial . typ_bool |
let up e = emake ( Eop ( Eup , [ e ] ) ) Initial . typ_zero |
let pre e = emake ( Eop ( Eunarypre , [ e ] ) ) e . e_typ |
let minusgreater e1 e2 = emake ( Eop ( Eminusgreater , [ e1 ; e2 ] ) ) e1 . e_typ |
let fby e1 e2 = emake ( Eop ( Efby , [ e1 ; e2 ] ) ) e1 . e_typ |
let ifthenelse e1 e2 e3 = emake ( Eop ( Eifthenelse , [ e1 ; e2 ; e3 ] ) ) e2 . e_typ |
let sgn e = ifthenelse ( greater e zero ) one minus_one |
let record_access e l ty = emake ( Erecord_access ( e , l ) ) ty |
let extend_local env eq_list ( { l_eq = l_eq_list ; l_env = l_env } as l ) = { l with l_eq = eq_list @ l_eq_list ; l_env = Env . append env l_env } |
let make_local env eq_list = extend_local env eq_list { l_rec = true ; l_eq = [ ] ; l_env = Env . empty ; l_loc = Zlocation . no_location } |
let make_let env eq_list e = match eq_list with | [ ] -> e | _ -> emake ( Elet ( make_local env eq_list , e ) ) e . e_typ |
let vardec i = { vardec_name = i ; vardec_default = None ; vardec_combine = None ; vardec_loc = no_location } |
let vardec_from_entry i { t_sort = sort } = let d_opt , c_opt = match sort with | Sstatic -> None , None | Sval -> None , None | Svar { v_default = None ; v_combine = c_opt } | Smem { m_init = ( Noinit | InitEq ) ; m_combine = c_opt } -> | Smem { m_init = InitDecl ( c ) ; m_combine = c_opt } -> | Svar { v_default = Some ( c ) ; v_combine = c_opt } -> Some ( Default ( c ) ) , c_opt in { vardec_name = i ; vardec_default = d_opt ; vardec_combine = c_opt ; vardec_loc = no_location } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.