AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let round t = t . round
let get_continuation_scope t = TE . current_scope t . typing_env
let can_inline t = t . can_inline
let float_const_prop t = t . float_const_prop
let unit_toplevel_exn_continuation t = t . unit_toplevel_exn_continuation
let unit_toplevel_return_continuation t = t . unit_toplevel_return_continuation
let at_unit_toplevel t = t . at_unit_toplevel
let set_not_at_unit_toplevel t = { t with at_unit_toplevel = false }
let set_at_unit_toplevel_state t at_unit_toplevel = { t with at_unit_toplevel }
let is_defined_at_toplevel t var = Variable . Set . mem var t . variables_defined_at_toplevel
let get_inlining_state t = t . inlining_state
let set_inlining_state t inlining_state = { t with inlining_state }
let inlining_history_tracker t = t . inlining_history_tracker
let relative_history t = Inlining_history . Tracker . relative t . inlining_history_tracker
let set_inlining_history_tracker inlining_history_tracker t = { t with inlining_history_tracker }
let increment_continuation_scope t = { t with typing_env = TE . increment_scope t . typing_env }
let increment_continuation_scope_twice t = increment_continuation_scope ( increment_continuation_scope t )
let enter_set_of_closures { round ; typing_env ; inlined_debuginfo = _ ; can_inline ; inlining_state ; float_const_prop ; at_unit_toplevel = _ ; unit_toplevel_return_continuation ; unit_toplevel_exn_continuation ; variables_defined_at_toplevel ; cse = _ ; do_not_rebuild_terms ; closure_i...
let define_variable t var kind = let typing_env = let var = Bound_name . create_var var in TE . add_definition t . typing_env var kind in let variables_defined_at_toplevel = if t . at_unit_toplevel then Variable . Set . add ( Bound_var . var var ) t . variables_defined_at_toplevel else t . var...
let add_name t name ty = let typing_env = TE . add_equation ( TE . add_definition t . typing_env name ( T . kind ty ) ) ( Bound_name . name name ) ty in let variables_defined_at_toplevel = Name . pattern_match ( Bound_name . name name ) ~ var ( : fun var -> if t . at_unit_topleve...
let add_variable0 t var ty ~ at_unit_toplevel = let typing_env = let var ' = Bound_name . create_var var in TE . add_equation ( TE . add_definition t . typing_env var ' ( T . kind ty ) ) ( Name . var ( Bound_var . var var ) ) ty in let variables_defined_at_toplevel = if at_unit_to...
let add_variable t var ty = add_variable0 t var ty ~ at_unit_toplevel : t . at_unit_toplevel
let add_equation_on_variable t var ty = let typing_env = TE . add_equation t . typing_env ( Name . var var ) ty in { t with typing_env }
let mem_name t name = TE . mem t . typing_env name
let mem_variable t var = TE . mem t . typing_env ( Name . var var )
let define_symbol t sym kind = let typing_env = let sym = Bound_name . create ( Name . symbol sym ) Name_mode . normal in TE . add_definition t . typing_env sym kind in { t with typing_env }
let define_symbol_if_undefined t sym kind = if TE . mem t . typing_env ( Name . symbol sym ) then t else define_symbol t sym kind
let add_symbol t sym ty = let typing_env = let sym = Name . symbol sym in let sym ' = Bound_name . create sym Name_mode . normal in TE . add_equation ( TE . add_definition t . typing_env sym ' ( T . kind ty ) ) sym ty in { t with typing_env }
let add_equation_on_symbol t sym ty = let typing_env = let sym = Name . symbol sym in TE . add_equation t . typing_env sym ty in { t with typing_env }
let mem_symbol t sym = mem_name t ( Name . symbol sym )
let find_symbol t sym = TE . find ( typing_env t ) ( Name . symbol sym ) ( Some K . value )
let add_symbol_projection t var proj = { t with typing_env = TE . add_symbol_projection t . typing_env var proj }
let find_symbol_projection t var = TE . find_symbol_projection t . typing_env var
let define_name t name kind = let typing_env = TE . add_definition t . typing_env name kind in let variables_defined_at_toplevel = Name . pattern_match ( Bound_name . name name ) ~ var ( : fun var -> if t . at_unit_toplevel then Variable . Set . add var t . variables_defined_at_toplevel else...
let define_name_if_undefined t name kind = if TE . mem t . typing_env ( Bound_name . name name ) then t else define_name t name kind
let add_equation_on_name t name ty = let typing_env = TE . add_equation t . typing_env name ty in { t with typing_env }
let define_parameters t ~ params = List . fold_left ( fun t param -> let var = Bound_var . create ( BP . var param ) Name_mode . normal in define_variable t var ( K . With_subkind . kind ( BP . kind param ) ) ) t ( Bound_parameters . to_list params )
let add_parameters ( ? name_mode = Name_mode . normal ) ? at_unit_toplevel t params ~ param_types = let params ' = params in let params = Bound_parameters . to_list params in if List . compare_lengths params param_types <> 0 then Misc . fatal_errorf " Mismatch between number of [ params ] a...
let add_parameters_with_unknown_types ' ? name_mode ? at_unit_toplevel t params = let param_types = ListLabels . map ( Bound_parameters . to_list params ) ~ f ( : fun param -> T . unknown_with_subkind ( BP . kind param ) ) in add_parameters ? name_mode ? at_unit_toplevel t params ~ param...
let add_parameters_with_unknown_types ? name_mode ? at_unit_toplevel t params = fst ( add_parameters_with_unknown_types ' ? name_mode ? at_unit_toplevel t params )
let mark_parameters_as_toplevel t params = let variables_defined_at_toplevel = Variable . Set . union t . variables_defined_at_toplevel ( Bound_parameters . var_set params ) in { t with variables_defined_at_toplevel }
let define_variable_and_extend_typing_environment t var kind env_extension = let typing_env = let var ' = Bound_name . create_var var in TE . add_definition t . typing_env var ' kind in let variables_defined_at_toplevel = if t . at_unit_toplevel then Variable . Set . add ( Bound_var . var var ) ...
let add_variable_and_extend_typing_environment t var ty env_extension = let typing_env = let var ' = Bound_name . create_var var in TE . add_equation ( TE . add_definition t . typing_env var ' ( T . kind ty ) ) ( Name . var ( Bound_var . var var ) ) ty in let variables_defined_at_to...
let extend_typing_environment t env_extension = let typing_env = TE . add_env_extension_with_extra_variables t . typing_env env_extension in { t with typing_env }
let with_typing_env t typing_env = { t with typing_env }
let map_typing_env t ~ f = with_typing_env t ( f t . typing_env )
let check_name_is_bound t name = if not ( TE . mem t . typing_env name ) then Misc . fatal_errorf " Unbound name % a in environment :@ % a " Name . print name print t
let check_simple_is_bound t ( simple : Simple . t ) = Simple . pattern_match simple ~ name ( : fun name ~ coercion : _ -> check_name_is_bound t name ) ~ const ( : fun _ -> ( ) )
let mem_code t id = Code_id . Map . mem id t . all_code \|\| Exported_code . mem id ( t . get_imported_code ( ) )
let find_code_exn t id = match Code_id . Map . find id t . all_code with \| code -> Code_or_metadata . create code \| exception Not_found -> ( match Exported_code . find_exn ( t . get_imported_code ( ) ) id with \| code_or_metadata -> code_or_metadata \| exception Not_found -> ( match TE . ...
let define_code t ~ code_id ~ code = if not ( Code_id . in_compilation_unit code_id ( Compilation_unit . get_current_exn ( ) ) ) then Misc . fatal_errorf " Cannot define code ID % a as it is from another unit :@ % a " Code_id . print code_id Code . print code ; if not ( Code_id . e...
let set_inlined_debuginfo t dbg = { t with inlined_debuginfo = dbg }
let get_inlined_debuginfo t = t . inlined_debuginfo
let add_inlined_debuginfo t dbg = Debuginfo . inline t . inlined_debuginfo dbg
let cse t = t . cse
let add_cse t prim ~ bound_to = let scope = get_continuation_scope t in let cse = CSE . add t . cse prim ~ bound_to scope in { t with cse }
let find_cse t prim = CSE . find t . cse prim
let with_cse t cse = { t with cse }
let set_do_not_rebuild_terms_and_disable_inlining t = { t with do_not_rebuild_terms = true ; can_inline = false }
let disable_inlining t = { t with can_inline = false }
let set_rebuild_terms t = { t with do_not_rebuild_terms = false }
let are_rebuilding_terms t = Are_rebuilding_terms . of_bool ( not t . do_not_rebuild_terms )
let enter_closure code_id ~ return_continuation ~ exn_continuation t = { t with closure_info = Closure_info . in_a_closure code_id ~ return_continuation ~ exn_continuation }
let closure_info t = t . closure_info
let inlining_arguments { inlining_state ; _ } = Inlining_state . arguments inlining_state
let inlining_depth { inlining_state ; _ } = Inlining_state . depth inlining_state
let set_inlining_arguments arguments t = { t with inlining_state = Inlining_state . with_arguments arguments t . inlining_state }
let enter_inlined_apply ~ called_code ~ apply t = let arguments = Inlining_state . arguments t . inlining_state \|> Inlining_arguments . meet ( Code . inlining_arguments called_code ) \|> Inlining_arguments . meet ( Apply . inlining_arguments apply ) in let inlining_state = Inlining_state . w...
let generate_phantom_lets t = Flambda_features . debug ( ) && Flambda_features . Expert . phantom_lets ( ) && Are_rebuilding_terms . are_rebuilding ( are_rebuilding_terms t )
type ( ' model , ' action , ' state ) t = { model_var : ' model Incr . Var . t ; old_model_var : ' model Incr . Var . t ; state : ' state ; view_incr : Vdom . Node . t Incr . t ; app_obs : ( ' action , ' model , ' state ) Incr_dom . Component . t Incr ...
let create ( type model action state ) ( ~ initial_model : model ) ~ sexp_of_model ~ initial_state : state ( module App : Incr_dom . App_intf . S with type Model . t = model and type Action . t = action and type State . t = state ) = let action_queue = Queue . create ( ) in let mo...
let perform_update t = let schedule_action = Queue . enqueue t . action_queue in let apply_action action = let apply_action = t . app_obs \|> Incr . Observer . value_exn \|> Incr_dom . Component . apply_action in let new_model = apply_action action t . state ~ schedule_action in Incr . Var . s...
let rec pp_list ( ? bracket = true ) pp fmt list = let rec loop fmt = function \| [ ] -> ( ) \| [ x ] -> pp fmt x \| x :: xs -> fprintf fmt " % a , % a " pp x loop xs in if bracket then fprintf fmt " [ % a ] " loop list else loop fmt list
let pp_opt pp fmt = function \| None -> pp_string fmt " None " \| Some x -> pp fmt x
let rec pp_identifier fmt id = fprintf fmt " ' % s ' " id pp_string fmt ( string_of_number num ) let escape_char d fmt = function \| ' \ r ' -> pp_string fmt " \\ r " \| ' \ n ' -> pp_string fmt " \\ n " \| ' ' \\ -> pp_string fmt " " \\\\ \| ' " ' when d -> pp_str...
let pp_print_mod fmt modl = pp_mod fmt modl
let pp_print_stmt fmt stmt = pp_stmt fmt stmt
let pp_print_expr fmt expr = pp_expr fmt expr
let print_mod modl = pp_print_mod std_formatter modl
let print_stmt stmt = pp_print_stmt std_formatter stmt
let print_expr expr = pp_print_expr std_formatter expr
let print_to_string pp node = let buf = Buffer . create 4096 in let fmt = formatter_of_buffer buf in pp fmt node ; pp_print_flush fmt ( ) ; Buffer . contents buf
let dump_mod modl = print_to_string pp_print_mod modl
let dump_stmt stmt = print_to_string pp_print_stmt stmt
let dump_expr expr = print_to_string pp_print_expr expr
module Id = struct value name = " Camlp4Printers . DumpCamlp4Ast " ; value version = Sys . ocaml_version ; end ;
module Make ( Syntax : Sig . Syntax ) include Syntax ; value with_open_out_file x f = match x with [ Some file -> do { let oc = open_out_bin file ; f oc ; flush oc ; close_out oc } \| None -> do { set_binary_mode_out stdout True ; f stdout ; flush stdout } ] ; value dump_ast magic a...
let inputu ic = let b1 = input_byte ic in let b2 = input_byte ic in let b3 = input_byte ic in let b4 = input_byte ic in ( b4 lsl 24 ) + ( b3 lsl 16 ) + ( b2 lsl 8 ) + b1
let inputs ic = let b1 = input_byte ic in let b2 = input_byte ic in let b3 = input_byte ic in let b4 = input_byte ic in let b4 ' = if b4 >= 128 then b4 - 256 else b4 in ( b4 ' lsl 24 ) + ( b3 lsl 16 ) + ( b2 lsl 8 ) + b1
type global_table_entry = Empty \| Global of Ident . t \| Constant of Obj . t
let start = ref 0
let reloc = ref ( [ ] : ( reloc_info * int ) list )
let globals = ref ( [ ] \|\| : global_table_entry array )
let primitives = ref ( [ ] \|\| : string array )
let objfile = ref false
let event_table = ( Hashtbl . create 253 : ( int , debug_event ) Hashtbl . t )
let relocate_event orig ev = ev . ev_pos <- orig + ev . ev_pos ; match ev . ev_repr with Event_parent repr -> repr := ev . ev_pos \| _ -> ( )
let record_events orig evl = List . iter ( fun ev -> relocate_event orig ev ; Hashtbl . add event_table ev . ev_pos ev ) evl
let print_float f = if String . contains f ' . ' then printf " % s " f else printf " % s . " f ; ;
let rec print_struct_const = function Const_base ( Const_int i ) -> printf " % d " i \| Const_base ( Const_float f ) -> print_float f \| Const_base ( Const_string s ) -> printf " % S " s \| Const_immstring s -> printf " % S " s \| Const_base ( Const_char c ) -> printf " % C " c...

let round t = t . round

let get_continuation_scope t = TE . current_scope t . typing_env

let can_inline t = t . can_inline

let float_const_prop t = t . float_const_prop

let unit_toplevel_exn_continuation t = t . unit_toplevel_exn_continuation

let unit_toplevel_return_continuation t = t . unit_toplevel_return_continuation

let at_unit_toplevel t = t . at_unit_toplevel

let set_not_at_unit_toplevel t = { t with at_unit_toplevel = false }

let set_at_unit_toplevel_state t at_unit_toplevel = { t with at_unit_toplevel }

let is_defined_at_toplevel t var = Variable . Set . mem var t . variables_defined_at_toplevel

let get_inlining_state t = t . inlining_state

let set_inlining_state t inlining_state = { t with inlining_state }

let inlining_history_tracker t = t . inlining_history_tracker

let relative_history t = Inlining_history . Tracker . relative t . inlining_history_tracker

let set_inlining_history_tracker inlining_history_tracker t = { t with inlining_history_tracker }

let increment_continuation_scope t = { t with typing_env = TE . increment_scope t . typing_env }

let increment_continuation_scope_twice t = increment_continuation_scope ( increment_continuation_scope t )

let enter_set_of_closures { round ; typing_env ; inlined_debuginfo = _ ; can_inline ; inlining_state ; float_const_prop ; at_unit_toplevel = _ ; unit_toplevel_return_continuation ; unit_toplevel_exn_continuation ; variables_defined_at_toplevel ; cse = _ ; do_not_rebuild_terms ; closure_i...

let define_variable t var kind = let typing_env = let var = Bound_name . create_var var in TE . add_definition t . typing_env var kind in let variables_defined_at_toplevel = if t . at_unit_toplevel then Variable . Set . add ( Bound_var . var var ) t . variables_defined_at_toplevel else t . var...

let add_name t name ty = let typing_env = TE . add_equation ( TE . add_definition t . typing_env name ( T . kind ty ) ) ( Bound_name . name name ) ty in let variables_defined_at_toplevel = Name . pattern_match ( Bound_name . name name ) ~ var ( : fun var -> if t . at_unit_topleve...

let add_variable0 t var ty ~ at_unit_toplevel = let typing_env = let var ' = Bound_name . create_var var in TE . add_equation ( TE . add_definition t . typing_env var ' ( T . kind ty ) ) ( Name . var ( Bound_var . var var ) ) ty in let variables_defined_at_toplevel = if at_unit_to...

let add_variable t var ty = add_variable0 t var ty ~ at_unit_toplevel : t . at_unit_toplevel

let add_equation_on_variable t var ty = let typing_env = TE . add_equation t . typing_env ( Name . var var ) ty in { t with typing_env }

let mem_name t name = TE . mem t . typing_env name

let mem_variable t var = TE . mem t . typing_env ( Name . var var )

let define_symbol t sym kind = let typing_env = let sym = Bound_name . create ( Name . symbol sym ) Name_mode . normal in TE . add_definition t . typing_env sym kind in { t with typing_env }

let define_symbol_if_undefined t sym kind = if TE . mem t . typing_env ( Name . symbol sym ) then t else define_symbol t sym kind

let add_symbol t sym ty = let typing_env = let sym = Name . symbol sym in let sym ' = Bound_name . create sym Name_mode . normal in TE . add_equation ( TE . add_definition t . typing_env sym ' ( T . kind ty ) ) sym ty in { t with typing_env }

let add_equation_on_symbol t sym ty = let typing_env = let sym = Name . symbol sym in TE . add_equation t . typing_env sym ty in { t with typing_env }

let mem_symbol t sym = mem_name t ( Name . symbol sym )

let find_symbol t sym = TE . find ( typing_env t ) ( Name . symbol sym ) ( Some K . value )

let add_symbol_projection t var proj = { t with typing_env = TE . add_symbol_projection t . typing_env var proj }

let find_symbol_projection t var = TE . find_symbol_projection t . typing_env var

let define_name t name kind = let typing_env = TE . add_definition t . typing_env name kind in let variables_defined_at_toplevel = Name . pattern_match ( Bound_name . name name ) ~ var ( : fun var -> if t . at_unit_toplevel then Variable . Set . add var t . variables_defined_at_toplevel else...

let define_name_if_undefined t name kind = if TE . mem t . typing_env ( Bound_name . name name ) then t else define_name t name kind

let add_equation_on_name t name ty = let typing_env = TE . add_equation t . typing_env name ty in { t with typing_env }

let define_parameters t ~ params = List . fold_left ( fun t param -> let var = Bound_var . create ( BP . var param ) Name_mode . normal in define_variable t var ( K . With_subkind . kind ( BP . kind param ) ) ) t ( Bound_parameters . to_list params )

let add_parameters ( ? name_mode = Name_mode . normal ) ? at_unit_toplevel t params ~ param_types = let params ' = params in let params = Bound_parameters . to_list params in if List . compare_lengths params param_types <> 0 then Misc . fatal_errorf " Mismatch between number of [ params ] a...

let add_parameters_with_unknown_types ' ? name_mode ? at_unit_toplevel t params = let param_types = ListLabels . map ( Bound_parameters . to_list params ) ~ f ( : fun param -> T . unknown_with_subkind ( BP . kind param ) ) in add_parameters ? name_mode ? at_unit_toplevel t params ~ param...

let add_parameters_with_unknown_types ? name_mode ? at_unit_toplevel t params = fst ( add_parameters_with_unknown_types ' ? name_mode ? at_unit_toplevel t params )

let mark_parameters_as_toplevel t params = let variables_defined_at_toplevel = Variable . Set . union t . variables_defined_at_toplevel ( Bound_parameters . var_set params ) in { t with variables_defined_at_toplevel }

let define_variable_and_extend_typing_environment t var kind env_extension = let typing_env = let var ' = Bound_name . create_var var in TE . add_definition t . typing_env var ' kind in let variables_defined_at_toplevel = if t . at_unit_toplevel then Variable . Set . add ( Bound_var . var var ) ...

let add_variable_and_extend_typing_environment t var ty env_extension = let typing_env = let var ' = Bound_name . create_var var in TE . add_equation ( TE . add_definition t . typing_env var ' ( T . kind ty ) ) ( Name . var ( Bound_var . var var ) ) ty in let variables_defined_at_to...

let extend_typing_environment t env_extension = let typing_env = TE . add_env_extension_with_extra_variables t . typing_env env_extension in { t with typing_env }

let with_typing_env t typing_env = { t with typing_env }

let map_typing_env t ~ f = with_typing_env t ( f t . typing_env )

let check_name_is_bound t name = if not ( TE . mem t . typing_env name ) then Misc . fatal_errorf " Unbound name % a in environment :@ % a " Name . print name print t

let check_simple_is_bound t ( simple : Simple . t ) = Simple . pattern_match simple ~ name ( : fun name ~ coercion : _ -> check_name_is_bound t name ) ~ const ( : fun _ -> ( ) )

let mem_code t id = Code_id . Map . mem id t . all_code || Exported_code . mem id ( t . get_imported_code ( ) )

let find_code_exn t id = match Code_id . Map . find id t . all_code with | code -> Code_or_metadata . create code | exception Not_found -> ( match Exported_code . find_exn ( t . get_imported_code ( ) ) id with | code_or_metadata -> code_or_metadata | exception Not_found -> ( match TE . ...

let define_code t ~ code_id ~ code = if not ( Code_id . in_compilation_unit code_id ( Compilation_unit . get_current_exn ( ) ) ) then Misc . fatal_errorf " Cannot define code ID % a as it is from another unit :@ % a " Code_id . print code_id Code . print code ; if not ( Code_id . e...

let set_inlined_debuginfo t dbg = { t with inlined_debuginfo = dbg }

let get_inlined_debuginfo t = t . inlined_debuginfo

let add_inlined_debuginfo t dbg = Debuginfo . inline t . inlined_debuginfo dbg

let cse t = t . cse

let add_cse t prim ~ bound_to = let scope = get_continuation_scope t in let cse = CSE . add t . cse prim ~ bound_to scope in { t with cse }

let find_cse t prim = CSE . find t . cse prim

let with_cse t cse = { t with cse }

let set_do_not_rebuild_terms_and_disable_inlining t = { t with do_not_rebuild_terms = true ; can_inline = false }

let disable_inlining t = { t with can_inline = false }

let set_rebuild_terms t = { t with do_not_rebuild_terms = false }

let are_rebuilding_terms t = Are_rebuilding_terms . of_bool ( not t . do_not_rebuild_terms )

let enter_closure code_id ~ return_continuation ~ exn_continuation t = { t with closure_info = Closure_info . in_a_closure code_id ~ return_continuation ~ exn_continuation }

let closure_info t = t . closure_info

let inlining_arguments { inlining_state ; _ } = Inlining_state . arguments inlining_state

let inlining_depth { inlining_state ; _ } = Inlining_state . depth inlining_state

let set_inlining_arguments arguments t = { t with inlining_state = Inlining_state . with_arguments arguments t . inlining_state }

let enter_inlined_apply ~ called_code ~ apply t = let arguments = Inlining_state . arguments t . inlining_state |> Inlining_arguments . meet ( Code . inlining_arguments called_code ) |> Inlining_arguments . meet ( Apply . inlining_arguments apply ) in let inlining_state = Inlining_state . w...

let generate_phantom_lets t = Flambda_features . debug ( ) && Flambda_features . Expert . phantom_lets ( ) && Are_rebuilding_terms . are_rebuilding ( are_rebuilding_terms t )

type ( ' model , ' action , ' state ) t = { model_var : ' model Incr . Var . t ; old_model_var : ' model Incr . Var . t ; state : ' state ; view_incr : Vdom . Node . t Incr . t ; app_obs : ( ' action , ' model , ' state ) Incr_dom . Component . t Incr ...

let create ( type model action state ) ( ~ initial_model : model ) ~ sexp_of_model ~ initial_state : state ( module App : Incr_dom . App_intf . S with type Model . t = model and type Action . t = action and type State . t = state ) = let action_queue = Queue . create ( ) in let mo...

let perform_update t = let schedule_action = Queue . enqueue t . action_queue in let apply_action action = let apply_action = t . app_obs |> Incr . Observer . value_exn |> Incr_dom . Component . apply_action in let new_model = apply_action action t . state ~ schedule_action in Incr . Var . s...

let rec pp_list ( ? bracket = true ) pp fmt list = let rec loop fmt = function | [ ] -> ( ) | [ x ] -> pp fmt x | x :: xs -> fprintf fmt " % a , % a " pp x loop xs in if bracket then fprintf fmt " [ % a ] " loop list else loop fmt list

let pp_opt pp fmt = function | None -> pp_string fmt " None " | Some x -> pp fmt x

let rec pp_identifier fmt id = fprintf fmt " ' % s ' " id pp_string fmt ( string_of_number num ) let escape_char d fmt = function | ' \ r ' -> pp_string fmt " \\ r " | ' \ n ' -> pp_string fmt " \\ n " | ' ' \\ -> pp_string fmt " " \\\\ | ' " ' when d -> pp_str...

let pp_print_mod fmt modl = pp_mod fmt modl

let pp_print_stmt fmt stmt = pp_stmt fmt stmt

let pp_print_expr fmt expr = pp_expr fmt expr

let print_mod modl = pp_print_mod std_formatter modl

let print_stmt stmt = pp_print_stmt std_formatter stmt

let print_expr expr = pp_print_expr std_formatter expr

let print_to_string pp node = let buf = Buffer . create 4096 in let fmt = formatter_of_buffer buf in pp fmt node ; pp_print_flush fmt ( ) ; Buffer . contents buf

let dump_mod modl = print_to_string pp_print_mod modl

let dump_stmt stmt = print_to_string pp_print_stmt stmt

let dump_expr expr = print_to_string pp_print_expr expr

module Id = struct value name = " Camlp4Printers . DumpCamlp4Ast " ; value version = Sys . ocaml_version ; end ;

module Make ( Syntax : Sig . Syntax ) include Syntax ; value with_open_out_file x f = match x with [ Some file -> do { let oc = open_out_bin file ; f oc ; flush oc ; close_out oc } | None -> do { set_binary_mode_out stdout True ; f stdout ; flush stdout } ] ; value dump_ast magic a...

let inputu ic = let b1 = input_byte ic in let b2 = input_byte ic in let b3 = input_byte ic in let b4 = input_byte ic in ( b4 lsl 24 ) + ( b3 lsl 16 ) + ( b2 lsl 8 ) + b1

let inputs ic = let b1 = input_byte ic in let b2 = input_byte ic in let b3 = input_byte ic in let b4 = input_byte ic in let b4 ' = if b4 >= 128 then b4 - 256 else b4 in ( b4 ' lsl 24 ) + ( b3 lsl 16 ) + ( b2 lsl 8 ) + b1

type global_table_entry = Empty | Global of Ident . t | Constant of Obj . t

let start = ref 0

let reloc = ref ( [ ] : ( reloc_info * int ) list )

let globals = ref ( [ ] || : global_table_entry array )

let primitives = ref ( [ ] || : string array )

let objfile = ref false

let event_table = ( Hashtbl . create 253 : ( int , debug_event ) Hashtbl . t )

let relocate_event orig ev = ev . ev_pos <- orig + ev . ev_pos ; match ev . ev_repr with Event_parent repr -> repr := ev . ev_pos | _ -> ( )

let record_events orig evl = List . iter ( fun ev -> relocate_event orig ev ; Hashtbl . add event_table ev . ev_pos ev ) evl

let print_float f = if String . contains f ' . ' then printf " % s " f else printf " % s . " f ; ;

let rec print_struct_const = function Const_base ( Const_int i ) -> printf " % d " i | Const_base ( Const_float f ) -> print_float f | Const_base ( Const_string s ) -> printf " % S " s | Const_immstring s -> printf " % S " s | Const_base ( Const_char c ) -> printf " % C " c...