| new_indirect [Bap_taint.Std.Taint.Tracker.Make] |
new_indirect ~addr:v ~len:n k establishes a new indirect
relation between a set of addresses, denoted by interval
[v,v+n-1] , and a freshly created object of specified
kind.
|
| new_property [Bap.Std.Insn] |
new_property must_or_may name creates a new instruction
property with the specified name.
|
| new_var [Arm_env] |
new_var name creates a freshly new variable prefixed with name
|
| next [Bap_strings_scanner] |
next ~is_stop ~read off reads characters starting with the
offset off , using the read function to map offsets to
characters, until the is_stop character occurs, or the read
function returns None .
|
| next [Bap_traces.Std.Trace] |
next trace tag reads and discards events until an event with a
given tag is found.
|
| next [Bap_byteweight.S] |
next decider ~length ~threshold data begin returns an offset
greater then begin of the next substring of the given
length , that is positively classified, with the given
thresold .
|
| next [Bap_primus.Std.Primus.Generator.Make] |
next iter switches the internal state of iter to the
next state and returns the current value
|
| next [Bap_primus.Std.Primus.Iterator.Infinite] |
next iterator moves the iterator to the next element of
the sequence.
|
| next [Bap_primus.Std.Primus.Iterator.Finite] |
next iterator moves an iterator to the next element of
the sequence, or returns None if there are no more
elements.
|
| next [Bap_primus.Std.Primus.Pos] |
next p cls t moves the cursor position p to the next
position, that points to the term t of the class
cls .
|
| next [Bap.Std.Term] |
next t p id returns a term that is after a term with a given
id , if such exists.
|
| next [Bap.Std.Table] |
next table elt returns element next to elt , if any
|
| next_event [Bap_traces.Std.Trace] |
next_event trace reads next event from the trace
|
| next_matching [Bap_traces.Std.Trace] |
next_matching trace matcher reads and discards trace events
until an event matching with the matcher is found.
|
| nf [Arm_env] |
|
| nf [Bap.Std.CPU] |
|
| nil_reg_of_sexp [Arm_types] |
|
| no_qualifier_of_sexp [Bap_c_type] |
|
| node [Graphlib.Std.Predicate] |
|
| nodes [Graphlib.Std.Graph] |
nodes g returns all nodes of graph g in an unspecified order
|
| non [Monads.Std.Monad.S2.Fn] |
non f returns a negation of the function f .
|
| non [Monads.Std.Monad.S.Fn] |
non f returns a negation of the function f .
|
| non_dir_file [Bap.Std.Self.Config] |
non_dir_file converts a value with the identity function and checks
with Sys.file_exists and Sys.is_directory
that a non directory file with that name exists.
|
| non_nil_reg_of_sexp [Arm_types] |
|
| none [Bap.Std.Eff] |
an expression doesn't have any effects
|
| nonnull [Bap.Std.Arg] |
a contract requirement that this argument is not NULL.
|
| noreturn [Bap.Std.Sub] |
A subroutine will not return (either loop infinitely or abort
a program)
|
| normalize [Bap.Std.Stmt] |
normalize ?normalize_exp xs produces a normalized BIL
program with the same^1 semantics but in the BIL normalized
form (BNF).
|
| normalize [Bap.Std.Exp] |
normalize x ensures no-lets and normalized-memory (BNF2).
|
| normalize [Bap.Std.Bil.Trie] |
normalize ?subst bil normalize BIL.
|
| normalize_negatives [Bap.Std.Exp] |
normalize_negatives exp returns an exp where all negative
additions are substituted by subtractions.
|
| normalize_negatives [Bap.Std.Bil] |
normalize_negatives p transform x + y to x - abs(y) if y < 0
|
| not [Ogre.Query] |
|
| not [Bap.Std.Bil] |
|
| nothing [Graphlib.Std.Graphlib] |
|
| nothing [Monads.Std.Monad.S2.Fn] |
nothing is a computation that does nothing.
|
| nothing [Monads.Std.Monad.S.Fn] |
nothing is a computation that does nothing.
|
| nothrow [Bap.Std.Sub] |
A subroutine doesn't throw exceptions
|
| npred [Bap_primus.Std.Primus.Value.Make] |
|
| npred [Bap.Std.Bitvector] |
npred m n is Fn.apply_n_times ~n pred addr , but more
efficient.
|
| nsucc [Bap_primus.Std.Primus.Value.Make] |
|
| nsucc [Bap.Std.Bitvector] |
nsucc m n is Fn.apply_n_times ~n succ m , but more
efficient.
|
| nth [Bap_future.Std.Stream] |
nth xs n returns n 'th element of the stream xs .
|
| nth [Bap.Std.Term] |
nth t p n returns n 'th t -term of parent p .
|
| nth [Bap.Std.Vector] |
nth vec n returns n 'th element of vector vec
|
| nth_exn [Bap.Std.Term] |
nth_exn t p n same as nth , but raises exception if n is
not a valid position number.
|
| nth_token [Bap.Std.Trie.Key] |
nth_token key n the n 'th token of key.
|
| null [Bap_strings_index.Key] |
|
| nullary [Monads.Std.Monad.S2.Lift] |
nullary x lifts x (a synonym to return )
|
| nullary [Monads.Std.Monad.S.Lift] |
nullary x lifts x (a synonym to return )
|
| number_of_edges [Graphlib.Std.Graph] |
number_of_edges g returns the size of a graph g .
|
| number_of_groups [Graphlib.Std.Partition] |
number_of_groups p returns the amount of groups in a given
partitioning p .
|
| number_of_nodes [Graphlib.Std.Graph] |
number_of_nodes g returns the order of a graph g
|
| numbers [Graphlib.Std.Graphlib] |
numbers from zero to inifinity (Sys.max_int in fact)
|
| nums [X86_env.ModeVars] |
Legacy version of the `r` array.
|
O |
| oF [X86_env] |
|
| o_fs [X86_env] |
|
| o_gs [X86_env] |
|
| o_rax [X86_env] |
|
| o_rbp [X86_env] |
|
| o_rbx [X86_env] |
|
| o_rcx [X86_env] |
|
| o_rdx [X86_env] |
|
| o_rsp [X86_env] |
|
| observe [Bap_primus.Std.Primus.Machine.S.Observation] |
observe obs on_observation subscribes to the given
observation obs .
|
| observe [Bap_future.Std.Stream] |
observe s f is like watch but a subscription identifier is
not passed to the function f .
|
| observers [Bap_primus.Std.Primus.Observation.Provider] |
a total number of observers that subscribed to this provider
|
| ocaml_version [Bap_config] |
|
| occurs [Bap.Std.Blk] |
occurs blk after:x def if def is occurs after definition
def in blk .
|
| of_array [Bap_future.Std.Stream] |
of_array xs returns a stream ss , a signal s and a future
es .
|
| of_array [Regular.Std.Seq] |
|
| of_basic [Arm_insn] |
of_basic insn translate from BAP basic insn
|
| of_basic [Bap.Std.Insn] |
Creating
The following functions will create insn instances from a lower
level representation.
|
| of_bigstring [Regular.Std.Data.Read] |
of_bigstring readable buf deserializes a readable value
from the bigstring.
|
| of_bigstring [Regular.Std.Data.S] |
of_bigstring ?ver ?fmt buf deserializes a datum from bigstring
|
| of_bigstring [Bap.Std.Image] |
of_bigstring ?backend ~data creates an image from the specified
data .
|
| of_bil [Bap.Std.Brancher] |
of_bil arch creates a brancher that will use a BIL code to
statically deduce the instruction destinations.
|
| of_binary [Bap.Std.Bitvector] |
of_binary ?width endian num creates a bitvector from a string
interpreted as a sequence of bytes in a specified order.
|
| of_blocks [Bap.Std.Reconstructor] |
of_blocks produces a reconstructor from a serialized
sequence of blocks.
|
| of_blocks [Bap.Std.Rooter] |
of_blocks produces a rooter from a serialized
sequence of blocks.
|
| of_blocks [Bap.Std.Symbolizer] |
of_blocks produces a symbolizer from a serialized
sequence of blocks.
|
| of_bool [Bap_primus.Std.Primus.Value.Make] |
of_bool x creates a fresh new value from the boolean x .
|
| of_bool [Bap.Std.Bitvector] |
of_bool x is a bitvector with length 1 and value b0 if
x is false and b1 otherwise.
|
| of_bytes [Regular.Std.Data.Read] |
of_bytes readable bytes reads a value from bytes
|
| of_bytes [Regular.Std.Data.S] |
of_bytes ?ver ?fmt bytes deserializes a value from bytes.
|
| of_cfg [Bap.Std.Sub] |
of_cfg cfg extracts a sub term from a given graph cfg .
|
| of_channel [Regular.Std.Data.Read] |
of_channel readable channel inputs a value from a
channel.
|
| of_equiv [Graphlib.Std.Partition] |
of_equiv p n rebuilds a group from an equivalence class
ordinal number.
|
| of_file [Bap_strings_unscrambler.Make] |
of_file name reads the dictionary from file name ,
each word is on a separate line.
|
| of_file [Bap.Std.Disasm.With_exn] |
|
| of_file [Bap.Std.Disasm] |
disassemble_file ?roots path takes a path to a binary and
disassembles it
|
| of_file [Bap.Std.Memory] |
of_file endian start name creates a memory region from file.
|
| of_files [Bap_strings_unscrambler.Make] |
of_files names reads the dictionary from all provided file
names , each file should be a sequence of newline separated
words.
|
| of_image [Bap.Std.Rooter] |
of_image img create a rooter that will use existing symbol
information inside the image, to find roots.
|
| of_image [Bap.Std.Disasm.With_exn] |
|
| of_image [Bap.Std.Disasm] |
disassemble_image image disassemble a given image.
|
| of_int [Bap_dwarf.Std.Leb128] |
|
| of_int [Bap_primus.Std.Primus.Value.Make] |
of_int ~width x creates a fresh new value of the given
width from the integer x
|
| of_int [Bap.Std.Bitvector] |
of_int ~width n creates a bitvector of the specified
bit-width with the value equal to n .
|
| of_int [Bap.Std.Size] |
of_int n return Ok `rn if `rn exists, Error
otherwise.
|
| of_int32 [Bap_dwarf.Std.Leb128] |
|
| of_int32 [Bap_primus.Std.Primus.Value.Make] |
of_int32 x creates a fresh new value from x
|
| of_int32 [Bap.Std.Bitvector] |
of_int32 ?width n creates a bitvector of the specified
bit-width with the value equal to n .
|
| of_int64 [Bap_dwarf.Std.Leb128] |
|
| of_int64 [Bap_primus.Std.Primus.Value.Make] |
of_int64 x creates a fresh new value from x
|
| of_int64 [Bap.Std.Bitvector] |
of_int32 ?width n creates a bitvector of the specified
bit-width with the value equal to n .
|
| of_int_exn [Bap.Std.Size] |
of_int_exn n the same as of_int , but raises exception
instead of returning Error
|
| of_int_opt [Bap.Std.Size] |
of_int_opt n the same as of_int but uses option type
instead of Or_error.t
|
| of_list [Bap_future.Std.Stream] |
of_list xs returns a stream ss , a signal s and a future
es .
|
| of_list [Bap.Std.Phi] |
of_list var bindings creates a phi-node, that for each pair
of label,exp in the bindings list associates variable var
with expression exp if control flow reaches this point via block
labeled with label .
|
| of_mem [Bap.Std.Disasm.With_exn] |
|
| of_mem [Bap.Std.Disasm] |
disassemble ?roots arch mem disassemble provided memory region
mem using best available algorithm and backend for the specified
arch .
|
| of_path [Bap_plugins.Std.Plugin] |
of_path path creates a plugin of a give path
|
| of_reg [Arm_env] |
of_reg arm_reg lifts arm register into BIL variable
|
| of_sequence [Bap_future.Std.Stream] |
of_seq xs returns a stream ss , a signal s and a future
es .
|
| of_string [Bare.Rule] |
of_string s parses the rule specification s .
|
| of_string [Bap_primus.Std.Primus.Value.Make] |
of_string s computes a fresh new value from a textual
representation of a machine word x .
|
| of_string [Regular.Std.Bytes.Unsafe] |
of_string s - unsafely converts a shared string to a byte
sequence that should not be mutated.
|
| of_string [Regular.Std.Bytes] |
of_string s returns a new byte sequence that contains the
same bytes as the given string.
|
| of_string [Bap.Std.Image] |
of_string ?backend ~data creates an image from the specified
data .
|
| of_string [Bap.Std.Arch] |
of_string s will try to be clever and to capture all
commonly known synonyms, e.g., of_string "i686" will
work
|
| of_string [Bap.Std.Bitvector] |
of_string s parses a bitvector from a string representation
defined in section bv_string .
|
| of_uri [Bap_bundle.Std.Bundle] |
creates new bundle or opens existing
|
| of_value [Bap_primus.Std.Primus.Value.Make.Symbol] |
of_value v returns a symbolic representation of the
value v .
|
| of_value [Bap_taint.Std.Value] |
of_value v project the value v to the abstract domain of t
|
| of_word [Bap_primus.Std.Primus.Value.Make] |
of_word x computes a fresh new value from x
|
| of_word_size [Bap.Std.Bitvector.Int_err] |
of_word_size w creates a lifter for a specified word size
w , i.e.
|
| off [Bap.Std.Image.Scheme] |
|
| on [Monads.Std.Monad.Choice.S2] |
on cond x computes x only iff cond is true
|
| on [Monads.Std.Monad.Choice.S] |
on cond x computes x only iff cond is true
|
| on_subscribe [Bap_future.Std.Stream] |
on_subscribe s f will call a function f every time someone
is subscribed to a stream s
|
| on_unsubscribe [Bap_future.Std.Stream] |
on_unsubscribe s f will call a function f every time
someone has canceled subscription to a stream s
|
| on_wait [Bap_future.Std.Stream] |
on_wait s f will be called every time someone, watching a
stream s , will call wait s to ask a producer to slow down.
|
| once [Bap_future.Std.Stream] |
once xs creates a stream that will at most contain the next value
produced by xs and nothing more.
|
| one [Bap_primus.Std.Primus.Lisp.Type.Spec] |
one t specifies that a function accepts one argument
of type t
|
| one [Bap_primus.Std.Primus.Value.Make] |
one x same as of_word @@ one x
|
| one [Bap.Std.Table] |
|
| one [Bap.Std.Bitvector] |
one width number one with a specified width , is a shortcut for
of_int 1 ~width
|
| one [Bap.Std.Integer.Base] |
element neutral to the multiplication
|
| ones [Bap.Std.Bitvector] |
ones width is a number with a specified width , and all bits
set to 1.
|
| op_of_sexp [Arm_types] |
|
| ops [Bap.Std.Insn] |
|
| ops [Bap.Std.Disasm_expert.Basic.Insn] |
ops insn gives an access to insn 's operands.
|
| origin [Bap.Std.Term] |
a term was artificially produced from a term with a given tid.
|
| os_type [Bap_config] |
|
| outputs [Graphlib.Std.Node] |
outputs node graph is outcomming edges of a node in graph
|
| owners [Bap.Std.Symtab] |
owners addr return a list of functions that owns addr
|
P |
| pack_errors [Bap_traces.Std.Trace.Monitor] |
pack_errors pack will transform any occured error into event
using pack function.
|
| pagefault [Bap_primus.Std.Primus.Interpreter] |
pagefault x occurs just before the pagefault trap is signaled.
|
| pagefault_handler [Bap_primus.Std.Primus.Interpreter] |
pagefault_hanlder is a trap handler that is invoked when the Pagefault
exception is raised by the machine memory component.
|
| pair [Core_printers] |
|
| pair [Bap.Std.Self.Config] |
pair sep c0 c1 splits the argument at the first sep character
(defaults to ',' ) and respectively converts the substrings with
c0 and c1 .
|
| param [Bap.Std.Self.Config] |
param conv ~default ~docv ~doc name creates a parameter
which is referred to on the command line, environment
variable, and config file using the value of name , with
the type defined by conv , using the default value if
unspecified by user.
|
| param_all [Bap.Std.Self.Config] |
Create a parameter which accepts a list at command line by
repetition of argument.
|
| parent [Graphlib.Std.Tree] |
parent tree n returns an immediate parent of a given node.
|
| parent [Monads.Std.Monad.State.Multi.S2] |
parent () returns an identifier of the closest alive parent.
|
| parent [Monads.Std.Monad.State.Multi.S] |
parent () returns an identifier of the closest alive parent.
|
| parent [Bap.Std.Program] |
parent t program id is Some p iff find t p id <> None
|
| parse [Bap_api.S] |
parse get_api apis creates a language processor from a list of
api.
|
| parse [Bap_future.Std.Stream] |
parse ss ~init ~f parses stream ss and builds new stream
ss' .
|
| parser [Bap_ida.Std.Command] |
parser command the associated parser function.
|
| pass [Bap_abi] |
pass will apply all registered passes in the unspecified order
|
| passes [Bap.Std.Project] |
passes () returns all currently registered passes.
|
| passes [Bap.Std.Bil] |
passes () returns all currently registered passes.
|
| path [Bap_plugins.Std.Plugin] |
path plugin is a plugin's path
|
| pc [Arm_env] |
|
| pc [Bap_primus.Std.Primus.Interpreter.Make] |
pc current value of a program counter.
|
| pc_change [Bap_primus.Std.Primus.Interpreter] |
pc_change x happens every time a code at address x is executed.
|
| pc_hi [Bap_dwarf.Std.Dwarf.Fn] |
pc_hi fn the highest address (if known)
|
| pc_lo [Bap_dwarf.Std.Dwarf.Fn] |
pc_lo fn the lowest address of a function (the entry point)
|
| pc_update [Bap_traces.Std.Event] |
CPU PC register changed its value
|
| pdfdir [Bap_config] |
|
| peek [Bap_future.Std.Future] |
peek f will return Some value if future f has already
occurred with this value .
|
| peek_exn [Bap_future.Std.Future] |
peek_exn f
will evaluate to x iff is_decided f && peek f x = Some x
|
| pf [X86_env] |
|
| phi_t [Bap.Std] |
|
| plugindir [Bap_config] |
|
| plus [Monads.Std.Monad.Plus.S2] |
plus x y an associative operation.
|
| plus [Monads.Std.Monad.Plus.S] |
plus x y an associative operation.
|
| plus [Monads.Std.Monoid.Base] |
plus x y an associative operation.
|
| plus [Bap.Std.Bil] |
|
| pos [Bap_dwarf.Std.Dwarf.Buffer] |
pos buf starting position
|
| pos [Bap_primus.Std.Primus.Interpreter.Make] |
pos m current program position.
|
| postcondition [Bap.Std.Term] |
must hold just after the term is left
|
| postorder_traverse [Graphlib.Std.Graphlib] |
returns a sequence of nodes in post order
|
| pp [Bap_strings_detector] |
|
| pp [Bap_byteweight.S] |
|
| pp [Bap_c_type_printer] |
|
| pp [Bare.Rule] |
pp ppf rule prints rule into the formatter ppf .
|
| pp [Bap_primus.Std.Primus.Lisp.Message] |
pp ppf msg prints the message into the specified
formatter ppf .
|
| pp [Bap_primus.Std.Primus.Lisp.Doc.Element] |
|
| pp [Graphlib.Std.Group] |
pp pp_elem g prints group g using element printer pp_elem
|
| pp [Graphlib.Std.Partition] |
pp pp_elem p prints partition p using element printer pp_elem
|
| pp [Graphlib.Std.Path] |
pp pp_elt constructs a pretty based on element printer
pp_elt
|
| pp [Graphlib.Std.Frontier] |
pp pp_elt instantiates a pretty-printer for a given
element.
|
| pp [Graphlib.Std.Tree] |
pp pp_elt creates a pretty-printer for a node, based on
element's pretty-printer pp_elt .
|
| pp [Ogre.Doc] |
pp ppf doc prints a doc in the specified formatter ppf
|
| pp [Monads.Std.Monad.State.Multi.Id] |
|
| pp [Regular.Std.Seq] |
|
| pp [Bap.Std.Memmap] |
pp pp_elem constracts a printer for a memmap to the given element.
|
| pp [Bap.Std.Table] |
pp printer - creates a printer for table from value printer
|
| pp [Bap.Std.Vector] |
pp pp_elem creates a vector printer that uses pp_elem to
print elements.
|
| pp [Bap.Std.Value.S] |
|
| pp [Bap.Std.Bitvector] |
printf "%a" pp x prints x into a formatter.
|
| pp [Bap.Std.Trie.S] |
pp pp_val creates a printer for a given value printer
pp_val .
|
| pp_adt [Bap.Std.Insn] |
pp_adt prints instruction in ADT format, suitable for reading
by evaluating in many languages, e.g.
|
| pp_adt [Bap.Std.Op] |
|
| pp_adt [Bap.Std.Stmt] |
|
| pp_adt [Bap.Std.Exp] |
|
| pp_bag [Core_printers] |
|
| pp_bin [Bap.Std.Bitvector] |
printf "%a" pp_bin x prints x in the binary (0 and 1) format omitting
suffixes, and the prefix if it is not necessary.
|
| pp_bin_full [Bap.Std.Bitvector] |
printf "%a" pp_bin_full x prints x in the binary (0 and 1)
format omitting suffixes, and the prefix if it is necessary.
|
| pp_binop [Bap.Std.Bil] |
printf "%a" pp_binop op prints a binary operation op .
|
| pp_blang [Core_printers] |
|
| pp_cast [Bap.Std.Bil] |
printf "%a" pp_cast t prints a cast type t
|
| pp_comma [Core_printers] |
|
| pp_dec [Bap.Std.Bitvector] |
printf "%a" pp_dec x prints x in the decimal format omitting
suffixes and prefixes.
|
| pp_dec_full [Bap.Std.Bitvector] |
printf "%a" pp_dec_full x prints x in the decimal format with
suffixes and prefixes.
|
| pp_decision [Bap_strings_detector] |
|
| pp_deque [Core_printers] |
|
| pp_doubly_linked [Core_printers] |
|
| pp_error [Bap_primus.Std.Primus.Lisp.Type] |
pp_error ppf err prints a description of the type error
err into the formatter ppf
|
| pp_error [Bap_primus.Std.Primus.Lisp.Load] |
pp_error ppf err outputs error information into the
pretty-printing formatter ppf .
|
| pp_fdeque [Core_printers] |
|
| pp_fheap [Core_printers] |
|
| pp_fqueue [Core_printers] |
|
| pp_generic [Bap.Std.Bitvector] |
pp_generic ?case ?prefix ?suffix ?format ppf x - a printer
to suit all tastes.
|
| pp_graph [Graphlib.Std.Graphlib.Dot] |
pp_graph ~nodes_of_edge ~nodes ~edges ppf - generic dot
printer.
|
| pp_hashset [Core_printers] |
|
| pp_hashtbl [Core_printers] |
|
| pp_heap [Core_printers] |
|
| pp_hex [Bap.Std.Bitvector] |
printf "%a" pp_hex x prints x in the hexadecimal format omitting
suffixes, and the prefix if it is not necessary.
|
| pp_hex_full [Bap.Std.Bitvector] |
printf "%a" pp_hex_full x prints x in the hexadecimal format with
suffixes, and the prefix if it is necessary.
|
| pp_map [Core_printers] |
|
| pp_map [Bap.Std.Taint] |
|
| pp_oct [Bap.Std.Bitvector] |
printf "%a" pp_oct x prints x in the octal format omitting
suffixes, and the prefix if it is not necessary.
|
| pp_oct_full [Bap.Std.Bitvector] |
printf "%a" pp_oct_full x prints x in the octal format with
suffixes, and the prefix if it is necessary.
|
| pp_program [Bap_primus.Std.Primus.Lisp.Load] |
pp_program ppf program dumps program definitions into the formatter ppf
|
| pp_proto [Bap_c_type_printer] |
|
| pp_queue [Core_printers] |
|
| pp_seq [Regular.Std.Printable.S] |
prints a sequence of values of type t
|
| pp_set [Core_printers] |
|
| pp_set [Bap.Std.Taint] |
|
| pp_stack [Core_printers] |
|
| pp_stats [Bap_strings_detector] |
|
| pp_unop [Bap.Std.Bil] |
printf "%a" pp_unop op prints an unary operation op
|
| ppo [Regular.Std.Printable.S] |
will print to a standard output_channel , useful for using in
printf , fprintf , etc.
|
| pps [Regular.Std.Printable.S] |
|
| precondition [Bap.Std.Term] |
precondition must on the entrance to the subroutine
|
| pred [Bap_primus.Std.Primus.Value.Make] |
|
| pred [Bap.Std.Bitvector] |
pred n returns a value preceding n .
|
| pred [Bap.Std.Integer.Base] |
pred n is a predecessor of n
|
| preds [Graphlib.Std.Node] |
preds node graph returns a sequence of predecessors of a
node in a a given graph
|
| preds [Bap.Std.Disasm_expert.Basic] |
current set of predicates
|
| pref_addrsize [X86_env] |
|
| pref_cs [X86_env] |
|
| pref_ds [X86_env] |
|
| pref_es [X86_env] |
|
| pref_fs [X86_env] |
|
| pref_gs [X86_env] |
|
| pref_lock [X86_env] |
|
| pref_opsize [X86_env] |
|
| pref_ss [X86_env] |
|
| prefix [Bap_config] |
|
| prepend [Bap.Std.Term] |
prepend t ~before:this p c returns the p with c inserted
before this term.
|
| pretty_writer [Regular.Std.Data] |
pretty_printer (module T creates a writer that uses T.pp
function for outputting.
|
| prev [Bap.Std.Term] |
prev t p id returns a term that preceeds a term with a given
id , if such exists.
|
| prev [Bap.Std.Table] |
next table elt returns element preceding to elt , if any
|
| print [Regular.Std.Data.S.Io] |
print ?ver ?fmt ppf prints datum to a given formatter, using
a default_printer if fmt is left unspecified.
|
| print_colors [Text_tags.Attr] |
print_colors yesno enable/disable color submode.
|
| probe [Bap_traces.Std.Trace.P] |
|
| process [Bap_api] |
apply the language processor
|
| processors [Bap_api] |
enumerate all registered language processors
|
| profile [Bap_config] |
|
| program [Bap_primus.Std.Primus.Lisp.Make] |
program is the current Machine program.
|
| program [Bap_primus.Std.Primus.Lisp.Load] |
program ?paths proj features loads a program that
implements a set of features .
|
| program [Bap_primus.Std.Primus.Machine.S] |
program program representation
|
| program [Bap.Std.Project.Info] |
occurs every time a program term is changed during the
project reconstruction process.
|
| program [Bap.Std.Project] |
program project returns a program lifted into IR
|
| program_t [Bap.Std] |
|
| progress [Bap.Std.Event.Log] |
progress ?note ?stage ?total name sends a progress report.
|
| proj [Bap.Std.Term] |
proj cls t ?case a special case of pattern matching,
where all cases by default returns None
|
| project [Bap_primus.Std.Primus.Machine.S] |
project is a computation that results with the project
data structure.
|
| propagate [Bap_taint.Std.Taint.Propagation.Policy.Make] |
propagate p rs rd srcs dst transfers objects
associated with srcs to dst based on the selected
policy p .
|
| propagate_consts [Bap.Std.Bil] |
propagate_consts bil propagates consts from their reaching definitions.
|
| proto [Bap_c_term_attributes] |
|
| proto_of_sexp [Bap_c_type] |
|
| provide [Bap_ida.Std.Service] |
provide creator provides for a service that can perform the
roles of Ida.create , Ida.exec , Ida.close .
|
| provide [Bap_c_parser] |
called by a plugin that provides a parser.
|
| provide [Bap_primus.Std.Primus.Observation] |
provide ?inspect name returns a pair of two handlers.
|
| provide [Ogre.S] |
provide attr v1 v2 ... vm stores the constituents of an
attribute value in the document.
|
| provide [Regular.Std.Data.Cache.Service] |
provide service will substitute current caching service
with a new service .
|
| prune_dead_virtuals [Bap.Std.Bil] |
prune_dead_virtuals bil removes definitions of virtual variables that are
not live in the provided bil program.
|
| prune_unreferenced [Bap.Std.Bil] |
prune_unreferenced ?physicals ?virtuals ?such_that p remove
all assignments to variables that are not used in the program
p .
|
| psdir [Bap_config] |
|
| ptr [Bap.Std.Taint] |
value stored at memory location, that is stored
in the register is tainted.
|
| ptrs [Bap.Std.Taint] |
maps each variable that is used in a term to a set of pointer taints
|
| pure [Monads.Std.Monad.Choice.Basic2] |
pure x creates a computation that results in x .
|
| pure [Monads.Std.Monad.Choice.Basic] |
pure x creates a computation that results in x .
|
| pure [Bap.Std.Sub] |
A subroutine have no effects except the return value and their
return value depends only on the parameters and/or global
variables.
|
| put [Bap_primus.Std.Primus.Machine.State] |
put state x saves a machine state
|
| put [Monads.Std.Monad.State.S2] |
put s changes the current state to s
|
| put [Monads.Std.Monad.State.S] |
put s changes the current state to s
|
| put_data [Bap_bundle.Std.Bundle.Builder] |
put_data builder ~name ~data insert data at path
name .
|
| put_file [Bap_bundle.Std.Bundle.Builder] |
put_file ?name builder uri insert a file specified by the
uri .
|
| python [Bap.Std] |
A command in python language
|
Q |
| qf [Arm_env] |
qf underflow (saturation) Flag
|
| qualifier_of_sexp [Bap_c_type] |
|
| quaternary [Monads.Std.Monad.S2.Lift] |
|
| quaternary [Monads.Std.Monad.S.Lift] |
|
| quinary [Monads.Std.Monad.S2.Lift] |
|
| quinary [Monads.Std.Monad.S.Lift] |
|
R |
| r [X86_cpu.AMD64] |
|
| r [X86_env.ModeVars] |
|
| r0 [Arm_env] |
|
| r1 [Arm_env] |
|
| r10 [Arm_env] |
|
| r11 [Arm_env] |
|
| r12 [Arm_env] |
|
| r128_of_sexp [X86_asm_reg_types] |
|
| r16_of_sexp [X86_asm_reg_types] |
|
| r2 [Arm_env] |
|
| r256_of_sexp [X86_asm_reg_types] |
|
| r3 [Arm_env] |
|
| r32_of_sexp [X86_asm_reg_types] |
|
| r4 [Arm_env] |
|
| r5 [Arm_env] |
|
| r6 [Arm_env] |
|
| r64_of_sexp [X86_asm_reg_types] |
|
| r7 [Arm_env] |
|
| r8 [Arm_env] |
|
| r8_of_sexp [X86_asm_reg_types] |
|
| r8h_of_sexp [X86_asm_reg_types] |
|
| r8l_of_sexp [X86_asm_reg_types] |
|
| r9 [Arm_env] |
|
| raise [Bap_primus.Std.Primus.Machine.S] |
raise exn raises the machine exception exn , intiating
an abonormal control flow
|
| raise [Bap.Std.Eff] |
an expression raises a CPU exception
|
| raises [Bap.Std.Eff] |
raises eff if raise in eff
|
| range [Bap.Std.Memory] |
range mem a0 a1 returns a view on mem starting from
address a0 and ending at a1 , bounds inclusive
|
| rax [X86_cpu.IA32] |
|
| rax [X86_env.ModeVars] |
|
| rbp [X86_cpu.IA32] |
|
| rbp [X86_env.ModeVars] |
|
| rbx [X86_cpu.IA32] |
|
| rbx [X86_env.ModeVars] |
|
| rcontains_from [Regular.Std.Bytes] |
rcontains_from s stop c tests if byte c appears in s before
position stop+1 .
|
| rcx [X86_cpu.IA32] |
|
| rcx [X86_env.ModeVars] |
|
| rdi [X86_cpu.IA32] |
|
| rdi [X86_env.ModeVars] |
|
| rdx [X86_cpu.IA32] |
|
| rdx [X86_env.ModeVars] |
|
| read [Bap_dwarf.Std.Leb128] |
|
| read [Bap_primus.Std.Primus.Interpreter] |
read (var,x) happens after a variable var is evaluated
to the value x
|
| read [Monads.Std.Monad.Reader.S2] |
read () reads the environment.
|
| read [Monads.Std.Monad.Reader.S] |
read () reads the environemnt
|
| read [Monads.Std.Monad.Writer.S] |
read m reads the current state of computation m
|
| read [Regular.Std.Data.S.Io] |
read ?ver ?fmt file reads datum from a file
|
| read [Bap.Std.Eff] |
an expression reads a register (nonvirtual) variable.
|
| read_all [Bap_traces.Std.Trace] |
read_all trace tag reads all event of the a given type
|
| read_all_matching [Bap_traces.Std.Trace] |
read_all_matching trace matcher reads all events
matching with a provided matcher .
|
| read_events [Bap_traces.Std.Trace] |
read_events trace reads a sequence of events from the trace .
|
| readable [Bap.Std.Image.Scheme] |
|
| reading [Bap_primus.Std.Primus.Interpreter] |
reading x happens before the variable x is read from the
environment.
|
| reads [Bap.Std.Eff] |
|
| real_of_sexp [Bap_c_type] |
|
| reduce [Monads.Std.Monad.Collection.S] |
reduce xs ~f same as fold except that the initial
state is obtained from the first element of the
container, i.e., computes a sequence
|
| reduce [Monads.Std.Monad.Collection.S2] |
reduce xs ~f same as fold except that the initial
state is obtained from the first element of the
container, i.e., computes a sequence
|
| refine [Graphlib.Std.Partition] |
refine p ~rel ~comp takes a partition p , and refines it
according to the equivalence relation r , so that the
resulting partition corresponds to the classes of r , assuming
that those classes are finer that the original p .
|
| reg [Bap.Std.Taint] |
value stored in register is source of taint
|
| reg128_t [Bap.Std] |
|
| reg16_t [Bap.Std] |
|
| reg256_t [Bap.Std] |
|
| reg32_t [Bap.Std] |
|
| reg64_t [Bap.Std] |
|
| reg8_t [Bap.Std] |
|
| reg_of_sexp [X86_asm] |
|
| reg_of_sexp [Arm_types] |
|
| regions [Bap.Std.Table] |
regions table returns in an ascending order of addresses all
memory regions mapped in a table
|
| register [Bap_strings_index.Persistent.S] |
register idx data registers data in the index idx .
|
| register [Bap_demangle.Std.Demanglers] |
register demangler register new demangler.
|
| register [Bap_bml.Registry] |
register name value register value with a given name .
|
| register [Bap_c_attr] |
|
| register [Bap.Std.Source.Factory.S] |
register name cons registers a method that creates a given
source of information.
|
| register [Bap.Std.Value.Tag] |
|
| register_backend [Bap.Std.Image] |
register_backend ~name backend tries to register backend under
the specified name .
|
| register_loader [Bap.Std.Project.Input] |
register_loader name load register a loader under provided
name .
|
| register_loader [Bap.Std.Image] |
register_loader ~name backend registers new loader.
|
| register_mode [Text_tags] |
register_mode mode init installs new mode.
|
| register_pass [Bap_abi] |
register_pass pass registers a pass for the later execution.
|
| register_pass [Bap.Std.Project] |
register_pass ?autorun ?runonce ?deps ?name pass registers a
pass over a project.
|
| register_pass [Bap.Std.Bil] |
register_pass ~desc name pass provides a pass to the BIL transformation pipeline.
|
| register_pass' [Bap.Std.Project] |
register_pass' pass registers pass that doesn't modify
the project effect and is run only for side effect.
|
| register_printer [Bap.Std.Event] |
register_printer f when event e is printed, f e must be
None if f is not a subset of events, that is intended to be
printed by an f .
|
| register_proto [Bap_traces.Std.Trace] |
|
| register_read [Bap_traces.Std.Event] |
a value was read from a given register
|
| register_reader [Bap_traces.Std.Trace] |
|
| register_target [Bap.Std] |
Register new target architecture.
|
| register_tool [Bap_traces.Std.Trace] |
|
| register_write [Bap_traces.Std.Event] |
a value is written to the specified register
|
| register_writer [Bap_traces.Std.Trace] |
|
| registered [Bap_strings_index.Persistent.S] |
registered idx data is true if data was registered in
the index.
|
| regs [Bap.Std.Taint] |
maps each variable that is used in a term to a set of register taints
|
| reject [Monads.Std.Monad.Choice.S2] |
reject () rejects the rest of computation sequence, and
terminate the computation with the zero result (Same as
zero ()
|
| reject [Monads.Std.Monad.Choice.S] |
reject () rejects the rest of computation sequence, and
terminate the computation with the zero result (Same as
zero ()
|
| relocation [Bap.Std.Image.Scheme] |
relocation fixup addr a value referenced at the code that
has the fixup address is relocated to the specified address
addr .
|
| remove [Bap_traces.Std.Traces] |
remove trace removes a trace from the repository, do
nothing if it wasn't registered.
|
| remove [Graphlib.Std.Edge] |
remove e g returns a graph g' that doesn't contain edge
e .
|
| remove [Graphlib.Std.Node] |
remove n g returns graph g' , with a node n removed from
a set of nodes N .
|
| remove [Bap.Std.Phi] |
remove def id removes definition with a given id
|
| remove [Bap.Std.Term] |
remove t p id returns a term that doesn't contain element
with the a given id
|
| remove [Bap.Std.Symtab] |
remove table fn removes symbol fn from table
|
| remove [Bap.Std.Memmap] |
remove map mem removes all bindings to mem
|
| remove [Bap.Std.Table] |
returns a new table with all mappings from the mem region
mem removed
|
| remove [Bap.Std.Dict] |
remove map tag returns a map without a value associated
with tag
|
| remove [Bap.Std.Interval_tree.S] |
remove t k removes all bindings to the key k
|
| remove [Bap.Std.Trie.S] |
remove trie key removes value bound with key if any.
|
| remove_dominators [Bap.Std.Memmap] |
remove_dominators map mem removes all bindings that are
dominators to mem
|
| remove_dominators [Bap.Std.Interval_tree.S] |
remove_dominators t k removes all bindings that are
included (dominated by) in the interval k
|
| remove_intersections [Bap.Std.Memmap] |
remove_intersections map mem removes all bindings that
that intersects with mem
|
| remove_intersections [Bap.Std.Interval_tree.S] |
remove_intersections t k removes all bindings that
intersect with the key k .
|
| repair_imm [Arm_mem_shift] |
takes a word and converts it to an exp that is the offset for some
memory instructions sign_mask - a bitmask that determines the bit
in src that is the repair bit imm_mask - a bitmask that determines
which bits in src are the immediate type - whether a set mask
indicates a positive or negative immediate.
|
| repair_reg [Arm_mem_shift] |
|
| repeat [Bap_future.Std.Signal] |
repeat s ~times:n x sends value x to an associated
stream n times
|
| repeat [Bap_future.Std.Stream] |
repeat x returns a stream xs and a signal s .
|
| repnz [X86_env] |
|
| report_error [Bare.Rule] |
|
| report_progress [Bap.Std.Self] |
report_progress ~task:t ~note:n ~state:s ~total:s' () reports
a progress of the task t .
|
| repz [X86_env] |
|
| request [Ogre.S] |
request a ~that:p request no more than one value of an
attribute a , that satisfies a predicate p .
|
| request [Regular.Std.Data.Cache.Service] |
request reader writer returns a caching service for
type 'a .
|
| require [Ogre.S] |
require a ~that:p requires that an attribute a has one and
only one value that satisfies a predicate p .
|
| reset [Bare.Rule] |
reset rule discards the matching state and returns a fresh rule.
|
| resolve [Bap.Std.Brancher] |
resolve brancher mem insn returns a list of destinations of
the instruction insn , that occupies memory region mem .
|
| resolve [Bap.Std.Symbolizer] |
resolve symbolizer addr returns a name of function,
to which a given address belongs.
|
| resolve_addr [Bap_primus.Std.Primus.Linker.Make] |
resolve_addr name returns the address associated with the
given name .
|
| resolve_symbol [Bap_primus.Std.Primus.Linker.Make] |
resolve_symbol name returns the symbolic name associated
with the given name .
|
| resolve_tid [Bap_primus.Std.Primus.Linker.Make] |
resolve_tid name returns the term identifier associated
with the given name .
|
| result [Bap_strings_detector] |
|
| result [Bap_c_type_mapper.Search] |
result s runs the computation s and extracts the result.
|
| result [Bap.Std.Blk.Builder] |
|
| result [Bap.Std.Sub.Builder] |
|
| result [Bap.Std.Program.Builder] |
|
| return [Bap_traces.Std.Event] |
a return from a call has occured
|
| return [Bap_primus.Std.Primus.Linker.Trace] |
occurs just before a subroutine returns.
|
| return [Monads.Std.Monad.Minimal2] |
|
| return [Monads.Std.Monad.Minimal] |
|
| return [Monads.Std.Monad.Basic2] |
return x creates a trivial compuation that results in x
|
| return [Monads.Std.Monad.Basic] |
return x creates a trivial compuation that results in x
|
| return [Monads.Std.Monad.Collection.Basic] |
return x creates a singleton container holding x
|
| return [Bap.Std.Call] |
returns call continuation
|
| return [Bap.Std.Insn] |
instruction is a return from a call
|
| returns_twice [Bap.Std.Sub] |
A subroutine may return more than one time.
|
| rev_map [Bap.Std.Table] |
rev_map arity t tab creates a reverse mapping from values of
typeclass t stored in table tab to memory regions.
|
| reverse_postorder_traverse [Graphlib.Std.Graphlib] |
returns a sequence of nodes in reverse post order.
|
| rflags [X86_env.ModeVars] |
|
| rhs [Bare.Rule] |
rhs rule is the right hand side of the rule
|
| rhs [Bap.Std.Arg] |
rhs arg returns an expression to which argument is
bound.
|
| rhs [Bap.Std.Def] |
returns the right hand side of a definition
|
| rindex [Regular.Std.Bytes] |
rindex s c returns the index of the last occurrence of byte c
in s .
|
| rindex_from [Regular.Std.Bytes] |
rindex_from s i c returns the index of the last occurrence of
byte c in s before position i+1 .
|
| rip [X86_cpu.IA32] |
|
| rip [X86_env.ModeVars] |
|
| root [Bap.Std.Image.Scheme] |
|
| roots [Bap.Std.Rooter] |
roots r enumerates roots found by rooter r
|
| rshift [Bap_primus.Std.Primus.Value.Make] |
|
| rshift [Bap.Std.Bil] |
|
| rshift [Bap.Std.Integer.Base] |
rshift x y shift x by y bits to the right
|
| rsi [X86_cpu.IA32] |
|
| rsi [X86_env.ModeVars] |
|
| rsp [X86_cpu.IA32] |
|
| rsp [X86_env.ModeVars] |
|
| run [Bap_strings_detector] |
|
| run [Bap_strings_scanner] |
scan ~is_stop ~read off applies next ~is_stop ~read for all
offsets that are bigger than off until read off is not None .
|
| run [Bap_demangle.Std.Demangler] |
run demangler name demangle given name
|
| run [Bap_c_parser] |
run filename parses file and returns a mapping from identifier
to its type.
|
| run [Bap_primus.Std.Primus.Lisp.Closure] |
run args performs the computation.
|
| run [Bap_primus.Std.Primus.Machine.Main] |
run ?envp ?args proj returns a computation that will
run a program represented with the proj data structure.
|
| run [Ogre.S] |
run op doc runs an operation op that does some inference as
well as may update the document.
|
| run [Monads.Std.Monad.Trans.S2] |
|
| run [Monads.Std.Monad.Trans.S1] |
|
| run [Monads.Std.Monad.Trans.S] |
|
| run [Bap_plugins.Std.Plugins] |
run ?env ?provides ?library ?exclude load and execute all plugins that can
be found in the library paths, and are not in the exclude
list.
|
| run [Bap.Std.Project.Pass] |
run_pass project pass applies pass to a project .
|
| run [Bap.Std.Reconstructor] |
run reconstructor cfg reconstructs a symbol table from a
given cfg
|
| run [Bap.Std.Disasm_expert.Recursive] |
run ?backend ?brancher ?rooter arch mem disassemble and
reconstruct a CFG of the code in mem , assuming
architecture arch .
|
| run [Bap.Std.Disasm_expert.Basic] |
run ?stop_on ?invalid ?stopped dis mem ~init ~return ~hit
performs the recursive disassembly of the specified chunk of
memory mem .
|
| run_exn [Bap.Std.Project.Pass] |
run_pass_exn proj is the same as run_pass , but raises an
exception on error.
|
S |
| same [Bap.Std.Term] |
same x y returns true if x and y represents the same
entity, i.e., Tid.(tid x = tid y)
|
| same [Bap.Std.Value.Tag] |
same x y is true if tags x and y have the same type.
|
| same [Bap.Std.Var] |
same x y compares variables ignoring indices, i.e., for
variables x and y the same x y is true iff equal
(base x) (base y)
|
| same_witness [Bap.Std.Value.Tag] |
same_witness x y returns a value witnessing that value tags
x and y has the same type.
|
| same_witness_exn [Bap.Std.Value.Tag] |
same_witness_exn x y is the same as same_witness but
raises exception if not (same x y) .
|
| sample [Bap_future.Std.Stream] |
sample ~clk ss is semantically the same as
frame ~clk ss >>| fst
|
| sanitize [Bap_taint.Std.Taint.Tracker.Make] |
Taint.sanitize r k v detaches all objects related to the
value v by the relation r that has the given kind k .
|
| save [Bap_traces.Std.Trace] |
save uri pushes trace to a provided uri
|
| save [Bap_byteweight_signatures] |
save ?comp ~mode ~path arch data store signatures data in the
database of signatures specified by the path parameter.
|
| save [Ogre.Doc] |
save doc out stores the document in a channel.
|
| save [Regular.Std.Data.Cache] |
save cls digest x stores entry x with a given digest
to the cache.
|
| save [Regular.Std.Data.S.Cache] |
save id data store data under given id .
|
| save [Regular.Std.Data.S.Io] |
save ?ver ?fmt channel datum saves the datum to the channel
|
| save_all [Regular.Std.Data.S.Io] |
save_all ?ver ?fmt data channel saves a list of data into
a channel
|
| sbindir [Bap_config] |
|
| scalar_of_sexp [Bap_c_type] |
|
| scan [Regular.Std.Data.S.Io] |
scan ?ver ?fmt channel creates a stream of data, that
are loaded consequently from the channel
|
| scheme [Ogre.Type] |
scheme field defines a scheme with one field.
|
| script [Bap_ida.Std.Command] |
script command the script text
|
| sdivide [Bap.Std.Bil] |
|
| section [Bap_dwarf.Std.Dwarf.Data] |
section data lookups for a section in data
|
| section [Bap.Std.Image.Scheme] |
section addr size a memory region is a section
|
| section [Bap.Std.Image] |
|
| seg_cs [X86_env.ModeVars] |
|
| seg_ds [X86_env.ModeVars] |
|
| seg_es [X86_env.ModeVars] |
|
| seg_fs [X86_env.ModeVars] |
|
| seg_gs [X86_env.ModeVars] |
|
| seg_ss [X86_env.ModeVars] |
|
| segfault [Bap_primus.Std.Primus.Interpreter] |
segfault x occurs when an invalid memory operation is performed
on the address x .
|
| segment [Bap.Std.Image.Scheme] |
segment addr size readable writable executable a memory
region (addr,size) has the specified permissions.
|
| segment [Bap.Std.Image] |
|
| segment_base_of_sexp [X86_asm_reg_types] |
|
| segment_of_sexp [X86_asm_reg_types] |
|
| segment_of_symbol [Bap.Std.Image] |
segment_of_symbol image sym a segment to which sym belongs.
|
| segments [Bap.Std.Image] |
segments image returns a mapping from addresses to segments
|
| select [Bap_taint.Std.Taint.Propagation.Policy.Make] |
select p k selects the taint propagation policy p
for objects of kind k .
|
| select [Ogre.Query] |
select ~where ~join (from t1 t2 ... tm) selects attributes
t1 , t2 , ..., tm , join them by the fields specified in the
join clause, and filters those that satisfy the condition
defined with the where clause.
|
| select [Bap.Std.Phi] |
select phi label takes the value corresponding to a control
flow path marked with label .
|
| select [Bap.Std.Value.Match] |
select matcher x applies matcher to value x .
|
| select_or_unknown [Bap.Std.Phi] |
select_or_unknown phi label is exp if
select phi label = Some exp , otherwise returns a
Bil.unknown expression.
|
| select_passes [Bap.Std.Bil] |
select_passes passes select the passes for the BIL transformation pipeline.
|
| selected [Bap_taint.Std.Taint.Propagation.Policy.Make] |
selected p k is true if the policy p was selected
for the kind k .
|
| send [Bap_future.Std.Signal] |
send s x sends value x to an associated stream.
|
| send [Bap.Std.Event] |
|
| sequence [Monads.Std.Monad.S2] |
sequence xs computes a sequence of computations xs in
the left to right order.
|
| sequence [Monads.Std.Monad.S] |
sequence xs computes a sequence of computations xs in
the left to right order.
|
| sequence [Monads.Std.Monad.Collection.S] |
sequence cs performs all computations in cs from left
to right.
|
| sequence [Monads.Std.Monad.Collection.S2] |
sequence cs performs all computations in cs from left
to right.
|
| set [Bap_build.Std.Plugin_options] |
set () set default options for bapbuild .
|
| set [Bap_primus.Std.Primus.Memory.Make] |
set a x stores the byte x at the address a .
|
| set [Bap_primus.Std.Primus.Env.Make] |
set var value binds a variable var to the given value .
|
| set [Bap_primus.Std.Primus.Interpreter.Make] |
|
| set [Regular.Std.Bytes] |
set s n c modifies s in place, replacing the byte at index n
with c .
|
| set [Bap.Std.Project] |
set project field value sets a field to a give value.
|
| set [Bap.Std.Vector] |
set vec n x sets n 'th element of a vector vec to x if
n < length vec then raises exception
|
| set [Bap.Std.Dict] |
set map tag x inserts or update
|
| set_adc [Arm_flags] |
|
| set_add [Arm_flags] |
|
| set_attr [Bap_traces.Std.Trace] |
set_attr trace attr value updates trace meta attribute attr
with a provided value.
|
| set_attr [Bap.Std.Term] |
set_attr term attr value attaches an value to attribute
attr in term
|
| set_cf_data [Arm_flags] |
|
| set_default [Bap_taint.Std.Taint.Propagation.Policy.Make] |
set_default policy makes policy the default policy
for all kinds that didn't select their own taint
propagation policies.
|
| set_default_printer [Regular.Std.Data.S] |
set_default_printer ?ver name sets new default printer.
|
| set_default_reader [Regular.Std.Data.S] |
set_default_reader ?ver name sets new default reader.
|
| set_default_writer [Regular.Std.Data.S] |
set_default_writer ?ver name sets new default writer.
|
| set_meta [Bap_traces.Std.Trace] |
set_meta trace meta substitutes meta attributes of a trace with
attributes taken from a dictionary meta .
|
| set_name [Bap.Std.Tid] |
set_name tid name associates a name with a given
term identifier tid .
|
| set_nzf [Arm_flags] |
|
| set_sbc [Arm_flags] |
|
| set_sub [Arm_flags] |
|
| set_vnzf_add [Arm_flags] |
|
| set_vnzf_sub [Arm_flags] |
|
| setup_dynamic_loader [Bap_plugins.Std] |
setup_dynamic_loader loader installs loader program.
|
| sexp_of_aggregate [Bap_c_type] |
|
| sexp_of_array [Bap_c_type] |
|
| sexp_of_attr [Bap_c_type] |
|
| sexp_of_basic [Bap_c_type] |
|
| sexp_of_bits_insn [Arm_types] |
|
| sexp_of_branch_insn [Arm_types] |
|
| sexp_of_ccr_or_nil [Arm_types] |
|
| sexp_of_ccr_reg [Arm_types] |
|
| sexp_of_char [Bap_c_type] |
|
| sexp_of_cint [Bap_c_type] |
|
| sexp_of_complex [Bap_c_type] |
|
| sexp_of_compound [Bap_c_type] |
|
| sexp_of_cond [Arm_types] |
|
| sexp_of_cv [Bap_c_type] |
|
| sexp_of_cvr [Bap_c_type] |
|
| sexp_of_enum [Bap_c_type] |
|
| sexp_of_floating [Bap_c_type] |
|
| sexp_of_gpr [X86_asm_reg_types] |
|
| sexp_of_gpr_or_nil [Arm_types] |
|
| sexp_of_gpr_reg [Arm_types] |
|
| sexp_of_insn [Arm_types] |
|
| sexp_of_integer [Bap_c_type] |
|
| sexp_of_ip [X86_asm_reg_types] |
|
| sexp_of_long [Bap_c_type] |
|
| sexp_of_long_long [Bap_c_type] |
|
| sexp_of_mem_insn [Arm_types] |
|
| sexp_of_mem_multi_insn [Arm_types] |
|
| sexp_of_move_insn [Arm_types] |
|
| sexp_of_mult_insn [Arm_types] |
|
| sexp_of_nil_reg [Arm_types] |
|
| sexp_of_no_qualifier [Bap_c_type] |
|
| sexp_of_non_nil_reg [Arm_types] |
|
| sexp_of_op [Arm_types] |
|
| sexp_of_proto [Bap_c_type] |
|
| sexp_of_qualifier [Bap_c_type] |
|
| sexp_of_r128 [X86_asm_reg_types] |
|
| sexp_of_r16 [X86_asm_reg_types] |
|
| sexp_of_r256 [X86_asm_reg_types] |
|
| sexp_of_r32 [X86_asm_reg_types] |
|
| sexp_of_r64 [X86_asm_reg_types] |
|
| sexp_of_r8 [X86_asm_reg_types] |
|
| sexp_of_r8h [X86_asm_reg_types] |
|
| sexp_of_r8l [X86_asm_reg_types] |
|
| sexp_of_real [Bap_c_type] |
|
| sexp_of_reg [X86_asm] |
|
| sexp_of_reg [Arm_types] |
|
| sexp_of_scalar [Bap_c_type] |
|
| sexp_of_segment [X86_asm_reg_types] |
|
| sexp_of_segment_base [X86_asm_reg_types] |
|
| sexp_of_short [Bap_c_type] |
|
| sexp_of_signed [Bap_c_type] |
|
| sexp_of_spec [Bap_c_type] |
|
| sexp_of_special_insn [Arm_types] |
|
| sexp_of_t [Bap_c_data] |
|
| sexp_of_t [Bap_c_type.Array] |
|
| sexp_of_t [Bap_c_type.Compound] |
|
| sexp_of_t [Bap_c_type.Proto] |
|
| sexp_of_t [Bap_c_type.Spec] |
|
| sexp_of_t [Bap_c_type.Attr] |
|
| sexp_of_t [Bap_c_type.Qualifier] |
|
| sexp_of_t [Bap_c_type] |
|
| sexp_of_t [X86_asm_reg_types] |
|
| sexp_of_t [Bap.Std.Disasm_expert.Basic.Insn] |
sexp_of_t insn returns a sexp representation of insn
|
| sexp_of_unsigned [Bap_c_type] |
|
| sexp_of_value [Bap_c_data] |
|
| sexp_reader [Regular.Std.Data] |
sexp_reader (module T) returns a reader in sexp format.
|
| sexp_writer [Regular.Std.Data] |
|
| sexpable_of_string [Arm_helpers] |
|
| sf [X86_env] |
|
| sharedstatedir [Bap_config] |
|
| shell [Bap.Std] |
A command in shell language
|
| short_of_sexp [Bap_c_type] |
|
| shortest_path [Graphlib.Std.Graphlib] |
shortest_path (module G) ?weight ?rev g u v
Find a shortest path from node u to node v .
|
| should [Bap.Std.Insn] |
must property insn postulate that insn may have the property
|
| shouldn't [Bap.Std.Insn] |
must property insn postulate that insn shouldn't have the property
|
| show [Text_tags.Attr] |
show name enable attribute with the name .
|
| show [Regular.Std.Data.S.Io] |
show ?ver ?fmt datum saves datum to standard output
channel, using a default_printer if fmt is not
specified.
|
| signal [Bap_primus.Std.Primus.Lisp.Make] |
signal ?params ?docs obs proj defines a new signal.
|
| signed [Bap_primus.Std.Primus.Value.Make] |
signed x same as of_word @@ signed x
|
| signed [Bap.Std.Bil] |
|
| signed [Bap.Std.Bitvector] |
signed t casts t to a signed type, so that any operations
applied on t will be signed.
|
| signed_of_sexp [Bap_c_type] |
|
| simpl [Bap.Std.Stmt] |
simpl ?ignore xs recursively applies Exp.simpl and also
simplifies if and while expressions with statically known
conditionals, e.g., if (true) xs ys is simplified to xs ,
while (false) xs is simplified to xs .
|
| simpl [Bap.Std.Exp] |
simpl ~ignore:effects x iff expression x is well-typed,
then returns an expression with the same semantics as x ,
that might smaller according to some metrics.
|
| singleton [Bap.Std.Memmap] |
singleton a memory map containing only one memory region
|
| singleton [Bap.Std.Table] |
creates a table containing one bindins
|
| singleton [Bap.Std.Interval_tree.S] |
singleton k x creates an interval tree that has only one
mapping - from the key k to data x
|
| size [Bap_dwarf.Std.Leb128] |
size leb return size in bytes of the number stored in LEB128
encoding.
|
| size [Regular.Std.Data.Write] |
size writebale value returns a size in bytes that
writeable will use to write value
|
| size [Bap.Std.Image.Scheme] |
|
| size_in_bytes [Regular.Std.Data.S] |
size_in_bytes ?ver ?fmt datum returns the amount of bytes
that is needed to represent datum in the given format
and version
|
| sle [Bap.Std.Bil] |
|
| slt [Bap.Std.Bil] |
|
| smodulo [Bap.Std.Bil] |
|
| snd [Monads.Std.Monad.S2.Triple] |
|
| snd [Monads.Std.Monad.S2.Pair] |
|
| snd [Monads.Std.Monad.S.Triple] |
|
| snd [Monads.Std.Monad.S.Pair] |
|
| some [Bap.Std.Self.Config] |
some none c is like the converter c except it returns
Some value.
|
| sp [Arm_env] |
|
| sp [Bap.Std.CPU] |
|
| span [Bap.Std.Symtab] |
span fn returns a memory map of a region occupied by a
function fn
|
| spec [Bare.Rule] |
spec rule is the human readable and machine parseable
well-formed rule specification.
|
| spec [Bap.Std.Project.Info] |
occurs once image spec is known
|
| spec [Bap.Std.Image] |
spec image returns the image specification.
|
| spec_of_sexp [Bap_c_type] |
|
| special [Bap.Std.Bil] |
special msg -> Special msg
|
| special_insn_of_sexp [Arm_types] |
|
| specification [Bap.Std.Image] |
an image specification in OGRE
|
| split [Bap_future.Std.Stream] |
split xs ~f returns a pair of streams, where the first stream
contains fst (f x) for each x in xs and the second stream
contains snd (f x) for each x in xs .
|
| split_after [Bap.Std.Blk] |
split_after blk def creates two new blocks, where the first
block contains all defintions up to def inclusive, the
second contains the rest.
|
| split_before [Bap.Std.Blk] |
split_before blk def is like split_after but
def will fall into the second blk
|
| split_bot [Bap.Std.Blk] |
split_top blk returns two blocks, where first block shares
the same tid as blk , has all $\Phi$-nodes and definitions
from blk , but has only one destination, namely the second
block.
|
| split_top [Bap.Std.Blk] |
split_top blk returns two blocks, where first block shares
the same tid as blk and has all $\Phi$-nodes of blk , but
has only one destination, namely the second block.
|
| split_while [Bap.Std.Blk] |
split_while blk ~f splits blk into two block: the first
block holds all definitions for which f p is true and has
the same tid as blk .
|
| spsr [Arm_env] |
spsr Saved Processor Status Register
|
| src [Graphlib.Std.Edge] |
src e returns a source of an edge e
|
| ss [X86_env] |
|
| ssa [Bap.Std.Sub] |
ssa sub returns sub in SSA form.
|
| standard_library [Bap_config] |
|
| standard_prefs [X86_env] |
Prefixes that we can usually handle automatically
|
| start [Graphlib.Std.Path] |
start p the starting edge of a path p
|
| start [Bap.Std.Log] |
|
| static [Bap_primus.Std.Primus.Generator] |
static value returns a generator that always produces the
same value .
|
| status [Monads.Std.Monad.State.Multi.S2] |
status id returns a status of a state with the given id
|
| status [Monads.Std.Monad.State.Multi.S] |
status id returns a status of a state with the given id
|
| step [Bap_strings_detector] |
step t data char performs one observation.
|
| step [Bap.Std.Disasm_expert.Basic] |
continue disassembling from the current point.
|
| stop [Bap.Std.Disasm_expert.Basic] |
stop the disassembly and return the provided value.
|
| stop_on_error [Bap_traces.Std.Trace.Monitor] |
stop_on_error will silently finish a stream in case of error.
|
| storage [Bap.Std.Project] |
returns an attribute storage of the project
|
| storage [Bap.Std.Bil.Result] |
storage s id creates a result with the given id and
storage s as a value
|
| store [Bap_primus.Std.Primus.Memory.Make] |
store a x stores the byte x at the address a .
|
| store [Bap_primus.Std.Primus.Interpreter.Make] |
store a x d s computes a store operation, that stores at
the address a the word x of size s , using an
ordering specified by the endianness d .
|
| store [Bap.Std.Insn] |
the instruction may store to memory
|
| store [Bap.Std.Eff] |
an expression stores a value in a memory
|
| store [Bap.Std.Bil] |
store ~mem ~addr exp endian size -> Store(mem,addr,endian,size)
|
| store_asm [Bap.Std.Disasm_expert.Basic] |
enables storing assembler information
|
| store_kinds [Bap.Std.Disasm_expert.Basic] |
enables storing instruction kinds information
|
| stored [Bap_primus.Std.Primus.Interpreter] |
stored (addr,value) happens after the value is stored at
the address addr
|
| stores [Bap.Std.Eff] |
stores eff if load in eff
|
| storing [Bap_primus.Std.Primus.Interpreter] |
storing x happens before a value is stored at address x
|
| str [Ogre.Query] |
str x creates a string constant.
|
| str [Ogre.Type] |
str represented by a sequence of characters.
|
| str [Regular.Std.Printable.S] |
str () t is formatted output function that matches "%a"
conversion format specifier in functions, that prints to string,
e.g., sprintf , failwithf , errorf and, suprisingly all
Lwt printing function, including Lwt_io.printf and logging
(or any other function with type ('a,unit,string,...)
formatN`.
|
| stream [Bap.Std.Event] |
|
| string [Bap_strings_index.Persistent.S] |
string idx key returns data associated with the
provided key .
|
| string [Bap.Std.Self.Config] |
string converts values with the identity function.
|
| string_of_binop [Bap.Std.Bil] |
string_of_binop op is a textual representation of op .
|
| string_of_cast [Bap.Std.Bil] |
string_of_cast t is a textual representation of a cast type
|
| string_of_error [Bap_byteweight_signatures] |
a human readable representation of an error.
|
| string_of_unop [Bap.Std.Bil] |
string_of_unop op is a textual representation of op .
|
| string_of_value [Bap.Std.Bitvector] |
string_of_value ?hex x returns a textual representation of
the x value, i.e., ignores size and signedness.
|
| strong_components [Graphlib.Std.Graphlib] |
strong_components (module G) g partition graph into strongly
connected components.
|
| stub [Bap.Std.Sub] |
|
| sub [Bap_primus.Std.Primus.Interpreter.Make] |
sub x computes the subroutine x .
|
| sub [Bap_primus.Std.Primus.Value.Make] |
|
| sub [Regular.Std.Bytes.To_string] |
|
| sub [Bap.Std.Integer.Base] |
|
| sub_t [Bap.Std] |
|
| subo [Regular.Std.Bytes.To_string] |
|
| subscribe [Bap_future.Std.Stream] |
subscribe s f subscribe to a stream s with a function
f .
|
| substitute [Bap.Std.Project] |
substitute p region tag value is like
tag_memory, but it will also apply
substitutions in the provided string value, as per OCaml
standard library's Buffer.add_substitute function.
|
| substitute [Bap.Std.Phi] |
substitute phi x y substitutes x by y in all right
hand-side expressions of the phi node.
|
| substitute [Bap.Std.Jmp] |
substitute jmp x y substitutes x by y in all expressions
that occur in jump jmp expressions.
|
| substitute [Bap.Std.Def] |
substitute def x y substitutes x by y in the right hand
side of a definition def
|
| substitute [Bap.Std.Blk] |
substitute ?skip blk x y substitutes each occurrence of
expression x with expression y in block blk .
|
| substitute [Bap.Std.Exp] |
substitute pat rep x subsitutes each occurence of an
expression pat in x with an expression rep
|
| substitute [Bap.Std.Bil] |
substitute x y p substitutes each occurrence of expression x by
expression y in program p .
|
| substitute_var [Bap.Std.Bil] |
substitute_var x y p substitutes all free occurences of
variable x in program p by expression y .
|
| succ [Bap_strings_index.Key] |
|
| succ [Bap_primus.Std.Primus.Value.Make] |
|
| succ [Bap.Std.Bil.Result.Id] |
|
| succ [Bap.Std.Bitvector] |
succ n returns next value after n .
|
| succ [Bap.Std.Integer.Base] |
|
| succs [Graphlib.Std.Node] |
succs node graph returns a sequence of successors of a
node in a a given graph
|
| suffix_program [Bap_config] |
|
| supports [Bap_traces.Std.Trace.S] |
|
| supports [Bap_traces.Std.Trace] |
supports trace feature is true if a tool that was used to
generate the trace, as well as transporting protocol and
underlying format support the given feature.
|
| sweep [Bap.Std.Disasm_expert.Linear.With_exn] |
Linear.With_exn.sweep same as
Linear_sweep.memory , but raises an exception, instead of
returning Or_error monad
|
| sweep [Bap.Std.Disasm_expert.Linear] |
Linear.sweep arch mem will perform a linear sweep
disassembly on the specified memory mem
|
| switch [Monads.Std.Monad.State.Multi.S2] |
switch id switches to the state with the given id if
such state is alive, otherwise switches to the closest
alive ancestor of the state with the given id
|
| switch [Monads.Std.Monad.State.Multi.S] |
switch id switches to the state with the given id if
such state is alive, otherwise switches to the closest
alive ancestor of the state with the given id
|
| switch [Bap.Std.Term] |
switch cls t ~program ~sub .. ~jmp performs a pattern
matching over a term t based on its type class cls .
|
| switch [Bap.Std.Value.Match] |
switch x matcher applies matcher to value x
|
| sym [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| symbol [Bap.Std.Image] |
|
| symbol_chunk [Bap.Std.Image.Scheme] |
symbol_chunk addr size root a contiguous piece of a program
symbol, that can be a function or some data.
|
| symbols [Graphlib.Std.Graphlib] |
lower case symbols, starting from 'a' and moving up to 'z'.
|
| symbols [Bap.Std.Project] |
symbols t returns reconstructed symbol table
|
| symbols [Bap.Std.Image] |
symbols image returns a mapping from addresses to symbols
|
| symbols_of_segment [Bap.Std.Image] |
symbols_of_segment img seg all symbols that belong to the
seg segment.
|
| symtab [Bap.Std.Project.Info] |
occurs everytime a symbol table is changed
|
| synthetic [Bap.Std.Term] |
a term was introduced artificially by an analysis.
|
| syscall [Bap_traces.Std.Event] |
a system call has occured
|
| system [Bap_config] |
|
T |
| t [Bap_c_term_attributes] |
A c type associated with a term.
|
| t2 [Bap.Std.Self.Config] |
|
| t3 [Bap.Std.Self.Config] |
t3 sep c0 c1 c2 splits the argument at the first two sep
characters (defaults to ',' ) and respectively converts the
substrings with c0 , c1 and c2 .
|
| t4 [Bap.Std.Self.Config] |
t4 sep c0 c1 c2 c3 splits the argument at the first three sep
characters (defaults to ',' ) respectively converts the substrings
with c0 , c1 , c2 and c3 .
|
| t_of_sexp [Bap_c_data] |
|
| t_of_sexp [Bap_c_type.Array] |
|
| t_of_sexp [Bap_c_type.Compound] |
|
| t_of_sexp [Bap_c_type.Proto] |
|
| t_of_sexp [Bap_c_type.Spec] |
|
| t_of_sexp [Bap_c_type.Attr] |
|
| t_of_sexp [Bap_c_type.Qualifier] |
|
| t_of_sexp [Bap_c_type] |
|
| t_of_sexp [X86_asm_reg_types] |
|
| tag_memory [Bap.Std.Project] |
tag_memory project region tag value tags a given region of
memory in project with a given tag and value .
|
| tagname [Bap.Std.Value] |
tagname value returns a constructor name of the value
|
| taint_finalize [Bap_taint.Std.Taint.Gc] |
taint_finalize (t,live) occurs either when the taint t
is no longer reachable or when when machine that created this
taint finishes.
|
| take [Bap_future.Std.Stream] |
take xs n returns a future that will evaluate to n values
of the stream xs that has occurred after the future was
created.
|
| target [Bap.Std.Call] |
returns the target of the call
|
| target_of_arch [Bap.Std] |
target_of_arch arch returns a module packed into value, that
abstracts target architecture.
|
| terminator [Bap.Std.Block] |
terminator blk last instruction of the block
|
| ternary [Monads.Std.Monad.S2.Lift] |
|
| ternary [Monads.Std.Monad.S.Lift] |
|
| tid [Bap_primus.Std.Primus.Pos] |
tid p is term identifier of the term enclosing position p
|
| tid [Bap.Std.Term] |
tid entity returns a unique identifier of the entity
|
| tid [Bap.Std.Graphs.Ir.Edge] |
tid e returns a tid of a jmp term that is associated
with an edge e
|
| times [Bap.Std.Bil] |
|
| timestamp [Bap_traces.Std.Event] |
this event can used to synchronize traces
|
| tl [Bap_future.Std.Stream] |
tl s ignores the next occurrence in the stream s
|
| tmp [Arm_utils] |
|
| to_addr_size [Bap.Std.Size] |
|
| to_bigstring [Regular.Std.Data.Write] |
to_bigstring writeable value serializes the value into
bigstring data type.
|
| to_bigstring [Regular.Std.Data.S] |
of_bigstring ?ver ?fmt datum serializes a datum to a sequence of
bytes represented as bigstring
|
| to_buffer [Bap.Std.Memory] |
to_buffers mem creates a buffer representing the memory mem .
|
| to_bytes [Regular.Std.Data.Write] |
to_bytes writeable value serializes the value into
bytes data type.
|
| to_bytes [Regular.Std.Data.S] |
to_bytes ?ver ?fmt datum serializes a datum to a sequence of
bytes.
|
| to_cfg [Bap.Std.Sub] |
to_cfg sub builds a graph representation of a subroutine
sub .
|
| to_channel [Regular.Std.Data.Write] |
to_channel writeable out value writes the writable
value into the channel chan
|
| to_dot [Graphlib.Std.Graphlib] |
to_dot (module G) ~filename:"graph.dot" g dumps graph g
using dot format.
|
| to_equiv [Graphlib.Std.Group] |
to_equiv g returns the ordinal number representing the
particular group g
|
| to_file [Ogre.Doc] |
to_file doc name stores a document to a file with the given name.
|
| to_float [Bap.Std.Fmm] |
to_float x maps floating point operans to the OCaml float type
|
| to_formatter [Regular.Std.Data.Write] |
to_formatter writeable ppf value outputs the value
into the formatter ppf
|
| to_graph [Bap.Std.Sub] |
to_graph sub builds a graph of subroutine sub .
|
| to_graph [Bap.Std.Program] |
to_graph program creates a callgraph of a program
|
| to_int [Bap_dwarf.Std.Leb128] |
|
| to_int [Graphlib.Std.Equiv] |
|
| to_int [Bap.Std.Imm] |
to_int x projects immediates to the OCaml int type.
|
| to_int [Bap.Std.Bitvector] |
to_int x projects x in to OCaml int .
|
| to_int32 [Bap_dwarf.Std.Leb128] |
|
| to_int32 [Bap.Std.Bitvector] |
to_int32 x projects x in to int32
|
| to_int32_exn [Bap.Std.Bitvector] |
to_int32_exn x projects x in to int32
|
| to_int64 [Bap_dwarf.Std.Leb128] |
|
| to_int64 [Bap.Std.Imm] |
to_int64 x maps immediates to the OCaml int64 type
|
| to_int64 [Bap.Std.Bitvector] |
to_int64 x projects x in to int64
|
| to_int64_exn [Bap.Std.Bitvector] |
to_int64_exn x projects x in to int64
|
| to_int_exn [Bap.Std.Bitvector] |
to_int_exn x projects x in to OCaml int .
|
| to_list [Bap_traces.Std.Traces] |
to_list () returns a list of currently loaded traces.
|
| to_sequence [Graphlib.Std.Frontier] |
to_sequence frontier enumerates all elements of a frontier
|
| to_sequence [Graphlib.Std.Tree] |
to_sequence tree enumerates nodes of a tree in an
unspecified order.
|
| to_sequence [Bap.Std.Term] |
to_sequence ?rev t p is a synonym for enum .
|
| to_sequence [Bap.Std.Symtab] |
to_sequence symtab returns a sequence of functions
|
| to_sequence [Bap.Std.Memmap] |
to_sequence map converts the memmap 'a t to a sequence of
key-value pairs
|
| to_sequence [Bap.Std.Table] |
to_sequence ~start ~until table converts the table to a
sequence of key-value pairs.
|
| to_sequence [Bap.Std.Dict] |
to_sequence dict is a sequence of all tid value
entries
|
| to_sequence [Bap.Std.Interval_tree.S] |
to_sequence t returns all bindings in t
|
| to_string [Bap_primus.Std.Primus.Exn] |
returns a textual representation of an error
|
| to_string [Bap_primus.Std.Primus.Pos] |
to_string level a textual and human readable
representation of a cursor.
|
| to_string [Ogre.Doc] |
to_string doc returns a textual representation of a document
|
| to_string [Regular.Std.Bytes.Unsafe] |
to_string b - unsafely converts a byte sequence into a string.
|
| to_string [Regular.Std.Bytes] |
to_string t returns a new string that contains the same
bytes as the given byte sequence.
|
| to_string [Regular.Std.Printable.S] |
to_string x returns a human-readable representation of x
|
| to_value [Bap_primus.Std.Primus.Value.Make.Symbol] |
to_value sym returns a value corresponding to the
provided symbolic representation.
|
| to_value [Bap_taint.Std.Value] |
|
| to_word [Bap_primus.Std.Primus.Value.Make] |
to_word x projects x to a machine word .
|
| to_word [Bap_primus.Std.Primus.Value] |
to_word x projects x to a machine word
|
| to_word [Bap.Std.Imm] |
to_word ~width x projects x to a word.
|
| token_hash [Bap.Std.Trie.Key] |
hash_token tok efficient hash function for the token type.
|
| tool [Bap_traces.Std.Trace] |
tool trace returns a descriptor of a tool that was used to
create the trace .
|
| top [Graphlib.Std.Group] |
top group returns the top element of a group also known as a
representative element.
|
| trace_stats [Bap_traces.Std.Meta] |
generic information about the trace.
|
| tracer [Bap_traces.Std.Meta] |
description of a tracer that was used to create the trace
|
| train [Bap_byteweight.S] |
train decider ~max_length test corpus train the decider on
the specified corpus .
|
| trd [Monads.Std.Monad.S2.Triple] |
|
| trd [Monads.Std.Monad.S.Triple] |
|
| triggers [Bap_primus.Std.Primus.Observation.Provider] |
triggers a stream of occurences of this observation
|
| trim [Regular.Std.Bytes] |
trim t returns a copy of t , without leading and trailing
whitespace.
|
| trivial [Graphlib.Std.Partition] |
trivial s creates the trivial partition with a single
equivalence class containing every member of s
|
| tuple [Bap_primus.Std.Primus.Lisp.Type.Spec] |
tuple [args] specifies that a function accepts
a tuple of arguments of specified types.
|
| typ [Bap.Std.Var] |
typ var returns a type assosiated with variable
|
| typeid [Bap.Std.Value.Tag] |
typeid t returns a type identifier of a type tag t .
|
| typeid [Bap.Std.Value] |
typeid value returns a type identifier of the value
|
U |
| uint16 [Bap.Std.Memory.Input] |
uint16 an unsigned 16-bit word reader
|
| uint8 [Bap.Std.Memory.Input] |
uint8 an unsigned byte reader
|
| unary [Monads.Std.Monad.S2.Lift] |
|
| unary [Monads.Std.Monad.S.Lift] |
|
| uncapitalize [Regular.Std.Bytes] |
uncapitalize t returns a copy of t , with the first byte set
to lowercase.
|
| undefined [Bap_primus.Std.Primus.Interpreter] |
undefined x happens when a computation produces an
undefined value x .
|
| undefined [Bap.Std.Bil.Result] |
undefined id creates a result with the given id and
undefined value
|
| unfold [Bap_primus.Std.Primus.Generator] |
unfold ~min ~max ~seed ~f creates a generator that
generates values by applying a function f to a pair of
a generator state and previous value.
|
| unfold [Bap_future.Std.Stream] |
unfold ~init ~f a more general than from way of building a
stream, that allows to pass state between consecutive
invocations of the generator function.
|
| unfold' [Bap_future.Std.Stream] |
unfold' ~init ~f is a batched version of the unfold
function.
|
| unfold_until [Bap_future.Std.Stream] |
unfold_until ~init ~f returns (stream,signal,future) is the
same as unfold , except that function f is called until it
returns a None value.
|
| union [Graphlib.Std.Graphlib] |
union (module G) g1 g2 returns a graph g that is a union
of graphs g1 and g2 , i.e., contains all nodes and edges
from this graphs.
|
| union [Graphlib.Std.Partition] |
union p x y returns the partition p with the classes of x
and y merged.
|
| union [Bap.Std.Rooter] |
union r1 r2 joins roots from rooters r1 and r2
|
| unit [Bap_primus.Std.Primus.Lisp.Type.Spec] |
unit specifies that a function doesn't have any parameters
|
| unknown [Bap.Std.Bil] |
unknown msg typ -> Unknown(msg,typ)
|
| unless [Monads.Std.Monad.Choice.S2] |
unless cond x computes x unless cond is true .
|
| unless [Monads.Std.Monad.Choice.S] |
unless cond x computes x unless cond is true .
|
| unlink [Bap_primus.Std.Primus.Linker.Make] |
unlink name removes code linked with the provided name .
|
| unop [Bap_primus.Std.Primus.Interpreter.Make] |
unop op x computes an unary operation op on x
|
| unop [Bap_primus.Std.Primus.Interpreter] |
unop ((op,x),r) happens after the unary operation op is
applied to x and results r
|
| unop [Bap.Std.Bil.Apply] |
unop op x applies the unary operation op to x .
|
| unop [Bap.Std.Bil] |
|
| unresolved [Bap_primus.Std.Primus.Linker] |
occurs when an unresolved name is called, just before the
unresolved trap is signaled.
|
| unresolved_handler [Bap_primus.Std.Primus.Linker] |
unresolved_handler is called instead of an unbound name.
|
| unsafe_blit [Regular.Std.Bytes.To_string] |
|
| unsigned [Bap.Std.Bil] |
|
| unsigned [Bap.Std.Bitvector] |
unsigned t casts t to an unsigned type, so that any
operations applied to it will interpret t as an unsigned
word.
|
| unsigned_of_sexp [Bap_c_type] |
|
| unsubscribe [Bap_future.Std.Stream] |
unsubscribe s id stop calling a function that was has a
provided identifier id
|
| unzip [Bap_future.Std.Stream] |
unzip xs creates a pair of streams, where the first stream contains
fst x for each x in xs and the second stream contains snd x for
each x in xs .
|
| update [Bap_primus.Std.Primus.Machine.State] |
update state ~f updates a state using function f .
|
| update [Graphlib.Std.Edge] |
update e l g if edge e exists in graph g then return a
new graph g' in which edge e is associated with label l .
|
| update [Graphlib.Std.Node] |
update n l g if node n is not in N(g) then return g ,
else return graph g where node n is labeled with l .
|
| update [Monads.Std.Monad.State.S2] |
update f updates the current state with the function f
|
| update [Monads.Std.Monad.State.S] |
update f updates the current state with the function f
|
| update [Bap_bundle.Std.Bundle] |
update bundle ~f:action add, remove or update data in the
bundle.
|
| update [Bap.Std.Phi] |
update phi label exp associates expression exp with a
control flow path labeled with label .
|
| update [Bap.Std.Term] |
update t p c if term p contains a term with id equal to
tid c then return p with this term substituted with p
|
| update_manifest [Bap_bundle.Std.Bundle] |
update_manifest bundle ~f update program manifest with
function f .
|
| upon [Bap_future.Std.Stream] |
upon e xs returns a future that will be fulfilled with a
last value of a stream xs before an event e has
occurred.
|
| upon [Bap_future.Std.Future] |
upon f action will call action as soon a future f occurs.
|
| upper [Bap.Std.Interval_tree.Interval] |
the upper bound of an interval
|
| uppercase [Regular.Std.Bytes] |
uppercase t returns a copy of t , with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
| uses_var [Bap.Std.Blk] |
uses_var blk x true if variable x is in free_vars blk .
|
V |
| validate_negative [Bap.Std.Bitvector] |
validate_negative validates that a value is negative.
|
| validate_non_negative [Bap.Std.Bitvector] |
validate_non_negative validates that a value is non negative.
|
| validate_non_positive [Bap.Std.Bitvector] |
validate_non_positive validates that a value is not positive.
|
| validate_positive [Bap.Std.Bitvector] |
validate_positive validates that a value is positive.
|
| value [Bap_primus.Std.Primus.Iterator.Base] |
|
| value [Bap.Std.Bil.Result] |
|
| value_of_sexp [Bap_c_data] |
|
| values [Bap.Std.Phi] |
values phi enumerate all possible values.
|
| var [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| var [Bap.Std.Bil] |
|
| vars_of_mode [X86_env] |
vars_of_mode mode creates registers for a mode
|
| version [Regular.Std.Data.S] |
Data representation version.
|
| version [Regular.Std.Data.Versioned.S] |
version of data representation
|
| version [Bap_config] |
|
| version [Bap.Std.Self.Config] |
|
| version [Bap.Std.Self] |
|
| vf [Arm_env] |
|
| vf [Bap.Std.CPU] |
|
| view [Graphlib.Std.Graphlib] |
view (module G) ~node ~edge ~node_label ~edge_label
creates a proxy module, that will transform back and
forward elements of graph, using corresponding functions.
|
| view [Bap.Std.Memory] |
view word_size ~from ~words mem returns a new memory
that represents the specified region of memory mem .
|
| visited [Bap.Std.Term] |
to mark a term as visited by some algorithm
|
| void [Monads.Std.Monad.S2] |
void m computes m and discrards the result.
|
| void [Monads.Std.Monad.S] |
void m computes m and discrards the result.
|
W |
| wait [Bap_future.Std.Stream] |
wait xs a polite way to notify a producer to slow down.
|
| walk [Bap.Std.Trie.S] |
walk trie key ~init ~f walks down the tree starting from the
root and ending with the last token of the key.
|
| warn_on_error [Bap_traces.Std.Trace.Monitor] |
|
| warn_unused [Bap.Std.Arg] |
a caller of the subroutine must use an argument tagged with
this attribute.
|
| warning [Bap.Std.Self] |
warning fmt ... send a warning message
|
| warning_formatter [Bap.Std.Self] |
formatter that sends warning messages
|
| watch [Bap_primus.Std.Primus.Machine.S.Observation] |
|
| watch [Bap_future.Std.Stream] |
watch s f watches a stream s with a function f .
|
| weight [Graphlib.Std.Path] |
weight p total weight of a path
|
| weight [Bap.Std] |
|
| when_decided [Bap_strings_detector] |
|
| when_ready [Bap.Std.Self.Config] |
when_ready f requests the system to call function f once
configuration parameters are established and stabilized.
|
| while_ [Bap.Std.Bil] |
while_ cond stmts -> While (cond,stmts)
|
| width [X86_asm_reg] |
width reg_type returns the size of the given reg_type
|
| with_attrs [Bap.Std.Term] |
with_attrs term attributes returns a term with a new set of attributes
|
| with_cond [Bap.Std.Jmp] |
updated jump's guard condition
|
| with_disasm [Bap.Std.Disasm_expert.Basic] |
with_disasm ?debug_level ?cpu ~backend ~f target creates a
disassembler passing all options to create function and
applies function f to it.
|
| with_file [Bap_ida.Std.Ida] |
with_file target analysis creates ida instance on target ,
perform analysis and close ida
|
| with_index [Bap.Std.Var] |
with_index v i returns a variable, that is identical to
v , but with the index i
|
| with_intent [Bap.Std.Arg] |
with_intent intent arg updates argument intent
|
| with_kind [Bap.Std.Jmp] |
|
| with_lhs [Bap.Std.Phi] |
with_lhs phi var updates a left hand side of phi with
var
|
| with_lhs [Bap.Std.Def] |
updates the lhs of definition
|
| with_memory [Bap.Std.Project] |
with_memory project updates project memory.
|
| with_mode [Text_tags] |
with_mode ppf mode f installs mode , calls f , and then
reinstalls the previous mode.
|
| with_name [Bap.Std.Sub] |
|
| with_noreturn [Bap.Std.Call] |
marks call as a "noreturn"
|
| with_off [Bap_dwarf.Std.Dwarf.Buffer] |
with_off buf off creates a new buffer that shares data with
buf , but has different starting position equal to pos buf + off
|
| with_pos [Bap_dwarf.Std.Dwarf.Buffer] |
with_pos buf pos creates a new buffer that shares data with
buf , but has different starting position
|
| with_preds [Bap.Std.Disasm_expert.Basic] |
updates the set of predicates, that rules the stop condition.
|
| with_printer [Regular.Std.Data.S] |
with_printer ?ver name operation temporary sets a default
printer to a printer with a specified name and version.
|
| with_program [Bap.Std.Project] |
with_program project program updates a project program
|
| with_reader [Regular.Std.Data.S] |
with_reader ?ver name operation temporary sets a default
reader to a reader with a specified name and version.
|
| with_return [Bap.Std.Call] |
updates return continuation
|
| with_rhs [Bap.Std.Def] |
updates the right hand side of a definition
|
| with_storage [Bap.Std.Project] |
updates the attribute storage
|
| with_symbols [Bap.Std.Project] |
with_symbols project symbols updates project symbols
|
| with_target [Bap.Std.Call] |
|
| with_unknown_intent [Bap.Std.Arg] |
removes the intent from an argument
|
| with_writer [Regular.Std.Data.S] |
with_writer ?ver name operation temporary sets a default
writer to a writer with a specified name and version.
|
| word [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| word [Bap.Std.Memory.Input] |
word ~word_size a reader that reads words of word_size
|
| word [Bap.Std.Bil.Result] |
word w id creates a result with the given id and
word w as a value
|
| word_of_addr_size [Bap.Std.Size] |
|
| words [Bap.Std.Image] |
words image size returns a mapping from addresses to words
of the specified size .
|
| writable [Bap.Std.Image.Scheme] |
|
| write [Bap_dwarf.Std.Leb128] |
|
| write [Monads.Std.Monad.Writer.S] |
write s add s to the current state
|
| write [Regular.Std.Data.S.Io] |
write ?ver ?fmt file datum writes the datum to the file
|
| writing [Bap_primus.Std.Primus.Interpreter] |
writing v happens before a value is written to the variable v
|
| written [Bap_primus.Std.Primus.Interpreter] |
written (v,x) happens after x is assinged to v
|
| wrong_cast [Bap.Std.Type.Error] |
wrong_cast () raises T bad_cast
|
Y |
| ymms [X86_cpu.IA32] |
YMM registers that are available
|
| ymms [X86_env.ModeVars] |
|
Z |
| zero [Arm_utils] |
|
| zero [Bap_primus.Std.Primus.Value.Make] |
zero x same as of_word @@ zero x
|
| zero [Monads.Std.Monad.Choice.Basic2] |
zero () creates a computation that has no result.
|
| zero [Monads.Std.Monad.Choice.Basic] |
zero () creates a computation that has no result.
|
| zero [Monads.Std.Monad.Plus.S2] |
zero () constructs a zero element
|
| zero [Monads.Std.Monad.Plus.S] |
zero () constructs a zero element
|
| zero [Monads.Std.Monoid.Base] |
zero an element that is neutral to plus
|
| zero [Bap.Std.Bil.Result.Id] |
|
| zero [Bap.Std.Bitvector] |
zero width zero with a specified width , is a shortcut for
of_int 0 ~width
|
| zero [Bap.Std.Integer.Base] |
element neutral to the addition
|
| zf [X86_env] |
|
| zf [Arm_env] |
|
| zf [Bap.Std.CPU] |
|
| zip [Bap_future.Std.Stream] |
zip xs ys creates a steam that will produce an element (x,y)
every time both xs and ys produce elements x and y respectively
|


This is a demo of a custom component that uses Ng2-Completer directives to create a material2 autocomplete component.
To use this compnent copy all completer-cmp-md files from the demo code
Local data of countries - using image, matchClass and maxLength
Selected country: {{countryName}}


Download Hanuman Chalisa audio.
Download bhajans of Lord Hanuman. This section contains a collection of songs and bhajans on Lord Hanuman.
Download Lord Hanuman wallpapers.
More Content Coming Soon...


Gen 5
Calibration
Target Seconds
00:00
Minutes Before Target:
0
Second Hit
Start
Update
Gen 4
Calibrated Delay
Calibrated Seconds
Target Delay
Target Seconds
00:00
00:00
Minutes Before Target:
0
Delay Hit
Start
Update
Options
Play a
tick
beep
pop
ding
sound
times at an interval of
milliseconds as the timer expires


Get Set Go!
Launch Anecdotes!
Here we go.. my long awaited DNS finally got engaged with an IP.
What’s this?
Umm.. Anecdotes :)
How it happened?
Well, I was sitting idle from past few days and surfing through web in search of some interesting tasks. Suddenly, a thought crossed my mind that I purchased a domain few months back. Why not build it, and this is how it happened.
Well, this is for now. I had some wonderful time creating this site, and learnt about few new things. I’ll share them in my next post.
Till then bbye :)
Twitter
Google+
Facebook
LinkedIn
Email


Everything went from bad to worse, money never changed a thing,
Death kept following, tracking us down, at least I heard your bluebird sing.
Now somebody's got to show their hand, time is an enemy.
I know you're long gone, I guess it must be up to me.
If I'd'a thought about it, I never woulda done it, I guess I woulda let it slide,
If I'd'a paid attention to what others were thinking, the heart inside me woulda died,
But I was just too stubborn to ever be governed by enforced insanity.
Someone had to reach for the rising star, I guess it was up to me.
Now, the Union Central is pulling out, the orchids are in bloom,
I've only got me one good shirt left and it smells of stale perfume.
In fourteen months I've only smiled once and I didn't do it consciously.
Somebody's got to find your trail, I guess it's gonna be up to me.
It was like a revelation when you betrayed me with your touch,
I'd just about convinced myself nothing had changed that much.
The old Rounder in the iron mask, he slipped me the master key.
Somebody had to unlock your heart, he said it was up to me.
Now, I watched you slowly disappear down into the officers' club,
I woulda followed you in the door, but I didn't have a ticket stub,
So I waited all night till the break of day, hoping one of us could get free.
Oh, when the dawn came over the river bridge, I knew it was up to me.
The only decent thing I did when I worked as a postal clerk
Was to haul your picture down off the wall near the cage where I used to work.
Was I a fool or not to protect your real identity?
You looked a little burned out, my friend, I thought it might be up to me.
I met somebody face-to-face, I had to remove my hat,
She's everything I need and love, but I can't be swayed by that.
It frightens me, the awful truth of how sweet life can be,
But she ain't gonna make a move, I guess it must be up to me.
Now, we heard the Sermon on the Mount and I knew it was too complex,
It didn't amount to anything more than what the broken glass reflects.
When you bite off more than you can chew, you got to pay the penalty.
Somebody's got to tell the tale, I guess it must be up to me.
Dupree came in pimping tonight to the Thunderbird Café,
Crystal wanted to talk to him, I had to look the other way.
Now I just can't rest without you, love, I need your company.
You ain't gonna cross the line, I guess it must be up to me.
There's a note left in the bottle, you can give it to Estelle.
She's the one you been wondering about, but there's a-really nothing much to tell.
We both heard voices for a while, now the rest is a-history.
Somebody's got to cry some tears, I guess it must be up to me.

One of us has got to hit the road, I guess it must be up to me.

No one else could play that tune, you knew it was up to me.


Inner Spec page
Specs ares generated directly from file system, to create new Spec page like this one, just copy starting template and put it at any new folder in Source.
Warning text, for important messages, like:
Highly recommended to read this document in HTML source.
Spec section heading
Here you can leave some useful notes for interface examples listed in this section in .source_example
blocks.
We have some special decorations for highlighting
some special text, like .class names.
Examples
Rendered code examples - main documentation blocks.
Engine decorative styles aren't affecting this block. Link your Project files and start prototyping.
This page has Twitter Botstrap styles linked through project.css
Hey!Show source code
.css_source {
maket-it: awesome;
}
Place for HTML code examples.
If <code class="brush : html"> is not set, it will be created
and filled automatically from "source_example".
Click "Show source" in inner navigation menu to show examples source code.
Project CSS linking
The most useful thing for spec (source documentation item) pages is ability to add your site styles directly to documentation page.
<link href="/data/docs/project.css" rel="stylesheet">
<link href="css/spec.css" rel="stylesheet">
Spec page markup
Documentation text
Documentation text in sections is marked up by simple HTML, using tags: p, ul, li, h1, h2, h3, h4
. Only those tags are decorated and have style reset from project CSS.
In nearest updates we will add Markdown support for easy text formatting inside documentation sections.
Head
After implementing Node.js, all common HTML markup parts will be included on the server.
Starting template will always be available for fast new spec page creation, just copy it to another folder.
Metas
To add some machine readable information for plugins like Global Navigation and Search we use metas:
<meta name="keywords" content="create spec, spec markup">
<meta name="author" content="Robert Haritonov">
Also, using meta information we're separating page roles like navigation:
<meta name="source-page-role" content="navigation">


First name
Last name
Position
Office
Start date
Salary
First name
Last name
Position
Office
Start date
Salary