Datasets:
AllenGeng
/
ocamlgithub

Dataset card Data Studio Files
xet
Community
text
stringlengths
12
786k
let empty_code = { mem = State . empty ; init = Osequence [ ] ;
let seq { mem = m1 ; init = i1 ; instances = j1 ; reset = r1 ; step = s1 } { mem = State . seq m1 m2 ; init = sequence i1 i2 ; instances = State . par j1 j2 ; reset = sequence r1 r2 ; step = sequence s1 s2 }
let entry_of n env = try Env . find n env with Not_found -> Zmisc . internal_error " Unbound variable " Printer . name n
let immediate = function | Deftypes . Eint ( i ) -> Oint ( i ) | Deftypes . Efloat ( f ) -> Ofloat ( f ) | Deftypes . Ebool ( b ) -> Obool ( b ) | Deftypes . Echar ( c ) -> Ochar ( c ) | Deftypes . Estring ( s ) -> Ostring ( s ) | Deftypes . Evoid -> Ovoid
let constant = function | Deftypes . Cimmediate ( i ) -> Oconst ( immediate i ) | Deftypes . Cglobal ( ln ) -> Oglobal ( ln )
let state is_read n k = match k with | None -> Oleft_state_name ( n ) | Some ( k ) -> match k with | Deftypes . Cont -> | Deftypes . Zero -> Oleft_state_primitive_access | Deftypes . Horizon | Deftypes . Period | Deftypes . Encore | Deftypes . Major -> Oleft_state_name ( n )
let rec index e = function [ ] -> e | ei :: ei_list -> Oaccess ( index e ei_list , Olocal ( ei ) )
let rec left_value_index lv = function | [ ] -> lv | ei :: ei_list -> Oleft_index ( left_value_index lv ei_list , Olocal ( ei ) )
let rec left_state_value_index lv = function | [ ] -> lv | ei :: ei_list -> Oleft_state_index ( left_state_value_index lv ei_list , Olocal ( ei ) )
let var { e_sort = sort ; e_typ = ty ; e_size = ei_list } = match sort with | In ( e ) -> index e ei_list | Out ( n , sort ) -> match sort with | Sstatic | Sval -> index ( Olocal ( n ) ) ei_list | Svar _ -> index ( Ovar ( is_mutable ty , n ) ) ei_list | Smem { m_kind = k } -> Ostate ( left_state_value_index ( state true n k ) ei_list )
let assign { e_sort = sort ; e_size = ei_list } e = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Sstatic | Sval -> assert false | Svar _ -> Oassign ( left_value_index ( Oleft_name n ) ei_list , e ) | Smem { m_kind = k } ->
let def { e_typ = ty ; e_sort = sort ; e_size = ei_list } e ( { step = s } as code ) = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Sstatic | Sval -> { code with step = Olet ( Ovarpat ( n , type_expression_of_typ ty ) , e , s ) } | Svar _ -> sequence | Smem { m_kind = k } ->
let der { e_sort = sort ; e_size = ei_list } e ( { step = s } as code ) = match sort with | In _ -> assert false | Out ( n , sort ) -> { code with step = e ) )
let ifthen r_e i_code s = sequence ( Oif ( r_e , i_code , None ) ) s
let for_loop direction ix e1 e2 i_body = match i_body with | Osequence [ ] -> Osequence [ ] | _ -> Ofor ( direction , ix , e1 , e2 , i_body )
let letpat p e ( { step = s } as code ) = { code with step = Olet ( p , e , s ) }
let rec letvar l s = match l with | [ ] -> s | ( n , is_mutable , ty , v_opt ) :: l -> Oletvar ( n , is_mutable , ty , v_opt , letvar l s )
let pluseq ( { e_sort = sort ; e_size = ei_list } as entry ) let ln = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Svar { v_combine = Some ( ln ) } | Smem { m_combine = Some ( ln ) } -> ln | _ -> Zmisc . internal_error " Unbound variable " Printer . name n in { code with step =
let out_of n env = let { e_typ = ty ; e_sort = sort ; e_size = ix_list } = entry_of n env in match sort with | In _ -> assert false | Out ( x , sort ) -> x , ty , sort , ix_list
let rec size_of_type = function | Tconst ( i ) -> Sconst ( i ) | Tglobal ( q ) -> Sglobal ( Lident . Modname ( q ) ) | Tname ( n ) -> Sname ( n ) | Top ( op , s1 , s2 ) -> let e1 = size_of_type s1 in let e2 = size_of_type s2 in match op with | Tplus -> Sop ( Splus , e1 , e2 ) | Tminus -> Sop ( Sminus , e1 , e2 )
let rec size { Zelus . desc = desc } = match desc with | Zelus . Sconst ( i ) -> Sconst ( i ) | Zelus . Sglobal ( ln ) -> Sglobal ( ln ) | Zelus . Sname n -> Sname ( n ) | Zelus . Sop ( op , s1 , s2 ) -> let s1 = size s1 in let s2 = size s2 in match op with | Zelus . Splus -> Sop ( Splus , s1 , s2 ) | Zelus . Sminus -> Sop ( Sminus , s1 , s2 )
let choose env ty = let tuple l = Otuple ( l ) in let efalse = Oconst ( Obool ( false ) ) in let echar0 = Oconst ( Ochar ( ' a ' ) ) in let ezero = Oconst ( Oint ( 42 ) ) in let efzero = Oconst ( Ofloat ( 42 . 0 ) ) in let estring0 = Oconst ( Ostring ( " aaaaaaa " ) ) in let evoid = Oconst ( Ovoid ) in let eany = Oconst ( Oany ) in let vec e s = Ovec ( e , s ) in let rec value_from_deftype id = try let { info = { type_desc = ty_c } } = Modules . find_type ( Lident . Modname ( id ) ) in match ty_c with | Variant_type ( g_list ) -> value_from_variant_list g_list | Abstract_type -> eany | Record_type ( l_list ) -> Orecord ( ( fun { qualid = qualid ; info = { label_res = ty } } -> ( Lident . Modname ( qualid ) , value ty ) ) l_list ) | Abbrev ( _ , ty ) -> value ty with | Not_found -> eany and value ty = match ty . t_desc with | Tvar -> eany | Tproduct ( ty_l ) -> tuple ( List . map value ty_l ) | Tfun _ -> eany | Tvec ( ty , s ) -> vec ( value ty ) ( size_of_type s ) | Tconstr ( id , _ , _ ) -> if id = Initial . int_ident then ezero else if id = Initial . bool_ident then efalse else if id = Initial . char_ident then echar0 else if id = Initial . float_ident then efzero else if id = Initial . string_ident then estring0 else if id = Initial . unit_ident then evoid else if id = Initial . zero_ident then efalse else value_from_deftype id | Tlink ( link ) -> value link and value_from_variant_list g_list = let rec findrec g_list = match g_list with | [ ] -> raise Not_found | { qualid = qualid ; info = { constr_arity = arity } } :: g_list -> if arity = 0 then Oconstr0 ( Lident . Modname ( qualid ) ) else findrec g_list in try findrec g_list with | Not_found -> let { qualid = qualid ; info = { constr_arg = ty_list } } = List . hd g_list in Oconstr1 ( Lident . Modname ( qualid ) , List . map value ty_list ) in Some ( value ty )
let default env ty v_opt = match v_opt with | None -> choose env ty | Some ( v ) -> Some ( constant v )
let append loop_path l_env env = let addrec n { t_sort = k ; t_typ = ty } ( env_acc , mem_acc , var_acc ) = match k with | Sstatic | Sval -> | Svar { v_default = v_opt } -> | Smem { m_kind = k_opt } -> Env . fold addrec l_env ( env , State . empty , [ ] )
let apply k env loop_path e e_list match k with | Deftypes . Tstatic _ | Deftypes . Tany | Deftypes . Tdiscrete ( false ) -> Oapp ( e , e_list ) , code | Deftypes . Tdiscrete ( true ) | Deftypes . Tcont | Deftypes . Tproba -> let se_list , arg = Zmisc . firsts e_list in let f_opt = match e with | Oglobal ( g ) -> Some ( g ) | _ -> None in let loop_path = List . map ( fun ix -> Olocal ( ix ) ) loop_path in let o = Zident . fresh " i " in let j_code = { i_name = o ; i_machine = e ; i_kind = k ; let reset_code = Omethodcall ( { met_machine = f_opt ; met_name = Oaux . reset ; let step_code = Omethodcall ( { met_machine = f_opt ; met_name = Oaux . step ; step_code , { code with instances = State . cons j_code j ;
let rec exp env loop_path code { Zelus . e_desc = desc } = match desc with | Zelus . Econst ( i ) -> Oconst ( immediate i ) , code | Zelus . Elocal ( n ) | Zelus . Elast ( n ) -> var ( entry_of n env ) , code | Zelus . Eglobal { lname = ln } -> Oglobal ( ln ) , code | Zelus . Econstr0 ( ln ) -> Oconstr0 ( ln ) , code | Zelus . Econstr1 ( ln , e_list ) -> let e_list , code = Zmisc . map_fold ( exp env loop_path ) code e_list in Oconstr1 ( ln , e_list ) , code | Zelus . Etuple ( e_list ) -> let e_list , code = Zmisc . map_fold ( exp env loop_path ) code e_list in Otuple ( e_list ) , code | Zelus . Erecord ( label_e_list ) -> let label_e_list , code = Zmisc . map_fold Orecord ( label_e_list ) , code | Zelus . Erecord_access ( e_record , longname ) -> let e_record , code = exp env loop_path code e_record in Orecord_access ( e_record , longname ) , code | Zelus . Erecord_with ( e_record , label_e_list ) -> let e_record , code = exp env loop_path code e_record in let label_e_list , code = Zmisc . map_fold Orecord_with ( e_record , label_e_list ) , code | Zelus . Etypeconstraint ( e , ty_exp ) -> let e , code = exp env loop_path code e in let ty_exp = type_expression ty_exp in Otypeconstraint ( e , ty_exp ) , code | Zelus . Eop ( Zelus . Eup , [ e ] ) -> let e = if ! Zmisc . zsign then Zaux . sgn e else e in exp env loop_path code e | Zelus . Eop ( Zelus . Ehorizon , [ e ] ) -> exp env loop_path code e | Zelus . Eop ( Zelus . Eifthenelse , [ e1 ; e2 ; e3 ] ) -> let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in let e3 , code = exp env loop_path code e3 in Oifthenelse ( e1 , e2 , e3 ) , code | Zelus . Eop ( Zelus . Eaccess , [ e1 ; e2 ] ) -> let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in Oaccess ( e1 , e2 ) , code | Zelus . Eop ( Zelus . Eupdate , [ e1 ; i ; e2 ] ) -> let _ , se = Ztypes . filter_vec e1 . Zelus . e_typ in let se = size_of_type se in let e1 , code = exp env loop_path code e1 in let i , code = exp env loop_path code i in let e2 , code = exp env loop_path code e2 in Oupdate ( se , e1 , i , e2 ) , code | Zelus . Eop ( Zelus . Eslice ( s1 , s2 ) , [ e ] ) -> let s1 = size s1 in let s2 = size s2 in let e , code = exp env loop_path code e in Oslice ( e , s1 , s2 ) , code | Zelus . Eop ( Zelus . Econcat , [ e1 ; e2 ] ) -> let _ , s1 = Ztypes . filter_vec e1 . Zelus . e_typ in let _ , s2 = Ztypes . filter_vec e2 . Zelus . e_typ in let s1 = size_of_type s1 in let s2 = size_of_type s2 in let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in Oconcat ( e1 , s1 , e2 , s2 ) , code | Zelus . Eop ( Zelus . Eatomic , [ e ] ) -> exp env loop_path code e | Zelus . Elet _ | Zelus . Eseq _ | Zelus . Eperiod _ | Zelus . Eop _ | Zelus . Epresent _ | Zelus . Ematch _ | Zelus . Eblock _ -> assert false | Zelus . Eapp ( _ , e_fun , e_list ) -> let se_list , ne_list , ty_res = Ztypes . split_arguments e_fun . Zelus . e_typ e_list in let e_fun , code = exp env loop_path code e_fun in let se_list , code = Zmisc . map_fold ( exp env loop_path ) code se_list in let ne_list , code = Zmisc . map_fold ( exp env loop_path ) code ne_list in let e_fun = app e_fun se_list in match ne_list with | [ ] -> e_fun , code | _ -> let k = Ztypes . kind_of_funtype ty_res in match desc with | Zelus . Ewildpat -> Owildpat | Zelus . Econstpat ( im ) -> Oconstpat ( immediate im ) | Zelus . Econstr0pat ( c0 ) -> Oconstr0pat ( c0 ) | Zelus . Econstr1pat ( c1 , p_list ) -> Oconstr1pat ( c1 , List . map pattern p_list ) | Zelus . Etuplepat ( p_list ) -> Otuplepat ( List . map pattern p_list ) | Zelus . Evarpat ( n ) -> Ovarpat ( n , type_expression_of_typ ty ) | Zelus . Erecordpat ( label_pat_list ) -> Orecordpat ( List . map ( fun ( label , pat ) -> ( label , pattern pat ) ) | Zelus . Etypeconstraintpat ( p , ty ) -> Otypeconstraintpat ( pattern p , type_expression ty ) | Zelus . Ealiaspat ( p , n ) -> Oaliaspat ( pattern p , n ) | Zelus . Eorpat ( p1 , p2 ) -> Oorpat ( pattern p1 , pattern p2 )
let rec equation env loop_path { Zelus . eq_desc = desc } code = match desc with | Zelus . EQeq ( { Zelus . p_desc = Zelus . Evarpat ( n ) } , e ) -> let e , code = exp env loop_path code e in def ( entry_of n env ) e code | Zelus . EQeq ( p , e ) -> let e , code = exp env loop_path code e in letpat ( pattern p ) e code | Zelus . EQpluseq ( n , e ) -> let e , code = exp env loop_path code e in pluseq ( entry_of n env ) e code | Zelus . EQder ( n , e , None , [ ] ) -> let e , code = exp env loop_path code e in der ( entry_of n env ) e code | Zelus . EQmatch ( _ , e , p_h_list ) -> let e , code = exp env loop_path code e in let p_step_h_list , p_h_code = match_handlers env loop_path p_h_list in seq { p_h_code with step = Omatch ( e , p_step_h_list ) } code | Zelus . EQreset ( [ { Zelus . eq_desc = Zelus . EQinit ( x , e ) } ] , r_e ) when not ( Reset . static e ) -> let r_e , code = exp env loop_path code r_e in let e , ( { init = i_code } as e_code ) = exp env loop_path empty_code e in let { step = s } as code = seq e_code code in { code with step = ifthen r_e ( sequence ( assign ( entry_of x env ) e ) i_code ) s } | Zelus . EQreset ( eq_list , r_e ) -> let { init = i_code } = code in let { init = ri_code } as r_code = equation_list env loop_path eq_list { code with init = Osequence [ ] } in let r_e , r_code = exp env loop_path r_code r_e in let { step = s } as code = seq r_code { empty_code with init = i_code } in { code with step = ifthen r_e ri_code s } | Zelus . EQinit ( x , e ) -> let e_c , code = exp env loop_path code e in let x_e = assign ( entry_of x env ) e_c in if Reset . static e then seq { empty_code with init = x_e ; reset = x_e } code else seq { empty_code with step = x_e } code | Zelus . EQforall { Zelus . for_index = i_list ; Zelus . for_init = init_list ; let rec index code = function | [ ] -> let id = Zident . fresh " i " in | { Zelus . desc = desc } :: i_list -> let in_out ix ( env_acc , code ) { Zelus . desc = desc } = match desc with | Zelus . Einput ( x , ( { Zelus . e_typ = ty } as e ) ) -> | Zelus . Eoutput ( x , y ) -> | Zelus . Eindex ( i , { Zelus . e_typ = ty } , _ ) -> let array_of_instance size ( { i_size } as ientry ) = { ientry with i_size = size :: i_size } in let array_of_memory size ( { m_size } as mentry ) = { mentry with m_size = size :: m_size } in let init code { Zelus . desc = desc } = match desc with | Zelus . Einit_last ( x , e ) -> let ( ix , e1 , e2 ) , code = index code i_list in let env , code = List . fold_left ( in_out ix ) ( env , code ) i_list in let { mem = m_code ; init = i_code ; instances = j_code ; block env ( ix :: loop_path ) b_eq_list in let j_code = State . map let m_code = State . map let initialization_list , Zmisc . map_fold init code init_list in { mem = State . seq m_code m ; instances = State . seq j_code j ; init = sequence ( for_loop true ix e1 e2 i_code ) i ; reset = sequence ( for_loop true ix e1 e2 r_code ) r ; step = sequence ( Osequence initialization_list ) | Zelus . EQbefore ( before_eq_list ) -> equation_list env loop_path before_eq_list code | Zelus . EQand _ | Zelus . EQblock _ | Zelus . EQnext _ | Zelus . EQder _ | Zelus . EQemit _ | Zelus . EQautomaton _ | Zelus . EQpresent _ -> assert false List . fold_right ( fun eq code -> equation env loop_path eq code ) eq_list code let body code { Zelus . m_pat = p ; Zelus . m_body = b ; Zelus . m_env = m_env } = let env , mem_acc , var_acc = append loop_path m_env env in let { mem = m_code ; step = s_code } as b_code = block env loop_path b in { w_pat = pattern p ; w_body = letvar var_acc s_code } , seq code Zmisc . map_fold body empty_code p_h_list let env , mem_acc , var_acc = append loop_path l_env env in let e , code = exp env loop_path empty_code e in let eq_code = equation_list env loop_path eq_list { code with step = Oexp ( e ) } in add_mem_vars_to_code eq_code mem_acc var_acc let env , mem_acc , var_acc = append loop_path n_env env in let eq_code = equation_list env loop_path eq_list empty_code in add_mem_vars_to_code eq_code mem_acc var_acc { code with mem = State . seq mem_acc mem ; step = letvar var_acc step }
let machine n k pat_list { mem = m ; instances = j ; reset = r ; step = s } let k = Interface . kindtype k in match k with | Deftypes . Tstatic _ | Deftypes . Tany | Deftypes . Tdiscrete ( false ) -> Oletfun ( n , pat_list , s ) | Deftypes . Tdiscrete ( true ) | Deftypes . Tcont | Deftypes . Tproba -> let pat_list , p = Zmisc . firsts pat_list in let body = { ma_kind = k ; me_typ = Initial . typ_unit } ; me_typ = ty_res } ] } in Oletmachine ( n , body )
let expression env ( { Zelus . e_desc = desc } as e ) = match desc with | Zelus . Elet ( l , e_let ) -> local env empty_path l e_let | _ -> let e , code = exp env empty_path empty_code e in
let implementation { Zelus . desc = desc } = match desc with | Zelus . Eopen ( n ) -> Oopen ( n ) | Zelus . Etypedecl ( n , params , ty_decl ) -> Otypedecl ( [ n , params , type_of_type_decl ty_decl ] ) | Zelus . Econstdecl ( n , _ , e ) -> let { step = s } = expression Env . empty e in Oletvalue ( n , s ) | Zelus . Efundecl ( n , { Zelus . f_kind = k ; Zelus . f_args = pat_list ; let pat_list = List . map pattern pat_list in let env , mem_acc , var_acc = append empty_path f_env Env . empty in let code = expression env e in let code = add_mem_vars_to_code code mem_acc var_acc in machine n k pat_list code e . Zelus . e_typ
let implementation_list impl_list = Zmisc . iter implementation impl_list
type concrete_regexp = | Epsilon | Eof | Characters of Fcset . t | Sequence of concrete_regexp * concrete_regexp | Alternative of concrete_regexp * concrete_regexp | Repetition of concrete_regexp | Bind of concrete_regexp * ( Locf . t * string )
type ' a entry = { shortest : bool ; clauses : ( concrete_regexp * ' a ) list }
let regexp_for_string s = let rec re_string n = let len = String . length s in if n >= len then Epsilon else if n + 1 = len then Characters ( Fcset . singleton ( Char . code s . [ n ] ) ) else Sequence ( Characters ( Fcset . singleton ( Char . code s . [ n ] ) ) , re_string ( n + 1 ) ) in re_string 0
let rec remove_as x = match x with | Bind ( e , _ ) -> remove_as e | Epsilon | Eof | Characters _ as e -> e | Sequence ( e1 , e2 ) -> Sequence ( remove_as e1 , remove_as e2 ) | Alternative ( e1 , e2 ) -> Alternative ( remove_as e1 , remove_as e2 ) | Repetition e -> Repetition ( remove_as e )
let as_cset = function | Characters s -> s | _ -> raise Bad
let remove_nested_as e : concrete_regexp = let rec do_remove_nested ( to_remove : Id_set . t ) x : concrete_regexp = match x with | Bind ( e , x ) -> if Id_set . mem x to_remove then do_remove_nested to_remove e else Bind ( do_remove_nested ( Id_set . add x to_remove ) e , x ) | Epsilon | Eof | Characters _ as e -> e | Sequence ( e1 , e2 ) -> Sequence ( do_remove_nested to_remove e1 , do_remove_nested to_remove e2 ) | Alternative ( e1 , e2 ) -> Alternative ( do_remove_nested to_remove e1 , do_remove_nested to_remove e2 ) | Repetition e -> Repetition ( do_remove_nested to_remove e ) in do_remove_nested Id_set . empty e
let rec find_all_vars ( x : concrete_regexp ) : Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> empty | Bind ( e , x ) -> add x ( find_all_vars e ) | Sequence ( e1 , e2 ) | Alternative ( e1 , e2 ) -> union ( find_all_vars e1 ) ( find_all_vars e2 ) | Repetition e -> find_all_vars e
let find_optional e = let rec do_find_opt x : Id_set . t * Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> ( empty , empty ) | Bind ( e , x ) -> let ( opt , all ) = do_find_opt e in ( opt , add x all ) | Sequence ( e1 , e2 ) -> let ( opt1 , all1 ) = do_find_opt e1 and ( opt2 , all2 ) = do_find_opt e2 in ( union opt1 opt2 , union all1 all2 ) | Alternative ( e1 , e2 ) -> let ( opt1 , all1 ) = do_find_opt e1 and ( opt2 , all2 ) = do_find_opt e2 in ( union ( union opt1 opt2 ) ( union ( diff all1 all2 ) ( diff all2 all1 ) ) , union all1 all2 ) | Repetition e -> let r = find_all_vars e in ( r , r ) in fst @@ do_find_opt e
let rec do_find_double x : Id_set . t * Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> ( empty , empty ) | Bind ( e , x ) -> let ( dbl , all ) = do_find_double e in ( ( if mem x all then add x dbl else dbl ) , add x all ) | Sequence ( e1 , e2 ) -> let ( dbl1 , all1 ) = do_find_double e1 and ( dbl2 , all2 ) = do_find_double e2 in ( union ( inter all1 all2 ) ( union dbl1 dbl2 ) , union all1 all2 ) | Alternative ( e1 , e2 ) -> let ( dbl1 , all1 ) = do_find_double e1 and ( dbl2 , all2 ) = do_find_double e2 in ( union dbl1 dbl2 , union all1 all2 ) | Repetition e -> let r = find_all_vars e in ( r , r )
let find_double e = do_find_double e
let add_some x = function | Some i -> Some ( x + i ) | None -> None
let add_some_some x y = match x , y with | ( Some i , Some j ) -> Some ( i + j ) | ( _ , _ ) -> None
let find_chars e = let open Id_set in let rec do_find_chars ( sz : int option ) x = match x with | Epsilon | Eof -> ( empty , empty , sz ) | Characters _ -> ( empty , empty , add_some 1 sz ) | Bind ( e , x ) -> let ( c , s , e_sz ) = do_find_chars ( Some 0 ) e in begin match e_sz with | Some 1 -> ( add x c , s , add_some 1 sz ) | _ -> ( c , add x s , add_some_some sz e_sz ) end | Sequence ( e1 , e2 ) -> let ( c1 , s1 , sz1 ) = do_find_chars sz e1 in let ( c2 , s2 , sz2 ) = do_find_chars sz1 e2 in ( union c1 c2 , union s1 s2 , sz2 ) | Alternative ( e1 , e2 ) -> let ( c1 , s1 , sz1 ) = do_find_chars sz e1 and ( c2 , s2 , sz2 ) = do_find_chars sz e2 in ( union c1 c2 , union s1 s2 , if sz1 = sz2 then sz1 else None ) | Repetition e -> do_find_chars None e in let ( c , s , _ ) = do_find_chars ( Some 0 ) e in diff c s
let chars = ref ( [ ] : Fcset . t list )
let chars_count = ref 0
let rec encode_regexp ( char_vars : Id_set . t ) ( act : int ) x : regexp = match x with | Epsilon -> Empty | Characters cl -> let n = ! chars_count in begin chars := cl :: ! chars ; incr chars_count ; Chars ( n , false ) end | Eof -> let n = ! chars_count in begin chars := Fcset . eof :: ! chars ; incr chars_count ; Chars ( n , true ) end | Sequence ( r1 , r2 ) -> let r1 = encode_regexp char_vars act r1 in let r2 = encode_regexp char_vars act r2 in Seq ( r1 , r2 ) | Alternative ( r1 , r2 ) -> let r1 = encode_regexp char_vars act r1 in let r2 = encode_regexp char_vars act r2 in Alt ( r1 , r2 ) | Repetition r -> Star ( encode_regexp char_vars act r ) | Bind ( r , ( ( _ , name ) as y ) ) -> let r = encode_regexp char_vars act r in if Id_set . mem y char_vars then Seq ( Tag { id = name ; start = true ; action = act } , r ) else Seq ( Tag { id = name ; start = true ; action = act } , Seq ( r , Tag { id = name ; start = false ; action = act } ) )
let mk_seq ( r1 : regexp ) ( r2 : regexp ) : regexp = match r1 , r2 with | Empty , _ -> r2 | _ , Empty -> r1 | _ -> Seq ( r1 , r2 )
let add_pos p i = match ( p : Automata_def . tag_addr option ) with | Some ( a , n ) -> Some ( a , n + i ) | None -> None
let mem_name name ( id_set : Id_set . t ) : bool = Id_set . exists ( function ( _ , id_name ) -> name = id_name ) id_set
let rec size_forward pos ( x : regexp ) : int option = match x with | Empty | Chars ( _ , true ) | Tag _ -> Some pos | Chars ( _ , false ) -> Some ( pos + 1 ) | Seq ( r1 , r2 ) -> begin match size_forward pos r1 with | None -> None | Some pos -> size_forward pos r2 end | Alt ( r1 , r2 ) -> let pos1 = size_forward pos r1 and pos2 = size_forward pos r2 in if pos1 = pos2 then pos1 else None | Star _ -> None | Action _ -> assert false
let rec size_backward pos ( x : regexp ) = match x with | Empty | Chars ( _ , true ) | Tag _ -> Some pos | Chars ( _ , false ) -> Some ( pos - 1 ) | Seq ( r1 , r2 ) -> begin match size_backward pos r2 with | None -> None | Some pos -> size_backward pos r1 end | Alt ( r1 , r2 ) -> let pos1 = size_backward pos r1 and pos2 = size_backward pos r2 in if pos1 = pos2 then pos1 else None | Star _ -> None | Action _ -> assert false
let opt_regexp all_vars char_vars optional_vars double_vars ( r : regexp ) : ( Id_set . elt * ident_info ) list * regexp * int = let env = Hashtbl . create 17 in let rec simple_forward pos r double_vars = match r with | Tag n -> if mem_name n . id double_vars then ( r , Some pos ) else begin Hashtbl . add env ( n . id , n . start ) ( Start , pos ) ; ( Empty , Some pos ) end | Empty -> ( r , Some pos ) | Chars ( _ , is_eof ) -> ( r , Some ( if is_eof then pos else pos + 1 ) ) | Seq ( r1 , r2 ) -> begin match simple_forward pos r1 double_vars with | r1 , None -> ( mk_seq r1 r2 , None ) | r1 , Some pos -> let ( r2 , pos ) = simple_forward pos r2 double_vars in ( mk_seq r1 r2 , pos ) end | Alt ( r1 , r2 ) -> let pos1 = size_forward pos r1 and pos2 = size_forward pos r2 in ( r , if pos1 = pos2 then pos1 else None ) | Star _ -> ( r , None ) | Action _ -> assert false in let rec simple_backward pos r double_vars = match r with | Tag n -> if mem_name n . id double_vars then ( r , Some pos ) else begin Hashtbl . add env ( n . id , n . start ) ( End , pos ) ; ( Empty , Some pos ) end | Empty -> ( r , Some pos ) | Chars ( _ , is_eof ) -> ( r , Some ( if is_eof then pos else pos - 1 ) ) | Seq ( r1 , r2 ) -> begin match simple_backward pos r2 double_vars with | r2 , None -> ( mk_seq r1 r2 , None ) | r2 , Some pos -> let ( r1 , pos ) = simple_backward pos r1 double_vars in ( mk_seq r1 r2 , pos ) end | Alt ( r1 , r2 ) -> let pos1 = size_backward pos r1 and pos2 = size_backward pos r2 in ( r , if pos1 = pos2 then pos1 else None ) | Star _ -> ( r , None ) | Action _ -> assert false in let r = let r , _ = simple_forward 0 r double_vars in let r , _ = simple_backward 0 r double_vars in r in let loc_count = ref 0 in let get_tag_addr t = try Hashtbl . find env t with Not_found -> let n = ! loc_count in begin incr loc_count ; Hashtbl . add env t ( Mem n , 0 ) ; ( Mem n , 0 ) end in let rec alloc_exp pos r = match r with | Tag n -> if mem_name n . id double_vars then ( r , pos ) else begin match pos with | Some a -> begin Hashtbl . add env ( n . id , n . start ) a ; ( Empty , pos ) end | None -> let a = get_tag_addr ( n . id , n . start ) in ( r , Some a ) end | Empty -> ( r , pos ) | Chars ( _ , is_eof ) -> ( r , ( if is_eof then pos else add_pos pos 1 ) ) | Seq ( r1 , r2 ) -> let ( r1 , pos ) = alloc_exp pos r1 in let ( r2 , pos ) = alloc_exp pos r2 in ( mk_seq r1 r2 , pos ) | Alt ( _ , _ ) -> let off = size_forward 0 r in begin match off with | Some i -> ( r , add_pos pos i ) | None -> ( r , None ) end | Star _ -> ( r , None ) | Action _ -> assert false in let ( r , _ ) = alloc_exp None r in let m = Id_set . fold ( fun ( ( _ , name ) as x ) r -> let v = if Id_set . mem x char_vars then Ident_char ( Id_set . mem x optional_vars , get_tag_addr ( name , true ) ) else Ident_string ( Id_set . mem x optional_vars , get_tag_addr ( name , true ) , get_tag_addr ( name , false ) ) in ( x , v ) :: r ) all_vars [ ] in ( m , r , ! loc_count )
let encode_casedef ( regexps ( : concrete_regexp * ' a ) list ) = List . fold_left ( fun ( reg , actions , count , ntags ) ( expr , act ) -> let expr = remove_nested_as expr in let char_vars = find_chars expr in let opt_vars = find_optional expr in let ( double_vars , all_vars ) = find_double expr in let r = encode_regexp char_vars count expr in let ( m , r , loc_ntags ) = opt_regexp all_vars char_vars opt_vars double_vars r in ( Alt ( reg , Seq ( r , Action count ) ) , ( count , m , act ) :: actions , count + 1 , max loc_ntags ntags ) ) ( Empty , [ ] , 0 , 0 ) regexps
let reset ( ) = chars := [ ] ; chars_count := 0
type ' a lexer_entry = { lex_regexp : regexp ; lex_mem_tags : int ; lex_actions : ( int * t_env * ' a ) list }
let encode_lexdef ( def ' : a entry list ) : Fcset . t array * ( ' a lexer_entry * bool ) list = reset ( ) ; let entry_list = List . map ( fun { shortest ; clauses } -> let ( lex_regexp , actions , _ , lex_mem_tags ) = encode_casedef clauses in ( { lex_regexp ; lex_mem_tags ; lex_actions = List . rev actions } , shortest ) ) def in Array . of_list ( List . rev ! chars ) , entry_list
let encode_single_lexdef ( def ' : a entry ) : Fcset . t array * ( ' a lexer_entry * bool ) = reset ( ) ; let result = match def with { shortest ; clauses } -> let ( lex_regexp , actions , _ , lex_mem_tags ) = encode_casedef clauses in ( { lex_regexp ; lex_mem_tags ; lex_actions = List . rev actions } , shortest ) in Array . of_list ( List . rev ! chars ) , result
module Table = Map . Make ( String )
module Namespace = struct type t = string Table . t let empty : t = Table . empty let translate ~ ocaml ~ coq = Table . add ocaml coq let preserve ocaml = translate ~ ocaml ~ coq : ocaml let find ~ ocaml : from = Table . find_opt from end
type t = Namespace . t Table . t
let qualname prefix suffix = prefix ^ " . " ^ suffix
let rec translate ( ? rev_namespace = [ ] ) ~ ocaml ~ coq t = let prefix = String . concat " . " rev_namespace in let t = Table . update prefix ( fun ns -> Option . value ~ default : Namespace . empty ns |> Namespace . translate ~ ocaml ~ coq |> Option . some ) t in match rev_namespace with | [ ] -> t | x :: rev_namespace -> translate ~ rev_namespace ~ ocaml ( : qualname x ocaml ) ~ coq ( : qualname x coq ) t
let preserve ( ? rev_namespace = [ ] ) ocaml = translate ~ rev_namespace ~ ocaml ~ coq : ocaml
let rec find ( ? rev_namespace = [ ] ) ~ ocaml t = let prefix = String . concat " . " rev_namespace in match Option . bind ( Table . find_opt prefix t ) ( Namespace . find ~ ocaml ) with | Some coq -> Some coq | None -> ( match rev_namespace with | _ :: rev_namespace -> find ~ rev_namespace ~ ocaml t | _ -> None )
let types_table = let rec ( -- ) x y = if x < y then x :: ( x + 1 -- y ) else [ y ] in let translate_tuples l ns = List . fold_left ( fun ns x -> Namespace . translate ~ ocaml ( : Format . sprintf " Coq_coqffi . Shim . tupl % d " x ) ~ coq ( : Format . sprintf " tupl % d " x ) ns ) ns l in let ns = Namespace . empty |> Namespace . preserve " bool " |> Namespace . translate ~ ocaml " : char " ~ coq " : ascii " |> Namespace . translate ~ ocaml " : int " ~ coq " : i63 " |> Namespace . translate ~ ocaml " : Stdlib . Seq . t " ~ coq " : Seq . t " |> Namespace . translate ~ ocaml " : Stdlib . result " ~ coq " : sum " |> Namespace . translate ~ ocaml " : int32 " ~ coq " : i32 " |> translate_tuples ( 3 -- max_tuple_size ) |> Namespace . preserve " float " |> Namespace . preserve " list " |> Namespace . preserve " option " |> Namespace . preserve " string " |> Namespace . preserve " unit " |> Namespace . preserve " exn " in Table . add " " ns empty
type token = | Range of Ckappa_sig . c_site_name * Ckappa_sig . c_state list | Equiv of ( Ckappa_sig . c_site_name * Ckappa_sig . c_state ) * ( Ckappa_sig . c_site_name * Ckappa_sig . c_state ) | Imply of ( Ckappa_sig . c_site_name * Ckappa_sig . c_state ) * ( Ckappa_sig . c_site_name * Ckappa_sig . c_state ) | Partition of ( Ckappa_sig . c_site_name * ( Ckappa_sig . c_state * token list ) list ) | No_known_translation of ( Ckappa_sig . c_site_name * Ckappa_sig . c_state ) list list
type rename_sites = ( Remanent_parameters_sig . parameters -> Exception . method_handler -> Ckappa_sig . Site_map_and_set . Map . elt -> Exception . method_handler * Ckappa_sig . Site_map_and_set . Map . elt )
let non_relational parameters handler error mvbdu = let error , handler , list = Ckappa_sig . Views_bdu . mvbdu_cartesian_abstraction parameters handler error mvbdu in let error , handler , mvbdu_true = Ckappa_sig . Views_bdu . mvbdu_true parameters handler error in let error , handler , recomposition = List . fold_left ( fun ( error , handler , conjunct ) term -> Ckappa_sig . Views_bdu . mvbdu_and parameters handler error conjunct term ) ( error , handler , mvbdu_true ) list in error , handler , Ckappa_sig . Views_bdu . equal mvbdu recomposition
let try_partitioning parameters handler error ( rename_site_inverse : rename_sites ) mvbdu = let error , handler , mvbdu_true = Ckappa_sig . Views_bdu . mvbdu_true parameters handler error in let error , handler , var_hconsed_list = Ckappa_sig . Views_bdu . variables_list_of_mvbdu parameters handler error mvbdu in let error , handler , var_list = Ckappa_sig . Views_bdu . extensional_of_variables_list parameters handler error var_hconsed_list in let rec aux l ( error , handler ) = match l with | [ ] -> error , handler , None | head :: tail -> let error ' , handler , singleton = Ckappa_sig . Views_bdu . build_variables_list parameters handler error [ head ] in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error_2 , handler , mvbdu_ref = Ckappa_sig . Views_bdu . mvbdu_project_abstract_away parameters handler error mvbdu singleton in let error = Exception . check_point Exception . warn parameters error error_2 __POS__ Exit in let error_3 , handler , proj_in = Ckappa_sig . Views_bdu . mvbdu_project_keep_only parameters handler error mvbdu singleton in let error = Exception . check_point Exception . warn parameters error error_3 __POS__ Exit in let error_4 , handler , list_asso = Ckappa_sig . Views_bdu . extensional_of_mvbdu parameters handler error proj_in in let error = Exception . check_point Exception . warn parameters error error_4 __POS__ Exit in let error_5 , range = let rec aux2 list ( error , output ) = match list with | [ ] -> ( error , output ) | [ ( x , i ) ] :: tail when x = head -> aux2 tail ( error , ( i :: output ) ) | _ :: tail -> aux2 tail ( Exception . warn parameters error __POS__ Exit output ) in aux2 list_asso ( error , [ ] ) in let error = Exception . check_point Exception . warn parameters error error_5 __POS__ Exit in let rec aux3 list ( error , handler , output ) = match list with | [ ] -> error , handler , Some output | h :: t -> begin let error_6 , handler , select = Ckappa_sig . Views_bdu . build_association_list parameters handler error [ head , h ] in let error = Exception . check_point Exception . warn parameters error error_6 __POS__ Exit in let error_7 , handler , mvbdu_case = Ckappa_sig . Views_bdu . mvbdu_redefine parameters handler error mvbdu_true select in let error = Exception . check_point Exception . warn parameters error error_7 __POS__ Exit in let error_8 , handler , case = Ckappa_sig . Views_bdu . mvbdu_and parameters handler error mvbdu_case mvbdu in let error = Exception . check_point Exception . warn parameters error error_8 __POS__ Exit in let error_9 , handler , bool = non_relational parameters handler error case in let error = Exception . check_point Exception . warn parameters error error_9 __POS__ Exit in if bool then let error_10 , handler , away = Ckappa_sig . Views_bdu . mvbdu_project_abstract_away parameters handler error case singleton in let error = Exception . check_point Exception . warn parameters error error_10 __POS__ Exit in if Ckappa_sig . Views_bdu . equal away mvbdu_ref then aux3 t ( error , handler , output ) else let error_11 , handler , list = Ckappa_sig . Views_bdu . mvbdu_cartesian_abstraction parameters handler error away in let error = Exception . check_point Exception . warn parameters error error_11 __POS__ Exit in let error , handler , list = List . fold_left ( fun ( error , handler , list ) elt -> let error , handler , mvbdu_test = Ckappa_sig . Views_bdu . mvbdu_and parameters handler error mvbdu_ref elt in if Ckappa_sig . Views_bdu . equal mvbdu_test mvbdu_ref then error , handler , list else let error_12 , handler , elt = Ckappa_sig . Views_bdu . extensional_of_mvbdu parameters handler error elt in let error = Exception . check_point Exception . warn parameters error error_12 __POS__ Exit in begin let error , var_list_opt = match elt with | [ ] | [ ] :: _ | ( ( _ , _ ) :: _ :: _ ) :: _ -> error , None | [ ( a , b ) ] :: q -> begin let rec aux4 q output = match q with | [ ] -> error , Some ( a , output ) | [ ( c , d ) ] :: q when c = a -> aux4 q ( d :: output ) | _ -> error , None in aux4 q [ b ] end in match var_list_opt with | None -> let error , ( ) = Exception . warn parameters error __POS__ Exit ( ) in error , handler , list | Some ( a , l ) -> let error ' , a ' = rename_site_inverse parameters error a in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in ( error , handler , ( ( Range ( a ' , l ) ) :: list ) ) end ) ( error , handler , [ ] ) ( List . rev list ) in aux3 t ( error , handler , ( ( h , list ) :: output ) ) else error , handler , None end in let error_13 , handler , output = aux3 range ( error , handler , [ ] ) in let error = Exception . check_point Exception . warn parameters error error_13 __POS__ Exit in match output with | None -> aux tail ( error , handler ) | Some l -> let error_14 , head = rename_site_inverse parameters error head in let error = Exception . check_point Exception . warn parameters error error_14 __POS__ Exit in error , handler , Some ( head , l ) in aux var_list ( error , handler )
let translate parameters handler error ( rename_site_inverse : rename_sites ) mvbdu = let error , handler , list = Ckappa_sig . Views_bdu . extensional_of_mvbdu parameters handler error mvbdu in let error , list = List . fold_left ( fun ( error , list ) elt1 -> let error , elt1 = List . fold_left ( fun ( error , list ) ( elt2 , asso ) -> let error , elt2 = rename_site_inverse parameters error elt2 in error , ( elt2 , asso ) :: list ) ( error , [ ] ) ( List . rev elt1 ) in error , elt1 :: list ) ( error , [ ] ) ( List . rev list ) in if Remanent_parameters . get_post_processing parameters then begin let error , handler , vars = Ckappa_sig . Views_bdu . variables_list_of_mvbdu parameters handler error mvbdu in let error , handler , var_list = Ckappa_sig . Views_bdu . extensional_of_variables_list parameters handler error vars in let error , var_list = List . fold_left ( fun ( error , list ) elt -> let error , elt = rename_site_inverse parameters error elt in error , elt :: list ) ( error , [ ] ) ( List . rev var_list ) in match var_list with | [ ] -> error , ( handler , No_known_translation list ) | [ x ] -> let error , list = List . fold_left ( fun ( error , list ) elt -> match elt with | [ a , b ] when a = x -> error , b :: list | _ -> Exception . warn parameters error __POS__ Exit list ) ( error , [ ] ) list in error , ( handler , Range ( x , list ) ) | [ _ ; _ ] -> begin match list with | [ ] | [ _ ] -> Exception . warn parameters error __POS__ Exit ( handler , No_known_translation list ) | [ [ site1 , state1 ; site2 , state2 ] ; [ site1 ' , state1 ' ; site2 ' , state2 ' ] ] -> begin if site1 = site1 ' && site2 = site2 ' then if state1 > state1 ' then error , ( handler , Equiv ( ( site1 , state1 ) , ( site2 , state2 ) ) ) else error , ( handler , Equiv ( ( site1 , state1 ' ) , ( site2 , state2 ' ) ) ) else Exception . warn parameters error __POS__ Exit ( handler , No_known_translation list ) end | [ [ site1 , state1 ; site2 , state2 ] ; [ site1 ' , state1 ' ; site2 ' , state2 ' ] ; [ site1 ' ' , state1 ' ' ; site2 ' ' , state2 ' ' ] ] -> begin if site1 = site1 ' && site1 = site1 ' ' && site2 = site2 ' && site2 = site2 ' ' then if state1 = state1 ' then if state1 < state1 ' ' then error , ( handler , Imply ( ( site1 , state1 ' ' ) , ( site2 , state2 ' ' ) ) ) else error , ( handler , Imply ( ( site2 , if state2 = state2 ' ' then state2 ' else state2 ) , ( ( site1 , state1 ) ) ) ) else if state1 = state1 ' ' then if state1 < state1 ' then error , ( handler , Imply ( ( site1 , state1 ' ) , ( site2 , state2 ' ) ) ) else error , ( handler , Imply ( ( site2 , if state2 = state2 ' then state2 ' ' else state2 ) , ( site1 , state1 ) ) ) else if state1 ' = state1 ' ' then if state1 ' < state1 then error , ( handler , Imply ( ( site1 , state1 ) , ( site2 , state2 ) ) ) else error , ( handler , Imply ( ( site2 , if state2 = state2 ' ' then state2 ' else state2 ' ' ) , ( site1 , state1 ' ) ) ) else error , ( handler , No_known_translation list ) else Exception . warn parameters error __POS__ Exit ( handler , No_known_translation list ) end | _ -> begin let error , handler , output = try_partitioning parameters handler error rename_site_inverse mvbdu in match output with | None -> error , ( handler , No_known_translation list ) | Some ( var , l ) -> error , ( handler , Partition ( var , l ) ) end end | _ -> begin let error , handler , output = try_partitioning parameters handler error rename_site_inverse mvbdu in match output with | None -> error , ( handler , No_known_translation list ) | Some ( var , l ) -> error , ( handler , Partition ( var , l ) ) end end else error , ( handler , No_known_translation list )
let rec print ? beginning_of_sentence ( : beggining = true ) ? prompt_agent_type ( : prompt_agent_type = true ) ? html_mode ( : html_mode = false ) ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type agent_id translation t = let tab = if html_mode then " < PRE > </ PRE " > else " \ t " in let endofline = if html_mode then " < Br >\ n " else " \ n " in let beginenumeration = if html_mode then " < UL >\ n " else " " in let endenumeration = if html_mode then " </ UL >\ n " else " " in let beginenum = if html_mode then " < LI " > else " " + in let endenum = if html_mode then " </ LI >\ n " else " " in let cap s = if beggining then Tools . capitalize s else s in let in_agent s = if prompt_agent_type then " in agent " ^ s " ^ " else " " in let in_agent_comma s = if prompt_agent_type then " in agent " ^ s " , ^ " else " " in let log = Remanent_parameters . get_logger parameters in let error , ( ) = match translation with | Range ( site_type , state_list ) -> begin if dim_min <= 1 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error , t = Site_graphs . KaSa_site_graph . add_site parameters error handler_kappa agent_id site_type t in let error = Site_graphs . KaSa_site_graph . print log parameters error t in let ( ) = Loggers . fprintf log " => " in let should_use_bracket = match state_list with | [ ] | [ _ ] -> false | _ :: _ -> true in let ( ) = if should_use_bracket then Loggers . fprintf log " [ " in let error , _bool = List . fold_left ( fun ( error , bool ) state -> let ( ) = if bool then Loggers . fprintf log " v " in let error , t = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site_type state t in let error = Site_graphs . KaSa_site_graph . print log parameters error t in error , true ) ( error , false ) state_list in let ( ) = if should_use_bracket then Loggers . fprintf log " ] " in let ( ) = Loggers . print_newline log in error , ( ) | Remanent_parameters_sig . Natural_language -> let error ' , site_string = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type site_type in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let rec aux list error = match list with | [ ] -> Exception . warn parameters error __POS__ Exit ( ) | [ state ] -> let error ' , state_string = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , Loggers . fprintf log " and % s . % s " state_string endofline | state :: tail -> let error ' , state_string = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let ( ) = Loggers . fprintf log " % s , " state_string in aux tail error in match state_list with | [ ] -> Exception . warn parameters error __POS__ Exit ( ) | [ state ] -> let error ' , state_string = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , Loggers . fprintf log " % s % s % sis always % s . % s " ( Remanent_parameters . get_prefix parameters ) ( cap site_string ) ( in_agent agent_string ) state_string endofline | [ state1 ; state2 ] -> let error ' , state_string1 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state1 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string2 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state2 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , Loggers . fprintf log " % s % s % sranges over % s and % s . % s " ( Remanent_parameters . get_prefix parameters ) ( cap site_string ) ( in_agent agent_string ) state_string1 state_string2 endofline | list -> let ( ) = Loggers . fprintf log " % s % s % sranges over " ( Remanent_parameters . get_prefix parameters ) ( cap site_string ) ( in_agent agent_string ) in aux list error end else error , ( ) end | Equiv ( ( site1 , state1 ) , ( site2 , state2 ) ) -> if dim_min <= 2 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site1 state1 t in let error , t ' ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site2 state2 t in let error = Site_graphs . KaSa_site_graph . print ( Remanent_parameters . get_logger parameters ) parameters error t ' in let ( ) = Loggers . fprintf ( Remanent_parameters . get_logger parameters ) " <=> " in let error = Site_graphs . KaSa_site_graph . print ( Remanent_parameters . get_logger parameters ) parameters error t ' ' in let ( ) = Loggers . print_newline ( Remanent_parameters . get_logger parameters ) in error , ( ) | Remanent_parameters_sig . Natural_language -> let error ' , site_string1 = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type site1 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string1 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site1 state1 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , site_string2 = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type site2 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string2 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site2 state2 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , Loggers . fprintf ( Remanent_parameters . get_logger parameters ) " % s % s % s is % s , if and only if , % s is % s . % s " ( Remanent_parameters . get_prefix parameters ) ( cap ( in_agent_comma agent_string ) ) site_string1 state_string1 site_string2 state_string2 endofline end else error , ( ) | Imply ( ( site1 , state1 ) , ( site2 , state2 ) ) -> if dim_min <= 2 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error , t = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site1 state1 t in let error , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site2 state2 t in let error = Site_graphs . KaSa_site_graph . print ( Remanent_parameters . get_logger parameters ) parameters error t in let ( ) = Loggers . fprintf ( Remanent_parameters . get_logger parameters ) " => " in let error = Site_graphs . KaSa_site_graph . print ( Remanent_parameters . get_logger parameters ) parameters error t ' in let ( ) = Loggers . print_newline ( Remanent_parameters . get_logger parameters ) in error , ( ) | Remanent_parameters_sig . Natural_language -> let error ' , site_string1 = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type site1 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string1 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site1 state1 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , site_string2 = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type site2 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string2 = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site2 state2 in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , Loggers . fprintf ( Remanent_parameters . get_logger parameters ) " % s % s % s is % s whenever % s is % s . % s " ( Remanent_parameters . get_prefix parameters ) ( cap ( in_agent_comma agent_string ) ) site_string2 state_string2 site_string1 state_string1 endofline end else error , ( ) | Partition ( v , list ) -> let error , site_string = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type v in let parameters = Remanent_parameters . update_prefix parameters tab in let error = List . fold_left ( fun error ( a , list ) -> let error , parameters = match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Natural_language -> let error , state_string = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type v a in let ( ) = Loggers . fprintf log " % swhen % s is equal to % s , then :% s % s " ( Remanent_parameters . get_prefix parameters ) site_string state_string endofline beginenumeration in let parameters = Remanent_parameters . update_prefix parameters ( tab ^ beginenum ^ " " ) in error , parameters | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> error , parameters in let error , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id v a t in let error = List . fold_left ( fun error token -> let error = print ~ beginning_of_sentence : false ~ prompt_agent_type : false ~ html_mode ~ show_dep_with_dimmension_higher_than : 0 parameters handler_kappa error agent_string agent_type agent_id token t ' in let ( ) = Loggers . fprintf log " % s " endenum in error ) error list in let ( ) = Loggers . fprintf log " % s " endenumeration in error ) error list in error , ( ) | No_known_translation list -> begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> begin let error = Site_graphs . KaSa_site_graph . print log parameters error t in let prefix " = " in let ( ) = Loggers . fprintf log " =>\ n % s [ \ n " prefix in let prefix ' = prefix in let prefix " =\ t " in let error , _bool = List . fold_left ( fun ( error , bool ) state_list -> let ( ) = Loggers . fprintf log " % s % s " prefix ( if bool then " v " else " " ) in let error , t ' = List . fold_left ( fun ( error , t ) ( site , state ) -> Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site state t ) ( error , t ) state_list in let error = Site_graphs . KaSa_site_graph . print log parameters error t ' in let ( ) = Loggers . print_newline log in ( error , true ) ) ( error , false ) list in let ( ) = Loggers . fprintf log " % s ] \ n " prefix ' in error , ( ) end | Remanent_parameters_sig . Natural_language -> begin match list with | [ ] -> error , ( ) | head :: _ -> let n = List . length head in if n >= dim_min then let ( ) = Loggers . fprintf log " % s % s " ( Remanent_parameters . get_prefix parameters ) ( cap ( in_agent_comma agent_string ) ) in let error , ( ) = let rec aux l error = match l with | [ a , _ ] -> let error , string = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type a in let ( ) = Loggers . fprintf log " , and % s , " string in error , ( ) | [ ] -> Exception . warn parameters error __POS__ Exit ( ) | ( a , _ ) :: b -> let error , string = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type a in let ( ) = Loggers . fprintf log " , % s " string in aux b error in match head with | [ ] | [ _ ] -> Exception . warn parameters error __POS__ Exit ( ) | ( a , _ ) :: b -> let error , string = Handler . string_of_site_in_natural_language parameters error handler_kappa agent_type a in let ( ) = Loggers . fprintf log " % s " string in aux b error in let ( ) = Loggers . fprintf log " are entangled by the following % i - d relationship :% s " n endofline in let parameters = Remanent_parameters . update_prefix parameters " \ t " in List . fold_left ( fun error l -> let error , bool = List . fold_left ( fun ( error , bool ) ( site_type , state ) -> let error ' , site_string = Handler . string_of_site parameters error handler_kappa agent_type site_type in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' , state_string = Handler . string_of_state_fully_deciphered parameters error handler_kappa agent_type site_type state in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let ( ) = if bool then Loggers . fprintf log " , " else Loggers . fprintf log " % s % s ( " ( Remanent_parameters . get_prefix parameters ) agent_string in let ( ) = Loggers . fprintf log " % s % s " site_string state_string in error , true ) ( error , false ) l in let ( ) = if bool then Loggers . fprintf log " ) % s " endofline in error ) error list , ( ) else error , ( ) end end in error
let rec convert_views_internal_constraints_list_aux ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type agent_id translation t current_list = let error , current_list = match translation with | Range ( site_type , state_list ) -> begin if dim_min <= 1 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error , t = Site_graphs . KaSa_site_graph . add_site parameters error handler_kappa agent_id site_type t in let error ' ' , refinement = List . fold_left ( fun ( error , c_list ) state -> let error ' , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site_type state t in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , t ' :: c_list ) ( error , [ ] ) state_list in let lemma = { Public_data . hyp = t ; Public_data . refinement = refinement } in let current_list = lemma :: current_list in let error = Exception . check_point Exception . warn parameters error error ' ' __POS__ Exit in error , current_list | Remanent_parameters_sig . Natural_language -> error , current_list end else error , current_list end | Equiv ( ( site1 , state1 ) , ( site2 , state2 ) ) -> if dim_min <= 2 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error ' , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site1 state1 t in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' ' ' , t ' ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site2 state2 t in let error = Exception . check_point Exception . warn parameters error error ' ' ' __POS__ Exit in let lemma = { Public_data . hyp = t ' ; Public_data . refinement = [ t ' ' ] } in let current_list = lemma :: current_list in error , List . rev current_list | Remanent_parameters_sig . Natural_language -> error , current_list end else error , current_list | Imply ( ( site1 , state1 ) , ( site2 , state2 ) ) -> if dim_min <= 2 then begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> let error ' , t = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site1 state1 t in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' ' ' , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site2 state2 t in let error = Exception . check_point Exception . warn parameters error error ' ' ' __POS__ Exit in let lemma = { Public_data . hyp = t ; Public_data . refinement = [ t ' ] } in let current_list = lemma :: current_list in error , List . rev current_list | Remanent_parameters_sig . Natural_language -> error , current_list end else error , current_list | Partition ( site_type , list ) -> let error , current_list = List . fold_left ( fun ( error , current_list ) ( state , list ) -> let error ' , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site_type state t in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error ' ' , current_list = List . fold_left ( fun ( error , current_list ) token -> convert_views_internal_constraints_list_aux ~ show_dep_with_dimmension_higher_than : 0 parameters handler_kappa error agent_string agent_type agent_id token t ' current_list ) ( error , current_list ) list in let error = Exception . check_point Exception . warn parameters error error ' ' __POS__ Exit in error , current_list ) ( error , current_list ) list in error , current_list | No_known_translation list -> begin match Remanent_parameters . get_backend_mode parameters with | Remanent_parameters_sig . Kappa | Remanent_parameters_sig . Raw -> begin let error , current_list = let error ' ' , refinement = List . fold_left ( fun ( error , current_list ) state_list -> let error , t ' = List . fold_left ( fun ( error , t ' ) ( site , state ) -> let error ' , t ' = Site_graphs . KaSa_site_graph . add_state parameters error handler_kappa agent_id site state t ' in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in error , t ' ) ( error , t ) state_list in let refinement = t ' :: current_list in error , refinement ) ( error , [ ] ) list in let error = Exception . check_point Exception . warn parameters error error ' ' __POS__ Exit in let lemma = { Public_data . hyp = t ; Public_data . refinement = refinement } in let current_list = lemma :: current_list in error , current_list in error , current_list end | Remanent_parameters_sig . Natural_language -> error , current_list end in error , current_list
let convert_views_internal_constraints_list ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type translation current_list = let t = Site_graphs . KaSa_site_graph . empty in let error ' , agent_id , t = Site_graphs . KaSa_site_graph . add_agent parameters error handler_kappa agent_type t in let error = Exception . check_point Exception . warn parameters error error ' __POS__ Exit in let error , t = match translation with | Range ( site , _ ) -> Site_graphs . KaSa_site_graph . add_site parameters error handler_kappa agent_id site t | Equiv _ | Imply _ | Partition _ | No_known_translation _ -> error , t in convert_views_internal_constraints_list_aux ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type agent_id translation t current_list
let print ? beginning_of_sentence ( : beggining = true ) ? prompt_agent_type ( : prompt_agent_type = true ) ? html_mode ( : html_mode = false ) ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type translation = let t = Site_graphs . KaSa_site_graph . empty in let error , id , t = Site_graphs . KaSa_site_graph . add_agent parameters error handler_kappa agent_type t in print ~ beginning_of_sentence : beggining ~ prompt_agent_type ~ html_mode ~ show_dep_with_dimmension_higher_than : dim_min parameters handler_kappa error agent_string agent_type id translation t
exception Internal_error of [ ` Cannot_parse of exn | ` Ast_changed | ` Doc_comment of Normalize . docstring_error list | ` Comment | ` Comment_dropped of Cmt . t list | ` Warning50 of ( Location . t * Warnings . t ) list ] * ( string * Sexp . t ) list
let internal_error msg kvs = raise ( Internal_error ( msg , kvs ) )
type error = | Invalid_source of { exn : exn } | Unstable of { iteration : int ; prev : string ; next : string } | Ocamlformat_bug of { exn : exn } | User_error of string
let ellipsis n msg = let msg = String . strip msg in if n > 0 && String . length msg > ( n * 2 ) + 10 then Format . sprintf " % s . . . % s " ( String . prefix msg n ) ( String . suffix msg n ) else msg
let ellipsis_cmt = ellipsis 50
let with_file input_name output_file suf ext f = let dir = match output_file with | Some filename -> Filename . dirname filename | None -> Filename . get_temp_dir_name ( ) in let base = Filename . remove_extension ( Filename . basename input_name ) in let tmp = Filename . concat dir ( base ^ suf ^ ext ) in Out_channel . with_file tmp ~ f ; tmp
let dump_ast ~ input_name ? output_file ~ suffix fmt = let ext = " . ast " in with_file input_name output_file suffix ext ( fun oc -> fmt ( Format . formatter_of_out_channel oc ) )
let dump_formatted ~ input_name ? output_file ~ suffix fmted = let ext = Filename . extension input_name in with_file input_name output_file suffix ext ( fun oc -> Out_channel . output_string oc fmted )
let print_error ~ fmt ~ exe ~ debug ~ quiet ~ input_name error = match error with | Invalid_source _ when quiet -> ( ) | Invalid_source { exn } -> ( let reason = match exn with | Syntaxerr . Error _ | Lexer . Error _ -> " ( syntax error ) " | Warning50 _ -> " ( misplaced documentation comments - warning 50 ) " | _ -> " " in Format . fprintf fmt " % s : ignoring % S % s \ n " %! exe input_name reason ; match exn with | Syntaxerr . Error _ | Lexer . Error _ -> Location . report_exception fmt exn | Warning50 l -> List . iter l ~ f ( : fun ( l , w ) -> print_warning l w ) ; Format . fprintf fmt " { @< warning > Hint } @: ( Warning 50 ) This file contains a \ documentation comment that the OCaml compiler does \ not know how to attach to the AST . OCamlformat does not \ support these cases . You can find more information at : \ https :// github . com / ocaml - ppx / ocamlformat # overview . If you ' d \ like to disable this check and let ocamlformat make a choice \ ( though it might not be consistent with the ocaml compilers \ and odoc ) , you can set the -- no - comment - check option . \ n \ " %! | exn -> Format . fprintf fmt " % s \ n " %! ( Exn . to_string exn ) ) | Unstable { iteration ; prev ; next } -> if debug then ( let ext = Filename . extension input_name in let input_name = Filename . chop_extension ( Filename . basename input_name ) in let p = Filename . temp_file input_name ( Printf . sprintf " . prev % s " ext ) in Out_channel . write_all p ~ data : prev ; let n = Filename . temp_file input_name ( Printf . sprintf " . next % s " ext ) in Out_channel . write_all n ~ data : next ; ignore ( Unix . system ( Printf . sprintf " diff % S % S 1 >& 2 " p n ) ) ; Unix . unlink p ; Unix . unlink n ) ; if iteration <= 1 then Format . fprintf fmt " % s : % S was not already formatted . ( [ max - iters = 1 ] ) \ n " %! exe input_name else ( Format . fprintf fmt " % s : Cannot process % S . \ n \ \ Please report this bug at \ https :// github . com / ocaml - ppx / ocamlformat / issues . \ n \ " %! exe input_name ; Format . fprintf fmt " BUG : formatting did not stabilize after % i iterations . \ n " %! iteration ) | User_error msg -> Format . fprintf fmt " % s : % s . \ n " %! exe msg | Ocamlformat_bug { exn } -> ( Format . fprintf fmt " % s : Cannot process % S . \ n \ \ Please report this bug at \ https :// github . com / ocaml - ppx / ocamlformat / issues . \ n \ " %! exe input_name ; match exn with | Internal_error ( m , l ) -> let s = match m with | ` Cannot_parse _ -> " generating invalid ocaml syntax " | ` Ast_changed -> " ast changed " | ` Doc_comment _ -> " doc comments changed " | ` Comment -> " comments changed " | ` Comment_dropped _ -> " comments dropped " | ` Warning50 _ -> " misplaced documentation comments " in Format . fprintf fmt " BUG : % s . \ n " %! s ; ( match m with | ` Doc_comment l when not quiet -> List . iter l ~ f ( : function | Normalize . Moved ( loc_before , loc_after , msg ) -> if Location . compare loc_before Location . none = 0 then Format . fprintf fmt " { %!@< loc >% a } , @:@\ { @< error > Error } @: Docstring added . \ n \ " %! Location . print loc_after ( ellipsis_cmt msg ) else if Location . compare loc_after Location . none = 0 then Format . fprintf fmt " { %!@< loc >% a } , @:@\ { @< error > Error } @: Docstring dropped . \ n \ " %! Location . print loc_before ( ellipsis_cmt msg ) else Format . fprintf fmt " { %!@< loc >% a } , @:@\ { @< error > Error } @: Docstring moved to \ { @< loc >% a } . @\ n \ " %! Location . print loc_before ( ellipsis_cmt msg ) Location . print loc_after | Normalize . Unstable ( loc , s ) -> Format . fprintf fmt " { %!@< loc >% a } , @:@\ { @< error > Error } @: Formatting of is \ unstable ( e . g . parses as a list or not depending on \ the margin ) , please tighten up this comment in the \ source or disable the formatting using the option \ -- no - parse - docstrings . \ n \ " %! Location . print loc ( ellipsis_cmt s ) ) | ` Comment_dropped l when not quiet -> List . iter l ~ f ( : fun Cmt . { txt = msg ; loc } -> Format . fprintf fmt " { %!@< loc >% a } , @:@\ { @< error > Error } @: Comment dropped . \ n \ " %! Location . print loc ( ellipsis_cmt msg ) ) | ` Cannot_parse ( ( Syntaxerr . Error _ | Lexer . Error _ ) as exn ) -> if debug then Location . report_exception fmt exn | ` Warning50 l -> if debug then List . iter l ~ f ( : fun ( l , w ) -> print_warning l w ) | _ -> ( ) ) ; if debug then List . iter l ~ f ( : fun ( msg , sexp ) -> Format . fprintf fmt " % s : % s \ n " %! msg ( Sexp . to_string sexp ) ) | exn -> Format . fprintf fmt " BUG : unhandled exception . Use [ -- debug ] for details . \ n " %! ; if debug then Format . fprintf fmt " % s \ n " %! ( Exn . to_string exn ) )
let check_all_locations fmt cmts_t = match Cmts . remaining_locs cmts_t with | [ ] -> ( ) | l -> let print l = Format . fprintf fmt " % a \ n " %! Location . print l in Format . fprintf fmt " Warning : Some locations have not been considered \ n " %! ; List . iter ~ f : print ( List . sort l ~ compare : Location . compare )
let check_margin conf ~ filename ~ fmted = List . iteri ( String . split_lines fmted ) ~ f ( : fun i line -> if String . length line > conf . Conf . margin then Format . fprintf Format . err_formatter " Warning : % s :% i exceeds the margin \ n " %! filename i )
let with_optional_box_debug ~ box_debug k = if box_debug then Fmt . with_box_debug k else k
let with_buffer_formatter ~ buffer_size k = let buffer = Buffer . create buffer_size in let fs = Format_ . formatter_of_buffer buffer in Fmt . eval fs k ; Format_ . pp_print_flush fs ( ) ; if Buffer . length buffer > 0 then Format_ . pp_print_newline fs ( ) ; Buffer . contents buffer
let equal fragment ~ ignore_doc_comments c a b = Normalize . equal fragment ~ ignore_doc_comments c a . Parse_with_comments . ast b . Parse_with_comments . ast
let normalize fragment c { Parse_with_comments . ast ; _ } = Normalize . normalize fragment c ast
let recover ( type a ) : a Traverse . fragment -> _ = function | Traverse . Structure -> Parse_wyc . Make_parsable . structure | Traverse . Signature -> Parse_wyc . Make_parsable . signature | Traverse . Use_file -> Parse_wyc . Make_parsable . use_file
let format fragment ? output_file ~ input_name ~ prev_source ~ parsed conf opts = let open Result . Monad_infix in let dump_ast ~ suffix ast = if opts . Conf . debug then Some ( dump_ast ~ input_name ? output_file ~ suffix ( fun fmt -> Migrate_ast . Printast . fragment fragment fmt ast ) ) else None in let dump_formatted ~ suffix fmted = if opts . debug then Some ( dump_formatted ~ input_name ? output_file ~ suffix fmted ) else None in Ocaml_common . Location . input_name := input_name ; let rec print_check ~ i ( ~ conf : Conf . t ) ~ prev_source t = let format ~ box_debug = let open Fmt in let cmts_t = Cmts . init fragment ~ debug : opts . debug t . source t . ast t . comments in let contents = with_buffer_formatter ~ buffer_size ( : String . length prev_source ) ( set_margin conf . margin $ opt conf . max_indent set_max_indent $ fmt_if_k ( not ( String . is_empty t . prefix ) ) ( str t . prefix $ fmt " . " ) @ $ with_optional_box_debug ~ box_debug ( Fmt_ast . fmt_fragment fragment ~ debug : opts . debug t . source cmts_t conf t . ast ) ) in ( contents , cmts_t ) in if opts . debug then format ~ box_debug : true |> fst |> dump_formatted ~ suffix " . : boxes " |> ( ignore : string option -> unit ) ; let fmted , cmts_t = format ~ box_debug : false in let conf = if opts . debug then conf else { conf with Conf . quiet = true } in if String . equal prev_source fmted then ( if opts . debug then check_all_locations Format . err_formatter cmts_t ; if opts . Conf . margin_check then check_margin conf ~ fmted ~ filename ( : Option . value output_file ~ default : input_name ) ; Ok fmted ) else let exn_args ( ) = [ ( " output file " , dump_formatted ~ suffix " . : invalid - ast " fmted ) ] |> List . filter_map ~ f ( : fun ( s , f_opt ) -> Option . map f_opt ~ f ( : fun f -> ( s , String . sexp_of_t f ) ) ) in ( match parse fragment conf ~ source : fmted with | exception Sys_error msg -> Error ( User_error msg ) | exception Warning50 l -> internal_error ( ` Warning50 l ) ( exn_args ( ) ) | exception exn -> if opts . Conf . format_invalid_files then ( match parse fragment conf ~ source ( : recover fragment fmted ) with | exception exn -> internal_error ( ` Cannot_parse exn ) ( exn_args ( ) ) | t_new -> Format . fprintf Format . err_formatter " Warning : % s is invalid , recovering . \ n " %! input_name ; Ok t_new ) else internal_error ( ` Cannot_parse exn ) ( exn_args ( ) ) | t_new -> Ok t_new ) >>= fun t_new -> ( if not ( equal fragment ~ ignore_doc_comments ( : not conf . comment_check ) conf t t_new ) then let old_ast = dump_ast ~ suffix " . : old " ( normalize fragment conf t ) in let new_ast = dump_ast ~ suffix " . : new " ( normalize fragment conf t_new ) in let args ~ suffix = [ ( " output file " , dump_formatted ~ suffix fmted ) ; ( " old ast " , old_ast ) ; ( " new ast " , new_ast ) ] |> List . filter_map ~ f ( : fun ( s , f_opt ) -> Option . map f_opt ~ f ( : fun f -> ( s , String . sexp_of_t f ) ) ) in if equal fragment ~ ignore_doc_comments : true conf t t_new then let docstrings = Normalize . moved_docstrings fragment conf t . Parse_with_comments . ast t_new . Parse_with_comments . ast in let args = args ~ suffix " . : unequal - docs " in internal_error ( ` Doc_comment docstrings ) args else let args = args ~ suffix " . : unequal - ast " in internal_error ` Ast_changed args ) ; if conf . comment_check then ( ( match Cmts . remaining_comments cmts_t with | [ ] -> ( ) | l -> internal_error ( ` Comment_dropped l ) [ ] ) ; let is_docstring Cmt . { txt ; _ } = conf . parse_docstrings && Char . equal txt . [ 0 ] ' ' * in let old_docstrings , old_comments = List . partition_tf t . comments ~ f : is_docstring in let t_newdocstrings , t_newcomments = List . partition_tf t_new . comments ~ f : is_docstring in let f = ellipsis_cmt in let f x = Either . First . map ~ f x |> Either . Second . map ~ f in let diff_cmts = Sequence . append ( Cmts . diff conf old_comments t_newcomments ) ( Fmt_odoc . diff conf old_docstrings t_newdocstrings ) |> Sequence . map ~ f in if not ( Sequence . is_empty diff_cmts ) then let old_ast = dump_ast ~ suffix " . : old " t . ast in let new_ast = dump_ast ~ suffix " . : new " t_new . ast in let args = [ ( " diff " , Some ( Sequence . sexp_of_t ( Either . sexp_of_t String . sexp_of_t String . sexp_of_t ) diff_cmts ) ) ; ( " old ast " , Option . map old_ast ~ f : String . sexp_of_t ) ; ( " new ast " , Option . map new_ast ~ f : String . sexp_of_t ) ] |> List . filter_map ~ f ( : fun ( s , f_opt ) -> Option . map f_opt ~ f ( : fun f -> ( s , f ) ) ) in internal_error ` Comment args ) ; if i >= conf . max_iters then ( Caml . flush_all ( ) ; Error ( Unstable { iteration = i ; prev = prev_source ; next = fmted } ) ) else print_check ~ i ( : i + 1 ) ~ conf ~ prev_source : fmted t_new in try print_check ~ i : 1 ~ conf ~ prev_source parsed with | Sys_error msg -> Error ( User_error msg ) | exn -> Error ( Ocamlformat_bug { exn } )
let parse_result fragment conf ( opts : Conf . opts ) ~ source ~ input_name = match parse fragment conf ~ source with | exception exn -> if opts . format_invalid_files then ( match parse fragment conf ~ source ( : recover fragment source ) with | exception exn -> Error ( Invalid_source { exn } ) | parsed -> Format . fprintf Format . err_formatter " Warning : % s is invalid , recovering . \ n " %! input_name ; Ok parsed ) else Error ( Invalid_source { exn } ) | parsed -> Ok parsed
let parse_and_format fragment ? output_file ~ input_name ~ source conf opts = Ocaml_common . Location . input_name := input_name ; let open Result . Monad_infix in parse_result fragment conf opts ~ source ~ input_name >>= fun parsed -> format fragment ? output_file ~ input_name ~ prev_source : source ~ parsed conf opts
module Config = struct type config = { generator_config : Michelson_generation . generator_config ; michelson_terms_file : string option ; } let default_config = { generator_config = Michelson_generation . default_generator_config ; michelson_terms_file = None ; } let config_encoding = let open Data_encoding in conv ( fun { generator_config ; michelson_terms_file } -> ( generator_config , michelson_terms_file ) ) ( fun ( generator_config , michelson_terms_file ) -> { generator_config ; michelson_terms_file } ) ( obj2 ( req " generator_config " Michelson_generation . generator_config_encoding ) ( opt " michelson_terms_file " string ) ) end
module Default_boilerplate = struct type workload = Translator_workload . t let workload_encoding = Translator_workload . encoding let workload_to_vector = Translator_workload . workload_to_sparse_vec let tags = [ Tags . translator ] let make_models t_kind code_or_data = [ ( " gas_translator_model " , Translator_model . gas_based_model t_kind code_or_data ) ; ( " size_translator_model " , Translator_model . size_based_model t_kind code_or_data ) ; ] end
type phase = Workload_production | In_protocol | Global
type error_kind = | Global_error of { benchmark_name : string ; workload : Tezos_base . TzPervasives . tztrace ; } | Bad_data of { benchmark_name : string ; micheline : Alpha_context . Script . expr ; expected_type : Alpha_context . Script . expr ; phase : phase ; } | Bad_code of { benchmark_name : string ; micheline : Alpha_context . Script . expr ; expected_stack_type : Alpha_context . Script . expr list ; phase : phase ; }
let pp_phase fmtr ( phase : phase ) = match phase with | Workload_production -> Format . fprintf fmtr " workload production " | In_protocol -> Format . fprintf fmtr " in protocol " | Global -> Format . fprintf fmtr " global "
let report_michelson_errors fmtr errs = Michelson_v1_error_reporter . report_errors ~ details : true ~ show_source : true fmtr errs