text stringlengths 0 601k |
|---|
let read filename = let ic = open_in_bin filename in Misc . try_finally ~ always ( : fun ( ) -> close_in ic ) ( fun ( ) -> let magic_number = read_magic_number ic in let cmi , cmt = if magic_number = Config . cmt_magic_number then None , Some ( input_cmt ic ) else if magic_number = Config . cmi_magic_number then let cm... |
let read_cmt filename = match read filename with _ , None -> raise ( Error ( Not_a_typedtree filename ) ) | _ , Some cmt -> cmt |
let read_cmi filename = match read filename with None , _ -> raise ( Cmi_format . Error ( Cmi_format . Not_an_interface filename ) ) | Some cmi , _ -> cmi |
let saved_types = ref [ ] |
let value_deps = ref [ ] |
let clear ( ) = saved_types := [ ] ; value_deps := [ ] |
let add_saved_type b = saved_types := b :: ! saved_types |
let get_saved_types ( ) = ! saved_types |
let set_saved_types l = saved_types := l |
let record_value_dependency vd1 vd2 = if vd1 . Types . val_loc <> vd2 . Types . val_loc then value_deps := ( vd1 , vd2 ) :: ! value_deps |
let save_cmt filename modname binary_annots sourcefile initial_env cmi = if ! Clflags . binary_annotations && not ! Clflags . print_types then begin Misc . output_to_file_via_temporary ~ mode [ : Open_binary ] filename ( fun temp_file_name oc -> let this_crc = match cmi with | None -> None | Some cmi -> Some ( output_c... |
let node_sh_map_fold ( f : ' a -> ' b -> ' c * ' b ) ( node : ' a node ) ( acc : ' b ) : ' c node * ' b = begin match node with | N_undefined id -> N_undefined id , acc | N_filled ( id , x ) -> let x , acc = f x acc in N_filled ( id , x ) , acc | N_rejected ( id , x ) -> let x , acc = f x acc in N_rejected ( id , x ) ,... |
let node_sh_map ( f : ' a -> ' b ) ( node : ' a node ) : ' b node = let node , ( ) = node_sh_map_fold ( fun x ( ) -> f x , ( ) ) node ( ) in node |
let node_sh_fold ( f : ' a -> ' b -> ' b ) ( node : ' a node ) ( acc : ' b ) : ' b = let _ , acc = node_sh_map_fold ( fun x acc -> x , f x acc ) node acc in acc |
let node_list_sh_map_fold ( f_elem : ' a -> ' b -> ' c * ' b ) ( f_closed : unit node -> ' b -> unit node * ' b ) ( l : ' a node_list ) ( acc : ' b ) : ' c node_list * ' b = let rev_l , acc = List . fold_left ( fun ( rev_l , acc ) elem -> let elem , acc = f_elem elem acc in elem :: rev_l , acc ) ( [ ] , acc ) l . list_... |
let node_list_sh_map ( f_elem : ' a -> ' b ) ( f_closed : unit node -> unit node ) ( node : ' a node_list ) : ' b node_list = let node , ( ) = node_list_sh_map_fold ( fun x ( ) -> f_elem x , ( ) ) ( fun x ( ) -> f_closed x , ( ) ) node ( ) in node |
let node_list_sh_fold ( f_elem : ' a -> ' b -> ' b ) ( f_closed : unit node -> ' b -> ' b ) ( node : ' a node_list ) ( acc : ' b ) : ' b = let _ , acc = node_list_sh_map_fold ( fun x acc -> x , f_elem x acc ) ( fun x acc -> x , f_closed x acc ) node acc in acc |
let rule_sh_map_fold ( f_evnt : cnl_event -> ' a -> cnl_event * ' a ) ( f_cond : cnl_cond -> ' a -> cnl_cond * ' a ) ( f_actns : cnl_actions -> ' a -> cnl_actions * ' a ) ( rule : cnl_rule ) ( acc : ' a ) : cnl_rule * ' a = let node , acc = node_sh_map_fold ( fun desc acc -> let evnt , acc = f_evnt desc . rule_evnt acc... |
let rule_sh_map ( f_evnt : cnl_event -> cnl_event ) ( f_cond : cnl_cond -> cnl_cond ) ( f_actns : cnl_actions -> cnl_actions ) ( rule : cnl_rule ) : cnl_rule = let rule , ( ) = rule_sh_map_fold ( fun x ( ) -> f_evnt x , ( ) ) ( fun x ( ) -> f_cond x , ( ) ) ( fun x ( ) -> f_actns x , ( ) ) rule ( ) in rule |
let rule_sh_fold ( f_evnt : cnl_event -> ' a -> ' a ) ( f_cond : cnl_cond -> ' a -> ' a ) ( f_actns : cnl_actions -> ' a -> ' a ) ( rule : cnl_rule ) ( acc : ' a ) : ' a = let _ , acc = rule_sh_map_fold ( fun x acc -> x , f_evnt x acc ) ( fun x acc -> x , f_cond x acc ) ( fun x acc -> x , f_actns x acc ) rule acc in ac... |
let evnt_sh_map_fold ( f : unit -> ' a -> unit * ' a ) ( evnt : cnl_event ) ( acc : ' a ) : cnl_event * ' a = evnt , acc |
let evnt_sh_map ( f : unit -> unit ) ( evnt : cnl_event ) : cnl_event = let evnt , ( ) = evnt_sh_map_fold ( fun x ( ) -> f x , ( ) ) evnt ( ) in evnt |
let evnt_sh_fold ( f : unit -> ' a -> ' a ) ( evnt : cnl_event ) ( acc : ' a ) : ' a = let _ , acc = evnt_sh_map_fold ( fun x acc -> x , f x acc ) evnt acc in acc |
let cond_sh_map_fold ( f_expr : cnl_expr -> ' a -> cnl_expr * ' a ) ( cond : cnl_cond ) ( acc : ' a ) : cnl_cond * ' a = let node , acc = node_sh_map_fold ( fun desc acc -> begin match desc with | C_no_condition -> C_no_condition , acc | C_condition e -> let e , acc = f_expr e acc in C_condition e , acc end ) cond . co... |
let cond_sh_map ( f_expr : cnl_expr -> cnl_expr ) ( cond : cnl_cond ) : cnl_cond = let cond , ( ) = cond_sh_map_fold ( fun x ( ) -> f_expr x , ( ) ) cond ( ) in cond |
let cond_sh_fold ( f_expr : cnl_expr -> ' a -> ' a ) ( cond : cnl_cond ) ( acc : ' a ) : ' a = let _ , acc = cond_sh_map_fold ( fun x acc -> x , f_expr x acc ) cond acc in acc |
let actns_sh_map_fold ( f_actn : cnl_action -> ' a -> cnl_action * ' a ) ( f_closed : unit node -> ' a -> unit node * ' a ) ( actns : cnl_actions ) ( acc : ' a ) : cnl_actions * ' a = let f_desc desc acc = node_list_sh_map_fold f_actn f_closed desc acc in let node , acc = node_sh_map_fold f_desc actns . actns_node acc ... |
let actns_sh_map ( f_actn : cnl_action -> cnl_action ) ( f_closed : unit node -> unit node ) ( actns : cnl_actions ) : cnl_actions = let actns , ( ) = actns_sh_map_fold ( fun x ( ) -> f_actn x , ( ) ) ( fun x ( ) -> f_closed x , ( ) ) actns ( ) in actns |
let actns_sh_fold ( f_actn : cnl_action -> ' a -> ' a ) ( f_closed : unit node -> ' a -> ' a ) ( actns : cnl_actions ) ( acc : ' a ) : ' a = let _ , acc = actns_sh_map_fold ( fun x acc -> x , f_actn x acc ) ( fun x acc -> x , f_closed x acc ) actns acc in acc |
let actn_sh_map_fold ( f_expr : cnl_expr -> ' a -> cnl_expr * ' a ) ( actn : cnl_action ) ( acc : ' a ) : cnl_action * ' a = let f_desc desc acc = begin match desc with | A_print e -> let e , acc = f_expr e acc in A_print e , acc | A_emit e -> let e , acc = f_expr e acc in A_emit e , acc | A_define ( x , e ) -> let e ,... |
let actns_sh_map ( f_expr : cnl_expr -> cnl_expr ) ( actn : cnl_action ) : cnl_action = let actn , ( ) = actn_sh_map_fold ( fun x ( ) -> f_expr x , ( ) ) actn ( ) in actn |
let actn_sh_fold ( f_expr : cnl_expr -> ' a -> ' a ) ( actn : cnl_action ) ( acc : ' a ) : ' a = let _ , acc = actn_sh_map_fold ( fun x acc -> x , f_expr x acc ) actn acc in acc |
let expr_sh_map_fold ( f_expr : cnl_expr -> ' a -> cnl_expr * ' a ) ( expr : cnl_expr ) ( acc : ' a ) : cnl_expr * ' a = let f_desc expr_desc acc = begin match expr_desc with | E_lit x -> E_lit x , acc | E_var x -> E_var x , acc | E_get ( e , x ) -> let e , acc = f_expr e acc in E_get ( e , x ) , acc | E_agg ( op , e ,... |
let expr_sh_map ( f_expr : cnl_expr -> cnl_expr ) ( expr : cnl_expr ) : cnl_expr = let expr , ( ) = expr_sh_map_fold ( fun x ( ) -> f_expr x , ( ) ) expr ( ) in expr |
let expr_sh_fold ( f_expr : cnl_expr -> ' a -> ' a ) ( expr : cnl_expr ) ( acc : ' a ) : ' a = let _ , acc = expr_sh_map_fold ( fun x acc -> x , f_expr x acc ) expr acc in acc |
type ' acc map_fold_over_node_fun = { poly_map_fold_fun : ' a . cnl_kind -> ' a node -> ' acc -> ' a node * ' acc ; rule_map_fold_fun : ( cnl_rule_desc node -> ' acc -> cnl_rule_desc node * ' acc ) ; evnt_map_fold_fun : ( cnl_evnt_desc node -> ' acc -> cnl_evnt_desc node * ' acc ) ; cond_map_fold_fun : ( cnl_cond_desc ... |
type map_over_node_fun = { poly_map_fun : ' a . cnl_kind -> ' a node -> ' a node ; rule_map_fun : ( cnl_rule_desc node -> cnl_rule_desc node ) ; evnt_map_fun : ( cnl_evnt_desc node -> cnl_evnt_desc node ) ; cond_map_fun : ( cnl_cond_desc node -> cnl_cond_desc node ) ; actns_map_fun : ( cnl_actns_desc node -> cnl_actns_... |
type ' acc fold_over_node_fun = { poly_fold_fun : ' a . cnl_kind -> ' a node -> ' acc -> ' acc ; rule_fold_fun : ( cnl_rule_desc node -> ' acc -> ' acc ) ; evnt_fold_fun : ( cnl_evnt_desc node -> ' acc -> ' acc ) ; cond_fold_fun : ( cnl_cond_desc node -> ' acc -> ' acc ) ; actns_fold_fun : ( cnl_actns_desc node -> ' ac... |
let id_map_fold_over_node_fun = let id node acc = ( node , acc ) in { poly_map_fold_fun = ( fun kind node acc -> ( node , acc ) ) ; rule_map_fold_fun = id ; evnt_map_fold_fun = id ; cond_map_fold_fun = id ; actns_map_fold_fun = id ; actn_map_fold_fun = id ; expr_map_fold_fun = id ; } |
let id_map_over_node_fun = let id node = node in { poly_map_fun = ( fun kind node -> node ) ; rule_map_fun = id ; evnt_map_fun = id ; cond_map_fun = id ; actns_map_fun = id ; actn_map_fun = id ; expr_map_fun = id ; } |
let id_fold_over_node_fun = let id node acc = acc in { poly_fold_fun = ( fun kind node acc -> acc ) ; rule_fold_fun = id ; evnt_fold_fun = id ; cond_fold_fun = id ; actns_fold_fun = id ; actn_fold_fun = id ; expr_fold_fun = id ; } |
let map_fold_over_node_fun_of_map_over_node_fun f = { poly_map_fold_fun = ( fun kind node acc -> ( f . poly_map_fun kind node , acc ) ) ; rule_map_fold_fun = ( fun node acc -> ( f . rule_map_fun node , acc ) ) ; evnt_map_fold_fun = ( fun node acc -> ( f . evnt_map_fun node , acc ) ) ; cond_map_fold_fun = ( fun node acc... |
let map_fold_over_node_fun_of_fold_over_node_fun f = { poly_map_fold_fun = ( fun kind node acc -> ( node , f . poly_fold_fun kind node acc ) ) ; rule_map_fold_fun = ( fun node acc -> ( node , f . rule_fold_fun node acc ) ) ; evnt_map_fold_fun = ( fun node acc -> ( node , f . evnt_fold_fun node acc ) ) ; cond_map_fold_f... |
let rec expr_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( expr : cnl_expr ) ( acc : ' a ) : cnl_expr * ' a = let node , acc = f . poly_map_fold_fun ( K_expr expr . expr_field ) expr . expr_node acc in let node , acc = f . expr_map_fold_fun node acc in expr_sh_map_fold ( fun e acc -> expr_dp_map_fold_over... |
let expr_dp_map_over_nodes ( f : map_over_node_fun ) ( expr : cnl_expr ) : cnl_expr = let node , _ = expr_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) expr ( ) in node |
let expr_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( expr : cnl_expr ) ( acc : ' a ) : ' a = let _ , acc = expr_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) expr acc in acc |
let evnt_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( evnt : cnl_event ) ( acc : ' a ) : cnl_event * ' a = let node , acc = f . poly_map_fold_fun K_evnt evnt . evnt_node acc in let node , acc = f . evnt_map_fold_fun node acc in evnt_sh_map_fold ( fun ( ) acc -> ( ) , acc ) { evnt with evnt_node = node } ... |
let evnt_dp_map_over_nodes ( f : map_over_node_fun ) ( evnt : cnl_event ) : cnl_event = let node , _ = evnt_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) evnt ( ) in node |
let evnt_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( evnt : cnl_event ) ( acc : ' a ) : ' a = let _ , acc = evnt_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) evnt acc in acc |
let cond_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( cond : cnl_cond ) ( acc : ' a ) : cnl_cond * ' a = let node , acc = f . poly_map_fold_fun K_cond cond . cond_node acc in let node , acc = f . cond_map_fold_fun node acc in cond_sh_map_fold ( expr_dp_map_fold_over_nodes f ) { cond with cond_node = node... |
let cond_dp_map_over_nodes ( f : map_over_node_fun ) ( cond : cnl_cond ) : cnl_cond = let node , _ = cond_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) cond ( ) in node |
let cond_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( cond : cnl_cond ) ( acc : ' a ) : ' a = let _ , acc = cond_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) cond acc in acc |
let actn_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( actn : cnl_action ) ( acc : ' a ) : cnl_action * ' a = let node , acc = f . poly_map_fold_fun K_actn actn . actn_node acc in let node , acc = f . actn_map_fold_fun node acc in actn_sh_map_fold ( expr_dp_map_fold_over_nodes f ) { actn with actn_node = ... |
let actn_dp_map_over_nodes ( f : map_over_node_fun ) ( actn : cnl_action ) : cnl_action = let node , _ = actn_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) actn ( ) in node |
let actn_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( actn : cnl_action ) ( acc : ' a ) : ' a = let _ , acc = actn_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) actn acc in acc |
let actns_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( actns : cnl_actions ) ( acc : ' a ) : cnl_actions * ' a = let node , acc = f . poly_map_fold_fun K_actns actns . actns_node acc in let node , acc = f . actns_map_fold_fun node acc in actns_sh_map_fold ( actn_dp_map_fold_over_nodes f ) ( f . poly_map_... |
let actns_dp_map_over_nodes ( f : map_over_node_fun ) ( actns : cnl_actions ) : cnl_actions = let node , _ = actns_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) actns ( ) in node |
let actns_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( actns : cnl_actions ) ( acc : ' a ) : ' a = let _ , acc = actns_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) actns acc in acc |
let rule_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( rule : cnl_rule ) ( acc : ' a ) : cnl_rule * ' a = let node , acc = f . poly_map_fold_fun K_rule rule . rule_node acc in let node , acc = f . rule_map_fold_fun node acc in rule_sh_map_fold ( evnt_dp_map_fold_over_nodes f ) ( cond_dp_map_fold_over_node... |
let rule_dp_map_over_nodes ( f : map_over_node_fun ) ( rule : cnl_rule ) : cnl_rule = let node , _ = rule_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_map_over_node_fun f ) rule ( ) in node |
let rule_dp_fold_over_nodes ( f : ' a fold_over_node_fun ) ( rule : cnl_rule ) ( acc : ' a ) : ' a = let _ , acc = rule_dp_map_fold_over_nodes ( map_fold_over_node_fun_of_fold_over_node_fun f ) rule acc in acc |
let cnl_dp_map_fold_over_nodes ( f : ' a map_fold_over_node_fun ) ( cnl : cnl_ast ) ( acc : ' a ) : cnl_ast * ' a = begin match cnl with | Cnl_expr expr -> let expr , acc = expr_dp_map_fold_over_nodes f expr acc in Cnl_expr expr , acc | Cnl_actn actn -> let actn , acc = actn_dp_map_fold_over_nodes f actn acc in Cnl_act... |
let mk_expr_with_loc node ofname loc = { expr_node = node ; expr_field = ofname ; expr_loc = loc ; } |
let mk_expr node = mk_expr_with_loc node None ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_expr_undefined ( ) = mk_expr ( N_undefined None ) |
let mk_expr_f desc = mk_expr ( N_filled ( None , desc ) ) |
let mk_expr_in_field node field_info = mk_expr_with_loc node ( Some field_info ) ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_expr_in_field_undefined field_info = mk_expr_in_field ( N_undefined None ) field_info |
let mk_expr_in_field_f desc field_info = mk_expr_in_field ( N_filled ( None , desc ) ) field_info |
let mk_boolean_f b = mk_expr_f ( E_lit ( L_boolean b ) ) |
let mk_int_f i = mk_expr_f ( E_lit ( L_int i ) ) |
let mk_int_as_string_f i = mk_expr_f ( E_lit ( L_int_as_string i ) ) |
let mk_float_f f = mk_expr_f ( E_lit ( L_real f ) ) |
let mk_float_as_string_f i = mk_expr_f ( E_lit ( L_real_as_string i ) ) |
let mk_boolean_as_string_f i = mk_expr_f ( E_lit ( L_boolean_as_string i ) ) |
let mk_string_f s = mk_expr_f ( E_lit ( L_string s ) ) |
let mk_enum_f s = mk_expr_f ( E_lit ( L_enum s ) ) |
let mk_var_f v = mk_expr_f ( E_var v ) |
let mk_get_f e ( fname : field_name ) = mk_expr_f ( E_get ( e , fname ) ) |
let mk_aggregate_f e ( op : Cnl_t . cnl_aggop ) ( fname : field_name ) = mk_expr_f ( E_agg ( op , e , fname ) ) |
let mk_get_var_f ( vname : variable_name ) ( fname : field_name ) = mk_get_f ( mk_var_f vname ) fname |
let mk_concat_f e1 e2 = mk_expr_f ( E_binop ( Op_concat , e1 , e2 ) ) |
let mk_concat_list_f el = begin match el with | [ ] -> mk_string_f " " | [ e1 ] -> e1 | e1 :: el -> List . fold_left mk_concat_f e1 el end |
let mk_lt_f e1 e2 = mk_expr_f ( E_binop ( Op_lt , e1 , e2 ) ) |
let mk_plus_f e1 e2 = mk_expr_f ( E_binop ( Op_plus , e1 , e2 ) ) |
let mk_div_f e1 e2 = mk_expr_f ( E_binop ( Op_div , e1 , e2 ) ) |
let mk_binop_expr_f op e1 e2 = mk_expr_f ( E_binop ( op , e1 , e2 ) ) |
let mk_binop_f op = mk_expr_f ( E_binop ( op , mk_expr_undefined ( ) , mk_expr_undefined ( ) ) ) |
let mk_unop_f op = mk_expr_f ( E_unop ( op , mk_expr_undefined ( ) ) ) |
let mk_this_f ename = mk_expr_f ( E_this ename ) |
let mk_new_event_f ename setters = mk_expr_f ( E_new ( ename , setters ) ) |
let mk_new_event_for_concept_f ename field_names = let setters = List . map ( fun fname -> ( fname , mk_expr_in_field_undefined ( ename , fname ) ) ) field_names in mk_new_event_f ename setters |
let mk_avg_f fname e = mk_expr_f ( E_agg ( A_avg , e , fname ) ) |
let mk_evnt_with_loc node loc = { evnt_node = node ; evnt_loc = loc ; } |
let mk_evnt node = mk_evnt_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_evnt_undefined ( ) = mk_evnt ( N_undefined None ) |
let mk_evnt_f desc = mk_evnt ( N_filled ( None , desc ) ) |
let mk_cond_with_loc node loc = { cond_node = node ; cond_loc = loc ; } |
let mk_cond node = mk_cond_with_loc node ( Parsing . symbol_start_pos ( ) , Parsing . symbol_end_pos ( ) ) |
let mk_cond_undefined ( ) = mk_cond ( N_undefined None ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.