Module Procdesc.Node

node of the control flow graph

type t

type of nodes

val compare : t -> t -> int
type id = private int

node id

val compare_id : id -> id -> int
val equal_id : id -> id -> bool
type destruction_kind =
| DestrBreakStmt
| DestrContinueStmt
| DestrFields
| DestrReturnStmt
| DestrScope
| DestrTemporariesCleanup
| DestrVirtualBase
type stmt_nodekind =
| AssertionFailure
| BetweenJoinAndExit
| BinaryConditionalStmtInit
| BinaryOperatorStmt of string
| Call of string
| CallObjCNew
| CaseStmt
| ClassCastException
| CompoundStmt
| ConditionalStmtBranch
| ConstructorInit
| CXXDynamicCast
| CXXNewExpr
| CXXStdInitializerListExpr
| CXXTemporaryMarkerSet
| CXXTry
| CXXTypeidExpr
| DeclStmt
| DefineBody
| Destruction of destruction_kind
| ExceptionHandler
| ExceptionsSink
| ExprWithCleanups
| FinallyBranch
| GCCAsmStmt
| GenericSelectionExpr
| IfStmtBranch
| InitializeDynamicArrayLength
| InitListExp
| LoopBody
| MessageCall of string
| MethodBody
| MonitorEnter
| MonitorExit
| ObjCCPPThrow
| ObjCIndirectCopyRestoreExpr
| OutOfBound
| ReturnStmt
| Scope of string
| Skip of string
| SwitchStmt
| ThisNotNull
| Throw
| ThrowNPE
| UnaryOperator

kind of statement node

type prune_node_kind =
| PruneNodeKind_ExceptionHandler
| PruneNodeKind_FalseBranch
| PruneNodeKind_InBound
| PruneNodeKind_IsInstance
| PruneNodeKind_MethodBody
| PruneNodeKind_NotNull
| PruneNodeKind_TrueBranch
type nodekind =
| Start_node
| Exit_node
| Stmt_node of stmt_nodekind
| Join_node
| Prune_node of bool * Sil.if_kind * prune_node_kind

(true/false branch, if_kind, comment)

| Skip_node of string

kind of cfg node

val compare_nodekind : nodekind -> nodekind -> int
val equal_nodekind : nodekind -> nodekind -> bool
val exn_handler_kind : nodekind

kind of Stmt_node for an exception handler.

val exn_sink_kind : nodekind

kind of Stmt_node for an exceptions sink.

val throw_kind : nodekind

kind of Stmt_node for a throw instruction.

val append_instrs : t -> Sil.instr list -> unit

Append the instructions to the list of instructions to execute

val d_instrs : highlight:Sil.instr option -> t -> unit

Dump instructions for the node, highlighting the given subinstruction if present

val dummy : Procname.t -> t

Create a dummy node

val equal : t -> t -> bool

Check if two nodes are equal

val get_description : IStdlib.Pp.env -> t -> string

Return a description of the node

val get_distance_to_exit : t -> int option

Get the distance to the exit node, if it has been computed

val get_exn : t -> t list

Get the exception nodes from the current node

val get_id : t -> id

Get the unique id of the node

val get_instrs : t -> Instrs.not_reversed_t

Get the instructions to be executed

val get_kind : t -> nodekind

Get the kind of the current node

val get_last_loc : t -> IBase.Location.t

Get the source location of the last instruction in the node

val find_in_node_or_preds : t -> f:(t -> Sil.instr -> 'a option) -> 'a option

Find in the given node or its predecessors

val get_loc : t -> IBase.Location.t

Get the source location of the node

val get_preds : t -> t list

Get the predecessor nodes of the current node

val get_siblings : t -> t IStdlib.IStd.Sequence.t

Get siblings of the current node

val get_proc_name : t -> Procname.t

Get the name of the procedure the node belongs to

val get_succs : t -> t list

Get the successor nodes of the current node

val get_wto_index : t -> int
val set_code_block_exit : t -> code_block_exit:t -> unit

Set an exit node corresponding to a start node of a code block. Using this, when there is a code block, frontend can keep the correspondence between start/exit nodes of a code block.

val get_code_block_exit : t -> t option

Get an exit node corresponding to a start node of a code block.

val is_dangling : t -> bool

Returns true if the node is dangling, i.e. no successors and predecessors

val hash : t -> int

Hash function for nodes

val pp : Stdlib.Format.formatter -> t -> unit

Pretty print the node

val pp_id : Stdlib.Format.formatter -> id -> unit

Pretty print a node id

val pp_stmt : Stdlib.Format.formatter -> stmt_nodekind -> unit
val compute_key : t -> NodeKey.t