A control transfer to another subroutine.
calls have two-fold representation. From the intra-procedural point of view call is a transfer of control to the next address with a side effect of calling to other subroutine. From the iter-procedural point of view, call is transfer of control from caller to the callee, that may or may not result in a return to the caller side. Thus each call is represented by two labels. The target label points to the procedure that is called, the return label denotes a block to which the control flow should (but may not) continue when called subroutine returns.
val create : ?return :label -> target :label -> unit -> t create ?return ~target () creates a call to the target subroutine. If return is not provided, that it is assumed that subroutine doesn't return.
returns the target of the call
val return : t -> label optionreturns call continuation
updates return continuation
val with_noreturn : t -> t marks call as a "noreturn"
include Regular .Std.Regular.S with type t := t val t_of_sexp : Sexplib .Sexp.t -> t val sexp_of_t : t -> Sexplib .Sexp.tval bin_t : t Core_kernel .Std.Bin_prot.Type_class.tval bin_read_t : t Core_kernel .Std.Bin_prot.Read.readerval __bin_read_t__ : (int -> t ) Core_kernel .Std.Bin_prot.Read.readerval bin_reader_t : t Core_kernel .Std.Bin_prot.Type_class.readerval bin_size_t : t Core_kernel .Std.Bin_prot.Size.sizerval bin_write_t : t Core_kernel .Std.Bin_prot.Write.writerval bin_writer_t : t Core_kernel .Std.Bin_prot.Type_class.writerval to_string : t -> val str : unit -> t -> val pps : unit -> t -> val ppo : Core_kernel .Std.out_channel -> t -> val pp_seq : Format .formatter -> t Core_kernel .Std.Sequence.t-> val pp : Format .formatter -> t -> val (>=) : t -> t -> val (<=) : t -> t -> val (<>) : t -> t -> val equal : t -> t -> val compare : t -> t -> val ascending : t -> t -> val descending : t -> t -> val between : t -> low :t -> high :t -> val clamp_exn : t -> min :t -> max :t -> t val clamp : t -> min :t -> max :t -> t Core_kernel .Or_error.tval validate_lbound :
min :t Core_kernel .Maybe_bound.t-> t Core_kernel .Validate.checkval validate_ubound :
max :t Core_kernel .Maybe_bound.t-> t Core_kernel .Validate.checkval validate_bound :
min :t Core_kernel .Maybe_bound.t-> max :t Core_kernel .Maybe_bound.t-> t Core_kernel .Validate.checkval hashable : t Core_kernel .Std.Hashable.Hashtbl.Hashable.tmodule Table : sig ... end type info = string * [ `Ver of string ] * string option val size_in_bytes : ?ver :string -> ?fmt :string -> t -> val of_bytes : ?ver :string -> ?fmt :string -> Regular .Std.bytes -> t val to_bytes : ?ver :string -> ?fmt :string -> t -> Regular .Std.bytesval blit_to_bytes :
?ver :string -> ?fmt :string -> Regular .Std.bytes -> t -> int ->
unitval of_bigstring : ?ver :string -> ?fmt :string -> Core_kernel .Std.bigstring -> t val to_bigstring : ?ver :string -> ?fmt :string -> t -> Core_kernel .Std.bigstringval blit_to_bigstring :
?ver :string -> ?fmt :string -> Core_kernel .Std.bigstring -> t -> int ->
unitmodule Cache : sig ... end val add_reader :
?desc :string -> ver :string -> string ->
t Regular .Std.reader-> val add_writer :
?desc :string -> ver :string -> string ->
t Regular .Std.writer-> val available_readers : unit -> info listval default_reader : unit -> info val set_default_reader : ?ver :string -> string -> unitval with_reader : ?ver :string -> string -> (unit -> 'a ) -> 'a val available_writers : unit -> info listval default_writer : unit -> info val set_default_writer : ?ver :string -> string -> unitval with_writer : ?ver :string -> string -> (unit -> 'a ) -> 'a val default_printer : unit -> info optionval set_default_printer : ?ver :string -> string -> unitval with_printer : ?ver :string -> string -> (unit -> 'a ) -> 'a val find_reader : ?ver :string -> string -> t Regular .Std.readerval find_writer : ?ver :string -> string -> t Regular .Std.writer