text stringlengths 12 786k |
|---|
let readlines file = let chan = open_in file in let lines = ref [ ] in try while true do lines := input_line chan :: ! lines done ; [ ] with End_of_file -> close_in chan ; List . rev ! lines |
let error_exit msg = Printf . eprintf " % s \ n " msg ; exit 1 |
let ( ) |> a b = b a |
let get_filesize path = let stat = Unix . stat path in stat . Unix . st_size |
let dissect_path pathenv = let path = Sys . getenv pathenv in let colon = Str . regexp_string " " : in Str . split colon path |
let check_program_availability prog = if Sys . file_exists prog then true else begin List . exists ( fun path -> Sys . file_exists ( Filename . concat path prog ) ) ( dissect_path " PATH " ) end |
let get_abspath_for_bin prog = let rec loop = function | path :: tl -> let abspath = Filename . concat path prog in if Sys . file_exists abspath then abspath else loop tl | [ ] -> raise Not_found in loop ( dissect_path " PATH " ) |
let time_string t = let open Unix in let tm = gmtime t in Printf . sprintf " % 4d /% 02d /% 02d -% 02d :% 02d :% 02d " ( tm . tm_year + 1900 ) ( tm . tm_mon + 1 ) tm . tm_mday tm . tm_hour tm . tm_min tm . tm_sec |
let to_abs path = if not ( Filename . is_relative path ) then path else Filename . concat ( Unix . getcwd ( ) ) path |
let to_abs_cmds cmds = let prog = List . hd cmds in if not ( Filename . is_relative prog ) then cmds else ( Filename . concat ( Unix . getcwd ( ) ) prog ) :: ( List . tl cmds ) |
let rm_if_exists file = if Sys . file_exists file then Unix . unlink file else ( ) |
module Subst = Map . Make ( struct type t = string let compare = compare end ) |
module Names = Set . Make ( struct type t = string let compare = compare end ) |
type var = [ ` Var of string ] |
let subst_var ~ subst : var -> _ = function ` Var s as x -> try Subst . find s subst with Not_found -> x |
let free_var : var -> _ = function ` Var s -> Names . singleton s |
type ' a lambda = [ ` Var of string | ` Abs of string * ' a | ` App of ' a * ' a ] |
let free_lambda ~ free_rec : _ lambda -> _ = function # var as x -> free_var x | ` Abs ( s , t ) -> Names . remove s ( free_rec t ) | ` App ( t1 , t2 ) -> Names . union ( free_rec t1 ) ( free_rec t2 ) |
let map_lambda ~ map_rec : _ lambda -> _ = function # var as x -> x | ` Abs ( s , t ) as l -> let t ' = map_rec t in if t == t ' then l else ` Abs ( s , t ' ) | ` App ( t1 , t2 ) as l -> let t ' 1 = map_rec t1 and t ' 2 = map_rec t2 in if t ' 1 == t1 && t ' 2 ... |
let next_id = let current = ref 3 in fun ( ) -> incr current ; ! current |
let subst_lambda ~ subst_rec ~ free ~ subst : _ lambda -> _ = function # var as x -> subst_var ~ subst x | ` Abs ( s , t ) as l -> let used = free t in let used_expr = Subst . fold subst ~ init [ ] : ~ f ( : fun ~ key ~ data acc -> if Names . mem s used then data :: acc else acc... |
let eval_lambda ~ eval_rec ~ subst l = match map_lambda ~ map_rec : eval_rec l with ` App ( ` Abs ( s , t1 ) , t2 ) -> eval_rec ( subst ~ subst ( : Subst . add ~ key : s ~ data : t2 Subst . empty ) t1 ) | t -> t |
let rec free1 x = free_lambda ~ free_rec : free1 x |
let rec subst1 ~ subst = subst_lambda ~ subst_rec : subst1 ~ free : free1 ~ subst |
let rec eval1 x = eval_lambda ~ eval_rec : eval1 ~ subst : subst1 x |
type ' a expr = [ ` Var of string | ` Num of int | ` Add of ' a * ' a | ` Neg of ' a | ` Mult of ' a * ' a ] |
let free_expr ~ free_rec : _ expr -> _ = function # var as x -> free_var x | ` Num _ -> Names . empty | ` Add ( x , y ) -> Names . union ( free_rec x ) ( free_rec y ) | ` Neg x -> free_rec x | ` Mult ( x , y ) -> Names . union ( free_rec x ) ( free_rec y ) |
let map_expr ~ map_rec : _ expr -> _ = function # var as x -> x | ` Num _ as x -> x | ` Add ( x , y ) as e -> let x ' = map_rec x and y ' = map_rec y in if x == x ' && y == y ' then e else ` Add ( x ' , y ' ) | ` Neg x as e -> let x ' = map_rec x in if x == x ' ... |
let subst_expr ~ subst_rec ~ subst : _ expr -> _ = function # var as x -> subst_var ~ subst x | # expr as e -> map_expr ~ map_rec ( : subst_rec ~ subst ) e |
let eval_expr ~ eval_rec e = match map_expr ~ map_rec : eval_rec e with ` Add ( ` Num m , ` Num n ) -> ` Num ( m + n ) | ` Neg ( ` Num n ) -> ` Num ( - n ) | ` Mult ( ` Num m , ` Num n ) -> ` Num ( m * n ) | # expr as e -> e |
let rec free2 x = free_expr ~ free_rec : free2 x |
let rec subst2 ~ subst = subst_expr ~ subst_rec : subst2 ~ subst |
let rec eval2 x = eval_expr ~ eval_rec : eval2 x |
type lexpr = [ ` Var of string | ` Abs of string * lexpr | ` App of lexpr * lexpr | ` Num of int | ` Add of lexpr * lexpr | ` Neg of lexpr | ` Mult of lexpr * lexpr ] |
let rec free : lexpr -> _ = function # lambda as x -> free_lambda ~ free_rec : free x | # expr as x -> free_expr ~ free_rec : free x |
let rec subst ~ subst : s : lexpr -> _ = function # lambda as x -> subst_lambda ~ subst_rec : subst ~ subst : s ~ free x | # expr as x -> subst_expr ~ subst_rec : subst ~ subst : s x |
let rec eval : lexpr -> _ = function # lambda as x -> eval_lambda ~ eval_rec : eval ~ subst x | # expr as x -> eval_expr ~ eval_rec : eval x |
let rec print = function | ` Var id -> print_string id | ` Abs ( id , l ) -> print_string ( " \ " ^ id ^ " . " ) ; print l | ` App ( l1 , l2 ) -> print l1 ; print_string " " ; print l2 | ` Num x -> print_int x | ` Add ( e1 , e2 ) -> print e1 ; print_st... |
let ( ) = let e1 = eval1 ( ` App ( ` Abs ( " x " , ` Var " x " ) , ` Var " y " ) ) in let e2 = eval2 ( ` Add ( ` Mult ( ` Num 3 , ` Neg ( ` Num 2 ) ) , ` Var " x " ) ) in let e3 = eval ( ` Add ( ` App ( ` Abs ( " x " , ... |
module Subst = Map . Make ( struct type t = string let compare = compare end ) |
module Names = Set . Make ( struct type t = string let compare = compare end ) |
let lazy_fix make = let rec obj ( ) = make ( lazy ( obj ( ) ) : _ Lazy . t ) in obj ( ) |
let ( ) !! = Lazy . force object method free : ' b -> Names . t method subst : sub ' : a Subst . t -> ' b -> ' a method eval : ' b -> ' a end |
type var = [ ` Var of string ] constraint ' a = [ > var ] method subst ~ sub ( ` Var s as x ) = try Subst . find s sub with Not_found -> x method free ( ` Var s ) = Names . singleton s method eval ( # var as v ) = v end |
type ' a lambda = [ ` Var of string | ` Abs of string * ' a | ` App of ' a * ' a ] |
let next_id = let current = ref 3 in fun ( ) -> incr current ; ! current let var : ' a var_ops = new var_ops and free = lazy !! ops # free and subst = lazy !! ops # subst and eval = lazy !! ops # eval in object ( self : ( ' a , ' a lambda ) # ops ) constraint ' a = [ > ' ... |
let lambda = lazy_fix ( new lambda_ops ) |
type ' a expr = [ ` Var of string | ` Num of int | ` Add of ' a * ' a | ` Neg of ' a | ` Mult of ' a * ' a ] let var : ' a var_ops = new var_ops and free = lazy !! ops # free and subst = lazy !! ops # subst and eval = lazy !! ops # eval in object ( self : ( ' a , '... |
let expr = lazy_fix ( new expr_ops ) |
type ' a lexpr = [ ' a lambda | ' a expr ] let lambda = new lambda_ops ops in let expr = new expr_ops ops in object ( self : ( ' a , ' a lexpr ) # ops ) constraint ' a = [ > ' a lexpr ] method free = function # lambda as x -> lambda # free x | # expr as x -> expr # free x... |
let lexpr = lazy_fix ( new lexpr_ops ) |
let rec print = function | ` Var id -> print_string id | ` Abs ( id , l ) -> print_string ( " \ " ^ id ^ " . " ) ; print l | ` App ( l1 , l2 ) -> print l1 ; print_string " " ; print l2 | ` Num x -> print_int x | ` Add ( e1 , e2 ) -> print e1 ; print_st... |
let ( ) = let e1 = lambda # eval ( ` App ( ` Abs ( " x " , ` Var " x " ) , ` Var " y " ) ) in let e2 = expr # eval ( ` Add ( ` Mult ( ` Num 3 , ` Neg ( ` Num 2 ) ) , ` Var " x " ) ) in let e3 = lexpr # eval ( ` Add ( ` App ( ... |
module Subst = Map . Make ( struct type t = string let compare = compare end ) |
module Names = Set . Make ( struct type t = string let compare = compare end ) |
let lazy_fix make = let rec obj ( ) = make ( lazy ( obj ( ) ) : _ Lazy . t ) in obj ( ) |
let ( ) !! = Lazy . force object method free : ' b -> Names . t method subst : sub ' : a Subst . t -> ' b -> ' a method eval : ' b -> ' a end |
type var = [ ` Var of string ] |
let var = object ( self : ( [ > var ] , var ) # ops ) method subst ~ sub ( ` Var s as x ) = try Subst . find s sub with Not_found -> x method free ( ` Var s ) = Names . singleton s method eval ( # var as v ) = v end |
type ' a lambda = [ ` Var of string | ` Abs of string * ' a | ` App of ' a * ' a ] |
let next_id = let current = ref 3 in fun ( ) -> incr current ; ! current |
let lambda_ops ( ops : ( ' a , ' a ) # ops Lazy . t ) = let free = lazy !! ops # free and subst = lazy !! ops # subst and eval = lazy !! ops # eval in object ( self : ( [ > ' a lambda ] , ' a lambda ) # ops ) method free = function # var as x -> var # free x | ` A... |
let lambda = lazy_fix lambda_ops |
type ' a expr = [ ` Var of string | ` Num of int | ` Add of ' a * ' a | ` Neg of ' a | ` Mult of ' a * ' a ] |
let expr_ops ( ops : ( ' a , ' a ) # ops Lazy . t ) = let free = lazy !! ops # free and subst = lazy !! ops # subst and eval = lazy !! ops # eval in object ( self : ( [ > ' a expr ] , ' a expr ) # ops ) method free = function # var as x -> var # free x | ` Num _ ... |
let expr = lazy_fix expr_ops |
type ' a lexpr = [ ' a lambda | ' a expr ] |
let lexpr_ops ( ops : ( ' a , ' a ) # ops Lazy . t ) = let lambda = lambda_ops ops in let expr = expr_ops ops in object ( self : ( [ > ' a lexpr ] , ' a lexpr ) # ops ) method free = function # lambda as x -> lambda # free x | # expr as x -> expr # free x method subst ... |
let lexpr = lazy_fix lexpr_ops |
let rec print = function | ` Var id -> print_string id | ` Abs ( id , l ) -> print_string ( " \ " ^ id ^ " . " ) ; print l | ` App ( l1 , l2 ) -> print l1 ; print_string " " ; print l2 | ` Num x -> print_int x | ` Add ( e1 , e2 ) -> print e1 ; print_st... |
let ( ) = let e1 = lambda # eval ( ` App ( ` Abs ( " x " , ` Var " x " ) , ` Var " y " ) ) in let e2 = expr # eval ( ` Add ( ` Mult ( ` Num 3 , ` Neg ( ` Num 2 ) ) , ` Var " x " ) ) in let e3 = lexpr # eval ( ` Add ( ` App ( ... |
let rec self ( interf , opts , incl ) = fun [ [ ] -> ( List . rev interf , List . rev opts , List . rev incl ) | [ " - I " ; dir :: args ] -> self ( interf , opts , [ dir ; " - I " :: incl ] ) args | [ " - version " :: _ ] -> do { printf " ... |
let input_word ic = let lo = input_byte ic in let hi = input_byte ic in ( hi lsl 8 ) + lo |
let find_pe_header ic = seek_in ic 0x3C ; let peheader = input_word ic in seek_in ic peheader ; if input_char ic <> ' P ' then raise Invalid_file_format ; if input_char ic <> ' E ' then raise Invalid_file_format ; peheader |
let find_optional_header ic = let peheader = find_pe_header ic in let coffheader = peheader + 4 in seek_in ic ( coffheader + 16 ) ; let optsize = input_word ic in if optsize < 96 then raise Invalid_file_format ; let optheader = coffheader + 20 in seek_in ic optheader ; let magic = input_word ic ... |
let change ic oc = let optheader = find_optional_header ic in seek_out oc ( optheader + 64 ) ; for i = 1 to 4 do output_byte oc 0 done ; output_byte oc 2 |
let main ( ) = if Array . length Sys . argv <> 2 then begin print_endline " Alters a Win32 executable file to use the Windows subsystem . " ; print_endline ( " Usage : mkwinapp < filename " ) ; > exit 1 end ; let filename = Sys . argv . ( 1 ) in let f = Unix . openfile fi... |
let _ = main ( ) |
type t = { name : string ; path : string list ; types : Type . t list ; values : Val . t list ; submodules : t StringMap . t ; recursive : bool ; descr : string option } |
let module_name s = let s = let last = String . length s - 1 in if s . [ 0 ] = ' { ' && s . [ last ] = ' } ' then " By_ " ^ String . sub s 1 ( last - 1 ) else s in s |> snake_case |> String . capitalize_ascii |> String . split_on_char ' . ' |> List . hd |
let create ~ name ? descr ( ? recursive = false ) ( ? path = [ ] ) ( ? types = [ ] ) ( ? submodules = StringMap . empty ) ( ? values = [ ] ) ( ) = { name = module_name name ; path = List . map module_name path ; types ; values ; submodules ; recursive ;... |
let empty name ( ? recursive = false ) ( ? path = [ ] ) ( ) = create ~ name ~ recursive ~ path ( ) |
let with_values name ( ? recursive = false ) ( ? path = [ ] ) values = create ~ name ~ recursive ~ path ~ values ( ) |
let name m = m . name |
let submodules m = m . submodules |> StringMap . bindings |> List . map snd |
let add_type t m = { m with types = t :: m . types } |
let add_val v m = { m with values = v :: m . values } |
let add_types ts m = { m with types = m . types @ ts } |
let map_submodules f m = { m with submodules = StringMap . map f m . submodules } [ @@@ end ] |
let has_submodules m = StringMap . is_empty m . submodules |
let add_vals vs m = { m with values = m . values @ vs } |
let add_mod subm m = { m with submodules = StringMap . add subm . name subm m . submodules } |
let find_submodule name m = StringMap . find_opt ( module_name name ) m . submodules |
let iter f m = f m ; StringMap . iter ( fun _name sub -> f sub ) m . submodules |
let path m = m . path |
let qualified_name m = match m . path with | [ ] -> m . name | _p -> sprintf " % s . % s " ( String . concat " . " m . path ) m . name |
let qualified_path m = m . path @ [ m . name ] |
let has_type_named n m = List . exists ( fun t -> Type . name t = n ) m . types |
let object_module_val ( ? indent = 0 ) ( ) = let pad = String . make indent ' ' in " \ n " ^ pad ^ " module Object : Object . S with type value := t \ n " |
let object_module_impl ( ? indent = 0 ) ( ) = let pad = String . make indent ' ' in " \ n " ^ pad ^ " module Object = Object . Make ( struct type value = t [ @@ deriving yojson ] end ) \ n " |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.