text
stringlengths 12
786k
|
|---|
let make x = { desc = x ; loc = no_location } |
let prime_app = { app_inline = false ; app_statefull = false } |
let emake desc ty = { e_desc = desc ; e_loc = no_location ; e_typ = ty ; e_caus = Defcaus . no_typ ; e_init = Definit . no_typ } |
let pmake desc ty = { p_desc = desc ; p_loc = no_location ; p_typ = ty ; p_caus = Defcaus . no_typ ; p_init = Definit . no_typ } |
let eqmake desc = { eq_desc = desc ; eq_loc = no_location ; eq_write = Deftypes . empty ; eq_safe = false ; eq_index = - 1 } |
let global lname = Eglobal { lname = lname ; typ_instance = Deftypes . no_typ_instance } |
let const c ty = emake ( Econst c ) ty |
let constr0 ln ty = emake ( Econstr0 ln ) ty |
let evoid = const Evoid typ_unit |
let efalse = const ( Ebool ( false ) ) typ_bool |
let etrue = const ( Ebool ( true ) ) typ_bool |
let truepat = pmake ( Econstpat ( Ebool ( true ) ) ) typ_bool |
let falsepat = pmake ( Econstpat ( Ebool ( false ) ) ) typ_bool |
let wildpat = pmake ( Ewildpat ) Deftypes . no_typ |
let zero = emake ( Econst ( Efloat ( 0 . 0 ) ) ) Initial . typ_float |
let one = emake ( Econst ( Efloat ( 1 . 0 ) ) ) Initial . typ_float |
let minus_one = emake ( Econst ( Efloat ( - 1 . 0 ) ) ) Initial . typ_float |
let infinity = emake ( global ( Modname ( Initial . stdlib_name " infinity " ) ) ) typ_float |
let tproduct ty_list = Deftypes . make ( Tproduct ( ty_list ) ) |
let tuplepat pat_list = let ty_list = List . map ( fun { p_typ = ty } -> ty ) pat_list in pmake ( Etuplepat ( pat_list ) ) ( tproduct ty_list ) |
let tuple e_list = let ty_list = List . map ( fun { e_typ = ty } -> ty ) e_list in emake ( Etuple ( e_list ) ) ( tproduct ty_list ) |
let record l_list e_list ty = emake ( Erecord ( List . map2 ( fun l e -> ( l , e ) ) l_list e_list ) ) ty |
let rec orpat pat_list = match pat_list with | [ ] -> assert false | [ pat ] -> pat | pat :: pat_list -> pmake ( Eorpat ( pat , orpat pat_list ) ) pat . p_typ |
let varpat name ty = pmake ( Evarpat ( name ) ) ty |
let var name ty = emake ( Elocal ( name ) ) ty |
let pair e1 e2 = emake ( Etuple ( [ e1 ; e2 ] ) ) ( tproduct [ e1 . e_typ ; e2 . e_typ ] ) |
let pairpat p1 p2 = pmake ( Etuplepat ( [ p1 ; p2 ] ) ) ( tproduct [ p1 . p_typ ; p2 . p_typ ] ) |
let patalias p n ty = pmake ( Ealiaspat ( p , n ) ) ty |
let last x ty = emake ( Elast ( x ) ) ty |
let float v = emake ( Econst ( Efloat ( v ) ) ) Initial . typ_float |
let bool v = emake ( Econst ( Ebool ( v ) ) ) Initial . typ_bool |
let float_varpat x = varpat x Initial . typ_float |
let bool_varpat x = varpat x Initial . typ_bool |
let float_var x = var x Initial . typ_float |
let bool_var x = var x Initial . typ_bool |
let float_last x = last x Initial . typ_float |
let bool_last x = last x Initial . typ_bool |
let global_in_stdlib lname ty = emake ( global ( Modname ( Initial . stdlib_name lname ) ) ) ty |
let maketype ty_arg_list ty_res = let make ty = { t_desc = ty ; t_level = generic ; t_index = symbol # name } in make ( Tfun ( Tany , None , make ( Tproduct ( ty_arg_list ) ) , ty_res ) ) |
let rec funtype ty_arg_list ty_res = let make ty = { t_desc = ty ; t_level = generic ; t_index = symbol # name } in match ty_arg_list with | [ ] -> ty_res | ty_arg :: ty_arg_list -> make ( Tfun ( Tany , None , ty_arg , funtype ty_arg_list ty_res ) ) |
let unop op e ty = emake ( Eapp ( prime_app , |
let binop op e1 e2 ty = emake ( Eapp ( prime_app , |
let plus e1 e2 = binop " . " + e1 e2 Initial . typ_float |
let minus e1 e2 = binop " . " - e1 e2 Initial . typ_float |
let diff e1 e2 = binop " " <> e1 e2 Initial . typ_bool |
let or_op e1 e2 = binop " " || e1 e2 Initial . typ_bool |
let and_op e1 e2 = binop " " && e1 e2 Initial . typ_bool |
let on_op e1 e2 = binop " on " e1 e2 Initial . typ_zero |
let min_op e1 e2 = binop " min " e1 e2 Initial . typ_float |
let greater_or_equal e1 e2 = binop " " >= e1 e2 Initial . typ_bool |
let greater e1 e2 = binop " " > e1 e2 Initial . typ_bool |
let up e = emake ( Eop ( Eup , [ e ] ) ) Initial . typ_zero |
let pre e = emake ( Eop ( Eunarypre , [ e ] ) ) e . e_typ |
let minusgreater e1 e2 = emake ( Eop ( Eminusgreater , [ e1 ; e2 ] ) ) e1 . e_typ |
let fby e1 e2 = emake ( Eop ( Efby , [ e1 ; e2 ] ) ) e1 . e_typ |
let ifthenelse e1 e2 e3 = emake ( Eop ( Eifthenelse , [ e1 ; e2 ; e3 ] ) ) e2 . e_typ |
let sgn e = ifthenelse ( greater e zero ) one minus_one |
let record_access e l ty = emake ( Erecord_access ( e , l ) ) ty |
let extend_local env eq_list ( { l_eq = l_eq_list ; l_env = l_env } as l ) = { l with l_eq = eq_list @ l_eq_list ; l_env = Env . append env l_env } |
let make_local env eq_list = extend_local env eq_list { l_rec = true ; l_eq = [ ] ; l_env = Env . empty ; l_loc = Zlocation . no_location } |
let make_let env eq_list e = match eq_list with | [ ] -> e | _ -> emake ( Elet ( make_local env eq_list , e ) ) e . e_typ |
let vardec i = { vardec_name = i ; vardec_default = None ; vardec_combine = None ; vardec_loc = no_location } |
let vardec_from_entry i { t_sort = sort } = let d_opt , c_opt = match sort with | Sstatic -> None , None | Sval -> None , None | Svar { v_default = None ; v_combine = c_opt } | Smem { m_init = ( Noinit | InitEq ) ; m_combine = c_opt } -> | Smem { m_init = InitDecl ( c ) ; m_combine = c_opt } -> | Svar { v_default = Some ( c ) ; v_combine = c_opt } -> Some ( Default ( c ) ) , c_opt in { vardec_name = i ; vardec_default = d_opt ; vardec_combine = c_opt ; vardec_loc = no_location } |
let extend_block env eq_list ( { b_vars = b_vars ; b_env = b_env ; b_body = body_eq_list } as b ) = let b_vars = Env . fold ( fun i entry acc -> vardec_from_entry i entry :: acc ) env b_vars in { b with b_vars = b_vars ; b_body = eq_list @ body_eq_list ; b_env = Env . append env b_env } |
let make_block env eq_list = extend_block env eq_list { b_vars = [ ] ; b_env = Env . empty ; b_locals = [ ] ; b_body = [ ] ; b_loc = Zlocation . no_location ; b_write = Deftypes . empty } |
let eq_make n e = eqmake ( EQeq ( varpat n e . e_typ , e ) ) |
let eq_next n e = eqmake ( EQnext ( n , e , None ) ) |
let eq_init n e = eqmake ( EQinit ( n , e ) ) |
let pluseq_make n e = eqmake ( EQpluseq ( n , e ) ) |
let eq_reset eq_list e = eqmake ( EQreset ( eq_list , e ) ) |
let eq_match e l = eqmake ( EQmatch ( ref true , e , l ) ) |
let eq_block b = eqmake ( EQblock ( b ) ) |
let eq_der x e = eqmake ( EQder ( x , e , None , [ ] ) ) |
let handler p b = { m_pat = p ; m_body = b ; m_env = Env . empty ; m_reset = false ; m_zero = false } |
let eq_ifthenelse e b1 b2 = eq_match e [ handler truepat b1 ; handler falsepat b2 ] |
let eq_ifthen e b = eqmake ( EQmatch ( ref false , e , [ handler truepat b ] ) ) |
let before eq_list = match eq_list with | [ ] -> assert false | [ eq ] -> eq | _ -> eqmake ( EQbefore ( eq_list ) ) |
let par eq_list = match eq_list with | [ ] -> assert false | [ eq ] -> eq | _ -> eqmake ( EQand ( eq_list ) ) |
let init i eq_list = ( eq_init i etrue ) :: ( eq_make i efalse ) :: eq_list |
let new_major env = let m = Zident . fresh " major " in let env = Env . add m { t_sort = Deftypes . major ( ) ; t_typ = Initial . typ_bool } env in let major = var m Initial . typ_bool in env , major |
let major env = let exception Return of Zelus . exp in let find x t = match t with | { t_sort = Smem { m_kind = Some ( Major ) } ; t_typ = typ } -> raise ( Return ( var x typ ) ) | _ -> ( ) in try Env . iter find env ; new_major env with | Return ( x ) -> env , x |
type table = cont Env . t and cont = { mutable c_vars : S . t ; mutable c_useful : bool ; mutable c_visited : bool ; } |
let print ff table = let names ff l = Pp_tools . print_list_r Printer . name " { " " , " " } " ff ( S . elements l ) in let entry x { c_vars = l ; c_useful = u } = Format . fprintf ff " [ @% a -> { c_vars = % a ; c_useful = % s } ] @@ " Env . iter entry table |
let add is_useful w r table = let mark_useful set table = let mark x table = try table with | Not_found -> S . fold mark set table in let add x table = try let { c_vars = l ; c_useful = u } as cont = Env . find x table in cont . c_vars <- S . union r l ; cont . c_useful <- u || is_useful ; table with | Not_found -> Env . add x let table = if is_useful then mark_useful r table else table in S . fold add w table |
let extend table names = Env . map ( fun ( { c_vars = l } as cont ) -> { cont with c_vars = S . union l names } ) table |
let merge table1 table2 = let add x ( { c_vars = l1 ; c_useful = u1 } as cont1 ) table = try let ( { c_vars = l2 ; c_useful = u2 } as cont2 ) = Env . find x table in cont2 . c_vars <- S . union l1 l2 ; cont2 . c_useful <- u1 || u2 ; table with | Not_found -> Env . add x cont1 table in Env . fold add table2 table1 |
let rec build_equation table { eq_desc = desc } = match desc with | EQeq ( p , e ) -> let w = fv_pat S . empty S . empty p in let r = fve S . empty e in add ( Unsafe . exp e ) w r table | EQpluseq ( n , e ) | EQinit ( n , e ) | EQder ( n , e , None , [ ] ) -> let r = fve S . empty e in add ( Unsafe . exp e ) ( S . singleton n ) r table | EQmatch ( _ , e , m_h_list ) -> let r = fve S . empty e in let u = Unsafe . exp e in let table = add u S . empty r table in let table_b = List . fold_left merge table ( extend table_b r ) | EQreset ( res_eq_list , e ) -> let r = fve S . empty e in let u = Unsafe . exp e in let table = add u S . empty r table in let table_res = build_equation_list Env . empty res_eq_list in merge table ( extend table_res r ) | EQforall { for_index = i_list ; for_init = init_list ; for_body = b_eq_list } -> let index table { desc = desc } = match desc with | Einput ( i , e ) -> | Eoutput ( i , j ) -> | Eindex ( i , e1 , e2 ) -> let init table { desc = desc } = match desc with | Einit_last ( i , e ) -> let table = List . fold_left index table i_list in let table = List . fold_left init table init_list in build_block table b_eq_list | EQand ( eq_list ) | EQbefore ( eq_list ) -> build_equation_list table eq_list | EQblock _ | EQder _ | EQnext _ | EQautomaton _ | EQpresent _ | EQemit _ -> assert false List . fold_left build_equation table eq_list |
let visit read table = let useful = ref S . empty in let rec visit x ( { c_vars = l ; c_useful = u ; c_visited = v } as entry ) = if not v then begin entry . c_visited <- true ; entry . c_useful <- true ; useful := S . add x ! useful ; end and visit_fathers x = useful := S . add x ! useful ; try let entry = Env . find x table in visit x entry with Not_found -> ( ) and visit_table x ( { c_useful = u ; c_visited = v } as entry ) = if not v && u then visit x entry in S . iter visit_fathers read ; Env . iter visit_table table ; ! useful |
let is_empty_block { b_locals = l ; b_body = eq_list } = ( l = [ ] ) && ( eq_list = [ ] ) |
let writes useful { dv = dv ; di = di ; der = der ; nv = nv ; mv = mv } = let filter set = S . filter ( fun x -> S . mem x useful ) set in { dv = filter dv ; di = filter di ; der = filter der ; nv = filter nv ; mv = filter mv } |
let rec pattern useful ( { p_desc = desc } as p ) = match desc with | Ewildpat | Econstpat _ | Econstr0pat _ -> p | Etuplepat ( p_list ) -> { p with p_desc = Etuplepat ( List . map ( pattern useful ) p_list ) } | Econstr1pat ( c , p_list ) -> { p with p_desc = Econstr1pat ( c , List . map ( pattern useful ) p_list ) } | Evarpat ( x ) -> if S . mem x useful then p else { p with p_desc = Ewildpat } | Ealiaspat ( p_alias , x ) -> let p_alias = pattern useful p_alias in if S . mem x useful then { p with p_desc = Ealiaspat ( p_alias , x ) } else p_alias | Eorpat ( p1 , p2 ) -> { p with p_desc = Eorpat ( pattern useful p1 , pattern useful p2 ) } | Erecordpat ( ln_pat_list ) -> { p with p_desc = Erecordpat ( List . map ( fun ( ln , p ) -> ( ln , pattern useful p ) ) ln_pat_list ) } | Etypeconstraintpat ( p , ty_exp ) -> let p = pattern useful p in { p with p_desc = Etypeconstraintpat ( p , ty_exp ) } |
let rec remove_equation useful match desc with | EQeq ( p , e ) -> let w = fv_pat S . empty S . empty p in if Unsafe . exp e || S . exists ( fun x -> S . mem x useful ) w then { eq with eq_desc = EQeq ( pattern useful p , e ) } :: eq_list else eq_list | EQpluseq ( n , e ) | EQder ( n , e , None , [ ] ) | EQinit ( n , e ) -> if Unsafe . exp e || S . mem n useful then eq :: eq_list else eq_list | EQmatch ( total , e , m_h_list ) -> let m_h_list = List . map if not ( Unsafe . exp e ) then eq_list else { eq with eq_desc = EQmatch ( total , e , m_h_list ) ; | EQreset ( res_eq_list , e ) -> let res_eq_list = remove_equation_list useful res_eq_list in if not ( Unsafe . exp e ) && res_eq_list = [ ] then eq_list else { eq with eq_desc = EQreset ( res_eq_list , e ) ; | EQforall ( { for_index = i_list ; for_init = init_list ; for_body = b_eq_list ; let index acc ( { desc = desc } as ind ) = match desc with | Einput ( i , e ) -> | Eoutput ( xo , o ) -> | Eindex _ -> let init acc ( { desc = desc } as ini ) = match desc with | Einit_last ( i , e ) -> let i_list = List . fold_left index [ ] i_list in let init_list = List . fold_left init [ ] init_list in let b_eq_list = remove_block useful b_eq_list in let in_env = Env . filter ( fun x entry -> S . mem x useful ) in_env in let out_env = Env . filter ( fun x entry -> S . mem x useful ) out_env in if is_empty_block b_eq_list then eq_list else { eq with eq_desc = EQforall { f_body with for_index = i_list ; | EQbefore ( before_eq_list ) -> let before_eq_list = remove_equation_list useful before_eq_list in if before_eq_list = [ ] then eq_list else ( Zaux . before before_eq_list ) :: eq_list | EQand ( and_eq_list ) -> let and_eq_list = remove_equation_list useful and_eq_list in if and_eq_list = [ ] then eq_list else ( Zaux . par and_eq_list ) :: eq_list | EQnext _ | EQder _ | EQautomaton _ | EQblock _ | EQpresent _ | EQemit _ -> assert false List . fold_right ( remove_equation useful ) eq_list [ ] ( { b_vars = n_list ; b_locals = l_list ; b_body = eq_list ; b_write = ( { dv = w } as defnames ) ; b_env = n_env } as b ) = let l_list = List . map ( remove_local useful ) l_list in let eq_list = remove_equation_list useful eq_list in let n_list = List . filter ( fun { vardec_name = x } -> S . mem x useful ) n_list in let n_env = Env . filter ( fun x entry -> S . mem x useful ) n_env in let w = S . filter ( fun x -> S . mem x useful ) w in { b with b_vars = n_list ; b_locals = l_list ; b_body = eq_list ; b_write = { defnames with dv = w } ; b_env = n_env } let eq_list = remove_equation_list useful eq_list in let l_env = Env . filter ( fun x entry -> S . mem x useful ) l_env in { l with l_eq = eq_list ; l_env = l_env } |
let horizon read { l_env = l_env } = let take h { t_sort = sort } acc = match sort with | Smem { m_kind = Some ( Horizon ) } -> S . add h acc | _ -> acc in Env . fold take l_env read |
let exp ( { e_desc = desc } as e ) = match desc with | Elet ( l , e_let ) -> let read = fve S . empty e_let in let read = horizon read l in let table = build_local Env . empty l in let useful = visit read table in let { l_eq = eq_list } as l = remove_local useful l in if eq_list = [ ] then e_let else { e with e_desc = Elet ( l , e_let ) } | _ -> e |
let implementation impl = match impl . desc with | Eopen _ | Etypedecl _ | Econstdecl _ -> impl | Efundecl ( n , ( { f_body = e } as body ) ) -> { impl with desc = Efundecl ( n , { body with f_body = exp e } ) } |
let implementation_list impl_list = Zmisc . iter implementation impl_list |
module StringSet = Set . Make ( struct type t = string let compare = compare end ) |
let add bv ln = match ln with | Modname { qual = s ; id = _ } -> if not ( StringSet . mem s ! bv ) then bv := StringSet . add s ! bv | Name _ -> ( ) |
let add_opt add_fn bv = function | None -> ( ) | Some x -> add_fn bv x |
let add_default add_fn bv = function | Init v | Default v -> add_fn bv v |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.