Datasets:
AllenGeng
/
OCaml_program_corpus

Dataset card Data Studio Files Community
text
stringlengths
0
601k
let implementation_label = " native toplevel "
let global_symbol id = let sym = Compilenv . symbol_for_global id in match Tophooks . lookup sym with | None -> fatal_error ( " Toploop . global_symbol " ^ ( Ident . unique_name id ) ) | Some obj -> obj
let remembered = ref Ident . empty
let rec remember phrase_name i = function | [ ] -> ( ) | Sig_value ( id , _ , _ ) :: rest | Sig_module ( id , _ , _ , _ , _ ) :: rest | Sig_typext ( id , _ , _ , _ ) :: rest | Sig_class ( id , _ , _ , _ ) :: rest -> remembered := Ident . add id ( phrase_name , i ) ! remembered ; remember phrase_name ( succ i ) rest | _ :: rest -> remember phrase_name i rest
let toplevel_value id = try Ident . find_same id ! remembered with _ -> Misc . fatal_error @@ " Unknown ident : " ^ Ident . unique_name id
let close_phrase lam = let open Lambda in Ident . Set . fold ( fun id l -> let glb , pos = toplevel_value id in let glob = Lprim ( Pfield ( pos , Pointer , Mutable ) , [ Lprim ( Pgetglobal glb , [ ] , Loc_unknown ) ] , Loc_unknown ) in Llet ( Strict , Pgenval , id , glob , l ) ) ( free_variables lam ) lam
let toplevel_value id = let glob , pos = if Config . flambda then toplevel_value id else Translmod . nat_toplevel_name id in ( Obj . magic ( global_symbol glob ) ) . ( pos )
module EvalBase = struct let eval_ident id = try if Ident . persistent id || Ident . global id then global_symbol id else toplevel_value id with _ -> raise ( Undefined_global ( Ident . name id ) ) end
let may_trace = ref false
let load_lambda ppf ~ module_ident ~ required_globals phrase_name lam size = if ! Clflags . dump_rawlambda then fprintf ppf " % a . " @ Printlambda . lambda lam ; let slam = Simplif . simplify_lambda lam in if ! Clflags . dump_lambda then fprintf ppf " % a . " @ Printlambda . lambda slam ; let program = { Lambda . code = slam ; main_module_block_size = size ; module_ident ; required_globals ; } in Tophooks . load ppf phrase_name program
let pr_item = Printtyp . print_items ( fun env -> function | Sig_value ( id , { val_kind = Val_reg ; val_type } , _ ) -> Some ( outval_of_value env ( toplevel_value id ) val_type ) | _ -> None )
let phrase_seqid = ref 0
let execute_phrase print_outcome ppf phr = match phr with | Ptop_def sstr -> let oldenv = ! toplevel_env in incr phrase_seqid ; let phrase_name = " TOP " ^ string_of_int ! phrase_seqid in Compilenv . reset ? packname : None phrase_name ; Typecore . reset_delayed_checks ( ) ; let sstr , rewritten = match sstr with | [ { pstr_desc = Pstr_eval ( e , attrs ) ; pstr_loc = loc } ] | [ { pstr_desc = Pstr_value ( Asttypes . Nonrecursive , [ { pvb_expr = e ; pvb_pat = { ppat_desc = Ppat_any ; _ } ; pvb_attributes = attrs ; _ } ] ) ; pstr_loc = loc } ] -> let pat = Ast_helper . Pat . var ( Location . mknoloc " _ " ) $ in let vb = Ast_helper . Vb . mk ~ loc ~ attrs pat e in [ Ast_helper . Str . value ~ loc Asttypes . Nonrecursive [ vb ] ] , true | _ -> sstr , false in let ( str , sg , names , shape , newenv ) = Typemod . type_toplevel_phrase oldenv sstr in if ! Clflags . dump_typedtree then Printtyped . implementation ppf str ; if ! Clflags . dump_shape then Shape . print ppf shape ; let sg ' = Typemod . Signature_names . simplify newenv names sg in ignore ( Includemod . signatures oldenv ~ mark : Mark_positive sg sg ' ) ; Typecore . force_delayed_checks ( ) ; let module_ident , res , required_globals , size = if Config . flambda then let { Lambda . module_ident ; main_module_block_size = size ; required_globals ; code = res } = Translmod . transl_implementation_flambda phrase_name ( str , Tcoerce_none ) in remember module_ident 0 sg ' ; module_ident , close_phrase res , required_globals , size else let size , res = Translmod . transl_store_phrases phrase_name str in Ident . create_persistent phrase_name , res , Ident . Set . empty , size in Warnings . check_fatal ( ) ; begin try toplevel_env := newenv ; let res = load_lambda ppf ~ required_globals ~ module_ident phrase_name res size in let out_phr = match res with | Result _ -> if Config . flambda then Env . register_import_as_opaque ( Ident . name module_ident ) else Compilenv . record_global_approx_toplevel ( ) ; if print_outcome then Printtyp . wrap_printing_env ~ error : false oldenv ( fun ( ) -> match str . str_items with | [ ] -> Ophr_signature [ ] | _ -> if rewritten then match sg ' with | [ Sig_value ( id , vd , _ ) ] -> let outv = outval_of_value newenv ( toplevel_value id ) vd . val_type in let ty = Printtyp . tree_of_type_scheme vd . val_type in Ophr_eval ( outv , ty ) | _ -> assert false else Ophr_signature ( pr_item oldenv sg ' ) ) else Ophr_signature [ ] | Exception exn -> toplevel_env := oldenv ; if exn = Out_of_memory then Gc . full_major ( ) ; let outv = outval_of_value ! toplevel_env ( Obj . repr exn ) Predef . type_exn in Ophr_exception ( exn , outv ) in ! print_out_phrase ppf out_phr ; begin match out_phr with | Ophr_eval ( _ , _ ) | Ophr_signature _ -> true | Ophr_exception _ -> false end with x -> toplevel_env := oldenv ; raise x end | Ptop_dir { pdir_name = { Location . txt = dir_name } ; pdir_arg } -> try_run_directive ppf dir_name pdir_arg
let getvalue _ = assert false
let setvalue _ _ = assert false
let load_file _ ppf name0 = let name = try Some ( Load_path . find name0 ) with Not_found -> None in match name with | None -> fprintf ppf " File not found : % s . " @ name0 ; false | Some name -> let fn , tmp = if Filename . check_suffix name " . cmx " || Filename . check_suffix name " . cmxa " then let cmxs = Filename . temp_file " caml " " . cmxs " in Asmlink . link_shared ~ ppf_dump : ppf [ name ] cmxs ; cmxs , true else name , false in let success = try Dynlink . loadfile fn ; true with | Dynlink . Error err -> fprintf ppf " Error while loading % s : % s . . " @ name ( Dynlink . error_message err ) ; false | exn -> print_exception_outcome ppf exn ; false in if tmp then ( try Sys . remove fn with Sys_error _ -> ( ) ) ; success
let init ( ) = Compmisc . init_path ( ) ; Clflags . dlcode := true ; ( )
let rec uniq = function x :: l when List . mem x l -> uniq l | x :: l -> x :: uniq l | l -> l
let split_in_words s = let l = String . length s in let rec split i j = if j < l then let j ' = succ j in match s . [ j ] with ( ' ' ' |\ t ' ' |\ n ' ' |\ r ' ' , ' ) | -> let rem = split j ' j ' in if i < j then ( String . sub s i ( j - i ) ) :: rem else rem | _ -> split i j ' else if i < j then [ String . sub s i ( j - i ) ] else [ ] in split 0 0
let normalize_dirname d = let s = String . copy d in let l = String . length d in let norm_dir_unix ( ) = for k = 1 to l - 1 do if s . [ k ] = ' ' / && s . [ k - 1 ] = ' ' / then s . [ k ] <- Char . chr 0 ; if s . [ k ] = ' ' / && k = l - 1 then s . [ k ] <- Char . chr 0 done in let norm_dir_win ( ) = if l >= 1 && s . [ 0 ] = ' ' / then s . [ 0 ] <- ' ' ; \\ if l >= 2 && s . [ 1 ] = ' ' / then s . [ 1 ] <- ' ' ; \\ for k = 2 to l - 1 do if s . [ k ] = ' ' / then s . [ k ] <- ' ' ; \\ if s . [ k ] = ' ' \\ && s . [ k - 1 ] = ' ' \\ then s . [ k ] <- Char . chr 0 ; if s . [ k ] = ' ' \\ && k = l - 1 then s . [ k ] <- Char . chr 0 done in let expunge ( ) = let n = ref 0 in for k = 0 to l - 1 do if s . [ k ] = Char . chr 0 then incr n done ; let s ' = String . create ( l - ! n ) in n := 0 ; for k = 0 to l - 1 do if s . [ k ] <> Char . chr 0 then begin end done ; s ' in match Sys . os_type with " Unix " | " Cygwin " -> norm_dir_unix ( ) ; expunge ( ) | " Win32 " -> norm_dir_win ( ) ; expunge ( ) | _ -> failwith " This os_type is not supported "
let forbidden = ref ( [ ] : string list )
let loaded = ref ( [ ] : string list )
let predicates = ref ( [ ] : string list )
let add_directory d = let d = normalize_dirname d in let d = expand_directory Config . standard_library d in if not ( List . mem d ! Config . load_path ) then begin Config . load_path := d :: ! Config . load_path ; if real_toploop then fprintf std_formatter " [ ` @% s ' added to search path ] . " @@ d end
let add_predicates pl = predicates := uniq ( pl @ ! predicates )
let syntax s = add_predicates [ " syntax " ; s ]
let standard_syntax ( ) = syntax " camlp4o "
let revised_syntax ( ) = syntax " camlp4r "
let load pl = List . iter ( fun p -> if not ( List . mem p ! loaded ) then begin let d = Findlib . package_directory p in add_directory d ; if not ( List . mem p ! forbidden ) then begin let archive = ( try Findlib . package_property ! predicates p " archive " with Not_found -> " " ) in let archives = split_in_words archive in List . iter ( fun arch -> let arch = Findlib . resolve_path ~ base : d arch in Jitlink . loadfile arch ; if real_toploop then fprintf std_formatter " [ ` @% s ' loaded ] . " @@ arch ) archives end ; loaded := p :: ! loaded end ) pl
let load_deeply pl = load ( Findlib . package_deep_ancestors ! predicates pl )
let don ' t_load pl = forbidden := uniq ( pl @ ! forbidden ) ; List . iter ( fun p -> ignore ( Findlib . package_directory p ) ) pl
let don ' t_load_deeply pl = List . iter ( fun p -> ignore ( Findlib . package_directory p ) ) pl ; don ' t_load ( Findlib . package_deep_ancestors ! predicates pl )
let protect f x = try ignore ( f x ) with Failure s -> fprintf err_formatter " [ @% s ] . " @@ s
let reset ( ) = loaded := [ ] ; Hashtbl . replace directive_table " require " ( Directive_string ( protect ( fun s -> load_deeply ( split_in_words s ) ) ) ) ; Hashtbl . replace directive_table " predicates " ( Directive_string ( protect ( fun s -> add_predicates ( split_in_words s ) ) ) ) ; Hashtbl . replace directive_table " camlp4o " ( Directive_none ( protect ( fun ( ) -> standard_syntax ( ) ; load_deeply [ " camlp4 " ] ) ) ) ; Hashtbl . replace directive_table " camlp4r " ( Directive_none ( protect ( fun ( ) -> revised_syntax ( ) ; load_deeply [ " camlp4 " ] ) ) ) ; Hashtbl . replace directive_table " list " ( Directive_none ( protect ( fun ( ) -> Findlib . list_packages stdout ; flush stdout ) ) ) ; Hashtbl . replace directive_table " thread " ( Directive_none ( protect ( fun ( ) -> ( ) ) ) )
let announce ( ) = if real_toploop then begin print_endline ( " Findlib has been successfully loaded . Additional directives :\ n " ^ " # require " \ package " ; ; \ to load a package \ n " ^ " # list ; ; to list the available packages \ n " ^ " # camlp4o ; ; to load camlp4 ( standard syntax ) \ n " ^ " # camlp4r ; ; to load camlp4 ( revised syntax ) \ n " ^ " # predicates " \ p , q , . . . " ; ; \ to set these predicates \ n " ^ " Topfind . reset ( ) ; ; to force that packages will be reloaded \ n " ) end
let lookup sym = Dynlink . unsafe_get_global_value ~ bytecode_or_asm_symbol : sym
let need_symbol sym = Option . is_none ( Dynlink . unsafe_get_global_value ~ bytecode_or_asm_symbol : sym )
let dll_run dll entry = match ( try Result ( Obj . magic ( ndl_run_toplevel dll entry ) ) with exn -> Exception exn ) with | Exception _ as r -> r | Result r -> match Obj . magic r with | Ok x -> Result x | Err s -> fatal_error ( " Toploop . dll_run " ^ s )
module Backend = struct let symbol_for_global ' = Compilenv . symbol_for_global ' let closure_symbol = Compilenv . closure_symbol let really_import_approx = Import_approx . really_import_approx let import_symbol = Import_approx . import_symbol let size_int = Arch . size_int let big_endian = Arch . big_endian let max_sensible_number_of_arguments = Proc . max_arguments_for_tailcalls - 1 end
let backend = ( module Backend : Backend_intf . S )
let load ppf phrase_name program = let dll = if ! Clflags . keep_asm_file then phrase_name ^ ext_dll else Filename . temp_file ( " caml " ^ phrase_name ) ext_dll in let filename = Filename . chop_extension dll in let middle_end = if Config . flambda then Flambda_middle_end . lambda_to_clambda else Closure_middle_end . lambda_to_clambda in Asmgen . compile_implementation ~ toplevel : need_symbol ~ backend ~ prefixname : filename ~ middle_end ~ ppf_dump : ppf program ; Asmlink . call_linker_shared [ filename ^ ext_obj ] dll ; Sys . remove ( filename ^ ext_obj ) ; let dll = if Filename . is_implicit dll then Filename . concat ( Sys . getcwd ( ) ) dll else dll in match Fun . protect ~ finally ( : fun ( ) -> ( try Sys . remove dll with Sys_error _ -> ( ) ) ) ( fun ( ) -> dll_run dll phrase_name ) with | res -> res | exception x -> record_backtrace ( ) ; Exception x
type lookup_fn = string -> Obj . t option
type load_fn = Format . formatter -> string -> Lambda . program -> Topcommon . evaluation_outcome
type assembler = { mutable lookup : lookup_fn ; mutable load : load_fn }
let fns = { lookup ; load }
let load ppf = fns . load ppf
let lookup sym = fns . lookup sym
let register_loader ~ lookup ~ load = fns . lookup <- lookup ; fns . load <- load
type output_type = [ | ` HTML of string | ` CSV of string ]
module Configuration = struct type t = { name : string ; rna_gene_fpkm_tracking_file : string option ; rna_min_gene_expression : float ; rna_transcript_fpkm_tracking_file : string option ; rna_min_transcript_expression : float ; rna_transcript_fkpm_gtf_file : string option ; mhc_epitope_lengths : int list ; only_novel_epitopes : bool ; ic50_cutoff : float ; percentile_cutoff : float ; padding_around_mutation : int option ; self_filter_directory : string option ; skip_variant_errors : bool ; parameters : ( string * string ) list ; } let to_json { name ; rna_gene_fpkm_tracking_file ; rna_min_gene_expression ; rna_transcript_fpkm_tracking_file ; rna_min_transcript_expression ; rna_transcript_fkpm_gtf_file ; mhc_epitope_lengths ; only_novel_epitopes ; ic50_cutoff ; percentile_cutoff ; padding_around_mutation ; self_filter_directory ; skip_variant_errors ; parameters } : Yojson . Basic . json = ` Assoc [ " name " , ` String name ; " rna_gene_fpkm_tracking_file " , ( match rna_gene_fpkm_tracking_file with | None -> ` Null | Some s -> ` String s ) ; " rna_min_gene_expression " , ` Float rna_min_gene_expression ; " rna_transcript_fpkm_tracking_file " , ( match rna_transcript_fpkm_tracking_file with | None -> ` Null | Some s -> ` String s ) ; " rna_min_transcript_expression " , ` Float rna_min_transcript_expression ; " rna_transcript_fkpm_gtf_file " , ( match rna_transcript_fkpm_gtf_file with | None -> ` Null | Some s -> ` String s ) ; " mhc_epitope_lengths " , ` List ( List . map mhc_epitope_lengths ~ f ( : fun i -> ` Int i ) ) ; " only_novel_epitopes " , ` Bool only_novel_epitopes ; " ic50_cutoff " , ` Float ic50_cutoff ; " percentile_cutoff " , ` Float percentile_cutoff ; " padding_around_mutation " , ( match padding_around_mutation with | None -> ` Null | Some i -> ` Int i ) ; " self_filter_directory " , ( match self_filter_directory with | None -> ` Null | Some s -> ` String s ) ; " skip_variant_errors " , ` Bool skip_variant_errors ; " parameters " , ` Assoc ( List . map parameters ~ f ( : fun ( k , s ) -> k , ` String s ) ) ; ] let render { parameters ; _ } = List . concat_map parameters ~ f ( : fun ( a , b ) -> [ a ; b ] ) let default = { name = " default " ; rna_gene_fpkm_tracking_file = None ; rna_min_gene_expression = 4 . 0 ; rna_transcript_fpkm_tracking_file = None ; rna_min_transcript_expression = 1 . 5 ; rna_transcript_fkpm_gtf_file = None ; mhc_epitope_lengths = [ 8 ; 9 ; 10 ; 11 ] ; only_novel_epitopes = false ; ic50_cutoff = 500 . 0 ; percentile_cutoff = 2 . 0 ; padding_around_mutation = None ; self_filter_directory = None ; skip_variant_errors = false ; parameters = [ ] } let name t = t . name end
let run ( ~ run_with : Machine . t ) ~ configuration ~ reference_build ~ vcfs ~ predictor ~ alleles_file ~ output = let open KEDSL in let open Hla_utilities in let topiary = Machine . get_tool run_with Machine . Tool . Default . topiary in let predictor_tool = predictor_to_tool ~ run_with predictor in let ( predictor_edges , predictor_init ) = match predictor_tool with | Some ( e , i ) -> ( [ depends_on e ; ] , i ) | None -> ( [ ] , Program . ( sh " echo ' No external prediction tool required ' " ) ) in let var_arg = List . concat_map vcfs ~ f ( : fun v -> [ " -- vcf " ; v # product # path ] ) in let predictor_arg = [ " -- mhc - predictor " ; ( predictor_to_string predictor ) ] in let allele_arg = [ " -- mhc - alleles - file " ; alleles_file # product # path ] in let ( output_arg , output_path ) = match output with | ` HTML html_file -> [ " -- output - html " ; html_file ] , html_file | ` CSV csv_file -> [ " -- output - csv " ; csv_file ] , csv_file in let str_of_str a = a in let maybe_argument ~ f arg_name value = match value with | None -> [ ] | Some arg_value -> [ arg_name ; f arg_value ] in let if_argument arg_name value = if value then [ arg_name ] else [ ] in let open Configuration in let c = configuration in let rna_arg = ( maybe_argument ~ f : str_of_str " -- rna - gene - fpkm - tracking - file " c . rna_gene_fpkm_tracking_file ) @ ( maybe_argument ~ f : string_of_float " -- rna - min - gene - expression " ( Some c . rna_min_gene_expression ) ) @ ( maybe_argument ~ f : str_of_str " -- rna - transcript - fpkm - tracking - file " c . rna_transcript_fpkm_tracking_file ) @ ( maybe_argument ~ f : string_of_float " -- rna - min - transcript - expression " ( Some c . rna_min_transcript_expression ) ) @ ( maybe_argument ~ f : str_of_str " -- rna - transcript - fpkm - gtf - file " c . rna_transcript_fkpm_gtf_file ) in let string_of_intlist l = l |> List . map ~ f : string_of_int |> String . concat ~ sep " , " : in let length_arg = maybe_argument ~ f : string_of_intlist " -- mhc - epitope - lengths " ( Some c . mhc_epitope_lengths ) in let ic50_arg = maybe_argument ~ f : string_of_float " -- ic50 - cutoff " ( Some c . ic50_cutoff ) in let percentile_arg = maybe_argument ~ f : string_of_float " -- percentile - cutoff " ( Some c . percentile_cutoff ) in let padding_arg = maybe_argument ~ f : string_of_int " -- padding - around - mutation " c . padding_around_mutation in let self_filter_directory = maybe_argument ~ f : str_of_str " -- self - filter - directory " c . self_filter_directory in let skip_error_arg = if_argument " -- skip - variant - errors " c . skip_variant_errors in let novel_arg = if_argument " -- only - novel - epitopes " c . only_novel_epitopes in let arguments = var_arg @ predictor_arg @ allele_arg @ output_arg @ rna_arg @ length_arg @ novel_arg @ ic50_arg @ percentile_arg @ padding_arg @ skip_error_arg @ self_filter_directory @ Configuration . render configuration in let name = sprintf " topiary_ % s " ( Filename . basename output_path ) in workflow_node ( single_file output_path ~ host : Machine . ( as_host run_with ) ) ~ name ~ edges ( [ : depends_on Machine . Tool . ( ensure topiary ) ; depends_on ( Pyensembl . cache_genome ~ run_with ~ reference_build ) ; depends_on alleles_file ; ] @ ( List . map ~ f : depends_on vcfs ) @ predictor_edges ) ~ make ( : Machine . run_program run_with ~ name Program . ( Machine . Tool . ( init topiary ) && predictor_init && Pyensembl . ( set_cache_dir_command ~ run_with ) && exec ( [ " topiary " ] @ arguments ) ) )
let received_msg = option int
let s = " ReWeb . Topic " , [ Alcotest . test_case " make , subscribe , publish , pull " ` Quick begin fun ( ) -> let topic = Topic . make ( ) in Lwt_main . run begin let open Lwt . Syntax in let * subscription = Topic . subscribe topic in let * ( ) = Topic . publish topic ~ msg in let + msg_option = Topic . pull subscription ~ timeout in check received_msg " " ( Some msg ) msg_option end end ; Alcotest . test_case " subscribe - subscriptions are automatically unsubscribed " ` Quick begin fun ( ) -> let topic = Topic . make ( ) in Lwt_main . run begin let open Lwt . Syntax in let * num = Topic . num_subscribers topic in check int " before any subscriptions " 0 num ; let subscribe ( ) = let * subscription = Topic . subscribe topic in let + num = Topic . num_subscribers topic in check int " after subscribing " 1 num in let * ( ) = subscribe ( ) in Gc . full_major ( ) ; let + num = Topic . num_subscribers topic in check int " after subscription goes out of scope " 0 num end end ; Alcotest . test_case " publish_from - publishes to subscribers other than sender " ` Quick begin fun ( ) -> let topic = Topic . make ( ) in Lwt_main . run begin let open Lwt . Syntax in let * sender_subscription = Topic . subscribe topic in let * receiver_subscription = Topic . subscribe topic in let * ( ) = Topic . publish_from sender_subscription ~ msg in let * sender_received = Topic . pull sender_subscription ~ timeout in check received_msg " sender did not receive message " None sender_received ; let + receiver_received = Topic . pull receiver_subscription ~ timeout in check received_msg " receiver received message " ( Some msg ) receiver_received end end ; ]
module type Env = sig val bool : string -> bool val native : bool val native_dynlink : bool end
module type Exts = sig val interface : string list val interface_opt : string list val library : string list val module_library : string list end
module type Pkg = sig type builder = [ ` OCamlbuild | ` Other of string * string ] type moves type field = ? cond : bool -> ? exts : string list -> ? dst : string -> string -> moves val lib : field val lib_exec : ? auto : bool -> field val bin : ? auto : bool -> field val sbin : ? auto : bool -> field val toplevel : field val share : field val share_root : field val etc : field val doc : field val misc : field val stublibs : field val man : field val describe : string -> builder : builder -> moves list -> unit end
module Topkg : sig val cmd : [ ` Build | ` Explain | ` Help ] val env : ( string * bool ) list val err_parse : string -> ' a val err_mdef : string -> ' a val err_miss : string -> ' a val err_file : string -> string -> ' a val warn_unused : string -> unit let err fmt = let k _ = exit 1 in Format . kfprintf k Format . err_formatter ( " % s : " ^^ fmt ^^ " . " ) @ Sys . argv . ( 0 ) let err_parse a = err " argument ` % s ' is not of the form key ( = true | false ) " a let err_mdef a = err " bool ` % s ' is defined more than once " a let err_miss a = err " argument ` % s ( = true | false ) ' is missing " a let err_file f e = err " % s : % s " f e let warn_unused k = Format . eprintf " % s : warning : environment key ` % s ` unused . . " @ Sys . argv . ( 0 ) k let cmd , env = let rec parse_env acc = function | arg :: args -> begin try let len = String . length arg in let eq = String . index arg ' ' = in let bool = bool_of_string ( String . sub arg ( eq + 1 ) ( len - eq - 1 ) ) in let key = String . sub arg 0 eq in if key = " " then raise Exit else try ignore ( List . assoc key acc ) ; err_mdef key with | Not_found -> parse_env ( ( key , bool ) :: acc ) args with | Invalid_argument _ | Not_found | Exit -> err_parse arg end | [ ] -> acc in match List . tl ( Array . to_list Sys . argv ) with | " explain " :: args -> ` Explain , parse_env [ ] args | ( " help " | " - h " | " -- help " | " - help " ) :: args -> ` Help , parse_env [ ] args | args -> ` Build , parse_env [ ] args end
module Env : sig include Env val get : unit -> ( string * bool ) list let env = ref [ ] let get ( ) = ! env let add_bool key b = env := ( key , b ) :: ! env let bool key = let b = try List . assoc key Topkg . env with | Not_found -> if Topkg . cmd = ` Build then Topkg . err_miss key else true in add_bool key b ; b let native = bool " native " let native_dynlink = bool " native - dynlink " end
module Exts : Exts = struct let interface = [ " . mli " ; " . cmi " ; " . cmti " ] let interface_opt = " . cmx " :: interface let library = [ " . cma " ; " . cmxa " ; " . cmxs " ; " . a " ] let module_library = ( interface_opt @ library ) end
module Pkg : Pkg = struct type builder = [ ` OCamlbuild | ` Other of string * string ] type moves = ( string * ( string * string ) ) list type field = ? cond : bool -> ? exts : string list -> ? dst : string -> string -> moves let str = Printf . sprintf let warn_unused ( ) = let keys = List . map fst Topkg . env in let keys_used = List . map fst ( Env . get ( ) ) in let unused = List . find_all ( fun k -> not ( List . mem k keys_used ) ) keys in List . iter Topkg . warn_unused unused let has_suffix = Filename . check_suffix let build_strings ( ? exec_sep = " " ) btool bdir mvs = let no_build = [ " . cmti " ; " . cmt " ] in let install = Buffer . create 1871 in let exec = Buffer . create 1871 in let rec add_mvs current = function | ( field , ( src , dst ) ) :: mvs when field = current -> if List . exists ( has_suffix src ) no_build then Buffer . add_string install ( str " \ n " \?% s /% s " \ { " \% s " } " \ bdir src dst ) else begin Buffer . add_string exec ( str " % s % s " exec_sep src ) ; Buffer . add_string install ( str " \ n " \% s /% s " \ { " \% s " } " \ bdir src dst ) ; end ; add_mvs current mvs | ( ( ( field , _ ) :: _ ) as mvs ) -> if current <> " " then Buffer . add_string install " ] \ n " ; Buffer . add_string install ( str " % s : [ " field ) ; add_mvs field mvs | [ ] -> ( ) in Buffer . add_string exec btool ; add_mvs " " mvs ; Buffer . add_string install " ] \ n " ; Buffer . contents install , Buffer . contents exec let pr = Format . printf let pr_explanation btool bdir pkg mvs = let env = Env . get ( ) in let install , exec = build_strings ~ exec_sep " : \\\ n " btool bdir mvs in pr " [ @< v " ; > pr " Package name : % s , " @ pkg ; pr " Build tool : % s , " @ btool ; pr " Build directory : % s , " @ bdir ; pr " Environment , :@ " ; List . iter ( fun ( k , v ) -> pr " % s =% b , @ " k v ) ( List . sort compare env ) ; pr " , @ Build invocation , " ; :@ pr " % s , , " @@ exec ; pr " Install file , " ; :@ pr " % s , " @ install ; pr " ] " ; @ ( ) let pr_help ( ) = pr " Usage example :@\ n % s " Sys . argv . ( 0 ) ; List . iter ( fun ( k , v ) -> pr " % s =% b " k v ) ( List . sort compare ( Env . get ( ) ) ) ; pr " . " @ let build btool bdir pkg mvs = let install , exec = build_strings btool bdir mvs in let e = Sys . command exec in if e <> 0 then exit e else let install_file = pkg ^ " . install " in try let oc = open_out install_file in output_string oc install ; flush oc ; close_out oc with Sys_error e -> Topkg . err_file install_file e let mvs ( ? drop_exts = [ ] ) field ( ? cond = true ) ( ? exts = [ ] ) ? dst src = if not cond then [ ] else let mv src dst = ( field , ( src , dst ) ) in let expand exts s d = List . map ( fun e -> mv ( s ^ e ) ( d ^ e ) ) exts in let dst = match dst with None -> Filename . basename src | Some dst -> dst in let files = if exts = [ ] then [ mv src dst ] else expand exts src dst in let keep ( _ , ( src , _ ) ) = not ( List . exists ( has_suffix src ) drop_exts ) in List . find_all keep files let lib = let drop_exts = if Env . native && not Env . native_dynlink then [ " . cmxs " ] else if not Env . native then [ " . a " ; " . cmx " ; " . cmxa " ; " . cmxs " ] else [ ] in mvs ~ drop_exts " lib " let share = mvs " share " let share_root = mvs " share_root " let etc = mvs " etc " let toplevel = mvs " toplevel " let doc = mvs " doc " let misc = mvs " misc " let stublibs = mvs " stublibs " let man = mvs " man " let bin_drops = if not Env . native then [ " . native " ] else [ ] let bin_mvs field ( ? auto = false ) ? cond ? exts ? dst src = let src , dst = if not auto then src , dst else let dst = match dst with | None -> Some ( Filename . basename src ) | Some _ as dst -> dst in let src = if Env . native then src ^ " . native " else src ^ " . byte " in src , dst in mvs ~ drop_exts : bin_drops field ? cond ? dst src let bin = bin_mvs " bin " let sbin = bin_mvs " sbin " let lib_exec = bin_mvs " lib " let describe pkg ~ builder mvs = let mvs = List . sort compare ( List . flatten mvs ) in let btool , bdir = match builder with | ` OCamlbuild -> " ocamlbuild - use - ocamlfind - classic - display " , " _build " | ` Other ( btool , bdir ) -> btool , bdir in match Topkg . cmd with | ` Explain -> pr_explanation btool bdir pkg mvs | ` Help -> pr_help ( ) | ` Build -> warn_unused ( ) ; build btool bdir pkg mvs end
let cmds = [ Bistro . cmd ; Browse . cmd ; Build . cmd ; Clean . cmd ; Distrib . cmd ; Doc . cmd ; Help . cmd ; Ipc . cmd ; Issue . cmd ; Lint . cmd ; Log . cmd ; Opam . cmd ; Publish . cmd ; Run . cmd ; Status . cmd ; Tag . cmd ; Test . cmd ; ]
let main ( ) = ` Help ( ` Pager , None ) None
let doc = " Topkg package care "
let man = [ ` S Manpage . s_description ; ` P ( " $ mname ) mname takes care of topkg packages . " ; ` P " Use ' ( $ mname ) mname help release ' for help to release a package . " ; ` Noblank ; ` P " Use ' ( $ mname ) mname help delegate ' for help about the topkg delegate . " ; ` Noblank ; ` P " Use ' ( $ mname ) mname help troubleshoot ' for a few troubleshooting tips . " ; ` Noblank ; ` P " Use ' ( $ mname ) mname help ( $ i , COMMAND ) COMMAND ' for help about ( $ i , COMMAND ) COMMAND . " ; ` S Manpage . s_bugs ; ` P " Report them , see ( $ i , %% PKG_HOMEPAGE ) %% for contact information . " ; ` S Manpage . s_authors ; ` P " Daniel C . Buenzli , ( $ i , http :// erratique . ch ) ch " ; ]
let main = Term ( . ret ( const main $ Cli . setup ) setup ) setup , Term . info " topkg " ~ version " :%% VERSION " %% ~ doc ~ sdocs ~ exits ~ man
let main ( ) = Topkg . Private . disable_main ( ) ; Term ( . exit_status @@ eval_choice main cmds ) cmds
let ( ) = main ( )
let ocamlbuild_flags = Topkg_cmd ( . empty % " - use - ocamlfind " % " - classic - display ) "
let build_cmd c os = let ocamlbuild = Topkg_conf . tool " ocamlbuild " os in let build_dir = Topkg_conf . build_dir c in let toolchain = match Topkg_conf . toolchain c with | Some toolchain -> Topkg_cmd ( . v " - toolchain " % toolchain ) toolchain | _ -> Topkg_cmd . empty in let debug = Topkg_cmd ( . on ( Topkg_conf . debug c ) c ( v " - tag " % " debug ) ) " in let profile = Topkg_cmd ( . on ( Topkg_conf . profile c ) c ( v " - tag " % " profile ) ) " in let jobs = let n = Topkg_conf . jobs c in Topkg_log . info ( fun m -> m " using % d jobs " n ) n ; Topkg_cmd ( . on ( n != 1 ) 1 ( v " - j " % string_of_int n ) n ) n in Topkg_cmd ( . ocamlbuild %% ocamlbuild_flags %% toolchain %% jobs %% debug %% profile % " - build - dir " % build_dir ) build_dir
let clean_cmd os ~ build_dir = let ocamlbuild = Topkg_conf . tool " ocamlbuild " os in Topkg_cmd ( . ocamlbuild %% ocamlbuild_flags % " - build - dir " % build_dir % " - clean ) "
type t = { prepare_on_pin : bool ; dir : Topkg_fpath . t ; pre : Topkg_conf . t -> unit result ; cmd : Topkg_conf . t -> Topkg_conf . os -> Topkg_fpath . t list -> unit result ; post : Topkg_conf . t -> unit result ; clean : Topkg_conf . os -> build_dir : Topkg_fpath . t -> unit result ; }
let with_dir b dir = { b with dir }
let nop = fun _ -> Ok ( )
let cmd c os files = Topkg_os . Cmd . run @@ Topkg_cmd ( . build_cmd c os %% of_list files ) files
let clean os ~ build_dir = Topkg_os . Cmd . run @@ clean_cmd os ~ build_dir
let v ( ? prepare_on_pin = true ) true ( ? dir = " _build ) " ( ? pre = nop ) nop ( ? cmd = cmd ) cmd ( ? post = nop ) nop ( ? clean = clean ) clean ( ) = { prepare_on_pin ; dir ; pre ; cmd ; post ; clean ; }
let prepare_on_pin b = b . prepare_on_pin
let dir b = b . dir
let pre b = b . pre
let cmd b = b . cmd
let post b = b . post
let clean b = b . clean
let codec = let prepare_on_pin = Topkg_codec ( . with_kind " prepare_on_pin " @@ bool ) bool in let dir = Topkg_codec ( . with_kind " dir " @@ string ) string in let fields = let stub _ = invalid_arg " not executable outside package definition " in ( fun b -> b . prepare_on_pin , b . dir ) dir , ( fun ( prepare_on_pin , dir ) dir -> { prepare_on_pin ; dir ; pre = stub ; cmd = stub ; post = stub ; clean = stub } ) in Topkg_codec . version 0 @@ Topkg_codec ( . view ~ kind " : build " fields ( pair prepare_on_pin dir ) dir ) dir
let ocb_tag c key tag = let tag = Topkg_string . strf " % s ( s % a ) a " tag ( Topkg_conf . pp_value c ) c key in Topkg_cmd ( . v " - tag " % tag ) tag
let ocb_bool_tag c key tag = Topkg_cmd ( . on ( Topkg_conf . value c key ) key @@ v " - tag " % tag ) tag
let ocb_bool_tags c tags = let f ( key , tag ) tag = Topkg_cmd ( ) . %% ( ocb_bool_tag c key tag ) tag in List . fold_right f tags Topkg_cmd . empty
module Tar = struct type ptime = int type t = string list let empty = [ ] let to_unix_path_string = if Fpath . dir_sep = " " / then Fpath . to_string else fun f -> String . concat ~ sep " " :/ ( Fpath . segs f ) f let set_filename h f = let s = to_unix_path_string f in match String . length s with | n when n <= 100 -> Bytes . blit_string s 0 h 0 ( String . length s ) s | n -> try match String . cut ~ rev : true ~ sep " " :/ s with | None -> raise Exit | Some ( p , n ) n -> if String . length p > 155 || String . length n > 100 then raise Exit ; Bytes . blit_string n 0 h 0 ( String . length n ) n ; Bytes . blit_string p 0 h 345 ( String . length p ) p ; with | Exit -> failwith ( strf " % a : file name too long " Fpath . pp f ) f let set_string off h s = Bytes . blit_string s 0 h off ( String . length s ) s let set_octal field off len h n = let octal = Printf . sprintf " % 0 * o " ( len - 1 ) 1 n in if String . length octal < len then Bytes . blit_string octal 0 h off ( String . length octal ) octal else failwith ( strf " field % s : can ' t encode % d in % d - digit octal number " field ( len - 1 ) 1 n ) n let header_checksum h = let len = Bytes . length h in let rec loop acc i = if i > len then acc else loop ( acc + ( Char . to_int @@ Bytes . unsafe_get h i ) i ) i ( i + 1 ) 1 in loop 0 0 let header fname mode mtime size typeflag = try let h = Bytes . make 512 ' \ x00 ' in set_filename h fname ; set_octal " mode " 100 8 h mode ; set_octal " owner " 108 8 h 0 ; set_octal " group " 116 8 h 0 ; set_octal " size " 124 12 h size ; set_octal " mtime " 136 12 h mtime ; set_string 148 h " " ; set_string 156 h typeflag ; set_string 257 h " ustar " ; set_string 263 h " 00 " ; set_octal " devmajor " 329 8 h 0 ; set_octal " devminor " 329 8 h 0 ; let c = header_checksum h in set_octal " checksum " 148 9 h c ; Ok ( Bytes . unsafe_to_string h ) h with Failure msg -> R . error_msg msg let padding content = match String . length content mod 512 with | 0 -> " " | n -> Bytes . unsafe_to_string ( Bytes . make ( 512 - n ) n ' \ x00 ' ) x00 ' let add t fname ~ mode ~ mtime kind = let typeflag , size , data = match kind with | ` Dir -> " 5 " , 0 , [ ] | ` File cont -> " 0 " , String . length cont , [ cont ; padding cont ] cont in header fname mode mtime size typeflag >>| fun header -> List . rev_append data ( header :: t ) t let to_string t = let end_of_file = Bytes . unsafe_to_string ( Bytes . make 1024 ' \ x00 ' ) x00 ' in String . concat ( List . rev ( end_of_file :: t ) t ) t end
let path_set_of_dir dir ~ exclude_paths = let add_prefix p acc = Fpath ( . Set . add ( dir // p ) p acc ) acc in let exclude_paths = Fpath . Set ( . fold add_prefix exclude_paths empty ) empty in let not_excluded p = Ok ( not ( Fpath . Set . mem p exclude_paths ) exclude_paths ) exclude_paths in let traverse = ` Sat not_excluded in let elements = ` Sat not_excluded in let err _ e = e in OS . Dir . fold_contents ~ dotfiles : true ~ err ~ elements ~ traverse Fpath . Set . add Fpath . Set . empty dir
let tar dir ~ exclude_paths ~ root ~ mtime = let tar_add file tar = let fname = match Fpath . rem_prefix dir file with | None -> assert false | Some file -> Fpath ( . root // file ) file in Logs . info ( fun m -> m " Archiving % a " Fpath . pp fname ) fname ; tar >>= fun tar -> OS . Dir . exists file >>= function | true -> Tar . add tar fname ~ mode : 0o775 ~ mtime ` Dir | false -> OS . Path . Mode . get file >>= fun mode -> OS . File . read file >>= fun contents -> let mode = if 0o100 land mode > 0 then 0o775 else 0o664 in Tar . add tar fname ~ mode ~ mtime ( ` File contents ) contents in path_set_of_dir dir ~ exclude_paths >>= fun fset -> Fpath . Set . fold tar_add fset ( Ok Tar . empty ) empty >>| fun tar -> Tar . to_string tar
let bzip2_cmd = OS . Env ( . value " TOPKG_BZIP2 " cmd ~ absent ( : Cmd . v " bzip2 ) ) "
let ensure_bzip2 ( ) = OS . Cmd . must_exist bzip2_cmd >>| fun _ -> ( )
let bzip2 s ~ dst = OS . Cmd ( . in_string s |> run_io bzip2_cmd |> to_file dst ) dst
let tar_cmd = OS . Env ( . value " TOPKG_TAR " cmd ~ absent ( : Cmd . v " tar ) ) "
let ensure_tar ( ) = OS . Cmd . must_exist tar_cmd >>| fun _ -> ( )
let untbz ( ? clean = false ) false ar = let clean_dir dir = OS . Dir . exists dir >>= function | true when clean -> OS . Dir . delete ~ recurse : true dir | _ -> Ok ( ) in let archive_dir , ar = Fpath . split_base ar in let unarchive ar = let dir = Fpath . rem_ext ar in OS . Cmd . must_exist tar_cmd >>= fun cmd -> clean_dir dir >>= fun ( ) -> OS . Cmd . run Cmd ( . tar_cmd % " - xjf " % p ar ) ar >>= fun ( ) -> Ok Fpath ( . archive_dir // dir ) dir in R . join @@ OS . Dir . with_current archive_dir unarchive ar
let run_delegate pkg args = let verbosity = Logs . level_to_string ( Logs . level ( ) ) in Topkg_care_pkg . delegate pkg >>= fun del -> Ok Cmd ( . del % " ipc " % verbosity %% args ) args >>= fun cmd -> OS . Cmd . run_status cmd >>= function | ` Exited 0 -> Ok ( ) | ` Exited 1 -> R . error_msgf " Action unsupported by delegate % a " Cmd . pp del | ( ` Exited n | ` Signaled n ) n -> R . error_msgf " Delegate % a errored with % d " Cmd . pp del n
let publish_distrib p ~ msg ~ archive = Topkg_care_pkg . name p >>= fun name -> Topkg_care_pkg . version p >>= fun version -> Topkg_care_pkg . distrib_uri p >>= fun distrib_uri -> run_delegate p Cmd ( . v " publish " % " distrib " % distrib_uri % name % version % msg % p archive ) archive
let publish_doc p ~ msg ~ docdir = let doc_uri p = Topkg_care_pkg . opam_field_hd p " doc " >>= function | None -> Ok " " | Some uri -> Ok uri in Topkg_care_pkg . name p >>= fun name -> Topkg_care_pkg . version p >>= fun version -> doc_uri p >>= fun doc_uri -> run_delegate p Cmd ( . v " publish " % " doc " % doc_uri % name % version % msg % p docdir ) docdir
let publish_alt p ~ kind ~ msg ~ archive = Topkg_care_pkg . name p >>= fun name -> Topkg_care_pkg . version p >>= fun version -> Topkg_care_pkg . distrib_uri p >>= fun distrib_uri -> run_delegate p Cmd ( . v " publish " % " alt " % distrib_uri % kind % name % version % msg % p archive ) archive
let publish_in_git_branch ~ remote ~ branch ~ name ~ version ~ docdir ~ dir = let pp_distrib ppf ( name , version ) version = Fmt . pf ppf " % a % a " Topkg_care_text . Pp . name name Topkg_care_text . Pp . version version in let log_publish_result msg distrib dir = Logs . app ( fun m -> m " % s % a @ in @ directory @ % a @ of @ gh - pages @ branch " msg pp_distrib distrib Fpath . pp dir ) dir in let cp src dst = let dst_is_root = Fpath . is_current_dir dst in let src = if dst_is_root then Fpath . to_dir_path src else Fpath . rem_empty_seg src in OS . Cmd . run Cmd ( . v " cp " % " - R " % p src % p dst ) dst in let delete dir = if not ( Fpath . is_current_dir dir ) dir then OS . Dir . delete ~ recurse : true dir else let delete acc p = acc >>= fun ( ) -> OS . Path . delete ~ recurse : true p in let gitdir = Fpath . v " . git " in let not_git p = not ( Fpath . equal p gitdir ) gitdir in OS . Dir . contents dir >>= fun files -> List . fold_left delete ( Ok ( ) ) ( List . filter not_git files ) files in let git_for_repo r = Cmd . of_list ( Topkg . Cmd . to_list @@ Topkg . Vcs . cmd r ) r in let replace_dir_and_push docdir dir = let msg = strf " Update % s doc to % s . " name version in Topkg . Vcs . get ( ) >>= fun repo -> Ok ( git_for_repo repo ) repo >>= fun git -> OS . Cmd . run Cmd ( . git % " checkout " % branch ) branch >>= fun ( ) -> delete dir >>= fun ( ) -> cp docdir dir >>= fun ( ) -> Topkg . Vcs . is_dirty repo >>= function | false -> Ok false | true -> OS . Cmd . run Cmd ( . git % " add " % p dir ) dir >>= fun ( ) -> OS . Cmd . run Cmd ( . git % " commit " % " - m " % msg ) msg >>= fun ( ) -> OS . Cmd . run Cmd ( . git % " push ) " >>= fun ( ) -> Ok true in if not ( Fpath . is_rooted ~ root : Fpath ( . v ) " . " dir ) dir then R . error_msgf " % a directory is not rooted in the repository or not relative " Fpath . pp dir else let clonedir = Fpath ( . parent docdir / strf " % s -% s . pubdoc " name version ) version in OS . Dir . delete ~ recurse : true clonedir >>= fun ( ) -> Topkg . Vcs . get ( ) >>= fun repo -> Topkg . Vcs . clone repo ~ dir ( : Fpath . to_string clonedir ) clonedir >>= fun ( ) -> OS . Dir . with_current clonedir ( replace_dir_and_push docdir ) docdir dir >>= fun res -> res >>= function | false -> log_publish_result " No documentation changes for " ( name , version ) version dir ; Ok ( ) | true -> let push_spec = strf " % s :% s " branch branch in Ok ( git_for_repo repo ) repo >>= fun git -> OS . Cmd . run Cmd ( . git % " push " % remote % push_spec ) push_spec >>= fun ( ) -> OS . Dir . delete ~ recurse : true clonedir >>= fun ( ) -> log_publish_result " Published documentation for " ( name , version ) version dir ; Ok ( )