text
stringlengths 0
601k
|
|---|
let add_specialise_attribute expr loc attributes = match expr , get_specialise_attribute attributes with | expr , Default_specialise -> expr | Lfunction ( { attr = { stub = false } as attr } as funct ) , specialise -> begin match attr . specialise with | Default_specialise -> ( ) | Always_specialise | Never_specialise -> Location . prerr_warning loc ( Warnings . Duplicated_attribute " specialise " ) end ; let attr = { attr with specialise } in Lfunction { funct with attr } | expr , ( Always_specialise | Never_specialise ) -> Location . prerr_warning loc ( Warnings . Misplaced_attribute " specialise " ) ; expr
|
let add_local_attribute expr loc attributes = match expr , get_local_attribute attributes with | expr , Default_local -> expr | Lfunction ( { attr = { stub = false } as attr } as funct ) , local -> begin match attr . local with | Default_local -> ( ) | Always_local | Never_local -> Location . prerr_warning loc ( Warnings . Duplicated_attribute " local " ) end ; let attr = { attr with local } in check_local_inline loc attr ; Lfunction { funct with attr } | expr , ( Always_local | Never_local ) -> Location . prerr_warning loc ( Warnings . Misplaced_attribute " local " ) ; expr
|
let get_and_remove_inlined_attribute e = let attr , exp_attributes = find_attribute is_inlined_attribute e . exp_attributes in let inlined = parse_inline_attribute attr in inlined , { e with exp_attributes }
|
let get_and_remove_inlined_attribute_on_module e = let rec get_and_remove mod_expr = let attr , mod_attributes = find_attribute is_inlined_attribute mod_expr . mod_attributes in let attr = parse_inline_attribute attr in let attr , mod_desc = match mod_expr . Typedtree . mod_desc with | Tmod_constraint ( me , mt , mtc , mc ) -> let inner_attr , me = get_and_remove me in let attr = match attr with | Always_inline | Never_inline | Unroll _ -> attr | Default_inline -> inner_attr in attr , Tmod_constraint ( me , mt , mtc , mc ) | md -> attr , md in attr , { mod_expr with mod_desc ; mod_attributes } in get_and_remove e
|
let get_and_remove_specialised_attribute e = let attr , exp_attributes = find_attribute is_specialised_attribute e . exp_attributes in let specialised = parse_specialise_attribute attr in specialised , { e with exp_attributes }
|
let get_tailcall_attribute e = let is_tailcall_attribute = function | { Parsetree . attr_name = { txt ( " = tailcall " " | ocaml . tailcall " ) } ; _ } -> true | _ -> false in let tailcalls , exp_attributes = List . partition is_tailcall_attribute e . exp_attributes in match tailcalls with | [ ] -> false , e | _ :: r -> begin match r with | [ ] -> ( ) | { Parsetree . attr_name = { txt ; loc } ; _ } :: _ -> Location . prerr_warning loc ( Warnings . Duplicated_attribute txt ) end ; true , { e with exp_attributes }
|
let check_attribute e { Parsetree . attr_name = { txt ; loc } ; _ } = match txt with | " inline " | " ocaml . inline " | " specialise " | " ocaml . specialise " -> begin match e . exp_desc with | Texp_function _ -> ( ) | _ -> Location . prerr_warning loc ( Warnings . Misplaced_attribute txt ) end | " inlined " | " ocaml . inlined " | " specialised " | " ocaml . specialised " | " tailcall " | " ocaml . tailcall " -> Location . prerr_warning loc ( Warnings . Misplaced_attribute txt ) | _ -> ( )
|
let check_attribute_on_module e { Parsetree . attr_name = { txt ; loc } ; _ } = match txt with | " inline " | " ocaml . inline " -> begin match e . mod_desc with | Tmod_functor _ -> ( ) | _ -> Location . prerr_warning loc ( Warnings . Misplaced_attribute txt ) end | " inlined " | " ocaml . inlined " -> Location . prerr_warning loc ( Warnings . Misplaced_attribute txt ) | _ -> ( )
|
let add_function_attributes lam loc attr = let lam = add_inline_attribute lam loc attr in let lam = add_specialise_attribute lam loc attr in let lam = add_local_attribute lam loc attr in lam
|
type error = Tags of label * label
|
let lfunction params body = if params = [ ] then body else match body with | Lfunction { kind = Curried ; params = params ' ; body = body ' ; attr ; loc } -> Lfunction { kind = Curried ; params = params @ params ' ; return = Pgenval ; body = body ' ; attr ; loc } | _ -> Lfunction { kind = Curried ; params ; return = Pgenval ; body ; attr = default_function_attribute ; loc = Location . none }
|
let lapply ap = match ap . ap_func with Lapply ap ' -> Lapply { ap with ap_func = ap ' . ap_func ; ap_args = ap ' . ap_args @ ap . ap_args } | _ -> Lapply ap
|
let mkappl ( func , args ) = Lapply { ap_should_be_tailcall = false ; ap_loc = Location . none ; ap_func = func ; ap_args = args ; ap_inlined = Default_inline ; ap_specialised = Default_specialise } ; ;
|
let lsequence l1 l2 = if l2 = lambda_unit then l1 else Lsequence ( l1 , l2 )
|
let lfield v i = Lprim ( Pfield i , [ Lvar v ] , Location . none )
|
let transl_label l = share ( Const_immstring l )
|
let transl_meth_list lst = if lst = [ ] then Lconst ( Const_pointer 0 ) else share ( Const_block ( 0 , List . map ( fun lab -> Const_immstring lab ) lst ) )
|
let set_inst_var obj id expr = Lprim ( Psetfield_computed ( Typeopt . maybe_pointer expr , Assignment ) , [ Lvar obj ; Lvar id ; transl_exp expr ] , Location . none )
|
let transl_val tbl create name = mkappl ( oo_prim ( if create then " new_variable " else " get_variable " ) , [ Lvar tbl ; transl_label name ] )
|
let transl_vals tbl create strict vals rem = List . fold_right ( fun ( name , id ) rem -> Llet ( strict , Pgenval , id , transl_val tbl create name , rem ) ) vals rem
|
let meths_super tbl meths inh_meths = List . fold_right ( fun ( nm , id ) rem -> try ( nm , id , mkappl ( oo_prim " get_method " , [ Lvar tbl ; Lvar ( Meths . find nm meths ) ] ) ) :: rem with Not_found -> rem ) inh_meths [ ]
|
let bind_super tbl ( vals , meths ) cl_init = transl_vals tbl false StrictOpt vals ( List . fold_right ( fun ( _nm , id , def ) rem -> Llet ( StrictOpt , Pgenval , id , def , rem ) ) meths cl_init )
|
let create_object cl obj init = let obj ' = Ident . create_local " self " in let ( inh_init , obj_init , has_init ) = init obj ' in if obj_init = lambda_unit then ( inh_init , mkappl ( oo_prim ( if has_init then " create_object_and_run_initializers " else " create_object_opt " ) , [ obj ; Lvar cl ] ) ) else begin ( inh_init , Llet ( Strict , Pgenval , obj ' , mkappl ( oo_prim " create_object_opt " , [ obj ; Lvar cl ] ) , Lsequence ( obj_init , if not has_init then Lvar obj ' else mkappl ( oo_prim " run_initializers_opt " , [ obj ; Lvar obj ' ; Lvar cl ] ) ) ) ) end
|
let name_pattern default p = match p . pat_desc with | Tpat_var ( id , _ ) -> id | Tpat_alias ( _ , id , _ ) -> id | _ -> Ident . create_local default
|
let rec build_object_init cl_table obj params inh_init obj_init cl = match cl . cl_desc with Tcl_ident ( path , _ , _ ) -> let obj_init = Ident . create_local " obj_init " in let envs , inh_init = inh_init in let env = match envs with None -> [ ] | Some envs -> [ Lprim ( Pfield ( List . length inh_init + 1 ) , [ Lvar envs ] , Location . none ) ] in let path_lam = transl_class_path cl . cl_loc cl . cl_env path in ( ( envs , ( path , path_lam , obj_init ) :: inh_init ) , mkappl ( Lvar obj_init , env @ [ obj ] ) ) | Tcl_structure str -> create_object cl_table obj ( fun obj -> let ( inh_init , obj_init , has_init ) = List . fold_right ( fun field ( inh_init , obj_init , has_init ) -> match field . cf_desc with Tcf_inherit ( _ , cl , _ , _ , _ ) -> let ( inh_init , obj_init ' ) = build_object_init cl_table ( Lvar obj ) [ ] inh_init ( fun _ -> lambda_unit ) cl in ( inh_init , lsequence obj_init ' obj_init , true ) | Tcf_val ( _ , _ , id , Tcfk_concrete ( _ , exp ) , _ ) -> ( inh_init , lsequence ( set_inst_var obj id exp ) obj_init , has_init ) | Tcf_method _ | Tcf_val _ | Tcf_constraint _ | Tcf_attribute _ -> ( inh_init , obj_init , has_init ) | Tcf_initializer _ -> ( inh_init , obj_init , true ) ) str . cstr_fields ( inh_init , obj_init obj , false ) in ( inh_init , List . fold_right ( fun ( id , expr ) rem -> lsequence ( Lifused ( id , set_inst_var obj id expr ) ) rem ) params obj_init , has_init ) ) | Tcl_fun ( _ , pat , vals , cl , partial ) -> let ( inh_init , obj_init ) = build_object_init cl_table obj ( vals @ params ) inh_init obj_init cl in ( inh_init , let build params rem = let param = name_pattern " param " pat in Lfunction { kind = Curried ; params = ( param , Pgenval ) :: params ; return = Pgenval ; attr = default_function_attribute ; loc = pat . pat_loc ; body = Matching . for_function pat . pat_loc None ( Lvar param ) [ pat , rem ] partial } in begin match obj_init with Lfunction { kind = Curried ; params ; body = rem } -> build params rem | rem -> build [ ] rem end ) | Tcl_apply ( cl , oexprs ) -> let ( inh_init , obj_init ) = build_object_init cl_table obj params inh_init obj_init cl in ( inh_init , transl_apply obj_init oexprs Location . none ) | Tcl_let ( rec_flag , defs , vals , cl ) -> let ( inh_init , obj_init ) = build_object_init cl_table obj ( vals @ params ) inh_init obj_init cl in ( inh_init , Translcore . transl_let rec_flag defs obj_init ) | Tcl_open ( _ , cl ) | Tcl_constraint ( cl , _ , _ , _ , _ ) -> build_object_init cl_table obj params inh_init obj_init cl
|
let rec build_object_init_0 cl_table params cl copy_env subst_env top ids = match cl . cl_desc with Tcl_let ( _rec_flag , _defs , vals , cl ) -> build_object_init_0 cl_table ( vals @ params ) cl copy_env subst_env top ids | _ -> let self = Ident . create_local " self " in let env = Ident . create_local " env " in let obj = if ids = [ ] then lambda_unit else Lvar self in let envs = if top then None else Some env in let ( ( _ , inh_init ) , obj_init ) = build_object_init cl_table obj params ( envs , [ ] ) copy_env cl in let obj_init = if ids = [ ] then obj_init else lfunction [ self , Pgenval ] obj_init in ( inh_init , lfunction [ env , Pgenval ] ( subst_env env inh_init obj_init ) )
|
let bind_method tbl lab id cl_init = Llet ( Strict , Pgenval , id , mkappl ( oo_prim " get_method_label " , [ Lvar tbl ; transl_label lab ] ) , cl_init )
|
let bind_methods tbl meths vals cl_init = let methl = Meths . fold ( fun lab id tl -> ( lab , id ) :: tl ) meths [ ] in let len = List . length methl and nvals = List . length vals in if len < 2 && nvals = 0 then Meths . fold ( bind_method tbl ) meths cl_init else if len = 0 && nvals < 2 then transl_vals tbl true Strict vals cl_init else let ids = Ident . create_local " ids " in let i = ref ( len + nvals ) in let getter , names = if nvals = 0 then " get_method_labels " , [ ] else " new_methods_variables " , [ transl_meth_list ( List . map fst vals ) ] in Llet ( Strict , Pgenval , ids , mkappl ( oo_prim getter , [ Lvar tbl ; transl_meth_list ( List . map fst methl ) ] @ names ) , List . fold_right ( fun ( _lab , id ) lam -> decr i ; Llet ( StrictOpt , Pgenval , id , lfield ids ! i , lam ) ) ( methl @ vals ) cl_init )
|
let output_methods tbl methods lam = match methods with [ ] -> lam | [ lab ; code ] -> lsequence ( mkappl ( oo_prim " set_method " , [ Lvar tbl ; lab ; code ] ) ) lam | _ -> lsequence ( mkappl ( oo_prim " set_methods " , [ Lvar tbl ; Lprim ( Pmakeblock ( 0 , Immutable , None ) , methods , Location . none ) ] ) ) lam
|
let rec ignore_cstrs cl = match cl . cl_desc with Tcl_constraint ( cl , _ , _ , _ , _ ) -> ignore_cstrs cl | Tcl_apply ( cl , _ ) -> ignore_cstrs cl | _ -> cl
|
let rec index a = function [ ] -> raise Not_found | b :: l -> if b = a then 0 else 1 + index a l
|
let bind_id_as_val ( id , _ ) = ( " " , id )
|
let rec build_class_init cla cstr super inh_init cl_init msubst top cl = match cl . cl_desc with | Tcl_ident _ -> begin match inh_init with | ( _ , path_lam , obj_init ) :: inh_init -> ( inh_init , Llet ( Strict , Pgenval , obj_init , mkappl ( Lprim ( Pfield 1 , [ path_lam ] , Location . none ) , Lvar cla :: if top then [ Lprim ( Pfield 3 , [ path_lam ] , Location . none ) ] else [ ] ) , bind_super cla super cl_init ) ) | _ -> assert false end | Tcl_structure str -> let cl_init = bind_super cla super cl_init in let ( inh_init , cl_init , methods , values ) = List . fold_right ( fun field ( inh_init , cl_init , methods , values ) -> match field . cf_desc with Tcf_inherit ( _ , cl , _ , vals , meths ) -> let cl_init = output_methods cla methods cl_init in let inh_init , cl_init = build_class_init cla false ( vals , meths_super cla str . cstr_meths meths ) inh_init cl_init msubst top cl in ( inh_init , cl_init , [ ] , values ) | Tcf_val ( name , _ , id , _ , over ) -> let values = if over then values else ( name . txt , id ) :: values in ( inh_init , cl_init , methods , values ) | Tcf_method ( _ , _ , Tcfk_virtual _ ) | Tcf_constraint _ -> ( inh_init , cl_init , methods , values ) | Tcf_method ( name , _ , Tcfk_concrete ( _ , exp ) ) -> let met_code = msubst true ( transl_exp exp ) in let met_code = if ! Clflags . native_code && List . length met_code = 1 then let met = Ident . create_local ( " method_ " ^ name . txt ) in [ Llet ( Strict , Pgenval , met , List . hd met_code , Lvar met ) ] else met_code in ( inh_init , cl_init , Lvar ( Meths . find name . txt str . cstr_meths ) :: met_code @ methods , values ) | Tcf_initializer exp -> ( inh_init , Lsequence ( mkappl ( oo_prim " add_initializer " , Lvar cla :: msubst false ( transl_exp exp ) ) , cl_init ) , methods , values ) | Tcf_attribute _ -> ( inh_init , cl_init , methods , values ) ) str . cstr_fields ( inh_init , cl_init , [ ] , [ ] ) in let cl_init = output_methods cla methods cl_init in ( inh_init , bind_methods cla str . cstr_meths values cl_init ) | Tcl_fun ( _ , _pat , vals , cl , _ ) -> let ( inh_init , cl_init ) = build_class_init cla cstr super inh_init cl_init msubst top cl in let vals = List . map bind_id_as_val vals in ( inh_init , transl_vals cla true StrictOpt vals cl_init ) | Tcl_apply ( cl , _exprs ) -> build_class_init cla cstr super inh_init cl_init msubst top cl | Tcl_let ( _rec_flag , _defs , vals , cl ) -> let ( inh_init , cl_init ) = build_class_init cla cstr super inh_init cl_init msubst top cl in let vals = List . map bind_id_as_val vals in ( inh_init , transl_vals cla true StrictOpt vals cl_init ) | Tcl_constraint ( cl , _ , vals , meths , concr_meths ) -> let virt_meths = List . filter ( fun lab -> not ( Concr . mem lab concr_meths ) ) meths in let concr_meths = Concr . elements concr_meths in let narrow_args = [ Lvar cla ; transl_meth_list vals ; transl_meth_list virt_meths ; transl_meth_list concr_meths ] in let cl = ignore_cstrs cl in begin match cl . cl_desc , inh_init with | Tcl_ident ( path , _ , _ ) , ( path ' , path_lam , obj_init ) :: inh_init -> assert ( Path . same path path ' ) ; let inh = Ident . create_local " inh " and ofs = List . length vals + 1 and valids , methids = super in let cl_init = List . fold_left ( fun init ( nm , id , _ ) -> Llet ( StrictOpt , Pgenval , id , lfield inh ( index nm concr_meths + ofs ) , init ) ) cl_init methids in let cl_init = List . fold_left ( fun init ( nm , id ) -> Llet ( StrictOpt , Pgenval , id , lfield inh ( index nm vals + 1 ) , init ) ) cl_init valids in ( inh_init , Llet ( Strict , Pgenval , inh , mkappl ( oo_prim " inherits " , narrow_args @ [ path_lam ; Lconst ( Const_pointer ( if top then 1 else 0 ) ) ] ) , Llet ( StrictOpt , Pgenval , obj_init , lfield inh 0 , cl_init ) ) ) | _ -> let core cl_init = build_class_init cla true super inh_init cl_init msubst top cl in if cstr then core cl_init else let ( inh_init , cl_init ) = core ( Lsequence ( mkappl ( oo_prim " widen " , [ Lvar cla ] ) , cl_init ) ) in ( inh_init , Lsequence ( mkappl ( oo_prim " narrow " , narrow_args ) , cl_init ) ) end | Tcl_open ( _ , cl ) -> build_class_init cla cstr super inh_init cl_init msubst top cl
|
let rec build_class_lets cl = match cl . cl_desc with Tcl_let ( rec_flag , defs , _vals , cl ' ) -> let env , wrap = build_class_lets cl ' in ( env , fun x -> Translcore . transl_let rec_flag defs ( wrap x ) ) | _ -> ( cl . cl_env , fun x -> x )
|
let rec get_class_meths cl = match cl . cl_desc with Tcl_structure cl -> Meths . fold ( fun _ -> Ident . Set . add ) cl . cstr_meths Ident . Set . empty | Tcl_ident _ -> Ident . Set . empty | Tcl_fun ( _ , _ , _ , cl , _ ) | Tcl_let ( _ , _ , _ , cl ) | Tcl_apply ( cl , _ ) | Tcl_open ( _ , cl ) | Tcl_constraint ( cl , _ , _ , _ , _ ) -> get_class_meths cl
|
let rec transl_class_rebind obj_init cl vf = match cl . cl_desc with Tcl_ident ( path , _ , _ ) -> if vf = Concrete then begin try if ( Env . find_class path cl . cl_env ) . cty_new = None then raise Exit with Not_found -> raise Exit end ; let path_lam = transl_class_path cl . cl_loc cl . cl_env path in ( path , path_lam , obj_init ) | Tcl_fun ( _ , pat , _ , cl , partial ) -> let path , path_lam , obj_init = transl_class_rebind obj_init cl vf in let build params rem = let param = name_pattern " param " pat in Lfunction { kind = Curried ; params = ( param , Pgenval ) :: params ; return = Pgenval ; attr = default_function_attribute ; loc = pat . pat_loc ; body = Matching . for_function pat . pat_loc None ( Lvar param ) [ pat , rem ] partial } in ( path , path_lam , match obj_init with Lfunction { kind = Curried ; params ; body } -> build params body | rem -> build [ ] rem ) | Tcl_apply ( cl , oexprs ) -> let path , path_lam , obj_init = transl_class_rebind obj_init cl vf in ( path , path_lam , transl_apply obj_init oexprs Location . none ) | Tcl_let ( rec_flag , defs , _vals , cl ) -> let path , path_lam , obj_init = transl_class_rebind obj_init cl vf in ( path , path_lam , Translcore . transl_let rec_flag defs obj_init ) | Tcl_structure _ -> raise Exit | Tcl_constraint ( cl ' , _ , _ , _ , _ ) -> let path , path_lam , obj_init = transl_class_rebind obj_init cl ' vf in let rec check_constraint = function Cty_constr ( path ' , _ , _ ) when Path . same path path ' -> ( ) | Cty_arrow ( _ , _ , cty ) -> check_constraint cty | _ -> raise Exit in check_constraint cl . cl_type ; ( path , path_lam , obj_init ) | Tcl_open ( _ , cl ) -> transl_class_rebind obj_init cl vf
|
let rec transl_class_rebind_0 ( self : Ident . t ) obj_init cl vf = match cl . cl_desc with Tcl_let ( rec_flag , defs , _vals , cl ) -> let path , path_lam , obj_init = transl_class_rebind_0 self obj_init cl vf in ( path , path_lam , Translcore . transl_let rec_flag defs obj_init ) | _ -> let path , path_lam , obj_init = transl_class_rebind obj_init cl vf in ( path , path_lam , lfunction [ self , Pgenval ] obj_init )
|
let transl_class_rebind cl vf = try let obj_init = Ident . create_local " obj_init " and self = Ident . create_local " self " in let obj_init0 = lapply { ap_should_be_tailcall = false ; ap_loc = Location . none ; ap_func = Lvar obj_init ; ap_args [ = Lvar self ] ; ap_inlined = Default_inline ; ap_specialised = Default_specialise } in let _ , path_lam , obj_init ' = transl_class_rebind_0 self obj_init0 cl vf in let id = ( obj_init ' = lfunction [ self , Pgenval ] obj_init0 ) in if id then path_lam else let cla = Ident . create_local " class " and new_init = Ident . create_local " new_init " and env_init = Ident . create_local " env_init " and table = Ident . create_local " table " and envs = Ident . create_local " envs " in Llet ( Strict , Pgenval , new_init , lfunction [ obj_init , Pgenval ] obj_init ' , Llet ( Alias , Pgenval , cla , path_lam , Lprim ( Pmakeblock ( 0 , Immutable , None ) , [ mkappl ( Lvar new_init , [ lfield cla 0 ] ) ; lfunction [ table , Pgenval ] ( Llet ( Strict , Pgenval , env_init , mkappl ( lfield cla 1 , [ Lvar table ] ) , lfunction [ envs , Pgenval ] ( mkappl ( Lvar new_init , [ mkappl ( Lvar env_init , [ Lvar envs ] ) ] ) ) ) ) ; lfield cla 2 ; lfield cla 3 ] , Location . none ) ) ) with Exit -> lambda_unit
|
let rec module_path = function Lvar id -> let s = Ident . name id in s <> " " && s . [ 0 ] >= ' A ' && s . [ 0 ] <= ' Z ' | Lprim ( Pfield _ , [ p ] , _ ) -> module_path p | Lprim ( Pgetglobal _ , [ ] , _ ) -> true | _ -> false
|
let const_path local = function Lvar id -> not ( List . mem id local ) | Lconst _ -> true | Lfunction { kind = Curried ; body } -> let fv = free_variables body in List . for_all ( fun x -> not ( Ident . Set . mem x fv ) ) local | p -> module_path p
|
let rec builtin_meths self env env2 body = let const_path = const_path ( env :: self ) in let conv = function | p when const_path p -> " const " , [ p ] | Lprim ( Parrayrefu _ , [ Lvar s ; Lvar n ] , _ ) when List . mem s self -> " var " , [ Lvar n ] | Lprim ( Pfield n , [ Lvar e ] , _ ) when Ident . same e env -> " env " , [ Lvar env2 ; Lconst ( Const_pointer n ) ] | Lsend ( Self , met , Lvar s , [ ] , _ ) when List . mem s self -> " meth " , [ met ] | _ -> raise Not_found in match body with | Llet ( _str , _k , s ' , Lvar s , body ) when List . mem s self -> builtin_meths ( s ' :: self ) env env2 body | Lapply { ap_func = f ; ap_args = [ arg ] } when const_path f -> let s , args = conv arg in ( " app_ " ^ s , f :: args ) | Lapply { ap_func = f ; ap_args = [ arg ; p ] } when const_path f && const_path p -> let s , args = conv arg in ( " app_ " ^ s " ^ _const " , f :: args @ [ p ] ) | Lapply { ap_func = f ; ap_args = [ p ; arg ] } when const_path f && const_path p -> let s , args = conv arg in ( " app_const_ " ^ s , f :: p :: args ) | Lsend ( Self , Lvar n , Lvar s , [ arg ] , _ ) when List . mem s self -> let s , args = conv arg in ( " meth_app_ " ^ s , Lvar n :: args ) | Lsend ( Self , met , Lvar s , [ ] , _ ) when List . mem s self -> ( " get_meth " , [ met ] ) | Lsend ( Public , met , arg , [ ] , _ ) -> let s , args = conv arg in ( " send_ " ^ s , met :: args ) | Lsend ( Cached , met , arg , [ _ ; _ ] , _ ) -> let s , args = conv arg in ( " send_ " ^ s , met :: args ) | Lfunction { kind = Curried ; params = [ x , _ ] ; body } -> let rec enter self = function | Lprim ( Parraysetu _ , [ Lvar s ; Lvar n ; Lvar x ' ] , _ ) when Ident . same x x ' && List . mem s self -> ( " set_var " , [ Lvar n ] ) | Llet ( _str , _k , s ' , Lvar s , body ) when List . mem s self -> enter ( s ' :: self ) body | _ -> raise Not_found in enter self body | Lfunction _ -> raise Not_found | _ -> let s , args = conv body in ( " get_ " ^ s , args )
|
module M = struct open CamlinternalOO let builtin_meths self env env2 body = let builtin , args = builtin_meths self env env2 body in let tag = match builtin with " get_const " -> GetConst | " get_var " -> GetVar | " get_env " -> GetEnv | " get_meth " -> GetMeth | " set_var " -> SetVar | " app_const " -> AppConst | " app_var " -> AppVar | " app_env " -> AppEnv | " app_meth " -> AppMeth | " app_const_const " -> AppConstConst | " app_const_var " -> AppConstVar | " app_const_env " -> AppConstEnv | " app_const_meth " -> AppConstMeth | " app_var_const " -> AppVarConst | " app_env_const " -> AppEnvConst | " app_meth_const " -> AppMethConst | " meth_app_const " -> MethAppConst | " meth_app_var " -> MethAppVar | " meth_app_env " -> MethAppEnv | " meth_app_meth " -> MethAppMeth | " send_const " -> SendConst | " send_var " -> SendVar | " send_env " -> SendEnv | " send_meth " -> SendMeth | _ -> assert false in Lconst ( Const_pointer ( Obj . magic tag ) ) :: args end
|
let free_methods l = let fv = ref Ident . Set . empty in let rec free l = Lambda . iter_head_constructor free l ; match l with | Lsend ( Self , Lvar meth , _ , _ , _ ) -> fv := Ident . Set . add meth ! fv | Lsend _ -> ( ) | Lfunction { params } -> List . iter ( fun ( param , _ ) -> fv := Ident . Set . remove param ! fv ) params | Llet ( _str , _k , id , _arg , _body ) -> fv := Ident . Set . remove id ! fv | Lletrec ( decl , _body ) -> List . iter ( fun ( id , _exp ) -> fv := Ident . Set . remove id ! fv ) decl | Lstaticcatch ( _e1 , ( _ , vars ) , _e2 ) -> List . iter ( fun ( id , _ ) -> fv := Ident . Set . remove id ! fv ) vars | Ltrywith ( _e1 , exn , _e2 ) -> fv := Ident . Set . remove exn ! fv | Lfor ( v , _e1 , _e2 , _dir , _e3 ) -> fv := Ident . Set . remove v ! fv | Lassign _ | Lvar _ | Lconst _ | Lapply _ | Lprim _ | Lswitch _ | Lstringswitch _ | Lstaticraise _ | Lifthenelse _ | Lsequence _ | Lwhile _ | Levent _ | Lifused _ -> ( ) in free l ; ! fv
|
let transl_class ids cl_id pub_meths cl vflag = let rebind = transl_class_rebind cl vflag in if rebind <> lambda_unit then rebind else let tables = Ident . create_local ( Ident . name cl_id ^ " _tables " ) in let ( top_env , req ) = oo_add_class tables in let top = not req in let cl_env , llets = build_class_lets cl in let new_ids = if top then [ ] else Env . diff top_env cl_env in let env2 = Ident . create_local " env " in let meth_ids = get_class_meths cl in let subst env lam i0 new_ids ' = let fv = free_variables lam in let fv = List . fold_right Ident . Set . remove ! new_ids ' fv in method_ids := Ident . Set . diff ( Ident . Set . union ( free_methods lam ) ! method_ids ) meth_ids ; let new_ids = List . fold_right Ident . Set . add new_ids ! method_ids in let fv = Ident . Set . inter fv new_ids in new_ids ' := ! new_ids ' @ Ident . Set . elements fv ; let i = ref ( i0 - 1 ) in List . fold_left ( fun subst id -> incr i ; Ident . Map . add id ( lfield env ! i ) subst ) Ident . Map . empty ! new_ids ' in let new_ids_meths = ref [ ] in let no_env_update _ _ env = env in let msubst arr = function Lfunction { kind = Curried ; params = ( self , Pgenval ) :: args ; body } -> let env = Ident . create_local " env " in let body ' = if new_ids = [ ] then body else Lambda . subst no_env_update ( subst env body 0 new_ids_meths ) body in begin try if not arr || ! Clflags . debug then raise Not_found ; builtin_meths [ self ] env env2 ( lfunction args body ' ) with Not_found -> [ lfunction ( ( self , Pgenval ) :: args ) ( if not ( Ident . Set . mem env ( free_variables body ' ) ) then body ' else Llet ( Alias , Pgenval , env , Lprim ( Pfield_computed , [ Lvar self ; Lvar env2 ] , Location . none ) , body ' ) ) ] end | _ -> assert false in let new_ids_init = ref [ ] in let env1 = Ident . create_local " env " and env1 ' = Ident . create_local " env ' " in let copy_env self = if top then lambda_unit else Lifused ( env2 , Lprim ( Psetfield_computed ( Pointer , Assignment ) , [ Lvar self ; Lvar env2 ; Lvar env1 ' ] , Location . none ) ) and subst_env envs l lam = if top then lam else let lam = Lambda . subst no_env_update ( subst env1 lam 1 new_ids_init ) lam in Llet ( Alias , Pgenval , env1 , ( if l = [ ] then Lvar envs else lfield envs 0 ) , Llet ( Alias , Pgenval , env1 ' , ( if ! new_ids_init = [ ] then Lvar env1 else lfield env1 0 ) , lam ) ) in let cla = Ident . create_local " class " in let ( inh_init , obj_init ) = build_object_init_0 cla [ ] cl copy_env subst_env top ids in let inh_init ' = List . rev inh_init in let ( inh_init ' , cl_init ) = build_class_init cla true ( [ ] , [ ] ) inh_init ' obj_init msubst top cl in assert ( inh_init ' = [ ] ) ; let table = Ident . create_local " table " and class_init = Ident . create_local ( Ident . name cl_id ^ " _init " ) and env_init = Ident . create_local " env_init " and obj_init = Ident . create_local " obj_init " in let pub_meths = List . sort ( fun s s ' -> compare ( Btype . hash_variant s ) ( Btype . hash_variant s ' ) ) pub_meths in let tags = List . map Btype . hash_variant pub_meths in let rev_map = List . combine tags pub_meths in List . iter2 ( fun tag name -> let name ' = List . assoc tag rev_map in if name ' <> name then raise ( Error ( cl . cl_loc , Tags ( name , name ' ) ) ) ) tags pub_meths ; let ltable table lam = Llet ( Strict , Pgenval , table , mkappl ( oo_prim " create_table " , [ transl_meth_list pub_meths ] ) , lam ) and ldirect obj_init = Llet ( Strict , Pgenval , obj_init , cl_init , Lsequence ( mkappl ( oo_prim " init_class " , [ Lvar cla ] ) , mkappl ( Lvar obj_init , [ lambda_unit ] ) ) ) in if top && ids = [ ] then llets ( ltable cla ( ldirect obj_init ) ) else let concrete = ( vflag = Concrete ) and lclass lam = let cl_init = llets ( Lfunction { kind = Curried ; attr = default_function_attribute ; loc = Location . none ; return = Pgenval ; params = [ cla , Pgenval ] ; body = cl_init } ) in Llet ( Strict , Pgenval , class_init , cl_init , lam ( free_variables cl_init ) ) and lbody fv = if List . for_all ( fun id -> not ( Ident . Set . mem id fv ) ) ids then mkappl ( oo_prim " make_class " , [ transl_meth_list pub_meths ; Lvar class_init ] ) else ltable table ( Llet ( Strict , Pgenval , env_init , mkappl ( Lvar class_init , [ Lvar table ] ) , Lsequence ( mkappl ( oo_prim " init_class " , [ Lvar table ] ) , Lprim ( Pmakeblock ( 0 , Immutable , None ) , [ mkappl ( Lvar env_init , [ lambda_unit ] ) ; Lvar class_init ; Lvar env_init ; lambda_unit ] , Location . none ) ) ) ) and lbody_virt lenvs = Lprim ( Pmakeblock ( 0 , Immutable , None ) , [ lambda_unit ; Lfunction { kind = Curried ; attr = default_function_attribute ; loc = Location . none ; return = Pgenval ; params = [ cla , Pgenval ] ; body = cl_init } ; lambda_unit ; lenvs ] , Location . none ) in if top && concrete then lclass lbody else if top then llets ( lbody_virt lambda_unit ) else let envs = Ident . create_local " envs " and cached = Ident . create_local " cached " in let lenvs = if ! new_ids_meths = [ ] && ! new_ids_init = [ ] && inh_init = [ ] then lambda_unit else Lvar envs in let lenv = let menv = if ! new_ids_meths = [ ] then lambda_unit else Lprim ( Pmakeblock ( 0 , Immutable , None ) , List . map ( fun id -> Lvar id ) ! new_ids_meths , Location . none ) in if ! new_ids_init = [ ] then menv else Lprim ( Pmakeblock ( 0 , Immutable , None ) , menv :: List . map ( fun id -> Lvar id ) ! new_ids_init , Location . none ) and linh_envs = List . map ( fun ( _ , path_lam , _ ) -> Lprim ( Pfield 3 , [ path_lam ] , Location . none ) ) ( List . rev inh_init ) in let make_envs lam = Llet ( StrictOpt , Pgenval , envs , ( if linh_envs = [ ] then lenv else Lprim ( Pmakeblock ( 0 , Immutable , None ) , lenv :: linh_envs , Location . none ) ) , lam ) and def_ids cla lam = Llet ( StrictOpt , Pgenval , env2 , mkappl ( oo_prim " new_variable " , [ Lvar cla ; transl_label " " ] ) , lam ) in let inh_paths = List . filter ( fun ( path , _ , _ ) -> List . mem ( Path . head path ) new_ids ) inh_init in let inh_keys = List . map ( fun ( _ , path_lam , _ ) -> Lprim ( Pfield 1 , [ path_lam ] , Location . none ) ) inh_paths in let lclass lam = Llet ( Strict , Pgenval , class_init , Lfunction { kind = Curried ; params = [ cla , Pgenval ] ; return = Pgenval ; attr = default_function_attribute ; loc = Location . none ; body = def_ids cla cl_init } , lam ) and lcache lam = if inh_keys = [ ] then Llet ( Alias , Pgenval , cached , Lvar tables , lam ) else Llet ( Strict , Pgenval , cached , mkappl ( oo_prim " lookup_tables " , [ Lvar tables ; Lprim ( Pmakeblock ( 0 , Immutable , None ) , inh_keys , Location . none ) ] ) , lam ) and lset cached i lam = Lprim ( Psetfield ( i , Pointer , Assignment ) , [ Lvar cached ; lam ] , Location . none ) in let ldirect ( ) = ltable cla ( Llet ( Strict , Pgenval , env_init , def_ids cla cl_init , Lsequence ( mkappl ( oo_prim " init_class " , [ Lvar cla ] ) , lset cached 0 ( Lvar env_init ) ) ) ) and lclass_virt ( ) = lset cached 0 ( Lfunction { kind = Curried ; attr = default_function_attribute ; loc = Location . none ; return = Pgenval ; params = [ cla , Pgenval ] ; body = def_ids cla cl_init ; } ) in let lupdate_cache = if ids = [ ] then ldirect ( ) else if not concrete then lclass_virt ( ) else lclass ( mkappl ( oo_prim " make_class_store " , [ transl_meth_list pub_meths ; Lvar class_init ; Lvar cached ] ) ) in let lcheck_cache = if ! Clflags . native_code && ! Clflags . afl_instrument then lupdate_cache else Lifthenelse ( lfield cached 0 , lambda_unit , lupdate_cache ) in llets ( lcache ( Lsequence ( lcheck_cache , make_envs ( if ids = [ ] then mkappl ( lfield cached 0 , [ lenvs ] ) else Lprim ( Pmakeblock ( 0 , Immutable , None ) , ( if concrete then [ mkappl ( lfield cached 0 , [ lenvs ] ) ; lfield cached 1 ; lfield cached 0 ; lenvs ] else [ lambda_unit ; lfield cached 0 ; lambda_unit ; lenvs ] ) , Location . none ) ) ) ) ) let _arity = List . length ci . ci_params in let pub_meths = m in let cl = ci . ci_expr in let vflag = vf in ) *
|
let transl_class ids id pub_meths cl vf = oo_wrap cl . cl_env false ( transl_class ids id pub_meths cl ) vf
|
let ( ) = transl_object := ( fun id meths cl -> transl_class [ ] id meths cl Concrete )
|
let report_error ppf = function | Tags ( lab1 , lab2 ) -> fprintf ppf " Method labels ` % s ' and ` % s ' are incompatible . @ % s " lab1 lab2 " Change one of them . "
|
let ( ) = Location . register_error_of_exn ( function | Error ( loc , err ) -> Some ( Location . error_of_printer ~ loc report_error err ) | _ -> None )
|
let int n = Lconst ( Const_base ( Const_int n ) )
|
type binding = { let_kind : let_kind ; value_kind : value_kind ; var : Ident . t ; init : lambda }
|
let binding let_kind value_kind var init = { let_kind ; value_kind ; var ; init }
|
let gen_binding { let_kind ; value_kind ; var ; init } body = Llet ( let_kind , value_kind , var , init , body )
|
let gen_bindings bindings body = List . fold_right gen_binding bindings body
|
let valuekind_of_arraykind = function | Pgenarray -> Pgenval | Paddrarray | Pintarray -> Pintval | Pfloatarray -> Pfloatval
|
let transl_arr_clause ~ transl_exp ~ scopes ~ loc clause body = let len_var = Ident . create_local " len_var " in let bindings , for_ = match clause with | In ( pat , e2 ) -> let in_var = Ident . create_local " in_var " in let in_kind = Typeopt . array_kind e2 in let in_binding = binding Strict Pgenval in_var ( transl_exp ~ scopes e2 ) in let len_binding = let init = Lprim ( ( Parraylength ( in_kind ) ) , [ Lvar ( in_var ) ] , loc ) in binding Alias Pintval len_var init in let index = Ident . create_local " index " in let for_ = Lfor ( index , ( int 0 ) , Lprim ( Psubint , [ Lvar ( len_var ) ; int 1 ] , loc ) , Upto , Matching . for_let ~ scopes pat . pat_loc ( Lprim ( Parrayrefu ( in_kind ) , [ Lvar ( in_var ) ; Lvar ( index ) ] , loc ) ) pat ( valuekind_of_arraykind in_kind ) body ) in [ in_binding ; len_binding ] , for_ | From_to ( id , _ , e2 , e3 , dir ) -> let from_var = Ident . create_local " from " in let from_binding = binding Strict Pintval from_var ( transl_exp ~ scopes e2 ) in let to_var = Ident . create_local " to " in let to_binding = binding Strict Pintval to_var ( transl_exp ~ scopes e3 ) in let low , high = match dir with | Upto -> Lvar from_var , Lvar to_var | Downto -> Lvar to_var , Lvar from_var in let len_binding = let init = Lprim ( Psubint , [ Lprim ( Paddint , [ high ; int 1 ] , loc ) ; low ] , loc ) in binding Alias Pintval len_var init in let for_ = Lfor ( id , Lvar from_var , Lvar to_var , dir , body ) in [ from_binding ; to_binding ; len_binding ] , for_ in bindings , len_var , for_
|
let iterate_arr_block ~ transl_exp ~ loc ~ scopes { clauses ; guard } length_var body = let body = match guard with | None -> body | Some guard -> Lifthenelse ( transl_exp ~ scopes guard , body , lambda_unit , Pintval ) in let body , length_opt , bindings = List . fold_left ( fun ( body , length , bindings ) clause -> let new_bindings , new_length_var , body = transl_arr_clause ~ transl_exp ~ scopes ~ loc clause body in let rev_bindings = new_bindings @ bindings in let length = match length with | None -> Lvar new_length_var | Some length -> Lprim ( Pmulint , [ Lvar new_length_var ; length ] , loc ) in body , Some length , rev_bindings ) ( body , None , [ ] ) clauses in let length = Option . value length_opt ~ default ( : int 0 ) in let length_binding = binding Alias Pintval length_var length in let bindings = List . append bindings [ length_binding ] in bindings , body
|
let make_array_prim ~ loc size init = let prim = Primitive . simple ~ name " : caml_make_vect " ~ arity : 2 ~ alloc : true in Lprim ( Pccall prim , [ size ; init ] , loc )
|
let make_floatarray_prim ~ loc size = let prim = Primitive . simple ~ name " : caml_make_float_vect " ~ arity : 1 ~ alloc : true in Lprim ( Pccall prim , [ size ] , loc )
|
let blit_array_prim ~ loc src src_pos dst dst_pos len = let prim_blit_arr = Primitive . simple ~ name " : caml_array_blit " ~ arity : 5 ~ alloc : true in Lprim ( Pccall prim_blit_arr , [ src ; src_pos ; dst ; dst_pos ; len ] , loc )
|
let make_array ~ loc ~ kind ~ size ~ array = match kind with | Pgenarray -> let init = Lprim ( Pmakearray ( Pgenarray , Immutable , alloc_heap ) , [ ] , loc ) in binding Variable Pgenval array init | Pintarray | Paddrarray -> let init = make_array_prim ~ loc size ( int 0 ) in binding Strict Pgenval array init | Pfloatarray -> let init = make_floatarray_prim ~ loc size in binding Strict Pgenval array init
|
let init_array_elem ~ loc ~ kind ~ size ~ array ~ index ~ value = let set_elem = Lprim ( Parraysetu kind , [ Lvar array ; Lvar index ; Lvar value ] , loc ) in match kind with | Pgenarray -> let is_first_iteration = Lprim ( Pintcomp Ceq , [ Lvar index ; int 0 ] , loc ) in let make_array = Lassign ( array , make_array_prim ~ loc size ( Lvar value ) ) in Lifthenelse ( is_first_iteration , make_array , set_elem , Pintval ) | Pintarray | Paddrarray | Pfloatarray -> set_elem
|
let init_array_elems ~ loc ~ kind ~ size ~ array ~ index ~ src ~ len = let blit = blit_array_prim ~ loc ( Lvar src ) ( int 0 ) ( Lvar array ) ( Lvar index ) ( Lvar len ) in match kind with | Pgenarray -> let is_first_iteration = Lprim ( Pintcomp Ceq , [ Lvar index ; int 0 ] , loc ) in let is_not_empty = Lprim ( Pintcomp ( Cne ) , [ Lvar len ; int 0 ] , loc ) in let first_elem = Lprim ( Parrayrefu kind , [ Lvar src ; int 0 ] , loc ) in let make_array = Lassign ( array , make_array_prim ~ loc size first_elem ) in Lsequence ( Lifthenelse ( is_first_iteration , Lifthenelse ( is_not_empty , make_array , lambda_unit , Pintval ) , lambda_unit , Pintval ) , blit ) | Pintarray | Paddrarray | Pfloatarray -> blit
|
let make_counter counter = binding Variable Pintval counter ( int 0 )
|
let increment_counter ~ loc counter step = Lassign ( counter , Lprim ( Paddint , [ Lvar counter ; step ] , loc ) )
|
type block_lambda = | Without_size of { body : lambda } | With_size of { body : lambda ; raise_count : int }
|
let transl_arr_block ~ transl_exp ~ loc ~ scopes global_counter body array_kind value_kind block = let length_var = Ident . create_local " len " in let size = match body with | Without_size _ -> Lvar length_var | With_size _ -> Lprim ( Pmulint , [ Lvar length_var ; int 2 ] , loc ) in let result_array_var = Ident . create_local " arr " in let result_array_binding = make_array ~ loc ~ kind : array_kind ~ size ~ array : result_array_var in let counter_var = Ident . create_local " counter " in let counter_binding = make_counter counter_var in let elem_var = Ident . create_local " elem " in let init_elem = init_array_elem ~ loc ~ kind : array_kind ~ size ~ array : result_array_var ~ index : counter_var ~ value : elem_var in let set_result = match body with | Without_size { body } -> Llet ( Strict , value_kind , elem_var , body , Lsequence ( init_elem , increment_counter ~ loc counter_var ( int 1 ) ) ) | With_size { body ; raise_count } -> let elem_len_var = Ident . create_local " len " in let set_len = Lprim ( Parraysetu Paddrarray , [ Lvar result_array_var ; Lprim ( Paddint , [ Lvar counter_var ; int 1 ] , loc ) ; Lvar elem_len_var ] , loc ) in Lstaticcatch ( body , ( raise_count , [ ( elem_var , Pgenval ) ; ( elem_len_var , Pintval ) ] ) , Lsequence ( init_elem , Lsequence ( set_len , increment_counter ~ loc counter_var ( int 2 ) ) ) , Pintval ) in let bindings , loops = iterate_arr_block ~ transl_exp ~ loc ~ scopes block length_var set_result in let bindings = bindings @ [ result_array_binding ; counter_binding ] in let body = match global_counter with | None -> loops | Some global_counter_var -> let len = match body with | Without_size _ -> Lvar counter_var | With_size _ -> Lprim ( Pdivint Unsafe , [ Lvar counter_var ; int 2 ] , loc ) in Lsequence ( loops , increment_counter ~ loc global_counter_var len ) in match block . guard with | None -> let body = gen_bindings bindings ( Lsequence ( body , Lvar result_array_var ) ) in Without_size { body } | Some _ -> let raise_count = next_raise_count ( ) in let return = Lstaticraise ( raise_count , [ Lvar result_array_var ; Lvar counter_var ] ) in let body = gen_bindings bindings ( Lsequence ( body , return ) ) in With_size { body ; raise_count }
|
let sub_array ~ loc src src_pos len = let prim = Primitive . simple ~ name " : caml_array_sub " ~ arity : 3 ~ alloc : true in Lprim ( Pccall prim , [ src ; src_pos ; len ] , loc )
|
let transl_single_arr_block ~ transl_exp ~ loc ~ scopes block body array_kind value_kind = let body = transl_arr_block ~ transl_exp ~ loc ~ scopes None ( Without_size { body } ) array_kind value_kind block in match body with | Without_size { body } -> body | With_size { body ; raise_count } -> let array_var = Ident . create_local " array " in let len_var = Ident . create_local " len " in Lstaticcatch ( body , ( raise_count , [ ( array_var , Pgenval ) ; ( len_var , Pintval ) ] ) , sub_array ~ loc ( Lvar array_var ) ( int 0 ) ( Lvar len_var ) , Pintval )
|
type intermediate_array_shape = | Array_of_elements | Array_of_arrays of intermediate_array_shape | Array_of_filtered_arrays of intermediate_array_shape
|
let concat_arrays ~ loc arr kind shape global_count_var = let res_var = Ident . create_local " res " in let res_binding = make_array ~ loc ~ kind ~ size ( : Lvar global_count_var ) ~ array : res_var in let counter_var = Ident . create_local " counter " in let counter_binding = make_counter counter_var in let rec loop shape arr_var len_var = let kind = match shape with | Array_of_elements -> kind | Array_of_arrays _ | Array_of_filtered_arrays _ -> Paddrarray in let len_var , bindings = match len_var with | Some var -> var , [ ] | None -> let var = Ident . create_local " len " in let init = Lprim ( ( Parraylength kind ) , [ Lvar ( arr_var ) ] , loc ) in let binding = binding Alias Pintval var init in var , [ binding ] in match shape with | Array_of_elements -> gen_bindings bindings ( Lsequence ( init_array_elems ~ loc ~ kind ~ size ( : Lvar global_count_var ) ~ array : res_var ~ index : counter_var ~ src : arr_var ~ len : len_var , increment_counter ~ loc counter_var ( Lvar len_var ) ) ) | Array_of_arrays shape -> let index_var = Ident . create_local " index " in let sub_arr_var = Ident . create_local " arr " in let last_index = Lprim ( Psubint , [ Lvar len_var ; int 1 ] , loc ) in let sub_arr = Lprim ( Parrayrefu kind , [ Lvar arr_var ; Lvar index_var ] , loc ) in gen_bindings bindings ( Lfor ( index_var , int 0 , last_index , Upto , Llet ( Strict , Pgenval , sub_arr_var , sub_arr , loop shape sub_arr_var None ) ) ) | Array_of_filtered_arrays shape -> let index_var = Ident . create_local " index " in let index_binding = make_counter index_var in let sub_arr_var = Ident . create_local " arr " in let sub_arr = Lprim ( Parrayrefu kind , [ Lvar arr_var ; Lvar index_var ] , loc ) in let sub_arr_len_var = Ident . create_local " len " in let sub_arr_len = Lprim ( Parrayrefu kind , [ Lvar arr_var ; Lprim ( Paddint , [ Lvar index_var ; int 1 ] , loc ) ] , loc ) in gen_bindings bindings ( gen_binding index_binding ( Lwhile ( Lprim ( Pintcomp Clt , [ Lvar index_var ; Lvar len_var ] , loc ) , Lsequence ( Llet ( Strict , Pgenval , sub_arr_var , sub_arr , Llet ( Strict , Pintval , sub_arr_len_var , sub_arr_len , loop shape sub_arr_var ( Some sub_arr_len_var ) ) ) , increment_counter ~ loc index_var ( int 2 ) ) ) ) ) in match arr with | Without_size { body } -> let array_var = Ident . create_local " array " in Llet ( Strict , Pgenval , array_var , body , gen_binding res_binding ( gen_binding counter_binding ( Lsequence ( loop shape array_var None , Lvar res_var ) ) ) ) | With_size { body ; raise_count } -> let array_var = Ident . create_local " array " in let len_var = Ident . create_local " len " in Lstaticcatch ( body , ( raise_count , [ ( array_var , Pgenval ) ; ( len_var , Pintval ) ] ) , gen_binding res_binding ( gen_binding counter_binding ( ( Lsequence ( loop shape array_var ( Some len_var ) , Lvar res_var ) ) ) ) , Pgenval )
|
let transl_arr_comprehension ~ transl_exp ~ loc ~ scopes ~ array_kind exp blocks = let body = transl_exp ~ scopes exp in let value_kind = Typeopt . value_kind exp . exp_env exp . exp_type in match blocks with | [ ] -> assert false | [ block ] -> transl_single_arr_block ~ transl_exp ~ loc ~ scopes block body array_kind value_kind | inner_block :: rest -> let counter_var = Ident . create_local " counter " in let counter_binding = make_counter counter_var in let body = transl_arr_block ~ transl_exp ~ loc ~ scopes ( Some counter_var ) ( Without_size { body } ) array_kind value_kind inner_block in let shape , body = List . fold_left ( fun ( shape , body ) block -> let shape = match body with | Without_size _ -> Array_of_arrays shape | With_size _ -> Array_of_filtered_arrays shape in let body = transl_arr_block ~ transl_exp ~ loc ~ scopes None body Paddrarray Pgenval block in shape , body ) ( Array_of_elements , body ) rest in gen_binding counter_binding ( concat_arrays ~ loc body array_kind shape counter_var )
|
let from_to_comp_prim ~ dir = let function_name = match dir with | Upto -> " map_from_to_cons " | Downto -> " map_from_downto_cons " in Lambda . transl_prim " CamlinternalComprehension " function_name
|
let in_comp_prim ( ) = Lambda . transl_prim " CamlinternalComprehension " " map_cons "
|
let comp_rev ( ) = Lambda . transl_prim " CamlinternalComprehension " " rev "
|
let transl_list_comp type_comp body acc_var mats ~ transl_exp ~ scopes ~ loc = let new_acc = Ident . create_local " acc " in let param , pval , args , func , body , mats = match type_comp with | From_to ( param , _ , e2 , e3 , dir ) -> let pval = Pintval in let from_var = Ident . create_local " from " in let to_var = Ident . create_local " to_ " in let args = [ Lvar ( from_var ) ; Lvar ( to_var ) ; Lvar ( new_acc ) ] in let func = from_to_comp_prim ~ dir in let mats = ( from_var , transl_exp ~ scopes e2 ) ( :: to_var , transl_exp ~ scopes e3 ) :: mats in param , pval , args , func , body , mats | In ( pat , in_ ) -> let pat_id = Ident . create_local " pat " in let pval = Typeopt . value_kind pat . pat_env pat . pat_type in let in_var = Ident . create_local " in_var " in let args = [ Lvar ( in_var ) ; Lvar ( new_acc ) ] in let func = in_comp_prim ( ) in let body = Matching . for_let ~ scopes pat . pat_loc ( Lvar ( pat_id ) ) pat pval body in let mats = ( in_var , transl_exp ~ scopes in_ ) :: mats in pat_id , pval , args , func , body , mats in let fn = Lfunction { kind = Curried { nlocal = 0 } ; params = [ param , pval ; acc_var , Pgenval ] ; return = Pgenval ; attr = default_function_attribute ; loc = loc ; body = body ; mode = alloc_heap ; region = true } in Lapply { ap_loc = loc ; ap_region_close = Rc_normal ; ap_mode = alloc_heap ; ap_func = func ; ap_args = fn :: args ; ap_tailcall = Default_tailcall ; ap_inlined = Default_inlined ; ap_specialised = Default_specialise ; ap_probe = None ; } , new_acc , mats
|
let transl_list_comprehension ~ transl_exp ~ loc ~ scopes body blocks = let acc_var = Ident . create_local " acc " in let value_kind = Typeopt . value_kind body . exp_env body . exp_type in let bdy = Lprim ( Pmakeblock ( 0 , Immutable , None , alloc_heap ) , [ ( transl_exp ~ scopes body ) ; Lvar ( acc_var ) ] , loc ) in let res_list , res_var = List . fold_left ( fun ( body , acc_var ) block -> let body = match block . guard with | None -> body | Some guard -> Lifthenelse ( ( transl_exp ~ scopes guard ) , body , Lvar ( acc_var ) , value_kind ) in let body , acc_var , materialize = List . fold_left ( fun ( body , acc_var , mats ) el -> transl_list_comp ~ transl_exp ~ scopes ~ loc el body acc_var mats ) ( body , acc_var , [ ] ) block . clauses in let body = List . fold_right ( fun ( id , arr ) body -> Llet ( Strict , Pgenval , id , arr , body ) ) materialize body in body , acc_var ) ( bdy , acc_var ) blocks in Llet ( Alias , Pintval , res_var , int 0 , Lapply { ap_loc = loc ; ap_func = comp_rev ( ) ; ap_args [ = res_list ] ; ap_region_close = Rc_normal ; ap_mode = alloc_heap ; ap_tailcall = Default_tailcall ; ap_inlined = Default_inlined ; ap_specialised = Default_specialise ; ap_probe = None ; } )
|
type error = Free_super_var | Unreachable_reached
|
let transl_module = ref ( ( fun _cc _rootpath _modl -> assert false ) : module_coercion -> Path . t option -> module_expr -> lambda )
|
let transl_object = ref ( fun _id _s _cl -> assert false : Ident . t -> string list -> class_expr -> lambda )
|
let prim_fresh_oo_id = Pccall ( Primitive . simple ~ name " : caml_fresh_oo_id " ~ arity : 1 ~ alloc : false )
|
let transl_extension_constructor env path ext = let path = Printtyp . wrap_printing_env env ~ error : true ( fun ( ) -> Option . map ( Printtyp . rewrite_double_underscore_paths env ) path ) in let name = match path , ! Clflags . for_package with None , _ -> Ident . name ext . ext_id | Some p , None -> Path . name p | Some p , Some pack -> Printf . sprintf " % s . % s " pack ( Path . name p ) in let loc = ext . ext_loc in match ext . ext_kind with Text_decl _ -> Lprim ( Pmakeblock ( Obj . object_tag , Immutable , None ) , [ Lconst ( Const_base ( Const_string ( name , None ) ) ) ; Lprim ( prim_fresh_oo_id , [ Lconst ( Const_base ( Const_int 0 ) ) ] , loc ) ] , loc ) | Text_rebind ( path , _lid ) -> transl_extension_path loc env path
|
let extract_constant = function Lconst sc -> sc | _ -> raise Not_constant
|
let extract_float = function Const_base ( Const_float f ) -> f | _ -> fatal_error " Translcore . extract_float "
|
type binding = | Bind_value of value_binding list | Bind_module of Ident . t * string option loc * module_presence * module_expr
|
let rec push_defaults loc bindings cases partial = match cases with [ { c_lhs = pat ; c_guard = None ; c_rhs { = exp_desc = Texp_function { arg_label ; param ; cases ; partial ; } } as exp } ] -> let cases = push_defaults exp . exp_loc bindings cases partial in [ { c_lhs = pat ; c_guard = None ; c_rhs { = exp with exp_desc = Texp_function { arg_label ; param ; cases ; partial ; } } } ] | [ { c_lhs = pat ; c_guard = None ; c_rhs { = exp_attributes [ { = Parsetree . attr_name = { txt " =# default " } ; _ } ] ; exp_desc = Texp_let ( Nonrecursive , binds , ( { exp_desc = Texp_function _ } as e2 ) ) } } ] -> push_defaults loc ( Bind_value binds :: bindings ) [ { c_lhs = pat ; c_guard = None ; c_rhs = e2 } ] partial | [ { c_lhs = pat ; c_guard = None ; c_rhs { = exp_attributes [ { = Parsetree . attr_name = { txt " =# modulepat " } ; _ } ] ; exp_desc = Texp_letmodule ( Some id , name , pres , mexpr , ( { exp_desc = Texp_function _ } as e2 ) ) } } ] -> push_defaults loc ( Bind_module ( id , name , pres , mexpr ) :: bindings ) [ { c_lhs = pat ; c_guard = None ; c_rhs = e2 } ] partial | [ case ] -> let exp = List . fold_left ( fun exp binds -> { exp with exp_desc = match binds with | Bind_value binds -> Texp_let ( Nonrecursive , binds , exp ) | Bind_module ( id , name , pres , mexpr ) -> Texp_letmodule ( Some id , name , pres , mexpr , exp ) } ) case . c_rhs bindings in [ { case with c_rhs = exp } ] | { c_lhs = pat ; c_rhs = exp ; c_guard = _ } :: _ when bindings <> [ ] -> let param = Typecore . name_cases " param " cases in let desc = { val_type = pat . pat_type ; val_kind = Val_reg ; val_attributes = [ ] ; Types . val_loc = Location . none ; } in let env = Env . add_value param desc exp . exp_env in let name = Ident . name param in let exp = { exp with exp_loc = loc ; exp_env = env ; exp_desc = Texp_match ( { exp with exp_type = pat . pat_type ; exp_env = env ; exp_desc = Texp_ident ( Path . Pident param , mknoloc ( Longident . Lident name ) , desc ) } , cases , partial ) } in push_defaults loc bindings [ { c_lhs { = pat with pat_desc = Tpat_var ( param , mknoloc name ) } ; c_guard = None ; c_rhs = exp } ] Total | _ -> cases
|
let event_function exp lam = if ! Clflags . debug && not ! Clflags . native_code then let repr = Some ( ref 0 ) in let ( info , body ) = lam repr in ( info , Levent ( body , { lev_loc = exp . exp_loc ; lev_kind = Lev_function ; lev_repr = repr ; lev_env = exp . exp_env } ) ) else lam None
|
let assert_failed exp = let slot = transl_extension_path Location . none Env . initial_safe_string Predef . path_assert_failure in let ( fname , line , char ) = Location . get_pos_info exp . exp_loc . Location . loc_start in Lprim ( Praise Raise_regular , [ event_after exp ( Lprim ( Pmakeblock ( 0 , Immutable , None ) , [ slot ; Lconst ( Const_block ( 0 , [ Const_base ( Const_string ( fname , None ) ) ; Const_base ( Const_int line ) ; Const_base ( Const_int char ) ] ) ) ] , exp . exp_loc ) ) ] , exp . exp_loc ) ; ;
|
let rec cut n l = if n = 0 then ( [ ] , l ) else match l with [ ] -> failwith " Translcore . cut " | a :: l -> let ( l1 , l2 ) = cut ( n - 1 ) l in ( a :: l1 , l2 )
|
let rec iter_exn_names f pat = match pat . pat_desc with | Tpat_var ( id , _ ) -> f id | Tpat_alias ( p , id , _ ) -> f id ; iter_exn_names f p | _ -> ( )
|
let transl_ident loc env ty path desc = match desc . val_kind with | Val_prim p -> Translprim . transl_primitive loc p env ty ( Some path ) | Val_anc _ -> raise ( Error ( loc , Free_super_var ) ) | Val_reg | Val_self _ -> transl_value_path loc env path | _ -> fatal_error " Translcore . transl_exp : bad Texp_ident "
|
let rec transl_exp e = List . iter ( Translattribute . check_attribute e ) e . exp_attributes ; let eval_once = match e . exp_desc with Texp_function _ | Texp_for _ | Texp_while _ -> false | _ -> true in if eval_once then transl_exp0 e else Translobj . oo_wrap e . exp_env true transl_exp0 e match e . exp_desc with | Texp_ident ( path , _ , desc ) -> transl_ident e . exp_loc e . exp_env e . exp_type path desc | Texp_constant cst -> Lconst ( Const_base cst ) | Texp_let ( rec_flag , pat_expr_list , body ) -> transl_let rec_flag pat_expr_list ( event_before body ( transl_exp body ) ) | Texp_function { arg_label = _ ; param ; cases ; partial ; } -> let ( ( kind , params , return ) , body ) = event_function e ( function repr -> let pl = push_defaults e . exp_loc [ ] cases partial in let return_kind = function_return_value_kind e . exp_env e . exp_type in transl_function e . exp_loc return_kind ! Clflags . native_code repr partial param pl ) in let attr = default_function_attribute in let loc = e . exp_loc in let lam = Lfunction { kind ; params ; return ; body ; attr ; loc } in Translattribute . add_function_attributes lam loc e . exp_attributes | Texp_apply ( { exp_desc = Texp_ident ( path , _ , { val_kind = Val_prim p } ) ; exp_type = prim_type } as funct , oargs ) when List . length oargs >= p . prim_arity && List . for_all ( fun ( _ , arg ) -> arg <> None ) oargs -> let argl , extra_args = cut p . prim_arity oargs in let arg_exps = List . map ( function _ , Some x -> x | _ -> assert false ) argl in let args = transl_list arg_exps in let prim_exp = if extra_args = [ ] then Some e else None in let lam = Translprim . transl_primitive_application e . exp_loc p e . exp_env prim_type path prim_exp args arg_exps in if extra_args = [ ] then lam else begin let should_be_tailcall , funct = Translattribute . get_tailcall_attribute funct in let inlined , funct = Translattribute . get_and_remove_inlined_attribute funct in let specialised , funct = Translattribute . get_and_remove_specialised_attribute funct in let e = { e with exp_desc = Texp_apply ( funct , oargs ) } in event_after e ( transl_apply ~ should_be_tailcall ~ inlined ~ specialised lam extra_args e . exp_loc ) end | Texp_apply ( funct , oargs ) -> let should_be_tailcall , funct = Translattribute . get_tailcall_attribute funct in let inlined , funct = Translattribute . get_and_remove_inlined_attribute funct in let specialised , funct = Translattribute . get_and_remove_specialised_attribute funct in let e = { e with exp_desc = Texp_apply ( funct , oargs ) } in event_after e ( transl_apply ~ should_be_tailcall ~ inlined ~ specialised ( transl_exp funct ) oargs e . exp_loc ) | Texp_match ( arg , pat_expr_list , partial ) -> transl_match e arg pat_expr_list partial | Texp_try ( body , pat_expr_list ) -> let id = Typecore . name_cases " exn " pat_expr_list in Ltrywith ( transl_exp body , id , Matching . for_trywith ( Lvar id ) ( transl_cases_try pat_expr_list ) ) | Texp_tuple el -> let ll , shape = transl_list_with_shape el in begin try Lconst ( Const_block ( 0 , List . map extract_constant ll ) ) with Not_constant -> Lprim ( Pmakeblock ( 0 , Immutable , Some shape ) , ll , e . exp_loc ) end | Texp_construct ( _ , cstr , args ) -> let ll , shape = transl_list_with_shape args in if cstr . cstr_inlined <> None then begin match ll with | [ x ] -> x | _ -> assert false end else begin match cstr . cstr_tag with Cstr_constant n -> Lconst ( Const_pointer n ) | Cstr_unboxed -> ( match ll with [ v ] -> v | _ -> assert false ) | Cstr_block n -> begin try Lconst ( Const_block ( n , List . map extract_constant ll ) ) with Not_constant -> Lprim ( Pmakeblock ( n , Immutable , Some shape ) , ll , e . exp_loc ) end | Cstr_extension ( path , is_const ) -> let lam = transl_extension_path e . exp_loc e . exp_env path in if is_const then lam else Lprim ( Pmakeblock ( 0 , Immutable , Some ( Pgenval :: shape ) ) , lam :: ll , e . exp_loc ) end | Texp_extension_constructor ( _ , path ) -> transl_extension_path e . exp_loc e . exp_env path | Texp_variant ( l , arg ) -> let tag = Btype . hash_variant l in begin match arg with None -> Lconst ( Const_pointer tag ) | Some arg -> let lam = transl_exp arg in try Lconst ( Const_block ( 0 , [ Const_base ( Const_int tag ) ; extract_constant lam ] ) ) with Not_constant -> Lprim ( Pmakeblock ( 0 , Immutable , None ) , [ Lconst ( Const_base ( Const_int tag ) ) ; lam ] , e . exp_loc ) end | Texp_record { fields ; representation ; extended_expression } -> transl_record e . exp_loc e . exp_env fields representation extended_expression | Texp_field ( arg , _ , lbl ) -> let targ = transl_exp arg in begin match lbl . lbl_repres with Record_regular | Record_inlined _ -> Lprim ( Pfield lbl . lbl_pos , [ targ ] , e . exp_loc ) | Record_unboxed _ -> targ | Record_float -> Lprim ( Pfloatfield lbl . lbl_pos , [ targ ] , e . exp_loc ) | Record_extension _ -> Lprim ( Pfield ( lbl . lbl_pos + 1 ) , [ targ ] , e . exp_loc ) end | Texp_setfield ( arg , _ , lbl , newval ) -> let access = match lbl . lbl_repres with Record_regular | Record_inlined _ -> Psetfield ( lbl . lbl_pos , maybe_pointer newval , Assignment ) | Record_unboxed _ -> assert false | Record_float -> Psetfloatfield ( lbl . lbl_pos , Assignment ) | Record_extension _ -> Psetfield ( lbl . lbl_pos + 1 , maybe_pointer newval , Assignment ) in Lprim ( access , [ transl_exp arg ; transl_exp newval ] , e . exp_loc ) | Texp_array expr_list -> let kind = array_kind e in let ll = transl_list expr_list in begin try if List . length ll <= use_dup_for_constant_arrays_bigger_than then begin raise Not_constant end ; begin match List . map extract_constant ll with | exception Not_constant when kind = Pfloatarray -> let imm_array = Lprim ( Pmakearray ( kind , Immutable ) , ll , e . exp_loc ) in Lprim ( Pduparray ( kind , Mutable ) , [ imm_array ] , e . exp_loc ) | cl -> let imm_array = match kind with | Paddrarray | Pintarray -> Lconst ( Const_block ( 0 , cl ) ) | Pfloatarray -> Lconst ( Const_float_array ( List . map extract_float cl ) ) | Pgenarray -> raise Not_constant in Lprim ( Pduparray ( kind , Mutable ) , [ imm_array ] , e . exp_loc ) end with Not_constant -> Lprim ( Pmakearray ( kind , Mutable ) , ll , e . exp_loc ) end | Texp_ifthenelse ( cond , ifso , Some ifnot ) -> Lifthenelse ( transl_exp cond , event_before ifso ( transl_exp ifso ) , event_before ifnot ( transl_exp ifnot ) ) | Texp_ifthenelse ( cond , ifso , None ) -> Lifthenelse ( transl_exp cond , event_before ifso ( transl_exp ifso ) , lambda_unit ) | Texp_sequence ( expr1 , expr2 ) -> Lsequence ( transl_exp expr1 , event_before expr2 ( transl_exp expr2 ) ) | Texp_while ( cond , body ) -> Lwhile ( transl_exp cond , event_before body ( transl_exp body ) ) | Texp_for ( param , _ , low , high , dir , body ) -> Lfor ( param , transl_exp low , transl_exp high , dir , event_before body ( transl_exp body ) ) | Texp_send ( _ , _ , Some exp ) -> transl_exp exp | Texp_send ( expr , met , None ) -> let obj = transl_exp expr in let lam = match met with Tmeth_val id -> Lsend ( Self , Lvar id , obj , [ ] , e . exp_loc ) | Tmeth_name nm -> let ( tag , cache ) = Translobj . meth obj nm in let kind = if cache = [ ] then Public else Cached in Lsend ( kind , tag , obj , cache , e . exp_loc ) in event_after e lam | Texp_new ( cl , { Location . loc = loc } , _ ) -> Lapply { ap_should_be_tailcall = false ; ap_loc = loc ; ap_func = Lprim ( Pfield 0 , [ transl_class_path loc e . exp_env cl ] , loc ) ; ap_args [ = lambda_unit ] ; ap_inlined = Default_inline ; ap_specialised = Default_specialise } | Texp_instvar ( path_self , path , _ ) -> let self = transl_value_path e . exp_loc e . exp_env path_self in let var = transl_value_path e . exp_loc e . exp_env path in Lprim ( Pfield_computed , [ self ; var ] , e . exp_loc ) | Texp_setinstvar ( path_self , path , _ , expr ) -> let self = transl_value_path e . exp_loc e . exp_env path_self in let var = transl_value_path e . exp_loc e . exp_env path in transl_setinstvar e . exp_loc self var expr | Texp_override ( path_self , modifs ) -> let self = transl_value_path e . exp_loc e . exp_env path_self in let cpy = Ident . create_local " copy " in Llet ( Strict , Pgenval , cpy , Lapply { ap_should_be_tailcall = false ; ap_loc = Location . none ; ap_func = Translobj . oo_prim " copy " ; ap_args [ = self ] ; ap_inlined = Default_inline ; ap_specialised = Default_specialise } , List . fold_right ( fun ( path , _ , expr ) rem -> let var = transl_value_path e . exp_loc e . exp_env path in Lsequence ( transl_setinstvar Location . none ( Lvar cpy ) var expr , rem ) ) modifs ( Lvar cpy ) ) | Texp_letmodule ( None , loc , Mp_present , modl , body ) -> let lam = ! transl_module Tcoerce_none None modl in Lsequence ( Lprim ( Pignore , [ lam ] , loc . loc ) , transl_exp body ) | Texp_letmodule ( Some id , loc , Mp_present , modl , body ) -> let defining_expr = Levent ( ! transl_module Tcoerce_none None modl , { lev_loc = loc . loc ; lev_kind = Lev_module_definition id ; lev_repr = None ; lev_env = Env . empty ; } ) in Llet ( Strict , Pgenval , id , defining_expr , transl_exp body ) | Texp_letmodule ( _ , _ , Mp_absent , _ , body ) -> transl_exp body | Texp_letexception ( cd , body ) -> Llet ( Strict , Pgenval , cd . ext_id , transl_extension_constructor e . exp_env None cd , transl_exp body ) | Texp_pack modl -> ! transl_module Tcoerce_none None modl | Texp_assert { exp_desc = Texp_construct ( _ , { cstr_name " = false " } , _ ) } -> assert_failed e | Texp_assert ( cond ) -> if ! Clflags . noassert then lambda_unit else Lifthenelse ( transl_exp cond , lambda_unit , assert_failed e ) | Texp_lazy e -> begin match Typeopt . classify_lazy_argument e with | ` Constant_or_function -> transl_exp e | ` Float_that_cannot_be_shortcut -> Lprim ( Pmakeblock ( Obj . forward_tag , Immutable , None ) , [ transl_exp e ] , e . exp_loc ) | ` Identifier ` Forward_value -> Lprim ( Popaque , [ Lprim ( Pmakeblock ( Obj . forward_tag , Immutable , None ) , [ transl_exp e ] , e . exp_loc ) ] , e . exp_loc ) | ` Identifier ` Other -> transl_exp e | ` Other -> let fn = Lfunction { kind = Curried ; params = [ Ident . create_local " param " , Pgenval ] ; return = Pgenval ; attr = default_function_attribute ; loc = e . exp_loc ; body = transl_exp e } in Lprim ( Pmakeblock ( Config . lazy_tag , Mutable , None ) , [ fn ] , e . exp_loc ) end | Texp_object ( cs , meths ) -> let cty = cs . cstr_type in let cl = Ident . create_local " class " in ! transl_object cl meths { cl_desc = Tcl_structure cs ; cl_loc = e . exp_loc ; cl_type = Cty_signature cty ; cl_env = e . exp_env ; cl_attributes = [ ] ; } | Texp_letop { let_ ; ands ; param ; body ; partial } -> event_after e ( transl_letop e . exp_loc e . exp_env let_ ands param body partial ) | Texp_unreachable -> raise ( Error ( e . exp_loc , Unreachable_reached ) ) | Texp_open ( od , e ) -> let pure = pure_module od . open_expr in begin match od . open_bound_items with | [ ] when pure = Alias -> transl_exp e | _ -> let oid = Ident . create_local " open " in let body , _ = List . fold_left ( fun ( body , pos ) id -> Llet ( Alias , Pgenval , id , Lprim ( Pfield pos , [ Lvar oid ] , od . open_loc ) , body ) , pos + 1 ) ( transl_exp e , 0 ) ( bound_value_identifiers od . open_bound_items ) in Llet ( pure , Pgenval , oid , ! transl_module Tcoerce_none None od . open_expr , body ) end match m . mod_desc with Tmod_ident _ -> Alias | Tmod_constraint ( m , _ , _ , _ ) -> pure_module m | _ -> Strict List . map transl_exp expr_list let transl_with_shape e = let shape = Typeopt . value_kind e . exp_env e . exp_type in transl_exp e , shape in List . split ( List . map transl_with_shape expr_list ) let expr = event_before rhs ( transl_exp rhs ) in match guard with | None -> expr | Some cond -> event_before cond ( Lifthenelse ( transl_exp cond , expr , staticfail ) ) c_lhs , transl_guard c_guard c_rhs let cases = List . filter ( fun c -> c . c_rhs . exp_desc <> Texp_unreachable ) cases in List . map transl_case cases iter_exn_names Translprim . add_exception_ident c_lhs ; Misc . try_finally ( fun ( ) -> c_lhs , transl_guard c_guard c_rhs ) ~ always ( : fun ( ) -> iter_exn_names Translprim . remove_exception_ident c_lhs ) let cases = List . filter ( fun c -> c . c_rhs . exp_desc <> Texp_unreachable ) cases in List . map transl_case_try cases let patl_expr_list = List . filter ( fun ( _ , _ , e ) -> e . exp_desc <> Texp_unreachable ) patl_expr_list in List . map ( fun ( patl , guard , expr ) -> ( patl , transl_guard guard expr ) ) patl_expr_list ( ? specialised = Default_specialise ) lam sargs loc = let lapply funct args = match funct with Lsend ( k , lmet , lobj , largs , loc ) -> Lsend ( k , lmet , lobj , largs @ args , loc ) | Levent ( Lsend ( k , lmet , lobj , largs , loc ) , _ ) -> Lsend ( k , lmet , lobj , largs @ args , loc ) | Lapply ap -> Lapply { ap with ap_args = ap . ap_args @ args ; ap_loc = loc } | lexp -> Lapply { ap_should_be_tailcall = should_be_tailcall ; ap_loc = loc ; ap_func = lexp ; ap_args = args ; ap_inlined = inlined ; ap_specialised = specialised ; } in let rec build_apply lam args = function ( None , optional ) :: l -> let defs = ref [ ] in let protect name lam = match lam with Lvar _ | Lconst _ -> lam | _ -> let id = Ident . create_local name in defs := ( id , lam ) :: ! defs ; Lvar id in let args , args ' = if List . for_all ( fun ( _ , opt ) -> opt ) args then [ ] , args else args , [ ] in let lam = if args = [ ] then lam else lapply lam ( List . rev_map fst args ) in let handle = protect " func " lam in let l = List . map ( fun ( arg , opt ) -> Option . map ( protect " arg " ) arg , opt ) l in let id_arg = Ident . create_local " param " in let body = match build_apply handle ( ( Lvar id_arg , optional ) :: args ' ) l with Lfunction { kind = Curried ; params = ids ; return ; body = lam ; attr ; loc } -> Lfunction { kind = Curried ; params = ( id_arg , Pgenval ) :: ids ; return ; body = lam ; attr ; loc } | Levent ( Lfunction { kind = Curried ; params = ids ; return ; body = lam ; attr ; loc } , _ ) -> Lfunction { kind = Curried ; params = ( id_arg , Pgenval ) :: ids ; return ; body = lam ; attr ; loc } | lam -> Lfunction { kind = Curried ; params = [ id_arg , Pgenval ] ; return = Pgenval ; body = lam ; attr = default_stub_attribute ; loc = loc } in List . fold_left ( fun body ( id , lam ) -> Llet ( Strict , Pgenval , id , lam , body ) ) body ! defs | ( Some arg , optional ) :: l -> build_apply lam ( ( arg , optional ) :: args ) l | [ ] -> lapply lam ( List . rev_map fst args ) in ( build_apply lam [ ] ( List . map ( fun ( l , x ) -> Option . map transl_exp x , Btype . is_optional l ) sargs ) : Lambda . lambda ) match cases with [ { c_lhs = pat ; c_guard = None ; c_rhs { = exp_desc = Texp_function { arg_label = _ ; param = param ' ; cases ; partial = partial ' ; } ; exp_env ; exp_type } as exp } ] when Parmatch . inactive ~ partial pat -> let kind = value_kind pat . pat_env pat . pat_type in let return_kind = function_return_value_kind exp_env exp_type in let ( ( _ , params , return ) , body ) = transl_function exp . exp_loc return_kind false repr partial ' param ' cases in ( ( Curried , ( param , kind ) :: params , return ) , Matching . for_function loc None ( Lvar param ) [ pat , body ] partial ) | { c_lhs { = pat_desc = Tpat_tuple pl } } :: _ when untuplify_fn -> begin try let size = List . length pl in let pats_expr_list = List . map ( fun { c_lhs ; c_guard ; c_rhs } -> ( Matching . flatten_pattern size c_lhs , c_guard , c_rhs ) ) cases in let kinds = match pats_expr_list with | [ ] -> assert false | ( pats , _ , _ ) :: cases -> let first_case_kinds = List . map ( fun pat -> value_kind pat . pat_env pat . pat_type ) pats in List . fold_left ( fun kinds ( pats , _ , _ ) -> List . map2 ( fun kind pat -> value_kind_union kind ( value_kind pat . pat_env pat . pat_type ) ) kinds pats ) first_case_kinds cases in let tparams = List . map ( fun kind -> Ident . create_local " param " , kind ) kinds in let params = List . map fst tparams in ( ( Tupled , tparams , return ) , Matching . for_tupled_function loc params ( transl_tupled_cases pats_expr_list ) partial ) with Matching . Cannot_flatten -> ( ( Curried , [ param , Pgenval ] , return ) , Matching . for_function loc repr ( Lvar param ) ( transl_cases cases ) partial ) end | { c_lhs = pat } :: other_cases -> let kind = List . fold_left ( fun k { c_lhs = pat } -> Typeopt . value_kind_union k ( value_kind pat . pat_env pat . pat_type ) ) ( value_kind pat . pat_env pat . pat_type ) other_cases in ( ( Curried , [ param , kind ] , return ) , Matching . for_function loc repr ( Lvar param ) ( transl_cases cases ) partial ) | [ ] -> ( ( Curried , [ param , Pgenval ] , return ) , Matching . for_function loc repr ( Lvar param ) ( transl_cases cases ) partial ) match rec_flag with Nonrecursive -> let rec transl = function [ ] -> fun body -> body | { vb_pat = pat ; vb_expr = expr ; vb_attributes = attr ; vb_loc } :: rem -> let lam = transl_exp expr in let lam = Translattribute . add_function_attributes lam vb_loc attr in let mk_body = transl rem in fun body -> Matching . for_let pat . pat_loc lam pat ( mk_body body ) in transl pat_expr_list | Recursive -> let idlist = List . map ( fun { vb_pat = pat } -> match pat . pat_desc with Tpat_var ( id , _ ) -> id | Tpat_alias ( { pat_desc = Tpat_any } , id , _ ) -> id | _ -> assert false ) pat_expr_list in let transl_case { vb_expr = expr ; vb_attributes ; vb_loc } id = let lam = transl_exp expr in let lam = Translattribute . add_function_attributes lam vb_loc vb_attributes in ( id , lam ) in let lam_bds = List . map2 transl_case pat_expr_list idlist in fun body -> Lletrec ( lam_bds , body ) Lprim ( Psetfield_computed ( maybe_pointer expr , Assignment ) , [ self ; var ; transl_exp expr ] , loc ) let size = Array . length fields in let no_init = match opt_init_expr with None -> true | _ -> false in if no_init || size < Config . max_young_wosize then begin let init_id = Ident . create_local " init " in let lv = Array . mapi ( fun i ( _ , definition ) -> match definition with | Kept typ -> let field_kind = value_kind env typ in let access = match repres with Record_regular | Record_inlined _ -> Pfield i | Record_unboxed _ -> assert false | Record_extension _ -> Pfield ( i + 1 ) | Record_float -> Pfloatfield i in Lprim ( access , [ Lvar init_id ] , loc ) , field_kind | Overridden ( _lid , expr ) -> let field_kind = value_kind expr . exp_env expr . exp_type in transl_exp expr , field_kind ) fields in let ll , shape = List . split ( Array . to_list lv ) in let mut = if Array . exists ( fun ( lbl , _ ) -> lbl . lbl_mut = Mutable ) fields then Mutable else Immutable in let lam = try if mut = Mutable then raise Not_constant ; let cl = List . map extract_constant ll in match repres with | Record_regular -> Lconst ( Const_block ( 0 , cl ) ) | Record_inlined tag -> Lconst ( Const_block ( tag , cl ) ) | Record_unboxed _ -> Lconst ( match cl with [ v ] -> v | _ -> assert false ) | Record_float -> Lconst ( Const_float_array ( List . map extract_float cl ) ) | Record_extension _ -> raise Not_constant with Not_constant -> match repres with Record_regular -> Lprim ( Pmakeblock ( 0 , mut , Some shape ) , ll , loc ) | Record_inlined tag -> Lprim ( Pmakeblock ( tag , mut , Some shape ) , ll , loc ) | Record_unboxed _ -> ( match ll with [ v ] -> v | _ -> assert false ) | Record_float -> Lprim ( Pmakearray ( Pfloatarray , mut ) , ll , loc ) | Record_extension path -> let slot = transl_extension_path loc env path in Lprim ( Pmakeblock ( 0 , mut , Some ( Pgenval :: shape ) ) , slot :: ll , loc ) in begin match opt_init_expr with None -> lam | Some init_expr -> Llet ( Strict , Pgenval , init_id , transl_exp init_expr , lam ) end end else begin let copy_id = Ident . create_local " newrecord " in let update_field cont ( lbl , definition ) = match definition with | Kept _type -> cont | Overridden ( _lid , expr ) -> let upd = match repres with Record_regular | Record_inlined _ -> Psetfield ( lbl . lbl_pos , maybe_pointer expr , Assignment ) | Record_unboxed _ -> assert false | Record_float -> Psetfloatfield ( lbl . lbl_pos , Assignment ) | Record_extension _ -> Psetfield ( lbl . lbl_pos + 1 , maybe_pointer expr , Assignment ) in Lsequence ( Lprim ( upd , [ Lvar copy_id ; transl_exp expr ] , loc ) , cont ) in begin match opt_init_expr with None -> assert false | Some init_expr -> Llet ( Strict , Pgenval , copy_id , Lprim ( Pduprecord ( repres , size ) , [ transl_exp init_expr ] , loc ) , Array . fold_left update_field ( Lvar copy_id ) fields ) end end let rewrite_case ( val_cases , exn_cases , static_handlers as acc ) ( { c_lhs ; c_guard ; c_rhs } as case ) = if c_rhs . exp_desc = Texp_unreachable then acc else let val_pat , exn_pat = split_pattern c_lhs in match val_pat , exn_pat with | None , None -> assert false | Some pv , None -> let val_case = transl_case { case with c_lhs = pv } in val_case :: val_cases , exn_cases , static_handlers | None , Some pe -> let exn_case = transl_case_try { case with c_lhs = pe } in val_cases , exn_case :: exn_cases , static_handlers | Some pv , Some pe -> assert ( c_guard = None ) ; let lbl = next_raise_count ( ) in let static_raise ids = Lstaticraise ( lbl , List . map ( fun id -> Lvar id ) ids ) in let ids_full = Typedtree . pat_bound_idents_full pv in let ids = List . map ( fun ( id , _ , _ ) -> id ) ids_full in let ids_kinds = List . map ( fun ( id , _ , ty ) -> id , Typeopt . value_kind pv . pat_env ty ) ids_full in let vids = List . map Ident . rename ids in let pv = alpha_pat ( List . combine ids vids ) pv in iter_exn_names Translprim . add_exception_ident pe ; let rhs = Misc . try_finally ( fun ( ) -> event_before c_rhs ( transl_exp c_rhs ) ) ~ always ( : fun ( ) -> iter_exn_names Translprim . remove_exception_ident pe ) in ( pv , static_raise vids ) :: val_cases , ( pe , static_raise ids ) :: exn_cases , ( lbl , ids_kinds , rhs ) :: static_handlers in let val_cases , exn_cases , static_handlers = let x , y , z = List . fold_left rewrite_case ( [ ] , [ ] , [ ] ) pat_expr_list in List . rev x , List . rev y , List . rev z in let static_catch body val_ids handler = let id = Typecore . name_pattern " exn " ( List . map fst exn_cases ) in let static_exception_id = next_raise_count ( ) in Lstaticcatch ( Ltrywith ( Lstaticraise ( static_exception_id , body ) , id , Matching . for_trywith ( Lvar id ) exn_cases ) , ( static_exception_id , val_ids ) , handler ) in let classic = match arg , exn_cases with | { exp_desc = Texp_tuple argl } , [ ] -> assert ( static_handlers = [ ] ) ; Matching . for_multiple_match e . exp_loc ( transl_list argl ) val_cases partial | { exp_desc = Texp_tuple argl } , _ :: _ -> let val_ids = List . map ( fun arg -> Typecore . name_pattern " val " [ ] , Typeopt . value_kind arg . exp_env arg . exp_type ) argl in let lvars = List . map ( fun ( id , _ ) -> Lvar id ) val_ids in static_catch ( transl_list argl ) val_ids ( Matching . for_multiple_match e . exp_loc lvars val_cases partial ) | arg , [ ] -> assert ( static_handlers = [ ] ) ; Matching . for_function e . exp_loc None ( transl_exp arg ) val_cases partial | arg , _ :: _ -> let val_id = Typecore . name_cases " val " pat_expr_list in let k = Typeopt . value_kind arg . exp_env arg . exp_type in static_catch [ transl_exp arg ] [ val_id , k ] ( Matching . for_function e . exp_loc None ( Lvar val_id ) val_cases partial ) in List . fold_left ( fun body ( static_exception_id , val_ids , handler ) -> Lstaticcatch ( body , ( static_exception_id , val_ids ) , handler ) ) classic static_handlers let rec loop prev_lam = function | [ ] -> prev_lam | and_ :: rest -> let left_id = Ident . create_local " left " in let right_id = Ident . create_local " right " in let op = transl_ident and_ . bop_op_name . loc env and_ . bop_op_type and_ . bop_op_path and_ . bop_op_val in let exp = transl_exp and_ . bop_exp in let lam = bind Strict right_id exp ( Lapply { ap_should_be_tailcall = false ; ap_loc = and_ . bop_loc ; ap_func = op ; ap_args [ = Lvar left_id ; Lvar right_id ] ; ap_inlined = Default_inline ; ap_specialised = Default_specialise } ) in bind Strict left_id prev_lam ( loop lam rest ) in let op = transl_ident let_ . bop_op_name . loc env let_ . bop_op_type let_ . bop_op_path let_ . bop_op_val in let exp = loop ( transl_exp let_ . bop_exp ) ands in let func = let return_kind = value_kind case . c_rhs . exp_env case . c_rhs . exp_type in let ( kind , params , return ) , body = event_function case . c_rhs ( function repr -> transl_function case . c_rhs . exp_loc return_kind ! Clflags . native_code repr partial param [ case ] ) in let attr = default_function_attribute in let loc = case . c_rhs . exp_loc in Lfunction { kind ; params ; return ; body ; attr ; loc } in Lapply { ap_should_be_tailcall = false ; ap_loc = loc ; ap_func = op ; ap_args [ = exp ; func ] ; ap_inlined = Default_inline ; ap_specialised = Default_specialise }
|
let report_error ppf = function | Free_super_var -> fprintf ppf " Ancestor names can only be used to select inherited methods " | Unreachable_reached -> fprintf ppf " Unreachable expression was reached "
|
let ( ) = Location . register_error_of_exn ( function | Error ( loc , err ) -> Some ( Location . error_of_printer ~ loc report_error err ) | _ -> None )
|
type unsafe_component = | Unsafe_module_binding | Unsafe_functor | Unsafe_non_function | Unsafe_typext
|
type unsafe_info = | Unsafe of { reason : unsafe_component ; loc : Location . t ; subid : Ident . t } | Unnamed
|
type error = Circular_dependency of ( Ident . t * unsafe_info ) list
|
let cons_opt x_opt xs = match x_opt with | None -> xs | Some x -> x :: xs
|
let global_path glob = Some ( Pident glob )
|
let functor_path path param = match path with None -> None | Some p -> Some ( Papply ( p , Pident param ) )
|
let field_path path field = match path with None -> None | Some p -> Some ( Pdot ( p , Ident . name field ) )
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.