text stringlengths 12 786k |
|---|
let buffer_add_char buf c = buffer_check_size buf 1 ; Bytes . set buf . bytes buf . ind c ; buf . ind <- buf . ind + 1 |
let buffer_add_string buf s = let str_len = String . length s in buffer_check_size buf str_len ; String . blit s 0 buf . bytes buf . ind str_len ; buf . ind <- buf . ind + str_len |
let buffer_contents buf = Bytes . sub_string buf . bytes 0 buf . ind |
let char_of_iconv iconv = match iconv with | Int_d | Int_pd | Int_sd | Int_Cd -> ' d ' | Int_i | Int_pi | Int_si | Int_Ci -> ' i ' | Int_x | Int_Cx -> ' x ' | Int_X | Int_CX -> ' X ' | Int_o | Int_Co -> ' o ' | Int_u | Int_Cu -> ' u ' |
let char_of_fconv ( ? cF = ' F ' ) fconv = match snd fconv with | Float_f -> ' f ' | Float_e -> ' e ' | Float_E -> ' E ' | Float_g -> ' g ' | Float_G -> ' G ' | Float_F -> cF | Float_h -> ' h ' | Float_H -> ' H ' |
let char_of_counter counter = match counter with | Line_counter -> ' l ' | Char_counter -> ' n ' | Token_counter -> ' N ' |
let bprint_char_set buf char_set = let rec print_start set = let is_alone c = let before , after = Char . ( chr ( code c - 1 ) , chr ( code c + 1 ) ) in is_in_char_set set c && not ( is_in_char_set set before && is_in_char_set set after ) in if is_alone ' ] ' then buffer_add_char buf ' ] ' ; print_out set 1 ; if is_alone ' ' - then buffer_add_char buf ' ' - and print_out set i = if i < 256 then if is_in_char_set set ( char_of_int i ) then print_first set i else print_out set ( i + 1 ) and print_first set i = match char_of_int i with | ' \ 255 ' -> print_char buf 255 | ' ] ' | ' ' - -> print_out set ( i + 1 ) | _ -> print_second set ( i + 1 ) and print_second set i = if is_in_char_set set ( char_of_int i ) then match char_of_int i with | ' \ 255 ' -> print_char buf 254 ; print_char buf 255 | ( ' ] ' | ' ' ) - when not ( is_in_char_set set ( char_of_int ( i + 1 ) ) ) -> print_char buf ( i - 1 ) ; print_out set ( i + 1 ) | _ when not ( is_in_char_set set ( char_of_int ( i + 1 ) ) ) -> print_char buf ( i - 1 ) ; print_char buf i ; print_out set ( i + 2 ) | _ -> print_in set ( i - 1 ) ( i + 2 ) else ( print_char buf ( i - 1 ) ; print_out set ( i + 1 ) ) and print_in set i j = if j = 256 || not ( is_in_char_set set ( char_of_int j ) ) then ( print_char buf i ; print_char buf ( int_of_char ' ' ) ; - print_char buf ( j - 1 ) ; if j < 256 then print_out set ( j + 1 ) ) else print_in set i ( j + 1 ) and print_char buf i = match char_of_int i with | ' ' % -> buffer_add_char buf ' ' ; % buffer_add_char buf ' ' % | ' ' @ -> buffer_add_char buf ' ' ; % buffer_add_char buf ' ' @ | c -> buffer_add_char buf c in buffer_add_char buf ' [ ' ; print_start ( if is_in_char_set char_set ' \ 000 ' then ( buffer_add_char buf ' ' ; ^ rev_char_set char_set ) else char_set ) ; buffer_add_char buf ' ] ' |
let bprint_padty buf padty = match padty with | Left -> buffer_add_char buf ' ' - | Right -> ( ) | Zeros -> buffer_add_char buf ' 0 ' |
let bprint_ignored_flag buf ign_flag = if ign_flag then buffer_add_char buf ' _ ' |
let bprint_pad_opt buf pad_opt = match pad_opt with | None -> ( ) | Some width -> buffer_add_string buf ( Int . to_string width ) |
let bprint_padding : type a b . buffer -> ( a , b ) padding -> unit = fun buf pad -> match pad with | No_padding -> ( ) | Lit_padding ( padty , n ) -> bprint_padty buf padty ; buffer_add_string buf ( Int . to_string n ) | Arg_padding padty -> bprint_padty buf padty ; buffer_add_char buf ' ' * |
let bprint_precision : type a b . buffer -> ( a , b ) precision -> unit = fun buf prec -> match prec with | No_precision -> ( ) | Lit_precision n -> buffer_add_char buf ' . ' ; buffer_add_string buf ( Int . to_string n ) | Arg_precision -> buffer_add_string buf " . " * |
let bprint_iconv_flag buf iconv = match iconv with | Int_pd | Int_pi -> buffer_add_char buf ' ' + | Int_sd | Int_si -> buffer_add_char buf ' ' | Int_Cx | Int_CX | Int_Co | Int_Cd | Int_Ci | Int_Cu -> buffer_add_char buf ' ' # | Int_d | Int_i | Int_x | Int_X | Int_o | Int_u -> ( ) |
let bprint_int_fmt buf ign_flag iconv pad prec = buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_iconv_flag buf iconv ; bprint_padding buf pad ; bprint_precision buf prec ; buffer_add_char buf ( char_of_iconv iconv ) |
let bprint_altint_fmt buf ign_flag iconv pad prec c = buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_iconv_flag buf iconv ; bprint_padding buf pad ; bprint_precision buf prec ; buffer_add_char buf c ; buffer_add_char buf ( char_of_iconv iconv ) |
let bprint_fconv_flag buf fconv = match fst fconv with | Float_flag_p -> buffer_add_char buf ' ' + | Float_flag_s -> buffer_add_char buf ' ' | Float_flag_ -> ( ) |
let bprint_float_fmt buf ign_flag fconv pad prec = buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_fconv_flag buf fconv ; bprint_padding buf pad ; bprint_precision buf prec ; buffer_add_char buf ( char_of_fconv fconv ) |
let string_of_formatting_lit formatting_lit = match formatting_lit with | Close_box -> " ] " @ | Close_tag -> " } " @ | Break ( str , _ , _ ) -> str | FFlush -> " " @? | Force_newline -> " @\ n " | Flush_newline -> " . " @ | Magic_size ( str , _ ) -> str | Escaped_at -> " " @@ | Escaped_percent -> " " @% | Scan_indic c -> " " @ ^ String . make 1 c |
let string_of_formatting_gen : type a b c d e f . ( a , b , c , d , e , f ) formatting_gen -> string = fun formatting_gen -> match formatting_gen with | Open_tag ( Format ( _ , str ) ) -> str | Open_box ( Format ( _ , str ) ) -> str |
let bprint_char_literal buf chr = match chr with | ' ' % -> buffer_add_string buf " " %% | _ -> buffer_add_char buf chr |
let bprint_string_literal buf str = for i = 0 to String . length str - 1 do bprint_char_literal buf str . [ i ] done |
let rec bprint_fmtty : type a b c d e f g h i j k l . buffer -> ( a , b , c , d , e , f , g , h , i , j , k , l ) fmtty_rel -> unit = fun buf fmtty -> match fmtty with | Char_ty rest -> buffer_add_string buf " % c " ; bprint_fmtty buf rest | String_ty rest -> buffer_add_string buf " % s " ; bprint_fmtty buf rest | Int_ty rest -> buffer_add_string buf " % i " ; bprint_fmtty buf rest | Int32_ty rest -> buffer_add_string buf " % li " ; bprint_fmtty buf rest | Nativeint_ty rest -> buffer_add_string buf " % ni " ; bprint_fmtty buf rest | Int64_ty rest -> buffer_add_string buf " % Li " ; bprint_fmtty buf rest | Float_ty rest -> buffer_add_string buf " % f " ; bprint_fmtty buf rest | Bool_ty rest -> buffer_add_string buf " % B " ; bprint_fmtty buf rest | Alpha_ty rest -> buffer_add_string buf " % a " ; bprint_fmtty buf rest | Theta_ty rest -> buffer_add_string buf " % t " ; bprint_fmtty buf rest | Any_ty rest -> buffer_add_string buf " " ; %? bprint_fmtty buf rest | Reader_ty rest -> buffer_add_string buf " % r " ; bprint_fmtty buf rest | Ignored_reader_ty rest -> buffer_add_string buf " % _r " ; bprint_fmtty buf rest | Format_arg_ty ( sub_fmtty , rest ) -> buffer_add_string buf " { " ; % bprint_fmtty buf sub_fmtty ; buffer_add_string buf " } " ; % bprint_fmtty buf rest | Format_subst_ty ( sub_fmtty , _ , rest ) -> buffer_add_string buf " ( " ; % bprint_fmtty buf sub_fmtty ; buffer_add_string buf " ) " ; % bprint_fmtty buf rest | End_of_fmtty -> ( ) |
let rec int_of_custom_arity : type a b c . ( a , b , c ) custom_arity -> int = function | Custom_zero -> 0 | Custom_succ x -> 1 + int_of_custom_arity x |
let bprint_fmt buf fmt = let rec fmtiter : type a b c d e f . ( a , b , c , d , e , f ) fmt -> bool -> unit = fun fmt ign_flag -> match fmt with | String ( pad , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_padding buf pad ; buffer_add_char buf ' s ' ; fmtiter rest false | Caml_string ( pad , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_padding buf pad ; buffer_add_char buf ' S ' ; fmtiter rest false | Int ( iconv , pad , prec , rest ) -> bprint_int_fmt buf ign_flag iconv pad prec ; fmtiter rest false | Int32 ( iconv , pad , prec , rest ) -> bprint_altint_fmt buf ign_flag iconv pad prec ' l ' ; fmtiter rest false | Nativeint ( iconv , pad , prec , rest ) -> bprint_altint_fmt buf ign_flag iconv pad prec ' n ' ; fmtiter rest false | Int64 ( iconv , pad , prec , rest ) -> bprint_altint_fmt buf ign_flag iconv pad prec ' L ' ; fmtiter rest false | Float ( fconv , pad , prec , rest ) -> bprint_float_fmt buf ign_flag fconv pad prec ; fmtiter rest false | Char rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' c ' ; fmtiter rest false | Caml_char rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' C ' ; fmtiter rest false | Bool ( pad , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_padding buf pad ; buffer_add_char buf ' B ' ; fmtiter rest false | Alpha rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' a ' ; fmtiter rest false | Theta rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' t ' ; fmtiter rest false | Custom ( arity , _ , rest ) -> for _i = 1 to int_of_custom_arity arity do buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' ' ? done ; fmtiter rest false | Reader rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ' r ' ; fmtiter rest false | Flush rest -> buffer_add_string buf " " ; %! fmtiter rest ign_flag | String_literal ( str , rest ) -> bprint_string_literal buf str ; fmtiter rest ign_flag | Char_literal ( chr , rest ) -> bprint_char_literal buf chr ; fmtiter rest ign_flag | Format_arg ( pad_opt , fmtty , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_pad_opt buf pad_opt ; buffer_add_char buf ' { ' ; bprint_fmtty buf fmtty ; buffer_add_char buf ' ' ; % buffer_add_char buf ' } ' ; fmtiter rest false | Format_subst ( pad_opt , fmtty , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_pad_opt buf pad_opt ; buffer_add_char buf ' ( ' ; bprint_fmtty buf fmtty ; buffer_add_char buf ' ' ; % buffer_add_char buf ' ) ' ; fmtiter rest false | Scan_char_set ( width_opt , char_set , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_pad_opt buf width_opt ; bprint_char_set buf char_set ; fmtiter rest false | Scan_get_counter ( counter , rest ) -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; buffer_add_char buf ( char_of_counter counter ) ; fmtiter rest false | Scan_next_char rest -> buffer_add_char buf ' ' ; % bprint_ignored_flag buf ign_flag ; bprint_string_literal buf " 0c " ; fmtiter rest false | Ignored_param ( ign , rest ) -> let ( Param_format_EBB fmt ' ) = param_format_of_ignored_format ign rest in fmtiter fmt ' true | Formatting_lit ( fmting_lit , rest ) -> bprint_string_literal buf ( string_of_formatting_lit fmting_lit ) ; fmtiter rest ign_flag | Formatting_gen ( fmting_gen , rest ) -> bprint_string_literal buf " { " ; @ bprint_string_literal buf ( string_of_formatting_gen fmting_gen ) ; fmtiter rest ign_flag | End_of_format -> ( ) in fmtiter fmt false |
let string_of_fmt fmt = let buf = buffer_create 16 in bprint_fmt buf fmt ; buffer_contents buf |
type ( _ , _ ) eq = Refl : ( ' a , ' a ) eq |
let rec symm : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 . ( a1 , b1 , c1 , d1 , e1 , f1 , a2 , b2 , c2 , d2 , e2 , f2 ) fmtty_rel -> ( a2 , b2 , c2 , d2 , e2 , f2 , a1 , b1 , c1 , d1 , e1 , f1 ) fmtty_rel = function | Char_ty rest -> Char_ty ( symm rest ) | Int_ty rest -> Int_ty ( symm rest ) | Int32_ty rest -> Int32_ty ( symm rest ) | Int64_ty rest -> Int64_ty ( symm rest ) | Nativeint_ty rest -> Nativeint_ty ( symm rest ) | Float_ty rest -> Float_ty ( symm rest ) | Bool_ty rest -> Bool_ty ( symm rest ) | String_ty rest -> String_ty ( symm rest ) | Theta_ty rest -> Theta_ty ( symm rest ) | Alpha_ty rest -> Alpha_ty ( symm rest ) | Any_ty rest -> Any_ty ( symm rest ) | Reader_ty rest -> Reader_ty ( symm rest ) | Ignored_reader_ty rest -> Ignored_reader_ty ( symm rest ) | Format_arg_ty ( ty , rest ) -> Format_arg_ty ( ty , symm rest ) | Format_subst_ty ( ty1 , ty2 , rest ) -> Format_subst_ty ( ty2 , ty1 , symm rest ) | End_of_fmtty -> End_of_fmtty |
let rec fmtty_rel_det : type a1 b c d1 e1 f1 a2 d2 e2 f2 . ( a1 , b , c , d1 , e1 , f1 , a2 , b , c , d2 , e2 , f2 ) fmtty_rel -> ( ( f1 , f2 ) eq -> ( a1 , a2 ) eq ) * ( ( a1 , a2 ) eq -> ( f1 , f2 ) eq ) * ( ( e1 , e2 ) eq -> ( d1 , d2 ) eq ) * ( ( d1 , d2 ) eq -> ( e1 , e2 ) eq ) = function | End_of_fmtty -> ( fun Refl -> Refl ) , ( fun Refl -> Refl ) , ( fun Refl -> Refl ) , fun Refl -> Refl | Char_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | String_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Int_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Int32_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Int64_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Nativeint_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Float_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Bool_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Theta_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Alpha_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Any_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Reader_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ( fun Refl -> let Refl = ed Refl in Refl ) , fun Refl -> let Refl = de Refl in Refl ) | Ignored_reader_ty rest -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ( fun Refl -> let Refl = ed Refl in Refl ) , fun Refl -> let Refl = de Refl in Refl ) | Format_arg_ty ( _ty , rest ) -> let fa , af , ed , de = fmtty_rel_det rest in ( ( fun Refl -> let Refl = fa Refl in Refl ) , ( fun Refl -> let Refl = af Refl in Refl ) , ed , de ) | Format_subst_ty ( ty1 , ty2 , rest ) -> let fa , af , ed , de = fmtty_rel_det rest in let ty = trans ( symm ty1 ) ty2 in let ag , ga , dj , jd = fmtty_rel_det ty in ( ( fun Refl -> let Refl = fa Refl in let Refl = ag Refl in Refl ) , ( fun Refl -> let Refl = ga Refl in let Refl = af Refl in Refl ) , ( fun Refl -> let Refl = ed Refl in let Refl = dj Refl in Refl ) , fun Refl -> let Refl = jd Refl in let Refl = de Refl in Refl ) | Foo _ , _ | _ , Foo _ -> assert false ) * type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 a3 b3 c3 d3 e3 f3 . ( a1 , b1 , c1 , d1 , e1 , f1 , a2 , b2 , c2 , d2 , e2 , f2 ) fmtty_rel -> ( a2 , b2 , c2 , d2 , e2 , f2 , a3 , b3 , c3 , d3 , e3 , f3 ) fmtty_rel -> ( a1 , b1 , c1 , d1 , e1 , f1 , a3 , b3 , c3 , d3 , e3 , f3 ) fmtty_rel = fun ty1 ty2 -> match ty1 , ty2 with | Char_ty rest1 , Char_ty rest2 -> Char_ty ( trans rest1 rest2 ) | String_ty rest1 , String_ty rest2 -> String_ty ( trans rest1 rest2 ) | Bool_ty rest1 , Bool_ty rest2 -> Bool_ty ( trans rest1 rest2 ) | Int_ty rest1 , Int_ty rest2 -> Int_ty ( trans rest1 rest2 ) | Int32_ty rest1 , Int32_ty rest2 -> Int32_ty ( trans rest1 rest2 ) | Int64_ty rest1 , Int64_ty rest2 -> Int64_ty ( trans rest1 rest2 ) | Nativeint_ty rest1 , Nativeint_ty rest2 -> Nativeint_ty ( trans rest1 rest2 ) | Float_ty rest1 , Float_ty rest2 -> Float_ty ( trans rest1 rest2 ) | Alpha_ty rest1 , Alpha_ty rest2 -> Alpha_ty ( trans rest1 rest2 ) | Alpha_ty _ , _ -> assert false | _ , Alpha_ty _ -> assert false | Theta_ty rest1 , Theta_ty rest2 -> Theta_ty ( trans rest1 rest2 ) | Theta_ty _ , _ -> assert false | _ , Theta_ty _ -> assert false | Any_ty rest1 , Any_ty rest2 -> Any_ty ( trans rest1 rest2 ) | Any_ty _ , _ -> assert false | _ , Any_ty _ -> assert false | Reader_ty rest1 , Reader_ty rest2 -> Reader_ty ( trans rest1 rest2 ) | Reader_ty _ , _ -> assert false | _ , Reader_ty _ -> assert false | Ignored_reader_ty rest1 , Ignored_reader_ty rest2 -> Ignored_reader_ty ( trans rest1 rest2 ) | Ignored_reader_ty _ , _ -> assert false | _ , Ignored_reader_ty _ -> assert false | Format_arg_ty ( ty1 , rest1 ) , Format_arg_ty ( ty2 , rest2 ) -> Format_arg_ty ( trans ty1 ty2 , trans rest1 rest2 ) | Format_arg_ty _ , _ -> assert false | _ , Format_arg_ty _ -> assert false | Format_subst_ty ( ty11 , ty12 , rest1 ) , Format_subst_ty ( ty21 , ty22 , rest2 ) -> let ty = trans ( symm ty12 ) ty21 in let _ , f2 , _ , f4 = fmtty_rel_det ty in let Refl = f2 Refl in let Refl = f4 Refl in Format_subst_ty ( ty11 , ty22 , trans rest1 rest2 ) | Format_subst_ty _ , _ -> assert false | _ , Format_subst_ty _ -> assert false | End_of_fmtty , End_of_fmtty -> End_of_fmtty | End_of_fmtty , _ -> assert false | _ , End_of_fmtty -> assert false |
let rec fmtty_of_formatting_gen : type a b c d e f . ( a , b , c , d , e , f ) formatting_gen -> ( a , b , c , d , e , f ) fmtty = fun formatting_gen -> match formatting_gen with | Open_tag ( Format ( fmt , _ ) ) -> fmtty_of_fmt fmt | Open_box ( Format ( fmt , _ ) ) -> fmtty_of_fmt fmt type a b c d e f . ( a , b , c , d , e , f ) fmt -> ( a , b , c , d , e , f ) fmtty = fun fmtty -> match fmtty with | String ( pad , rest ) -> fmtty_of_padding_fmtty pad ( String_ty ( fmtty_of_fmt rest ) ) | Caml_string ( pad , rest ) -> fmtty_of_padding_fmtty pad ( String_ty ( fmtty_of_fmt rest ) ) | Int ( _ , pad , prec , rest ) -> let ty_rest = fmtty_of_fmt rest in let prec_ty = fmtty_of_precision_fmtty prec ( Int_ty ty_rest ) in fmtty_of_padding_fmtty pad prec_ty | Int32 ( _ , pad , prec , rest ) -> let ty_rest = fmtty_of_fmt rest in let prec_ty = fmtty_of_precision_fmtty prec ( Int32_ty ty_rest ) in fmtty_of_padding_fmtty pad prec_ty | Nativeint ( _ , pad , prec , rest ) -> let ty_rest = fmtty_of_fmt rest in let prec_ty = fmtty_of_precision_fmtty prec ( Nativeint_ty ty_rest ) in fmtty_of_padding_fmtty pad prec_ty | Int64 ( _ , pad , prec , rest ) -> let ty_rest = fmtty_of_fmt rest in let prec_ty = fmtty_of_precision_fmtty prec ( Int64_ty ty_rest ) in fmtty_of_padding_fmtty pad prec_ty | Float ( _ , pad , prec , rest ) -> let ty_rest = fmtty_of_fmt rest in let prec_ty = fmtty_of_precision_fmtty prec ( Float_ty ty_rest ) in fmtty_of_padding_fmtty pad prec_ty | Char rest -> Char_ty ( fmtty_of_fmt rest ) | Caml_char rest -> Char_ty ( fmtty_of_fmt rest ) | Bool ( pad , rest ) -> fmtty_of_padding_fmtty pad ( Bool_ty ( fmtty_of_fmt rest ) ) | Alpha rest -> Alpha_ty ( fmtty_of_fmt rest ) | Theta rest -> Theta_ty ( fmtty_of_fmt rest ) | Custom ( arity , _ , rest ) -> fmtty_of_custom arity ( fmtty_of_fmt rest ) | Reader rest -> Reader_ty ( fmtty_of_fmt rest ) | Format_arg ( _ , ty , rest ) -> Format_arg_ty ( ty , fmtty_of_fmt rest ) | Format_subst ( _ , ty , rest ) -> Format_subst_ty ( ty , ty , fmtty_of_fmt rest ) | Flush rest -> fmtty_of_fmt rest | String_literal ( _ , rest ) -> fmtty_of_fmt rest | Char_literal ( _ , rest ) -> fmtty_of_fmt rest | Scan_char_set ( _ , _ , rest ) -> String_ty ( fmtty_of_fmt rest ) | Scan_get_counter ( _ , rest ) -> Int_ty ( fmtty_of_fmt rest ) | Scan_next_char rest -> Char_ty ( fmtty_of_fmt rest ) | Ignored_param ( ign , rest ) -> fmtty_of_ignored_format ign rest | Formatting_lit ( _ , rest ) -> fmtty_of_fmt rest | Formatting_gen ( fmting_gen , rest ) -> concat_fmtty ( fmtty_of_formatting_gen fmting_gen ) ( fmtty_of_fmt rest ) | End_of_format -> End_of_fmtty type x y a b c d e f . ( a , x , y ) custom_arity -> ( a , b , c , d , e , f ) fmtty -> ( y , b , c , d , e , f ) fmtty = fun arity fmtty -> match arity with | Custom_zero -> fmtty | Custom_succ arity -> Any_ty ( fmtty_of_custom arity fmtty ) type x y a b c d e f . ( a , b , c , d , y , x ) ignored -> ( x , b , c , y , e , f ) fmt -> ( a , b , c , d , e , f ) fmtty = fun ign fmt -> match ign with | Ignored_char -> fmtty_of_fmt fmt | Ignored_caml_char -> fmtty_of_fmt fmt | Ignored_string _ -> fmtty_of_fmt fmt | Ignored_caml_string _ -> fmtty_of_fmt fmt | Ignored_int ( _ , _ ) -> fmtty_of_fmt fmt | Ignored_int32 ( _ , _ ) -> fmtty_of_fmt fmt | Ignored_nativeint ( _ , _ ) -> fmtty_of_fmt fmt | Ignored_int64 ( _ , _ ) -> fmtty_of_fmt fmt | Ignored_float ( _ , _ ) -> fmtty_of_fmt fmt | Ignored_bool _ -> fmtty_of_fmt fmt | Ignored_format_arg _ -> fmtty_of_fmt fmt | Ignored_format_subst ( _ , fmtty ) -> concat_fmtty fmtty ( fmtty_of_fmt fmt ) | Ignored_reader -> Ignored_reader_ty ( fmtty_of_fmt fmt ) | Ignored_scan_char_set _ -> fmtty_of_fmt fmt | Ignored_scan_get_counter _ -> fmtty_of_fmt fmt | Ignored_scan_next_char -> fmtty_of_fmt fmt type x a b c d e f . ( x , a ) padding -> ( a , b , c , d , e , f ) fmtty -> ( x , b , c , d , e , f ) fmtty = fun pad fmtty -> match pad with | No_padding -> fmtty | Lit_padding _ -> fmtty | Arg_padding _ -> Int_ty fmtty type x a b c d e f . ( x , a ) precision -> ( a , b , c , d , e , f ) fmtty -> ( x , b , c , d , e , f ) fmtty = fun prec fmtty -> match prec with | No_precision -> fmtty | Lit_precision _ -> fmtty | Arg_precision -> Int_ty fmtty |
let type_padding : type a b c d e f x y . ( x , y ) padding -> ( a , b , c , d , e , f ) fmtty -> ( a , b , c , d , e , f ) padding_fmtty_ebb = fun pad fmtty -> match pad , fmtty with | No_padding , _ -> Padding_fmtty_EBB ( No_padding , fmtty ) | Lit_padding ( padty , w ) , _ -> Padding_fmtty_EBB ( Lit_padding ( padty , w ) , fmtty ) | Arg_padding padty , Int_ty rest -> Padding_fmtty_EBB ( Arg_padding padty , rest ) | _ -> raise Type_mismatch |
let type_padprec : type a b c d e f x y z . ( x , y ) padding -> ( y , z ) precision -> ( a , b , c , d , e , f ) fmtty -> ( a , b , c , d , e , f ) padprec_fmtty_ebb = fun pad prec fmtty -> match prec , type_padding pad fmtty with | No_precision , Padding_fmtty_EBB ( pad , rest ) -> Padprec_fmtty_EBB ( pad , No_precision , rest ) | Lit_precision p , Padding_fmtty_EBB ( pad , rest ) -> Padprec_fmtty_EBB ( pad , Lit_precision p , rest ) | Arg_precision , Padding_fmtty_EBB ( pad , Int_ty rest ) -> Padprec_fmtty_EBB ( pad , Arg_precision , rest ) | _ , Padding_fmtty_EBB ( _ , _ ) -> raise Type_mismatch |
let rec type_format : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 . ( a1 , b1 , c1 , d1 , e1 , f1 ) fmt -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmtty -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmt = fun fmt fmtty -> match type_format_gen fmt fmtty with | Fmt_fmtty_EBB ( fmt ' , End_of_fmtty ) -> fmt ' | _ -> raise Type_mismatch type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 . ( a1 , b1 , c1 , d1 , e1 , f1 ) fmt -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmtty -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmt_fmtty_ebb = fun fmt fmtty -> match fmt , fmtty with | Char fmt_rest , Char_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Char fmt ' , fmtty ' ) | Caml_char fmt_rest , Char_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Caml_char fmt ' , fmtty ' ) | String ( pad , fmt_rest ) , _ -> ( match type_padding pad fmtty with | Padding_fmtty_EBB ( pad , String_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( String ( pad , fmt ' ) , fmtty ' ) | Padding_fmtty_EBB ( _ , _ ) -> raise Type_mismatch ) | Caml_string ( pad , fmt_rest ) , _ -> ( match type_padding pad fmtty with | Padding_fmtty_EBB ( pad , String_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Caml_string ( pad , fmt ' ) , fmtty ' ) | Padding_fmtty_EBB ( _ , _ ) -> raise Type_mismatch ) | Int ( iconv , pad , prec , fmt_rest ) , _ -> ( match type_padprec pad prec fmtty with | Padprec_fmtty_EBB ( pad , prec , Int_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Int ( iconv , pad , prec , fmt ' ) , fmtty ' ) | Padprec_fmtty_EBB ( _ , _ , _ ) -> raise Type_mismatch ) | Int32 ( iconv , pad , prec , fmt_rest ) , _ -> ( match type_padprec pad prec fmtty with | Padprec_fmtty_EBB ( pad , prec , Int32_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Int32 ( iconv , pad , prec , fmt ' ) , fmtty ' ) | Padprec_fmtty_EBB ( _ , _ , _ ) -> raise Type_mismatch ) | Nativeint ( iconv , pad , prec , fmt_rest ) , _ -> ( match type_padprec pad prec fmtty with | Padprec_fmtty_EBB ( pad , prec , Nativeint_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Nativeint ( iconv , pad , prec , fmt ' ) , fmtty ' ) | Padprec_fmtty_EBB ( _ , _ , _ ) -> raise Type_mismatch ) | Int64 ( iconv , pad , prec , fmt_rest ) , _ -> ( match type_padprec pad prec fmtty with | Padprec_fmtty_EBB ( pad , prec , Int64_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Int64 ( iconv , pad , prec , fmt ' ) , fmtty ' ) | Padprec_fmtty_EBB ( _ , _ , _ ) -> raise Type_mismatch ) | Float ( fconv , pad , prec , fmt_rest ) , _ -> ( match type_padprec pad prec fmtty with | Padprec_fmtty_EBB ( pad , prec , Float_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Float ( fconv , pad , prec , fmt ' ) , fmtty ' ) | Padprec_fmtty_EBB ( _ , _ , _ ) -> raise Type_mismatch ) | Bool ( pad , fmt_rest ) , _ -> ( match type_padding pad fmtty with | Padding_fmtty_EBB ( pad , Bool_ty fmtty_rest ) -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Bool ( pad , fmt ' ) , fmtty ' ) | Padding_fmtty_EBB ( _ , _ ) -> raise Type_mismatch ) | Flush fmt_rest , fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Flush fmt ' , fmtty ' ) | String_literal ( str , fmt_rest ) , fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( String_literal ( str , fmt ' ) , fmtty ' ) | Char_literal ( chr , fmt_rest ) , fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Char_literal ( chr , fmt ' ) , fmtty ' ) | ( Format_arg ( pad_opt , sub_fmtty , fmt_rest ) , Format_arg_ty ( sub_fmtty ' , fmtty_rest ) ) -> if Fmtty_EBB sub_fmtty <> Fmtty_EBB sub_fmtty ' then raise Type_mismatch ; let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Format_arg ( pad_opt , sub_fmtty ' , fmt ' ) , fmtty ' ) | ( Format_subst ( pad_opt , sub_fmtty , fmt_rest ) , Format_subst_ty ( sub_fmtty1 , _sub_fmtty2 , fmtty_rest ) ) -> if Fmtty_EBB ( erase_rel sub_fmtty ) <> Fmtty_EBB ( erase_rel sub_fmtty1 ) then raise Type_mismatch ; let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest ( erase_rel fmtty_rest ) in Fmt_fmtty_EBB ( Format_subst ( pad_opt , sub_fmtty1 , fmt ' ) , fmtty ' ) | Alpha fmt_rest , Alpha_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Alpha fmt ' , fmtty ' ) | Theta fmt_rest , Theta_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Theta fmt ' , fmtty ' ) | Formatting_lit ( formatting_lit , fmt_rest ) , fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Formatting_lit ( formatting_lit , fmt ' ) , fmtty ' ) | Formatting_gen ( formatting_gen , fmt_rest ) , fmtty_rest -> type_formatting_gen formatting_gen fmt_rest fmtty_rest | Reader fmt_rest , Reader_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Reader fmt ' , fmtty ' ) | Scan_char_set ( width_opt , char_set , fmt_rest ) , String_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Scan_char_set ( width_opt , char_set , fmt ' ) , fmtty ' ) | Scan_get_counter ( counter , fmt_rest ) , Int_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt_rest fmtty_rest in Fmt_fmtty_EBB ( Scan_get_counter ( counter , fmt ' ) , fmtty ' ) | Ignored_param ( ign , rest ) , fmtty_rest -> type_ignored_param ign rest fmtty_rest | End_of_format , fmtty_rest -> Fmt_fmtty_EBB ( End_of_format , fmtty_rest ) | _ -> raise Type_mismatch type a1 a3 b1 b3 c1 c3 d1 d3 e1 e2 e3 f1 f2 f3 . ( a1 , b1 , c1 , d1 , e1 , f1 ) formatting_gen -> ( f1 , b1 , c1 , e1 , e2 , f2 ) fmt -> ( a3 , b3 , c3 , d3 , e3 , f3 ) fmtty -> ( a3 , b3 , c3 , d3 , e3 , f3 ) fmt_fmtty_ebb = fun formatting_gen fmt0 fmtty0 -> match formatting_gen with | Open_tag ( Format ( fmt1 , str ) ) -> let ( Fmt_fmtty_EBB ( fmt2 , fmtty2 ) ) = type_format_gen fmt1 fmtty0 in let ( Fmt_fmtty_EBB ( fmt3 , fmtty3 ) ) = type_format_gen fmt0 fmtty2 in Fmt_fmtty_EBB ( Formatting_gen ( Open_tag ( Format ( fmt2 , str ) ) , fmt3 ) , fmtty3 ) | Open_box ( Format ( fmt1 , str ) ) -> let ( Fmt_fmtty_EBB ( fmt2 , fmtty2 ) ) = type_format_gen fmt1 fmtty0 in let ( Fmt_fmtty_EBB ( fmt3 , fmtty3 ) ) = type_format_gen fmt0 fmtty2 in Fmt_fmtty_EBB ( Formatting_gen ( Open_box ( Format ( fmt2 , str ) ) , fmt3 ) , fmtty3 ) type p q x y z t u v a b c d e f . ( x , y , z , t , q , p ) ignored -> ( p , y , z , q , u , v ) fmt -> ( a , b , c , d , e , f ) fmtty -> ( a , b , c , d , e , f ) fmt_fmtty_ebb = fun ign fmt fmtty -> match ign with | Ignored_char as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_caml_char as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_string _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_caml_string _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_int _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_int32 _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_nativeint _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_int64 _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_float _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_bool _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_scan_char_set _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_scan_get_counter _ as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_scan_next_char as ign ' -> type_ignored_param_one ign ' fmt fmtty | Ignored_format_arg ( pad_opt , sub_fmtty ) -> type_ignored_param_one ( Ignored_format_arg ( pad_opt , sub_fmtty ) ) fmt fmtty | Ignored_format_subst ( pad_opt , sub_fmtty ) -> let ( Fmtty_fmt_EBB ( sub_fmtty ' , Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) ) = type_ignored_format_substitution sub_fmtty fmt fmtty in Fmt_fmtty_EBB ( Ignored_param ( Ignored_format_subst ( pad_opt , sub_fmtty ' ) , fmt ' ) , fmtty ' ) | Ignored_reader -> ( match fmtty with | Ignored_reader_ty fmtty_rest -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt fmtty_rest in Fmt_fmtty_EBB ( Ignored_param ( Ignored_reader , fmt ' ) , fmtty ' ) | _ -> raise Type_mismatch ) type a1 a2 b1 b2 c1 c2 d1 d2 e1 e2 f1 f2 . ( a2 , b2 , c2 , d2 , d2 , a2 ) ignored -> ( a1 , b1 , c1 , d1 , e1 , f1 ) fmt -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmtty -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmt_fmtty_ebb = fun ign fmt fmtty -> let ( Fmt_fmtty_EBB ( fmt ' , fmtty ' ) ) = type_format_gen fmt fmtty in Fmt_fmtty_EBB ( Ignored_param ( ign , fmt ' ) , fmtty ' ) type w x y z p s t u a b c d e f . ( w , x , y , z , s , p ) fmtty -> ( p , x , y , s , t , u ) fmt -> ( a , b , c , d , e , f ) fmtty -> ( a , b , c , d , e , f ) fmtty_fmt_ebb = fun sub_fmtty fmt fmtty -> match sub_fmtty , fmtty with | Char_ty sub_fmtty_rest , Char_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Char_ty sub_fmtty_rest ' , fmt ' ) | String_ty sub_fmtty_rest , String_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( String_ty sub_fmtty_rest ' , fmt ' ) | Int_ty sub_fmtty_rest , Int_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Int_ty sub_fmtty_rest ' , fmt ' ) | Int32_ty sub_fmtty_rest , Int32_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Int32_ty sub_fmtty_rest ' , fmt ' ) | Nativeint_ty sub_fmtty_rest , Nativeint_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Nativeint_ty sub_fmtty_rest ' , fmt ' ) | Int64_ty sub_fmtty_rest , Int64_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Int64_ty sub_fmtty_rest ' , fmt ' ) | Float_ty sub_fmtty_rest , Float_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Float_ty sub_fmtty_rest ' , fmt ' ) | Bool_ty sub_fmtty_rest , Bool_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Bool_ty sub_fmtty_rest ' , fmt ' ) | Alpha_ty sub_fmtty_rest , Alpha_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Alpha_ty sub_fmtty_rest ' , fmt ' ) | Theta_ty sub_fmtty_rest , Theta_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Theta_ty sub_fmtty_rest ' , fmt ' ) | Reader_ty sub_fmtty_rest , Reader_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Reader_ty sub_fmtty_rest ' , fmt ' ) | Ignored_reader_ty sub_fmtty_rest , Ignored_reader_ty fmtty_rest -> let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Ignored_reader_ty sub_fmtty_rest ' , fmt ' ) | ( Format_arg_ty ( sub2_fmtty , sub_fmtty_rest ) , Format_arg_ty ( sub2_fmtty ' , fmtty_rest ) ) -> if Fmtty_EBB sub2_fmtty <> Fmtty_EBB sub2_fmtty ' then raise Type_mismatch ; let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in Fmtty_fmt_EBB ( Format_arg_ty ( sub2_fmtty ' , sub_fmtty_rest ' ) , fmt ' ) | ( Format_subst_ty ( sub1_fmtty , sub2_fmtty , sub_fmtty_rest ) , Format_subst_ty ( sub1_fmtty ' , sub2_fmtty ' , fmtty_rest ) ) -> if Fmtty_EBB ( erase_rel sub1_fmtty ) <> Fmtty_EBB ( erase_rel sub1_fmtty ' ) then raise Type_mismatch ; if Fmtty_EBB ( erase_rel sub2_fmtty ) <> Fmtty_EBB ( erase_rel sub2_fmtty ' ) then raise Type_mismatch ; let sub_fmtty ' = trans ( symm sub1_fmtty ' ) sub2_fmtty ' in let _ , f2 , _ , f4 = fmtty_rel_det sub_fmtty ' in let Refl = f2 Refl in let Refl = f4 Refl in let ( Fmtty_fmt_EBB ( sub_fmtty_rest ' , fmt ' ) ) = type_ignored_format_substitution ( erase_rel sub_fmtty_rest ) fmt fmtty_rest in Fmtty_fmt_EBB ( Format_subst_ty ( sub1_fmtty ' , sub2_fmtty ' , symm sub_fmtty_rest ' ) , fmt ' ) | End_of_fmtty , fmtty -> Fmtty_fmt_EBB ( End_of_fmtty , type_format_gen fmt fmtty ) | _ -> raise Type_mismatch |
let recast : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 . ( a1 , b1 , c1 , d1 , e1 , f1 ) fmt -> ( a1 , b1 , c1 , d1 , e1 , f1 , a2 , b2 , c2 , d2 , e2 , f2 ) fmtty_rel -> ( a2 , b2 , c2 , d2 , e2 , f2 ) fmt = fun fmt fmtty -> type_format fmt ( erase_rel ( symm fmtty ) ) |
let fix_padding padty width str = let len = String . length str in let width , padty = ( abs width , if width < 0 then Left else padty ) in if width <= len then str else let res = Bytes . make width ( if padty = Zeros then ' 0 ' else ' ' ) in begin match padty with | Left -> String . blit str 0 res 0 len | Right -> String . blit str 0 res ( width - len ) len | Zeros when len > 0 && ( str . [ 0 ] = ' ' + || str . [ 0 ] = ' ' - || str . [ 0 ] = ' ' ) -> Bytes . set res 0 str . [ 0 ] ; String . blit str 1 res ( width - len + 1 ) ( len - 1 ) | Zeros when len > 1 && str . [ 0 ] = ' 0 ' && ( str . [ 1 ] = ' x ' || str . [ 1 ] = ' X ' ) -> Bytes . set res 1 str . [ 1 ] ; String . blit str 2 res ( width - len + 2 ) ( len - 2 ) | Zeros -> String . blit str 0 res ( width - len ) len end ; Bytes . unsafe_to_string res |
let fix_int_precision prec str = let prec = abs prec in let len = String . length str in match str . [ 0 ] with | ( ' ' + | ' ' - | ' ' ) as c when prec + 1 > len -> let res = Bytes . make ( prec + 1 ) ' 0 ' in Bytes . set res 0 c ; String . blit str 1 res ( prec - len + 2 ) ( len - 1 ) ; Bytes . unsafe_to_string res | ' 0 ' when prec + 2 > len && len > 1 && ( str . [ 1 ] = ' x ' || str . [ 1 ] = ' X ' ) -> let res = Bytes . make ( prec + 2 ) ' 0 ' in Bytes . set res 1 str . [ 1 ] ; String . blit str 2 res ( prec - len + 4 ) ( len - 2 ) ; Bytes . unsafe_to_string res | ( ' 0 ' . . ' 9 ' | ' a ' . . ' f ' | ' A ' . . ' F ' ) when prec > len -> let res = Bytes . make prec ' 0 ' in String . blit str 0 res ( prec - len ) len ; Bytes . unsafe_to_string res | _ -> str |
let string_to_caml_string str = let str = String . escaped str in let l = String . length str in let res = Bytes . make ( l + 2 ) ' " ' \ in String . unsafe_blit str 0 res 1 l ; Bytes . unsafe_to_string res |
let format_of_iconv = function | Int_d | Int_Cd -> " % d " | Int_pd -> " %+ d " | Int_sd -> " % d " | Int_i | Int_Ci -> " % i " | Int_pi -> " %+ i " | Int_si -> " % i " | Int_x -> " % x " | Int_Cx -> " %# x " | Int_X -> " % X " | Int_CX -> " %# X " | Int_o -> " % o " | Int_Co -> " %# o " | Int_u | Int_Cu -> " % u " |
let format_of_iconvL = function | Int_d | Int_Cd -> " % Ld " | Int_pd -> " %+ Ld " | Int_sd -> " % Ld " | Int_i | Int_Ci -> " % Li " | Int_pi -> " %+ Li " | Int_si -> " % Li " | Int_x -> " % Lx " | Int_Cx -> " %# Lx " | Int_X -> " % LX " | Int_CX -> " %# LX " | Int_o -> " % Lo " | Int_Co -> " %# Lo " | Int_u | Int_Cu -> " % Lu " |
let format_of_iconvl = function | Int_d | Int_Cd -> " % ld " | Int_pd -> " %+ ld " | Int_sd -> " % ld " | Int_i | Int_Ci -> " % li " | Int_pi -> " %+ li " | Int_si -> " % li " | Int_x -> " % lx " | Int_Cx -> " %# lx " | Int_X -> " % lX " | Int_CX -> " %# lX " | Int_o -> " % lo " | Int_Co -> " %# lo " | Int_u | Int_Cu -> " % lu " |
let format_of_iconvn = function | Int_d | Int_Cd -> " % nd " | Int_pd -> " %+ nd " | Int_sd -> " % nd " | Int_i | Int_Ci -> " % ni " | Int_pi -> " %+ ni " | Int_si -> " % ni " | Int_x -> " % nx " | Int_Cx -> " %# nx " | Int_X -> " % nX " | Int_CX -> " %# nX " | Int_o -> " % no " | Int_Co -> " %# no " | Int_u | Int_Cu -> " % nu " |
let format_of_fconv fconv prec = let prec = abs prec in let symb = char_of_fconv ~ cF ' : g ' fconv in let buf = buffer_create 16 in buffer_add_char buf ' ' ; % bprint_fconv_flag buf fconv ; buffer_add_char buf ' . ' ; buffer_add_string buf ( Int . to_string prec ) ; buffer_add_char buf symb ; buffer_contents buf |
let transform_int_alt iconv s = match iconv with | Int_Cd | Int_Ci | Int_Cu -> let digits = let n = ref 0 in for i = 0 to String . length s - 1 do match String . unsafe_get s i with ' 0 ' . . ' 9 ' -> incr n | _ -> ( ) done ; ! n in let buf = Bytes . create ( String . length s + ( ( digits - 1 ) / 3 ) ) in let pos = ref 0 in let put c = Bytes . set buf ! pos c ; incr pos in let left = ref ( ( ( digits - 1 ) mod 3 ) + 1 ) in for i = 0 to String . length s - 1 do match String . unsafe_get s i with | ' 0 ' . . ' 9 ' as c -> if ! left = 0 then ( put ' _ ' ; left := 3 ) ; decr left ; put c | c -> put c done ; Bytes . unsafe_to_string buf | _ -> s |
let convert_int iconv n = transform_int_alt iconv ( format_int ( format_of_iconv iconv ) n ) |
let convert_int32 iconv n = transform_int_alt iconv ( format_int32 ( format_of_iconvl iconv ) n ) |
let convert_nativeint iconv n = transform_int_alt iconv ( format_nativeint ( format_of_iconvn iconv ) n ) |
let convert_int64 iconv n = transform_int_alt iconv ( format_int64 ( format_of_iconvL iconv ) n ) |
let convert_float fconv prec x = match snd fconv with | Float_h | Float_H -> ( let sign = match fst fconv with | Float_flag_p -> ' ' + | Float_flag_s -> ' ' | _ -> ' ' - in let str = hexstring_of_float x prec sign in match snd fconv with Float_H -> String . uppercase_ascii str | _ -> str ) | _ -> ( let str = format_float ( format_of_fconv fconv prec ) x in if snd fconv <> Float_F then str else let len = String . length str in let rec is_valid i = if i = len then false else match str . [ i ] with ' . ' | ' e ' | ' E ' -> true | _ -> is_valid ( i + 1 ) in match classify_float x with | FP_normal | FP_subnormal | FP_zero -> if is_valid 0 then str else str ^ " . " | FP_infinite -> if x < 0 . 0 then " neg_infinity " else " infinity " | FP_nan -> " nan " ) |
let format_caml_char c = let str = Char . escaped c in let l = String . length str in let res = Bytes . make ( l + 2 ) ' ' ' \ in String . unsafe_blit str 0 res 1 l ; Bytes . unsafe_to_string res |
let string_of_fmtty fmtty = let buf = buffer_create 16 in bprint_fmtty buf fmtty ; buffer_contents buf |
let rec make_printf : type a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> a = fun k acc fmt -> match fmt with | Bool ( pad , rest ) -> make_padding k acc rest pad string_of_bool | Alpha rest -> fun f x -> make_printf k ( Acc_delay ( acc , fun o -> f o x ) ) rest assert false | Flush rest -> make_printf k ( Acc_flush acc ) rest | String_literal ( str , rest ) -> make_printf k ( Acc_string_literal ( acc , str ) ) rest | Char_literal ( chr , rest ) -> make_printf k ( Acc_char_literal ( acc , chr ) ) rest | Format_arg ( _ , sub_fmtty , rest ) -> let ty = string_of_fmtty sub_fmtty in ( fun str -> ignore str ; make_printf k ( Acc_data_string ( acc , ty ) ) rest ) | Format_subst ( _ , fmtty , rest ) -> fun ( Format ( fmt , _ ) ) -> make_printf k acc ( concat_fmt ( recast fmt fmtty ) rest ) | Scan_char_set ( _ , _ , rest ) -> let new_acc = Acc_invalid_arg ( acc , " Printf : bad conversion [ " ) % in fun _ -> make_printf k new_acc rest | Scan_get_counter ( _ , rest ) -> fun n -> let new_acc = Acc_data_string ( acc , format_int " % u " n ) in make_printf k new_acc rest | Scan_next_char rest -> fun c -> let new_acc = Acc_data_char ( acc , c ) in make_printf k new_acc rest | Ignored_param ( ign , rest ) -> make_ignored_param k acc ign rest | Formatting_lit ( fmting_lit , rest ) -> make_printf k ( Acc_formatting_lit ( acc , fmting_lit ) ) rest | Formatting_gen ( Open_tag ( Format ( fmt ' , _ ) ) , rest ) -> let k ' kacc = make_printf k ( Acc_formatting_gen ( acc , Acc_open_tag kacc ) ) rest in make_printf k ' End_of_acc fmt ' | Formatting_gen ( Open_box ( Format ( fmt ' , _ ) ) , rest ) -> let k ' kacc = make_printf k ( Acc_formatting_gen ( acc , Acc_open_box kacc ) ) rest in make_printf k ' End_of_acc fmt ' | End_of_format -> k acc ) * | _ -> assert false type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , y , x ) ignored -> ( x , b , c , y , e , f ) fmt -> a = fun k acc ign fmt -> assert false type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , y , x ) fmtty -> ( x , b , c , y , e , f ) fmt -> a = fun k acc fmtty fmt -> assert false type a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> a = fun k acc fmt -> assert false type x z a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , z -> a ) padding -> ( z -> string ) -> x = fun k acc fmt pad trans -> assert false type x y z a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , y ) padding -> ( y , z -> a ) precision -> ( int_conv -> z -> string ) -> int_conv -> x = fun k acc fmt pad prec trans iconv -> assert false type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , y ) padding -> ( y , float -> a ) precision -> float_conv -> x = fun k acc fmt pad prec fconv -> assert false type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( a , x , y ) custom_arity -> x -> y = fun k acc rest arity f -> assert false and make_ignored_param : type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , y , x ) ignored -> ( x , b , c , y , e , f ) fmt -> a = fun k acc ign fmt -> match ign with | Ignored_char -> make_invalid_arg k acc fmt | Ignored_caml_char -> make_invalid_arg k acc fmt | Ignored_string _ -> make_invalid_arg k acc fmt | Ignored_caml_string _ -> make_invalid_arg k acc fmt | Ignored_int ( _ , _ ) -> make_invalid_arg k acc fmt | Ignored_int32 ( _ , _ ) -> make_invalid_arg k acc fmt | Ignored_nativeint ( _ , _ ) -> make_invalid_arg k acc fmt | Ignored_int64 ( _ , _ ) -> make_invalid_arg k acc fmt | Ignored_float ( _ , _ ) -> make_invalid_arg k acc fmt | Ignored_bool _ -> make_invalid_arg k acc fmt | Ignored_format_arg _ -> make_invalid_arg k acc fmt | Ignored_format_subst ( _ , fmtty ) -> make_from_fmtty k acc fmtty fmt | Ignored_reader -> assert false | Ignored_scan_char_set _ -> make_invalid_arg k acc fmt | Ignored_scan_get_counter _ -> make_invalid_arg k acc fmt | Ignored_scan_next_char -> make_invalid_arg k acc fmt and make_from_fmtty : type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , y , x ) fmtty -> ( x , b , c , y , e , f ) fmt -> a = fun k acc fmtty fmt -> match fmtty with | Char_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | String_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Int_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Int32_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Nativeint_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Int64_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Float_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Bool_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Alpha_ty rest -> fun _ _ -> make_from_fmtty k acc rest fmt | Theta_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Any_ty rest -> fun _ -> make_from_fmtty k acc rest fmt | Reader_ty _ -> assert false | Ignored_reader_ty _ -> assert false | Format_arg_ty ( _ , rest ) -> fun _ -> make_from_fmtty k acc rest fmt | End_of_fmtty -> make_invalid_arg k acc fmt | Format_subst_ty ( ty1 , ty2 , rest ) -> let ty = trans ( symm ty1 ) ty2 in fun _ -> make_from_fmtty k acc ( concat_fmtty ty rest ) fmt and make_invalid_arg : type a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> a = fun k acc fmt -> make_printf k ( Acc_invalid_arg ( acc , " Printf : bad conversion % _ " ) ) fmt and make_padding : type x z a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , z -> a ) padding -> ( z -> string ) -> x = fun k acc fmt pad trans -> match pad with | No_padding -> fun x -> let new_acc = Acc_data_string ( acc , trans x ) in make_printf k new_acc fmt | Lit_padding ( padty , width ) -> fun x -> let new_acc = Acc_data_string ( acc , fix_padding padty width ( trans x ) ) in make_printf k new_acc fmt | Arg_padding padty -> fun w x -> let new_acc = Acc_data_string ( acc , fix_padding padty w ( trans x ) ) in make_printf k new_acc fmt and make_int_padding_precision : type x y z a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , y ) padding -> ( y , z -> a ) precision -> ( int_conv -> z -> string ) -> int_conv -> x = fun k acc fmt pad prec trans iconv -> match pad , prec with | No_padding , No_precision -> fun x -> let str = trans iconv x in make_printf k ( Acc_data_string ( acc , str ) ) fmt | No_padding , Lit_precision p -> fun x -> let str = fix_int_precision p ( trans iconv x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | No_padding , Arg_precision -> fun p x -> let str = fix_int_precision p ( trans iconv x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Lit_padding ( padty , w ) , No_precision -> fun x -> let str = fix_padding padty w ( trans iconv x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Lit_padding ( padty , w ) , Lit_precision p -> fun x -> let str = fix_padding padty w ( fix_int_precision p ( trans iconv x ) ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Lit_padding ( padty , w ) , Arg_precision -> fun p x -> let str = fix_padding padty w ( fix_int_precision p ( trans iconv x ) ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Arg_padding padty , No_precision -> fun w x -> let str = fix_padding padty w ( trans iconv x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Arg_padding padty , Lit_precision p -> fun w x -> let str = fix_padding padty w ( fix_int_precision p ( trans iconv x ) ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Arg_padding padty , Arg_precision -> fun w p x -> let str = fix_padding padty w ( fix_int_precision p ( trans iconv x ) ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt and make_float_padding_precision : type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( x , y ) padding -> ( y , float -> a ) precision -> float_conv -> x = fun k acc fmt pad prec fconv -> match pad , prec with | No_padding , No_precision -> fun x -> let str = convert_float fconv ( default_float_precision fconv ) x in make_printf k ( Acc_data_string ( acc , str ) ) fmt | No_padding , Lit_precision p -> fun x -> let str = convert_float fconv p x in make_printf k ( Acc_data_string ( acc , str ) ) fmt | No_padding , Arg_precision -> fun p x -> let str = convert_float fconv p x in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Lit_padding ( padty , w ) , No_precision -> fun x -> let str = convert_float fconv ( default_float_precision fconv ) x in let str ' = fix_padding padty w str in make_printf k ( Acc_data_string ( acc , str ' ) ) fmt | Lit_padding ( padty , w ) , Lit_precision p -> fun x -> let str = fix_padding padty w ( convert_float fconv p x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Lit_padding ( padty , w ) , Arg_precision -> fun p x -> let str = fix_padding padty w ( convert_float fconv p x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Arg_padding padty , No_precision -> fun w x -> let str = convert_float fconv ( default_float_precision fconv ) x in let str ' = fix_padding padty w str in make_printf k ( Acc_data_string ( acc , str ' ) ) fmt | Arg_padding padty , Lit_precision p -> fun w x -> let str = fix_padding padty w ( convert_float fconv p x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt | Arg_padding padty , Arg_precision -> fun w p x -> let str = fix_padding padty w ( convert_float fconv p x ) in make_printf k ( Acc_data_string ( acc , str ) ) fmt and make_custom : type x y a b c d e f . ( ( b , c ) acc -> f ) -> ( b , c ) acc -> ( a , b , c , d , e , f ) fmt -> ( a , x , y ) custom_arity -> x -> y = fun k acc rest arity f -> match arity with | Custom_zero -> make_printf k ( Acc_data_string ( acc , f ) ) rest | Custom_succ arity -> fun x -> make_custom k acc rest arity ( f x ) ) * assert false | Flush rest -> make_iprintf k o rest | String_literal ( _ , rest ) -> make_iprintf k o rest | Char_literal ( _ , rest ) -> make_iprintf k o rest | Format_arg ( _ , _ , rest ) -> const ( make_iprintf k o rest ) | Format_subst ( _ , fmtty , rest ) -> fun ( Format ( fmt , _ ) ) -> make_iprintf k o ( concat_fmt ( recast fmt fmtty ) rest ) | Scan_char_set ( _ , _ , rest ) -> const ( make_iprintf k o rest ) | Scan_get_counter ( _ , rest ) -> const ( make_iprintf k o rest ) | Scan_next_char rest -> const ( make_iprintf k o rest ) | Ignored_param ( ign , rest ) -> make_ignored_param ( fun _ -> k o ) ( End_of_acc ) ign rest | Formatting_lit ( _ , rest ) -> make_iprintf k o rest | Formatting_gen ( Open_tag ( Format ( fmt ' , _ ) ) , rest ) -> make_iprintf ( fun koc -> make_iprintf k koc rest ) o fmt ' | Formatting_gen ( Open_box ( Format ( fmt ' , _ ) ) , rest ) -> make_iprintf ( fun koc -> make_iprintf k koc rest ) o fmt ' | End_of_format -> k o and fn_of_padding_precision : type x y z a b c d e f state . ( state -> f ) -> state -> ( a , b , c , d , e , f ) fmt -> ( x , y ) padding -> ( y , z -> a ) precision -> x = fun k o fmt pad prec -> match pad , prec with | No_padding , No_precision -> const ( make_iprintf k o fmt ) | No_padding , Lit_precision _ -> const ( make_iprintf k o fmt ) | No_padding , Arg_precision -> const ( const ( make_iprintf k o fmt ) ) | Lit_padding _ , No_precision -> const ( make_iprintf k o fmt ) | Lit_padding _ , Lit_precision _ -> const ( make_iprintf k o fmt ) | Lit_padding _ , Arg_precision -> const ( const ( make_iprintf k o fmt ) ) | Arg_padding _ , No_precision -> const ( const ( make_iprintf k o fmt ) ) | Arg_padding _ , Lit_precision _ -> const ( const ( make_iprintf k o fmt ) ) | Arg_padding _ , Arg_precision -> const ( const ( const ( make_iprintf k o fmt ) ) ) and fn_of_custom_arity : type x y a b c d e f state . ( state -> f ) -> state -> ( a , b , c , d , e , f ) fmt -> ( a , x , y ) custom_arity -> y = fun k o fmt -> function | Custom_zero -> make_iprintf k o fmt | Custom_succ arity -> const ( fn_of_custom_arity k o fmt arity ) let rec output_acc o acc = match acc with | Acc_formatting_lit ( p , fmting_lit ) -> let s = string_of_formatting_lit fmting_lit in output_acc o p ; output_string o s ; | Acc_formatting_gen ( p , Acc_open_tag acc ' ) -> output_acc o p ; output_string o " { " ; @ output_acc o acc ' ; | Acc_formatting_gen ( p , Acc_open_box acc ' ) -> output_acc o p ; output_string o " [ " ; @ output_acc o acc ' ; | Acc_string_literal ( p , s ) | Acc_data_string ( p , s ) -> output_acc o p ; output_string o s | Acc_char_literal ( p , c ) | Acc_data_char ( p , c ) -> output_acc o p ; output_char o c | Acc_delay ( p , f ) -> output_acc o p ; f o | Acc_flush p -> output_acc o p ; flush o | Acc_invalid_arg ( p , msg ) -> output_acc o p ; invalid_arg msg ; | End_of_acc -> ( ) let rec bufput_acc b acc = match acc with | Acc_formatting_lit ( p , fmting_lit ) -> let s = string_of_formatting_lit fmting_lit in bufput_acc b p ; Buffer . add_string b s ; | Acc_formatting_gen ( p , Acc_open_tag acc ' ) -> bufput_acc b p ; Buffer . add_string b " { " ; @ bufput_acc b acc ' ; | Acc_formatting_gen ( p , Acc_open_box acc ' ) -> bufput_acc b p ; Buffer . add_string b " [ " ; @ bufput_acc b acc ' ; | Acc_string_literal ( p , s ) | Acc_data_string ( p , s ) -> bufput_acc b p ; Buffer . add_string b s | Acc_char_literal ( p , c ) | Acc_data_char ( p , c ) -> bufput_acc b p ; Buffer . add_char b c | Acc_delay ( p , f ) -> bufput_acc b p ; f b | Acc_flush p -> bufput_acc b p ; | Acc_invalid_arg ( p , msg ) -> bufput_acc b p ; invalid_arg msg ; | End_of_acc -> ( ) let rec strput_acc b acc = match acc with | Acc_formatting_lit ( p , fmting_lit ) -> let s = string_of_formatting_lit fmting_lit in strput_acc b p ; Buffer . add_string b s ; | Acc_formatting_gen ( p , Acc_open_tag acc ' ) -> strput_acc b p ; Buffer . add_string b " { " ; @ strput_acc b acc ' ; | Acc_formatting_gen ( p , Acc_open_box acc ' ) -> strput_acc b p ; Buffer . add_string b " [ " ; @ strput_acc b acc ' ; | Acc_string_literal ( p , s ) | Acc_data_string ( p , s ) -> strput_acc b p ; Buffer . add_string b s | Acc_char_literal ( p , c ) | Acc_data_char ( p , c ) -> strput_acc b p ; Buffer . add_char b c | Acc_delay ( p , f ) -> strput_acc b p ; Buffer . add_string b ( f ( ) ) | Acc_flush p -> strput_acc b p ; | Acc_invalid_arg ( p , msg ) -> strput_acc b p ; invalid_arg msg ; | End_of_acc -> ( ) let failwith_message ( Format ( fmt , _ ) ) = let buf = Buffer . create 256 in let k acc = strput_acc buf acc ; failwith ( Buffer . contents buf ) in make_printf k End_of_acc fmt let open_box_of_string str = if str = " " then ( 0 , Pp_box ) else let len = String . length str in let invalid_box ( ) = failwith_message " invalid box description % S " str in let rec parse_spaces i = if i = len then i else match str . [ i ] with | ' ' | ' \ t ' -> parse_spaces ( i + 1 ) | _ -> i and parse_lword i j = if j = len then j else match str . [ j ] with | ' a ' . . ' z ' -> parse_lword i ( j + 1 ) | _ -> j and parse_int i j = if j = len then j else match str . [ j ] with | ' 0 ' . . ' 9 ' | ' ' - -> parse_int i ( j + 1 ) | _ -> j in let wstart = parse_spaces 0 in let wend = parse_lword wstart wstart in let box_name = String . sub str wstart ( wend - wstart ) in let nstart = parse_spaces wend in let nend = parse_int nstart nstart in let indent = if nstart = nend then 0 else try int_of_string ( String . sub str nstart ( nend - nstart ) ) with Failure _ -> invalid_box ( ) in let exp_end = parse_spaces nend in if exp_end <> len then invalid_box ( ) ; let box_type = match box_name with | " " | " b " -> Pp_box | " h " -> Pp_hbox | " v " -> Pp_vbox | " hv " -> Pp_hvbox | " hov " -> Pp_hovbox | _ -> invalid_box ( ) in ( indent , box_type ) let make_padding_fmt_ebb : type x y . ( x , y ) padding -> ( _ , _ , _ , _ , _ , _ ) fmt -> ( _ , _ , _ , _ , _ ) padding_fmt_ebb = fun pad fmt -> match pad with | No_padding -> Padding_fmt_EBB ( No_padding , fmt ) | Lit_padding ( s , w ) -> Padding_fmt_EBB ( Lit_padding ( s , w ) , fmt ) | Arg_padding s -> Padding_fmt_EBB ( Arg_padding s , fmt ) let make_precision_fmt_ebb : type x y . ( x , y ) precision -> ( _ , _ , _ , _ , _ , _ ) fmt -> ( _ , _ , _ , _ , _ ) precision_fmt_ebb = fun prec fmt -> match prec with | No_precision -> Precision_fmt_EBB ( No_precision , fmt ) | Lit_precision p -> Precision_fmt_EBB ( Lit_precision p , fmt ) | Arg_precision -> Precision_fmt_EBB ( Arg_precision , fmt ) let make_padprec_fmt_ebb : type x y z t . ( x , y ) padding -> ( z , t ) precision -> ( _ , _ , _ , _ , _ , _ ) fmt -> ( _ , _ , _ , _ , _ ) padprec_fmt_ebb = fun pad prec fmt -> let Precision_fmt_EBB ( prec , fmt ' ) = make_precision_fmt_ebb prec fmt in match pad with | No_padding -> Padprec_fmt_EBB ( No_padding , prec , fmt ' ) | Lit_padding ( s , w ) -> Padprec_fmt_EBB ( Lit_padding ( s , w ) , prec , fmt ' ) | Arg_padding s -> Padprec_fmt_EBB ( Arg_padding s , prec , fmt ' ) let fmt_ebb_of_string ? legacy_behavior str = let legacy_behavior = match legacy_behavior with | Some flag -> flag | None -> true in let invalid_format_message str_ind msg = failwith_message " invalid format % S : at character number % d , % s " str str_ind msg in let unexpected_end_of_format end_ind = invalid_format_message end_ind " unexpected end of format " in let invalid_nonnull_char_width str_ind = invalid_format_message str_ind " non - zero widths are unsupported for % c conversions " in let invalid_format_without str_ind c s = failwith_message " invalid format % S : at character number % d , ' % c ' without % s " str str_ind c s in let expected_character str_ind expected read = failwith_message " invalid format % S : at character number % d , % s expected , read % C " str str_ind expected read in let rec parse : type e f . int -> int -> ( _ , _ , e , f ) fmt_ebb = fun beg_ind end_ind -> parse_literal beg_ind beg_ind end_ind and parse_literal : type e f . int -> int -> int -> ( _ , _ , e , f ) fmt_ebb = fun lit_start str_ind end_ind -> if str_ind = end_ind then add_literal lit_start str_ind End_of_format else match str . [ str_ind ] with | ' ' % -> let Fmt_EBB fmt_rest = parse_format str_ind end_ind in add_literal lit_start str_ind fmt_rest | ' ' @ -> let Fmt_EBB fmt_rest = parse_after_at ( str_ind + 1 ) end_ind in add_literal lit_start str_ind fmt_rest | _ -> parse_literal lit_start ( str_ind + 1 ) end_ind and parse_format : type e f . int -> int -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind end_ind -> parse_ign pct_ind ( pct_ind + 1 ) end_ind and parse_ign : type e f . int -> int -> int -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind -> if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' _ ' -> parse_flags pct_ind ( str_ind + 1 ) end_ind true | _ -> parse_flags pct_ind str_ind end_ind false and parse_flags : type e f . int -> int -> int -> bool -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind ign -> let zero = ref false and minus = ref false and plus = ref false and space = ref false and hash = ref false in let set_flag str_ind flag = if ! flag && not legacy_behavior then failwith_message " invalid format % S : at character number % d , duplicate flag % C " str str_ind str . [ str_ind ] ; flag := true ; in let rec read_flags str_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; begin match str . [ str_ind ] with | ' 0 ' -> set_flag str_ind zero ; read_flags ( str_ind + 1 ) | ' ' - -> set_flag str_ind minus ; read_flags ( str_ind + 1 ) | ' ' + -> set_flag str_ind plus ; read_flags ( str_ind + 1 ) | ' ' # -> set_flag str_ind hash ; read_flags ( str_ind + 1 ) | ' ' -> set_flag str_ind space ; read_flags ( str_ind + 1 ) | _ -> parse_padding pct_ind str_ind end_ind ! zero ! minus ! plus ! hash ! space ign end in read_flags str_ind and parse_padding : type e f . int -> int -> int -> bool -> bool -> bool -> bool -> bool -> bool -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind zero minus plus hash space ign -> if str_ind = end_ind then unexpected_end_of_format end_ind ; let padty = match zero , minus with | false , false -> Right | false , true -> Left | true , false -> Zeros | true , true -> if legacy_behavior then Left else incompatible_flag pct_ind str_ind ' ' - " 0 " in match str . [ str_ind ] with | ' 0 ' . . ' 9 ' -> let new_ind , width = parse_positive str_ind end_ind 0 in parse_after_padding pct_ind new_ind end_ind minus plus hash space ign ( Lit_padding ( padty , width ) ) | ' ' * -> parse_after_padding pct_ind ( str_ind + 1 ) end_ind minus plus hash space ign ( Arg_padding padty ) | _ -> begin match padty with | Left -> if not legacy_behavior then invalid_format_without ( str_ind - 1 ) ' ' - " padding " ; parse_after_padding pct_ind str_ind end_ind minus plus hash space ign No_padding | Zeros -> parse_after_padding pct_ind str_ind end_ind minus plus hash space ign ( Lit_padding ( Right , 0 ) ) | Right -> parse_after_padding pct_ind str_ind end_ind minus plus hash space ign No_padding end and parse_after_padding : type x e f . int -> int -> int -> bool -> bool -> bool -> bool -> bool -> ( x , _ ) padding -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind minus plus hash space ign pad -> if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' . ' -> parse_precision pct_ind ( str_ind + 1 ) end_ind minus plus hash space ign pad | symb -> parse_conversion pct_ind ( str_ind + 1 ) end_ind plus hash space ign pad No_precision pad symb and parse_precision : type x e f . int -> int -> int -> bool -> bool -> bool -> bool -> bool -> ( x , _ ) padding -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind minus plus hash space ign pad -> if str_ind = end_ind then unexpected_end_of_format end_ind ; let parse_literal minus str_ind = let new_ind , prec = parse_positive str_ind end_ind 0 in parse_after_precision pct_ind new_ind end_ind minus plus hash space ign pad ( Lit_precision prec ) in match str . [ str_ind ] with | ' 0 ' . . ' 9 ' -> parse_literal minus str_ind | ( ' ' + | ' ' ) - as symb when legacy_behavior -> parse_literal ( minus || symb = ' ' ) - ( str_ind + 1 ) | ' ' * -> parse_after_precision pct_ind ( str_ind + 1 ) end_ind minus plus hash space ign pad Arg_precision | _ -> if legacy_behavior then parse_after_precision pct_ind str_ind end_ind minus plus hash space ign pad ( Lit_precision 0 ) else invalid_format_without ( str_ind - 1 ) ' . ' " precision " and parse_after_precision : type x y z t e f . int -> int -> int -> bool -> bool -> bool -> bool -> bool -> ( x , y ) padding -> ( z , t ) precision -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind minus plus hash space ign pad prec -> if str_ind = end_ind then unexpected_end_of_format end_ind ; let parse_conv ( type u ) ( type v ) ( padprec : ( u , v ) padding ) = parse_conversion pct_ind ( str_ind + 1 ) end_ind plus hash space ign pad prec padprec str . [ str_ind ] in match pad with | No_padding -> ( match minus , prec with | _ , No_precision -> parse_conv No_padding | false , Lit_precision n -> parse_conv ( Lit_padding ( Right , n ) ) | true , Lit_precision n -> parse_conv ( Lit_padding ( Left , n ) ) | false , Arg_precision -> parse_conv ( Arg_padding Right ) | true , Arg_precision -> parse_conv ( Arg_padding Left ) ) | pad -> parse_conv pad and parse_conversion : type x y z t u v e f . int -> int -> int -> bool -> bool -> bool -> bool -> ( x , y ) padding -> ( z , t ) precision -> ( u , v ) padding -> char -> ( _ , _ , e , f ) fmt_ebb = fun pct_ind str_ind end_ind plus hash space ign pad prec padprec symb -> let plus_used = ref false and hash_used = ref false and space_used = ref false and ign_used = ref false and pad_used = ref false and prec_used = ref false in let get_plus ( ) = plus_used := true ; plus and get_hash ( ) = hash_used := true ; hash and get_space ( ) = space_used := true ; space and get_ign ( ) = ign_used := true ; ign and get_pad ( ) = pad_used := true ; pad and get_prec ( ) = prec_used := true ; prec and get_padprec ( ) = pad_used := true ; padprec in let get_int_pad ( ) = match get_pad ( ) , get_prec ( ) with | pad , No_precision -> pad | No_padding , _ -> No_padding | Lit_padding ( Zeros , n ) , _ -> if legacy_behavior then Lit_padding ( Right , n ) else incompatible_flag pct_ind str_ind ' 0 ' " precision " | Arg_padding Zeros , _ -> if legacy_behavior then Arg_padding Right else incompatible_flag pct_ind str_ind ' 0 ' " precision " | Lit_padding _ as pad , _ -> pad | Arg_padding _ as pad , _ -> pad in let check_no_0 symb ( type a ) ( type b ) ( pad : ( a , b ) padding ) = match pad with | No_padding -> pad | Lit_padding ( ( Left | Right ) , _ ) -> pad | Arg_padding ( Left | Right ) -> pad | Lit_padding ( Zeros , width ) -> if legacy_behavior then Lit_padding ( Right , width ) else incompatible_flag pct_ind str_ind symb " 0 " | Arg_padding Zeros -> if legacy_behavior then Arg_padding Right else incompatible_flag pct_ind str_ind symb " 0 " in let opt_of_pad c ( type a ) ( type b ) ( pad : ( a , b ) padding ) = match pad with | No_padding -> None | Lit_padding ( Right , width ) -> Some width | Lit_padding ( Zeros , width ) -> if legacy_behavior then Some width else incompatible_flag pct_ind str_ind c " ' 0 ' " | Lit_padding ( Left , width ) -> if legacy_behavior then Some width else incompatible_flag pct_ind str_ind c " ' ' " - | Arg_padding _ -> incompatible_flag pct_ind str_ind c " ' ' " * in let get_pad_opt c = opt_of_pad c ( get_pad ( ) ) in let get_padprec_opt c = opt_of_pad c ( get_padprec ( ) ) in let get_prec_opt ( ) = match get_prec ( ) with | No_precision -> None | Lit_precision ndec -> Some ndec | Arg_precision -> incompatible_flag pct_ind str_ind ' _ ' " ' ' " * in let fmt_result = match symb with | ' , ' -> parse str_ind end_ind | ' c ' -> let char_format fmt_rest = if get_ign ( ) then Fmt_EBB ( Ignored_param ( Ignored_char , fmt_rest ) ) else Fmt_EBB ( Char fmt_rest ) in let scan_format fmt_rest = if get_ign ( ) then Fmt_EBB ( Ignored_param ( Ignored_scan_next_char , fmt_rest ) ) else Fmt_EBB ( Scan_next_char fmt_rest ) in let Fmt_EBB fmt_rest = parse str_ind end_ind in begin match get_pad_opt ' c ' with | None -> char_format fmt_rest | Some 0 -> scan_format fmt_rest | Some _n -> if not legacy_behavior then invalid_nonnull_char_width str_ind else char_format fmt_rest end | ' C ' -> let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then Fmt_EBB ( Ignored_param ( Ignored_caml_char , fmt_rest ) ) else Fmt_EBB ( Caml_char fmt_rest ) | ' s ' -> let pad = check_no_0 symb ( get_padprec ( ) ) in let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then let ignored = Ignored_string ( get_padprec_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padding_fmt_EBB ( pad ' , fmt_rest ' ) = make_padding_fmt_ebb pad fmt_rest in Fmt_EBB ( String ( pad ' , fmt_rest ' ) ) | ' S ' -> let pad = check_no_0 symb ( get_padprec ( ) ) in let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then let ignored = Ignored_caml_string ( get_padprec_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padding_fmt_EBB ( pad ' , fmt_rest ' ) = make_padding_fmt_ebb pad fmt_rest in Fmt_EBB ( Caml_string ( pad ' , fmt_rest ' ) ) | ' d ' | ' i ' | ' x ' | ' X ' | ' o ' | ' u ' -> let iconv = compute_int_conv pct_ind str_ind ( get_plus ( ) ) ( get_hash ( ) ) ( get_space ( ) ) symb in let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then let ignored = Ignored_int ( iconv , get_pad_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padprec_fmt_EBB ( pad ' , prec ' , fmt_rest ' ) = make_padprec_fmt_ebb ( get_int_pad ( ) ) ( get_prec ( ) ) fmt_rest in Fmt_EBB ( Int ( iconv , pad ' , prec ' , fmt_rest ' ) ) | ' N ' -> let Fmt_EBB fmt_rest = parse str_ind end_ind in let counter = Token_counter in if get_ign ( ) then let ignored = Ignored_scan_get_counter counter in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else Fmt_EBB ( Scan_get_counter ( counter , fmt_rest ) ) | ' l ' | ' n ' | ' L ' when str_ind = end_ind || not ( is_int_base str . [ str_ind ] ) -> let Fmt_EBB fmt_rest = parse str_ind end_ind in let counter = counter_of_char symb in if get_ign ( ) then let ignored = Ignored_scan_get_counter counter in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else Fmt_EBB ( Scan_get_counter ( counter , fmt_rest ) ) | ' l ' -> let iconv = compute_int_conv pct_ind ( str_ind + 1 ) ( get_plus ( ) ) ( get_hash ( ) ) ( get_space ( ) ) str . [ str_ind ] in let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in if get_ign ( ) then let ignored = Ignored_int32 ( iconv , get_pad_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padprec_fmt_EBB ( pad ' , prec ' , fmt_rest ' ) = make_padprec_fmt_ebb ( get_int_pad ( ) ) ( get_prec ( ) ) fmt_rest in Fmt_EBB ( Int32 ( iconv , pad ' , prec ' , fmt_rest ' ) ) | ' n ' -> let iconv = compute_int_conv pct_ind ( str_ind + 1 ) ( get_plus ( ) ) ( get_hash ( ) ) ( get_space ( ) ) str . [ str_ind ] in let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in if get_ign ( ) then let ignored = Ignored_nativeint ( iconv , get_pad_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padprec_fmt_EBB ( pad ' , prec ' , fmt_rest ' ) = make_padprec_fmt_ebb ( get_int_pad ( ) ) ( get_prec ( ) ) fmt_rest in Fmt_EBB ( Nativeint ( iconv , pad ' , prec ' , fmt_rest ' ) ) | ' L ' -> let iconv = compute_int_conv pct_ind ( str_ind + 1 ) ( get_plus ( ) ) ( get_hash ( ) ) ( get_space ( ) ) str . [ str_ind ] in let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in if get_ign ( ) then let ignored = Ignored_int64 ( iconv , get_pad_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padprec_fmt_EBB ( pad ' , prec ' , fmt_rest ' ) = make_padprec_fmt_ebb ( get_int_pad ( ) ) ( get_prec ( ) ) fmt_rest in Fmt_EBB ( Int64 ( iconv , pad ' , prec ' , fmt_rest ' ) ) | ' f ' | ' e ' | ' E ' | ' g ' | ' G ' | ' F ' | ' h ' | ' H ' -> let fconv = compute_float_conv pct_ind str_ind ( get_plus ( ) ) ( get_space ( ) ) symb in let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then let ignored = Ignored_float ( get_pad_opt ' _ ' , get_prec_opt ( ) ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padprec_fmt_EBB ( pad ' , prec ' , fmt_rest ' ) = make_padprec_fmt_ebb ( get_pad ( ) ) ( get_prec ( ) ) fmt_rest in Fmt_EBB ( Float ( fconv , pad ' , prec ' , fmt_rest ' ) ) | ' b ' | ' B ' -> let pad = check_no_0 symb ( get_padprec ( ) ) in let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then let ignored = Ignored_bool ( get_padprec_opt ' _ ' ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else let Padding_fmt_EBB ( pad ' , fmt_rest ' ) = make_padding_fmt_ebb pad fmt_rest in Fmt_EBB ( Bool ( pad ' , fmt_rest ' ) ) | ' a ' -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Alpha fmt_rest ) | ' t ' -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Theta fmt_rest ) | ' r ' -> let Fmt_EBB fmt_rest = parse str_ind end_ind in if get_ign ( ) then Fmt_EBB ( Ignored_param ( Ignored_reader , fmt_rest ) ) else Fmt_EBB ( Reader fmt_rest ) | ' ' ! -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Flush fmt_rest ) | ( ' ' % | ' ' ) @ as c -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Char_literal ( c , fmt_rest ) ) | ' { ' -> let sub_end = search_subformat_end str_ind end_ind ' } ' in let Fmt_EBB sub_fmt = parse str_ind sub_end in let Fmt_EBB fmt_rest = parse ( sub_end + 2 ) end_ind in let sub_fmtty = fmtty_of_fmt sub_fmt in if get_ign ( ) then let ignored = Ignored_format_arg ( get_pad_opt ' _ ' , sub_fmtty ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else Fmt_EBB ( Format_arg ( get_pad_opt ' { ' , sub_fmtty , fmt_rest ) ) | ' ( ' -> let sub_end = search_subformat_end str_ind end_ind ' ) ' in let Fmt_EBB fmt_rest = parse ( sub_end + 2 ) end_ind in let Fmt_EBB sub_fmt = parse str_ind sub_end in let sub_fmtty = fmtty_of_fmt sub_fmt in if get_ign ( ) then let ignored = Ignored_format_subst ( get_pad_opt ' _ ' , sub_fmtty ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else Fmt_EBB ( Format_subst ( get_pad_opt ' ( ' , sub_fmtty , fmt_rest ) ) | ' [ ' -> let next_ind , char_set = parse_char_set str_ind end_ind in let Fmt_EBB fmt_rest = parse next_ind end_ind in if get_ign ( ) then let ignored = Ignored_scan_char_set ( get_pad_opt ' _ ' , char_set ) in Fmt_EBB ( Ignored_param ( ignored , fmt_rest ) ) else Fmt_EBB ( Scan_char_set ( get_pad_opt ' [ ' , char_set , fmt_rest ) ) | ' ' - | ' ' + | ' ' # | ' ' | ' _ ' -> failwith_message " invalid format % S : at character number % d , \ flag % C is only allowed after the ' ' , %% before padding and precision " str pct_ind symb | _ -> failwith_message " invalid format % S : at character number % d , \ invalid conversion " \%%% c " " \ str ( str_ind - 1 ) symb in if not legacy_behavior then begin if not ! plus_used && plus then incompatible_flag pct_ind str_ind symb " ' ' " ; + if not ! hash_used && hash then incompatible_flag pct_ind str_ind symb " ' ' " ; # if not ! space_used && space then incompatible_flag pct_ind str_ind symb " ' ' " ; if not ! pad_used && Padding_EBB pad <> Padding_EBB No_padding then incompatible_flag pct_ind str_ind symb " ` padding ' " ; if not ! prec_used && Precision_EBB prec <> Precision_EBB No_precision then incompatible_flag pct_ind str_ind ( if ign then ' _ ' else symb ) " ` precision ' " ; if ign && plus then incompatible_flag pct_ind str_ind ' _ ' " ' ' " ; + end ; if not ! ign_used && ign then begin match symb with | ( ' ' @ | ' ' % | ' ' ! | ' , ' ) when legacy_behavior -> ( ) | _ -> incompatible_flag pct_ind str_ind symb " ' _ ' " end ; fmt_result and parse_after_at : type e f . int -> int -> ( _ , _ , e , f ) fmt_ebb = fun str_ind end_ind -> if str_ind = end_ind then Fmt_EBB ( Char_literal ( ' ' , @ End_of_format ) ) else match str . [ str_ind ] with | ' [ ' -> parse_tag false ( str_ind + 1 ) end_ind | ' ] ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Close_box , fmt_rest ) ) | ' { ' -> parse_tag true ( str_ind + 1 ) end_ind | ' } ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Close_tag , fmt_rest ) ) | ' , ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Break ( " , " , @ 0 , 0 ) , fmt_rest ) ) | ' ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Break ( " @ " , 1 , 0 ) , fmt_rest ) ) | ' ; ' -> parse_good_break ( str_ind + 1 ) end_ind | ' ' ? -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( FFlush , fmt_rest ) ) | ' \ n ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Force_newline , fmt_rest ) ) | ' . ' -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Flush_newline , fmt_rest ) ) | ' ' < -> parse_magic_size ( str_ind + 1 ) end_ind | ' ' @ -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Escaped_at , fmt_rest ) ) | ' ' % when str_ind + 1 < end_ind && str . [ str_ind + 1 ] = ' ' % -> let Fmt_EBB fmt_rest = parse ( str_ind + 2 ) end_ind in Fmt_EBB ( Formatting_lit ( Escaped_percent , fmt_rest ) ) | ' ' % -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Char_literal ( ' ' , @ fmt_rest ) ) | c -> let Fmt_EBB fmt_rest = parse ( str_ind + 1 ) end_ind in Fmt_EBB ( Formatting_lit ( Scan_indic c , fmt_rest ) ) and check_open_box : type a b c d e f . ( a , b , c , d , e , f ) fmt -> unit = fun fmt -> match fmt with | String_literal ( str , End_of_format ) -> ( try ignore ( open_box_of_string str ) with Failure _ -> ( ) ) | _ -> ( ) and parse_tag : type e f . bool -> int -> int -> ( _ , _ , e , f ) fmt_ebb = fun is_open_tag str_ind end_ind -> try if str_ind = end_ind then raise Not_found ; match str . [ str_ind ] with | ' ' < -> let ind = String . index_from str ( str_ind + 1 ) ' ' > in if ind >= end_ind then raise Not_found ; let sub_str = String . sub str str_ind ( ind - str_ind + 1 ) in let Fmt_EBB fmt_rest = parse ( ind + 1 ) end_ind in let Fmt_EBB sub_fmt = parse str_ind ( ind + 1 ) in let sub_format = Format ( sub_fmt , sub_str ) in let formatting = if is_open_tag then Open_tag sub_format else ( check_open_box sub_fmt ; Open_box sub_format ) in Fmt_EBB ( Formatting_gen ( formatting , fmt_rest ) ) | _ -> raise Not_found with Not_found -> let Fmt_EBB fmt_rest = parse str_ind end_ind in let sub_format = Format ( End_of_format , " " ) in let formatting = if is_open_tag then Open_tag sub_format else Open_box sub_format in Fmt_EBB ( Formatting_gen ( formatting , fmt_rest ) ) and parse_good_break : type e f . int -> int -> ( _ , _ , e , f ) fmt_ebb = fun str_ind end_ind -> let next_ind , formatting_lit = try if str_ind = end_ind || str . [ str_ind ] <> ' ' < then raise Not_found ; let str_ind_1 = parse_spaces ( str_ind + 1 ) end_ind in match str . [ str_ind_1 ] with | ' 0 ' . . ' 9 ' | ' ' - -> ( let str_ind_2 , width = parse_integer str_ind_1 end_ind in let str_ind_3 = parse_spaces str_ind_2 end_ind in match str . [ str_ind_3 ] with | ' ' > -> let s = String . sub str ( str_ind - 2 ) ( str_ind_3 - str_ind + 3 ) in str_ind_3 + 1 , Break ( s , width , 0 ) | ' 0 ' . . ' 9 ' | ' ' - -> let str_ind_4 , offset = parse_integer str_ind_3 end_ind in let str_ind_5 = parse_spaces str_ind_4 end_ind in if str . [ str_ind_5 ] <> ' ' > then raise Not_found ; let s = String . sub str ( str_ind - 2 ) ( str_ind_5 - str_ind + 3 ) in str_ind_5 + 1 , Break ( s , width , offset ) | _ -> raise Not_found ) | _ -> raise Not_found with Not_found | Failure _ -> str_ind , Break ( " ; " , @ 1 , 0 ) in let Fmt_EBB fmt_rest = parse next_ind end_ind in Fmt_EBB ( Formatting_lit ( formatting_lit , fmt_rest ) ) and parse_magic_size : type e f . int -> int -> ( _ , _ , e , f ) fmt_ebb = fun str_ind end_ind -> match try let str_ind_1 = parse_spaces str_ind end_ind in match str . [ str_ind_1 ] with | ' 0 ' . . ' 9 ' | ' ' - -> let str_ind_2 , size = parse_integer str_ind_1 end_ind in let str_ind_3 = parse_spaces str_ind_2 end_ind in if str . [ str_ind_3 ] <> ' ' > then raise Not_found ; let s = String . sub str ( str_ind - 2 ) ( str_ind_3 - str_ind + 3 ) in Some ( str_ind_3 + 1 , Magic_size ( s , size ) ) | _ -> None with Not_found | Failure _ -> None with | Some ( next_ind , formatting_lit ) -> let Fmt_EBB fmt_rest = parse next_ind end_ind in Fmt_EBB ( Formatting_lit ( formatting_lit , fmt_rest ) ) | None -> let Fmt_EBB fmt_rest = parse str_ind end_ind in Fmt_EBB ( Formatting_lit ( Scan_indic ' ' , < fmt_rest ) ) and parse_char_set str_ind end_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; let char_set = create_char_set ( ) in let add_char c = add_in_char_set char_set c ; in let add_range c c ' = for i = int_of_char c to int_of_char c ' do add_in_char_set char_set ( char_of_int i ) ; done ; in let fail_single_percent str_ind = failwith_message " invalid format % S : ' ' %% alone is not accepted in character sets , \ use %%%% instead at position % d . " str str_ind in let rec parse_char_set_start str_ind end_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; let c = str . [ str_ind ] in parse_char_set_after_char ( str_ind + 1 ) end_ind c and parse_char_set_content str_ind end_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' ] ' -> str_ind + 1 | ' ' - -> add_char ' ' ; - parse_char_set_content ( str_ind + 1 ) end_ind | c -> parse_char_set_after_char ( str_ind + 1 ) end_ind c and parse_char_set_after_char str_ind end_ind c = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' ] ' -> add_char c ; str_ind + 1 | ' ' - -> parse_char_set_after_minus ( str_ind + 1 ) end_ind c | ( ' ' % | ' ' ) @ as c ' when c = ' ' % -> add_char c ' ; parse_char_set_content ( str_ind + 1 ) end_ind | c ' -> if c = ' ' % then fail_single_percent str_ind ; add_char c ; parse_char_set_after_char ( str_ind + 1 ) end_ind c ' and parse_char_set_after_minus str_ind end_ind c = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' ] ' -> add_char c ; add_char ' ' ; - str_ind + 1 | ' ' % -> if str_ind + 1 = end_ind then unexpected_end_of_format end_ind ; begin match str . [ str_ind + 1 ] with | ( ' ' % | ' ' ) @ as c ' -> add_range c c ' ; parse_char_set_content ( str_ind + 2 ) end_ind | _ -> fail_single_percent str_ind end | c ' -> add_range c c ' ; parse_char_set_content ( str_ind + 1 ) end_ind in let str_ind , reverse = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' ' ^ -> str_ind + 1 , true | _ -> str_ind , false in let next_ind = parse_char_set_start str_ind end_ind in let char_set = freeze_char_set char_set in next_ind , ( if reverse then rev_char_set char_set else char_set ) and parse_spaces str_ind end_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; if str . [ str_ind ] = ' ' then parse_spaces ( str_ind + 1 ) end_ind else str_ind and parse_positive str_ind end_ind acc = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' 0 ' . . ' 9 ' as c -> let new_acc = acc * 10 + ( int_of_char c - int_of_char ' 0 ' ) in if new_acc > Sys . max_string_length then failwith_message " invalid format % S : integer % d is greater than the limit % d " str new_acc Sys . max_string_length else parse_positive ( str_ind + 1 ) end_ind new_acc | _ -> str_ind , acc and parse_integer str_ind end_ind = if str_ind = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind ] with | ' 0 ' . . ' 9 ' -> parse_positive str_ind end_ind 0 | ' ' - -> ( if str_ind + 1 = end_ind then unexpected_end_of_format end_ind ; match str . [ str_ind + 1 ] with | ' 0 ' . . ' 9 ' -> let next_ind , n = parse_positive ( str_ind + 1 ) end_ind 0 in next_ind , - n | c -> expected_character ( str_ind + 1 ) " digit " c ) | _ -> assert false and add_literal : type a d e f . int -> int -> ( a , _ , _ , d , e , f ) fmt -> ( _ , _ , e , f ) fmt_ebb = fun lit_start str_ind fmt -> match str_ind - lit_start with | 0 -> Fmt_EBB fmt | 1 -> Fmt_EBB ( Char_literal ( str . [ lit_start ] , fmt ) ) | size -> Fmt_EBB ( String_literal ( String . sub str lit_start size , fmt ) ) and search_subformat_end str_ind end_ind c = if str_ind = end_ind then failwith_message " invalid format % S : unclosed sub - format , \ expected " \%%% c " \ at character number % d " str c end_ind ; match str . [ str_ind ] with | ' ' % -> if str_ind + 1 = end_ind then unexpected_end_of_format end_ind ; if str . [ str_ind + 1 ] = c then str_ind else begin match str . [ str_ind + 1 ] with | ' _ ' -> if str_ind + 2 = end_ind then unexpected_end_of_format end_ind ; begin match str . [ str_ind + 2 ] with | ' { ' -> let sub_end = search_subformat_end ( str_ind + 3 ) end_ind ' } ' in search_subformat_end ( sub_end + 2 ) end_ind c | ' ( ' -> let sub_end = search_subformat_end ( str_ind + 3 ) end_ind ' ) ' in search_subformat_end ( sub_end + 2 ) end_ind c | _ -> search_subformat_end ( str_ind + 3 ) end_ind c end | ' { ' -> let sub_end = search_subformat_end ( str_ind + 2 ) end_ind ' } ' in search_subformat_end ( sub_end + 2 ) end_ind c | ' ( ' -> let sub_end = search_subformat_end ( str_ind + 2 ) end_ind ' ) ' in search_subformat_end ( sub_end + 2 ) end_ind c | ' } ' -> expected_character ( str_ind + 1 ) " character ' ) ' " ' } ' | ' ) ' -> expected_character ( str_ind + 1 ) " character ' } ' " ' ) ' | _ -> search_subformat_end ( str_ind + 2 ) end_ind c end | _ -> search_subformat_end ( str_ind + 1 ) end_ind c and is_int_base symb = match symb with | ' d ' | ' i ' | ' x ' | ' X ' | ' o ' | ' u ' -> true | _ -> false and counter_of_char symb = match symb with | ' l ' -> Line_counter | ' n ' -> Char_counter | ' L ' -> Token_counter | _ -> assert false and compute_int_conv pct_ind str_ind plus hash space symb = match plus , hash , space , symb with | false , false , false , ' d ' -> Int_d | false , false , false , ' i ' -> Int_i | false , false , true , ' d ' -> Int_sd | false , false , true , ' i ' -> Int_si | true , false , false , ' d ' -> Int_pd | true , false , false , ' i ' -> Int_pi | false , false , false , ' x ' -> Int_x | false , false , false , ' X ' -> Int_X | false , true , false , ' x ' -> Int_Cx | false , true , false , ' X ' -> Int_CX | false , false , false , ' o ' -> Int_o | false , true , false , ' o ' -> Int_Co | false , false , false , ' u ' -> Int_u | false , true , false , ' d ' -> Int_Cd | false , true , false , ' i ' -> Int_Ci | false , true , false , ' u ' -> Int_Cu | _ , true , _ , ' x ' when legacy_behavior -> Int_Cx | _ , true , _ , ' X ' when legacy_behavior -> Int_CX | _ , true , _ , ' o ' when legacy_behavior -> Int_Co | _ , true , _ , ( ' d ' | ' i ' | ' u ' ) -> if legacy_behavior then compute_int_conv pct_ind str_ind plus false space symb else incompatible_flag pct_ind str_ind symb " ' ' " # | true , _ , true , _ -> if legacy_behavior then compute_int_conv pct_ind str_ind plus hash false symb else incompatible_flag pct_ind str_ind ' ' " ' ' " + | false , _ , true , _ -> if legacy_behavior then compute_int_conv pct_ind str_ind plus hash false symb else incompatible_flag pct_ind str_ind symb " ' ' " | true , _ , false , _ -> if legacy_behavior then compute_int_conv pct_ind str_ind false hash space symb else incompatible_flag pct_ind str_ind symb " ' ' " + | false , _ , false , _ -> assert false and compute_float_conv pct_ind str_ind plus space symb = let flag = match plus , space with | false , false -> Float_flag_ | false , true -> Float_flag_s | true , false -> Float_flag_p | true , true -> if legacy_behavior then Float_flag_p else incompatible_flag pct_ind str_ind ' ' " ' ' " + in let kind = match symb with | ' f ' -> Float_f | ' e ' -> Float_e | ' E ' -> Float_E | ' g ' -> Float_g | ' G ' -> Float_G | ' h ' -> Float_h | ' H ' -> Float_H | ' F ' -> Float_F | _ -> assert false in flag , kind and incompatible_flag : type a . int -> int -> char -> string -> a = fun pct_ind str_ind symb option -> let subfmt = String . sub str pct_ind ( str_ind - pct_ind ) in failwith_message " invalid format % S : at character number % d , \ % s is incompatible with ' % c ' in sub - format % S " str pct_ind option symb subfmt in parse 0 ( String . length str ) let format_of_string_fmtty str fmtty = let Fmt_EBB fmt = fmt_ebb_of_string str in try Format ( type_format fmt fmtty , str ) with Type_mismatch -> failwith_message " bad input : format type mismatch between % S and % S " str ( string_of_fmtty fmtty ) let format_of_string_format str ( Format ( fmt ' , str ' ) ) = let Fmt_EBB fmt = fmt_ebb_of_string str in try Format ( type_format fmt ( fmtty_of_fmt fmt ' ) , str ) with Type_mismatch -> failwith_message " bad input : format type mismatch between % S and % S " str str ' ) * |
type padty = | Left | Right | Zeros |
type int_conv = | Int_d | Int_pd | Int_sd | Int_i | Int_pi | Int_si | Int_x | Int_Cx | Int_X | Int_CX | Int_o | Int_Co | Int_u | Int_Cd | Int_Ci | Int_Cu |
type float_flag_conv = | Float_flag_ | Float_flag_p | Float_flag_s |
type float_kind_conv = | Float_f | Float_e | Float_E | Float_g | Float_G | Float_F | Float_h | Float_H | Float_CF |
type float_conv = float_flag_conv * float_kind_conv |
type counter = | Line_counter | Char_counter | Token_counter |
type ( ' a , ' b ) padding = | No_padding : ( ' a , ' a ) padding | Lit_padding : padty * int -> ( ' a , ' a ) padding | Arg_padding : padty -> ( int -> ' a , ' a ) padding |
type pad_option = int option |
type ( ' a , ' b ) precision = | No_precision : ( ' a , ' a ) precision | Lit_precision : int -> ( ' a , ' a ) precision | Arg_precision : ( int -> ' a , ' a ) precision |
type prec_option = int option |
type ( ' a , ' b , ' c ) custom_arity = | Custom_zero : ( ' a , string , ' a ) custom_arity | Custom_succ : ( ' a , ' b , ' c ) custom_arity -> ( ' a , ' x -> ' b , ' x -> ' c ) custom_arity pad_option * ( ' d1 , ' q1 , ' d2 , ' q2 ) reader_nb_unifier * ( ' x , ' b , ' c , ' d1 , ' q1 , ' u ) fmtty * ( ' u , ' b , ' c , ' q1 , ' e1 , ' f ) fmt -> ( ( ' x , ' b , ' c , ' d2 , ' q2 , ' u ) format6 -> ' x , ' b , ' c , ' d1 , ' e1 , ' f ) fmt |
type of the expected format parameter depends of where the ( . . . ) %% # Printf . printf " ( ) " %% - : ( unit , out_channel , unit , ' _a , ' _a , unit ) CamlinternalFormatBasics . format6 -> unit = < fun > # Printf . printf " ( ) %%% d " - : ( int -> unit , out_channel , unit , ' _a , ' _a , int -> unit ) CamlinternalFormatBasics . format6 -> int -> unit = < fun > anymore : fun sep -> Format . printf " foo ( ) %% bar ( ) %% baz " sep sep ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( char -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , char -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel fmtty_rel : type ( ' a , ' b , ' c , ' d , ' e , ' f ) fmtty = ( ' a , ' b , ' c , ' d , ' e , ' f , ' a , ' b , ' c , ' d , ' e , ' f ) fmtty_rel pad_option * ( ' g , ' h , ' i , ' j , ' k , ' l , ' g2 , ' b , ' c , ' j2 , ' d , ' a ) fmtty_rel * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g2 , ' b , ' c , ' j2 , ' e , ' f ) fmt val recast : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 ) fmt -> ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmt ( ' g , ' h , ' i , ' j , ' k , ' l , ' g1 , ' b1 , ' c1 , ' j1 , ' d1 , ' a1 ) fmtty_rel * ( ' g , ' h , ' i , ' j , ' k , ' l , ' g2 , ' b2 , ' c2 , ' j2 , ' d2 , ' a2 ) fmtty_rel * ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g1 , ' b1 , ' c1 , ' j1 , ' e1 , ' f1 , ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g2 , ' b2 , ' c2 , ' j2 , ' e2 , ' f2 ) fmtty_rel val trans : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 , ' a3 , ' b3 , ' c3 , ' d3 , ' e3 , ' f3 ) fmtty_rel -> ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a3 , ' b3 , ' c3 , ' d3 , ' e3 , ' f3 ) fmtty_rel ) * |
type block_type = | Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits |
type formatting_lit = | Close_box | Close_tag | Break of string * int * int | FFlush | Force_newline | Flush_newline | Magic_size of string * int | Escaped_at | Escaped_percent | Scan_indic of char |
type ( ' a , ' b , ' c , ' d , ' e , ' f ) formatting_gen = | Open_tag : ( ' a , ' b , ' c , ' d , ' e , ' f ) format6 -> ( ' a , ' b , ' c , ' d , ' e , ' f ) formatting_gen | Open_box : ( ' a , ' b , ' c , ' d , ' e , ' f ) format6 -> ( ' a , ' b , ' c , ' d , ' e , ' f ) formatting_gen ( ' a , ' b , ' c , ' d , ' e , ' f , ' a , ' b , ' c , ' d , ' e , ' f ) fmtty_rel ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel = | Char_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( char -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , char -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | String_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( string -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , string -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Int_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( int -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , int -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Int32_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( int32 -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , int32 -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Nativeint_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( nativeint -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , nativeint -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Int64_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( int64 -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , int64 -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Float_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( float -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , float -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Bool_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( bool -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , bool -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Format_arg_ty : ( ' g , ' h , ' i , ' j , ' k , ' l ) fmtty * ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Format_subst_ty : ( ' g , ' h , ' i , ' j , ' k , ' l , ' g1 , ' b1 , ' c1 , ' j1 , ' d1 , ' a1 ) fmtty_rel * ( ' g , ' h , ' i , ' j , ' k , ' l , ' g2 , ' b2 , ' c2 , ' j2 , ' d2 , ' a2 ) fmtty_rel * ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g1 , ' b1 , ' c1 , ' j1 , ' e1 , ' f1 , ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g2 , ' b2 , ' c2 , ' j2 , ' e2 , ' f2 ) fmtty_rel | Alpha_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ( ' b1 -> ' x -> ' c1 ) -> ' x -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ( ' b2 -> ' x -> ' c2 ) -> ' x -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Theta_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ( ' b1 -> ' c1 ) -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ( ' b2 -> ' c2 ) -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Any_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ' x -> ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' x -> ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel | Reader_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ' x -> ' a1 , ' b1 , ' c1 , ( ' b1 -> ' x ) -> ' d1 , ' e1 , ' f1 , ' x -> ' a2 , ' b2 , ' c2 , ( ' b2 -> ' x ) -> ' d2 , ' e2 , ' f2 ) fmtty_rel | Ignored_reader_ty : ( ' a1 , ' b1 , ' c1 , ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ' d2 , ' e2 , ' f2 ) fmtty_rel -> ( ' a1 , ' b1 , ' c1 , ( ' b1 -> ' x ) -> ' d1 , ' e1 , ' f1 , ' a2 , ' b2 , ' c2 , ( ' b2 -> ' x ) -> ' d2 , ' e2 , ' f2 ) fmtty_rel | End_of_fmtty : ( ' f1 , ' b1 , ' c1 , ' d1 , ' d1 , ' f1 , ' f2 , ' b2 , ' c2 , ' d2 , ' d2 , ' f2 ) fmtty_rel | Char : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( char -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Caml_char : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( char -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | String : ( ' x , string -> ' a ) padding * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Caml_string : ( ' x , string -> ' a ) padding * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Int : int_conv * ( ' x , ' y ) padding * ( ' y , int -> ' a ) precision * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Int32 : int_conv * ( ' x , ' y ) padding * ( ' y , int32 -> ' a ) precision * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Nativeint : int_conv * ( ' x , ' y ) padding * ( ' y , nativeint -> ' a ) precision * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Int64 : int_conv * ( ' x , ' y ) padding * ( ' y , int64 -> ' a ) precision * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Float : float_conv * ( ' x , ' y ) padding * ( ' y , float -> ' a ) precision * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Bool : ( ' x , bool -> ' a ) padding * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x , ' b , ' c , ' d , ' e , ' f ) fmt | Flush : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt | String_literal : string * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Char_literal : char * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Format_arg : pad_option * ( ' g , ' h , ' i , ' j , ' k , ' l ) fmtty * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Format_subst : pad_option * ( ' g , ' h , ' i , ' j , ' k , ' l , ' g2 , ' b , ' c , ' j2 , ' d , ' a ) fmtty_rel * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ( ' g , ' h , ' i , ' j , ' k , ' l ) format6 -> ' g2 , ' b , ' c , ' j2 , ' e , ' f ) fmt | Alpha : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ( ' b -> ' x -> ' c ) -> ' x -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Theta : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ( ' b -> ' c ) -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Formatting_lit : formatting_lit * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Formatting_gen : ( ' a1 , ' b , ' c , ' d1 , ' e1 , ' f1 ) formatting_gen * ( ' f1 , ' b , ' c , ' e1 , ' e2 , ' f2 ) fmt -> ( ' a1 , ' b , ' c , ' d1 , ' e2 , ' f2 ) fmt | Reader : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' x -> ' a , ' b , ' c , ( ' b -> ' x ) -> ' d , ' e , ' f ) fmt | Scan_char_set : pad_option * char_set * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( string -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Scan_get_counter : counter * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( int -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Scan_next_char : ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( char -> ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Ignored_param : ( ' a , ' b , ' c , ' d , ' y , ' x ) ignored * ( ' x , ' b , ' c , ' y , ' e , ' f ) fmt -> ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt | Custom : ( ' a , ' x , ' y ) custom_arity * ( unit -> ' x ) * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt -> ( ' y , ' b , ' c , ' d , ' e , ' f ) fmt | End_of_format : ( ' f , ' b , ' c , ' e , ' e , ' f ) fmt | Ignored_char : ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_caml_char : ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_string : pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_caml_string : pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_int : int_conv * pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_int32 : int_conv * pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_nativeint : int_conv * pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_int64 : int_conv * pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_float : pad_option * prec_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_bool : pad_option -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_format_arg : pad_option * ( ' g , ' h , ' i , ' j , ' k , ' l ) fmtty -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_format_subst : pad_option * ( ' a , ' b , ' c , ' d , ' e , ' f ) fmtty -> ( ' a , ' b , ' c , ' d , ' e , ' f ) ignored | Ignored_reader : ( ' a , ' b , ' c , ( ' b -> ' x ) -> ' d , ' d , ' a ) ignored | Ignored_scan_char_set : pad_option * char_set -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_scan_get_counter : counter -> ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored | Ignored_scan_next_char : ( ' a , ' b , ' c , ' d , ' d , ' a ) ignored Format of ( ' a , ' b , ' c , ' d , ' e , ' f ) fmt * string |
let rec erase_rel : type a b c d e f g h i j k l . ( a , b , c , d , e , f , g , h , i , j , k , l ) fmtty_rel -> ( a , b , c , d , e , f ) fmtty | Char_ty rest -> Char_ty ( erase_rel rest ) | String_ty rest -> String_ty ( erase_rel rest ) | Int_ty rest -> Int_ty ( erase_rel rest ) | Int32_ty rest -> Int32_ty ( erase_rel rest ) | Int64_ty rest -> Int64_ty ( erase_rel rest ) | Nativeint_ty rest -> Nativeint_ty ( erase_rel rest ) | Float_ty rest -> Float_ty ( erase_rel rest ) | Bool_ty rest -> Bool_ty ( erase_rel rest ) | Format_arg_ty ( ty , rest ) -> Format_arg_ty ( ty , erase_rel rest ) | Format_subst_ty ( ty1 , _ty2 , rest ) -> Format_subst_ty ( ty1 , ty1 , erase_rel rest ) | Alpha_ty rest -> Alpha_ty ( erase_rel rest ) | Theta_ty rest -> Theta_ty ( erase_rel rest ) | Any_ty rest -> Any_ty ( erase_rel rest ) | Reader_ty rest -> Reader_ty ( erase_rel rest ) | Ignored_reader_ty rest -> Ignored_reader_ty ( erase_rel rest ) | End_of_fmtty -> End_of_fmtty |
let rec concat_fmtty : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 g1 j1 g2 j2 . ( g1 , b1 , c1 , j1 , d1 , a1 , g2 , b2 , c2 , j2 , d2 , a2 ) fmtty_rel -> ( a1 , b1 , c1 , d1 , e1 , f1 , a2 , b2 , c2 , d2 , e2 , f2 ) fmtty_rel -> ( g1 , b1 , c1 , j1 , e1 , f1 , g2 , b2 , c2 , j2 , e2 , f2 ) fmtty_rel = | Char_ty rest -> Char_ty ( concat_fmtty rest fmtty2 ) | String_ty rest -> String_ty ( concat_fmtty rest fmtty2 ) | Int_ty rest -> Int_ty ( concat_fmtty rest fmtty2 ) | Int32_ty rest -> Int32_ty ( concat_fmtty rest fmtty2 ) | Nativeint_ty rest -> Nativeint_ty ( concat_fmtty rest fmtty2 ) | Int64_ty rest -> Int64_ty ( concat_fmtty rest fmtty2 ) | Float_ty rest -> Float_ty ( concat_fmtty rest fmtty2 ) | Bool_ty rest -> Bool_ty ( concat_fmtty rest fmtty2 ) | Alpha_ty rest -> Alpha_ty ( concat_fmtty rest fmtty2 ) | Theta_ty rest -> Theta_ty ( concat_fmtty rest fmtty2 ) | Any_ty rest -> Any_ty ( concat_fmtty rest fmtty2 ) | Reader_ty rest -> Reader_ty ( concat_fmtty rest fmtty2 ) | Ignored_reader_ty rest -> Ignored_reader_ty ( concat_fmtty rest fmtty2 ) | Format_arg_ty ( ty , rest ) -> Format_arg_ty ( ty , concat_fmtty rest fmtty2 ) | Format_subst_ty ( ty1 , ty2 , rest ) -> Format_subst_ty ( ty1 , ty2 , concat_fmtty rest fmtty2 ) | End_of_fmtty -> fmtty2 |
let rec concat_fmt : type a b c d e f g h . ( a , b , c , d , e , f ) fmt -> ( f , b , c , e , g , h ) fmt -> ( a , b , c , d , g , h ) fmt = | String ( pad , rest ) -> String ( pad , concat_fmt rest fmt2 ) | Caml_string ( pad , rest ) -> Caml_string ( pad , concat_fmt rest fmt2 ) | Int ( iconv , pad , prec , rest ) -> Int ( iconv , pad , prec , concat_fmt rest fmt2 ) | Int32 ( iconv , pad , prec , rest ) -> Int32 ( iconv , pad , prec , concat_fmt rest fmt2 ) | Nativeint ( iconv , pad , prec , rest ) -> Nativeint ( iconv , pad , prec , concat_fmt rest fmt2 ) | Int64 ( iconv , pad , prec , rest ) -> Int64 ( iconv , pad , prec , concat_fmt rest fmt2 ) | Float ( fconv , pad , prec , rest ) -> Float ( fconv , pad , prec , concat_fmt rest fmt2 ) | Char ( rest ) -> Char ( concat_fmt rest fmt2 ) | Caml_char rest -> Caml_char ( concat_fmt rest fmt2 ) | Bool ( pad , rest ) -> Bool ( pad , concat_fmt rest fmt2 ) | Alpha rest -> Alpha ( concat_fmt rest fmt2 ) | Theta rest -> Theta ( concat_fmt rest fmt2 ) | Custom ( arity , f , rest ) -> Custom ( arity , f , concat_fmt rest fmt2 ) | Reader rest -> Reader ( concat_fmt rest fmt2 ) | Flush rest -> Flush ( concat_fmt rest fmt2 ) | String_literal ( str , rest ) -> String_literal ( str , concat_fmt rest fmt2 ) | Char_literal ( chr , rest ) -> Char_literal ( chr , concat_fmt rest fmt2 ) | Format_arg ( pad , fmtty , rest ) -> Format_arg ( pad , fmtty , concat_fmt rest fmt2 ) | Format_subst ( pad , fmtty , rest ) -> Format_subst ( pad , fmtty , concat_fmt rest fmt2 ) | Scan_char_set ( width_opt , char_set , rest ) -> Scan_char_set ( width_opt , char_set , concat_fmt rest fmt2 ) | Scan_get_counter ( counter , rest ) -> Scan_get_counter ( counter , concat_fmt rest fmt2 ) | Scan_next_char ( rest ) -> Scan_next_char ( concat_fmt rest fmt2 ) | Ignored_param ( ign , rest ) -> Ignored_param ( ign , concat_fmt rest fmt2 ) | Formatting_lit ( fmting_lit , rest ) -> Formatting_lit ( fmting_lit , concat_fmt rest fmt2 ) | Formatting_gen ( fmting_gen , rest ) -> Formatting_gen ( fmting_gen , concat_fmt rest fmt2 ) | End_of_format -> fmt2 |
type ' a t = ' a lazy_t |
let raise_undefined = Obj . repr ( fun ( ) -> raise Undefined ) |
let force_lazy_block ( blk : ' arg lazy_t ) = let closure = ( Obj . obj ( Obj . field ( Obj . repr blk ) 0 ) : unit -> ' arg ) in Obj . set_field ( Obj . repr blk ) 0 raise_undefined ; try let result = closure ( ) in make_forward ( Obj . repr blk ) ( Obj . repr result ) ; result with e -> Obj . set_field ( Obj . repr blk ) 0 ( Obj . repr ( fun ( ) -> raise e ) ) ; raise e |
let force_val_lazy_block ( blk : ' arg lazy_t ) = let closure = ( Obj . obj ( Obj . field ( Obj . repr blk ) 0 ) : unit -> ' arg ) in Obj . set_field ( Obj . repr blk ) 0 raise_undefined ; let result = closure ( ) in make_forward ( Obj . repr blk ) ( Obj . repr result ) ; result |
let force ( lzv : ' arg lazy_t ) = let lzv = Sys . opaque_identity lzv in let x = Obj . repr lzv in let t = Obj . tag x in if t = Obj . forward_tag then ( Obj . obj ( Obj . field x 0 ) : ' arg ) else if t <> Obj . lazy_tag then ( Obj . obj x : ' arg ) else force_lazy_block lzv |
let force_val ( lzv : ' arg lazy_t ) = let x = Obj . repr lzv in let t = Obj . tag x in if t = Obj . forward_tag then ( Obj . obj ( Obj . field x 0 ) : ' arg ) else if t <> Obj . lazy_tag then ( Obj . obj x : ' arg ) else force_val_lazy_block lzv |
type shape = | Function | Lazy | Class | Module of shape array | Value of Obj . t |
let rec init_mod_field modu i loc shape = let init = match shape with | Function -> let rec fn ( x : ' a ) = let fn ' : ' a -> ' b = Obj . obj ( Obj . field modu i ) in if fn == fn ' then raise ( Undefined_recursive_module loc ) else fn ' x in Obj . repr fn | Lazy -> let rec l = lazy ( let l ' = Obj . obj ( Obj . field modu i ) in if l == l ' then raise ( Undefined_recursive_module loc ) else Lazy . force l ' ) in Obj . repr l | Class -> Obj . repr ( CamlinternalOO . dummy_class loc ) | Module comps -> Obj . repr ( init_mod_block loc comps ) | Value v -> v in Obj . set_field modu i init let length = Array . length comps in let modu = Obj . new_block 0 length in for i = 0 to length - 1 do init_mod_field modu i loc comps . ( i ) done ; modu |
let [ @ inline never ] init_mod loc shape = match shape with | Module comps -> Obj . repr ( init_mod_block loc comps ) | _ -> failwith " CamlinternalMod . init_mod : not a module " |
let rec update_mod_field modu i shape n = match shape with | Function | Lazy -> Obj . set_field modu i n | Value _ -> ( ) | Class -> assert ( Obj . tag n = 0 && Obj . size n = 4 ) ; let cl = Obj . field modu i in for j = 0 to 3 do Obj . set_field cl j ( Obj . field n j ) done | Module comps -> update_mod_block comps ( Obj . field modu i ) n assert ( Obj . tag n = 0 && Obj . size n >= Array . length comps ) ; for i = 0 to Array . length comps - 1 do update_mod_field o i comps . ( i ) ( Obj . field n i ) done |
let [ @ inline never ] update_mod shape o n = match shape with | Module comps -> update_mod_block comps o n | _ -> failwith " CamlinternalMod . update_mod : not a module " |
let magic x = Sys . opaque_identity ( Obj . magic x ) |
let of_repr x = Sys . opaque_identity ( Obj . obj x ) |
let set_object_field ( arr : _ array ) field new_value = Array . unsafe_set ( Sys . opaque_identity arr ) field new_value |
let get_object_field ( arr : _ array ) field = Array . unsafe_get ( Sys . opaque_identity arr ) field |
let copy o = let o = ( of_repr ( dup ( repr o ) ) ) in set_id o |
type params = { mutable compact_table : bool ; mutable copy_parent : bool ; mutable clean_when_copying : bool ; mutable retry_count : int ; mutable bucket_small_size : int } |
let params = { compact_table = true ; copy_parent = true ; clean_when_copying = true ; retry_count = 3 ; bucket_small_size = 16 } |
type item = DummyA | DummyB | DummyC of int |
let _ = [ DummyA ; DummyB ; DummyC 0 ] |
let dummy_item = ( magic ( ) : item ) |
type t = DummyA | DummyB | DummyC of int |
let _ = [ DummyA ; DummyB ; DummyC 0 ] |
type obj = t array |
let public_method_label s : tag = let accu = ref 0 in for i = 0 to String . length s - 1 do accu := 223 * ! accu + Char . code s . [ i ] done ; accu := ! accu land ( 1 lsl 31 - 1 ) ; let tag = if ! accu > 0x3FFFFFFF then ! accu - ( 1 lsl 31 ) else ! accu in magic tag |
module Vars = Map . Make ( struct type t = string let compare ( x : t ) y = compare x y end ) |
type vars = int Vars . t |
module Meths = Map . Make ( struct type t = string let compare ( x : t ) y = compare x y end ) |
type meths = label Meths . t |
module Labs = Map . Make ( struct type t = label let compare ( x : t ) y = compare x y end ) |
type labs = bool Labs . t |
type table = { mutable size : int ; mutable methods : closure array ; mutable methods_by_name : meths ; mutable methods_by_label : labs ; mutable previous_states : ( meths * labs * ( label * item ) list * vars * label list * string list ) list ; mutable hidden_meths : ( label * item ) list ; mutable vars : vars ; mutable initializers : ( obj -> unit ) list } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.