log messages at different levels of verbosity

`module F = Format`
`include module type of Die`
`exception` `InferExternalError of string`
`exception` `InferInternalError of string`
`exception` `InferUserError of string`
`exception` `InferExit of int`

This can be used to avoid scattering exit invocations all over the codebase

`type error````=`

`|` `ExternalError`
`|` `InternalError`
`|` `UserError`

``

kind of error for `die`, with similar semantics as `Logging.{external,internal,user}_error`

`val exit : int ‑> 'a`
`val exit_code_of_exception : InferStdlib.IStd.Exn.t ‑> int`
`val set_log_uncaught_exception_callback : (exn ‑> exitcode:int ‑> unit) ‑> unit`
`val log_uncaught_exception : exn ‑> exitcode:int ‑> unit`
`val die : error ‑> ('a, Format.formatter, unit, _) InferStdlib.IStd.format4 ‑> 'a`

Raise the corresponding exception.

`val raise_error : error ‑> msg:string ‑> 'a`
`type style````=`

`|` `Error`
`|` `Fatal`
`|` `Normal`
`|` `Warning`

``
`val term_styles_of_style : style ‑> InferStdlib.IStd.ANSITerminal.style list`
`val environment_info : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

log information about the environment

`val progress : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

print immediately to standard error unless --quiet is specified

`val progressbar_file : unit ‑> unit`

Progress bar: start of the analysis of a file.

`val progressbar_procedure : unit ‑> unit`

Progress bar: start of the analysis of a procedure.

`val progressbar_timeout_event : SymOp.failure_kind ‑> unit`

Progress bar: log a timeout event if in developer mode.

`val result : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

Emit a result to stdout. Use only if the output format is stable and useful enough that it may conceivably get piped to another program, ie, almost never (use `progress` instead otherwise).

`val user_error : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

bad input, etc. detected

`val user_warning : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`
`val internal_error : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

huho, infer has a bug

`val external_error : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

some other tool has a bug or is called wrongly

`val external_warning : ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`
`type debug_kind````=`

`|` `Analysis`
`|` `BufferOverrun`
`|` `Capture`
`|` `Linters`
`|` `MergeCapture`
`|` `TestDeterminator`

``
`type debug_level````=`

`|` `Quiet` | (** innocuous, eg emitted once per toplevel execution *)
`|` `Medium` | (** still fairly lightweight, eg emitted O(<number of infer processes>) *)
`|` `Verbose` | (** go crazy *)

``

Level of verbosity for debug output. Each level enables all the levels before it.

`val debug : debug_kind ‑> debug_level ‑> ('a, F.formatter, unit) InferStdlib.IStd.format ‑> 'a`

log debug info

`val debug_dev : ('a, Format.formatter, unit) InferStdlib.IStd.format ‑> 'a`

For debugging during development.

- Deprecated Only use to debug during development. If you want more permanent logging, use [Logging.debug] instead.

`type ocaml_pos``= string * int * int * int```

Type of location in ml source: __POS__

`val ocaml_pos_to_string : ocaml_pos ‑> string`

Convert an ocaml position to a string

`val pp_ocaml_pos_opt : F.formatter ‑> ocaml_pos option ‑> unit`

Pretty print a position in ocaml source

log management

`val setup_log_file : unit ‑> unit`

Set up logging to go to the log file. Call this once the results directory has been set up.

`val reset_formatters : unit ‑> unit`

Reset the formatters used for logging. Call this when you fork(2).

Delayed printing (HTML debug, ...)

`type print_type````=`

`|` `PTatom`
`|` `PTattribute`
`|` `PTdecrease_indent`
`|` `PTexp`
`|` `PTexp_list`
`|` `PThpred`
`|` `PTincrease_indent`
`|` `PTinstr`
`|` `PTinstr_list`
`|` `PTjprop_list`
`|` `PTjprop_short`
`|` `PTloc`
`|` `PTnode_instrs`
`|` `PToff`
`|` `PToff_list`
`|` `PTpath`
`|` `PTprop`
`|` `PTproplist`
`|` `PTprop_list_with_typ`
`|` `PTprop_with_typ`
`|` `PTpvar`
`|` `PTspec`
`|` `PTstr`
`|` `PTstr_color`
`|` `PTstrln`
`|` `PTstrln_color`
`|` `PTpathset`
`|` `PTpi`
`|` `PTsexp`
`|` `PTsexp_list`
`|` `PTsigma`
`|` `PTtexp_full`
`|` `PTsub`
`|` `PTtyp_full`
`|` `PTtyp_list`
`|` `PTwarning`
`|` `PTerror`
`|` `PTinfo`

``

type of printable elements

`type print_action``= print_type * Obj.t```

delayable print action

data to be printed

`val printer_hook : (F.formatter ‑> print_action ‑> unit) InferStdlib.IStd.ref`

hook for the current printer of delayed print actions

`val add_print_action : print_action ‑> unit`

extend he current print log

`val get_delayed_prints : unit ‑> print_action list`

return the delayed print actions

`val set_delayed_prints : print_action list ‑> unit`

set the delayed print actions

`val reset_delayed_prints : unit ‑> unit`

reset the delayed print actions

`val d_str : string ‑> unit`

dump a string

`val d_str_color : InferStdlib.Pp.color ‑> string ‑> unit`

dump a string with the given color

`val d_strln : string ‑> unit`

dump a string plus newline

`val d_strln_color : InferStdlib.Pp.color ‑> string ‑> unit`

dump a string plus newline with the given color

`val d_ln : unit ‑> unit`

dump a newline

`val d_error : string ‑> unit`

dump an error string

`val d_warning : string ‑> unit`

dump a warning string

`val d_info : string ‑> unit`

dump an info string

`val d_indent : int ‑> unit`

dump an indentation

`val d_increase_indent : int ‑> unit`

dump command to increase the indentation level

`val d_decrease_indent : int ‑> unit`

dump command to decrease the indentation level