dead_code_scanner — Logtalk APIs v3.47.0 documentation

object

# `dead_code_scanner`

A tool for detecting likely dead code in compiled Logtalk entities and Prolog modules compiled as objects.

Author: Barry Evans and Paulo Moura
Version: 0:11:0
Date: 2017-08-10
Compilation flags:
`static, context_switching_calls`
Uses:
list
logtalk
os
Remarks:

> - Dead code: A predicate or non-terminal that is not called (directly or indirectly) by any scoped predicate or non-terminal. These predicates and non-terminals are not used, cannot be called without breaking encapsulation, and are thus considered dead code.

> - Known issues: Use of local meta-calls with goal arguments only know at runtime can result in false positives. Calls from non-standard meta-predicates may be missed if the meta-calls are not optimized.

> - Requirements: Source files must be compiled with the `source_data` flag turned on. To avoid false positives do to meta-calls, compilation of source files with the `optimized` flag turned on is also advised.

Inherited public predicates:
(none)

- Public predicates

  - `entity/1`

  - `file/1`

  - `directory/1`

  - `rdirectory/1`

  - `library/1`

  - `rlibrary/1`

  - `all/0`

  - `predicates/2`

  - `predicate/2`

- Protected predicates

- Private predicates

- Operators

## Public predicates

### `entity/1`

Scans a loaded entity for dead code. Fails if the entity does not exist.

Compilation flags:
`static`
Template:
`entity(Entity)`
Mode and number of proofs:
`entity(+entity_identifier)` - `zero_or_one`

### `file/1`

Scans all entities in a loaded source file for dead code. The file can be given by name, basename, full path, or using library notation. Fails if the file is not loaded.

Compilation flags:
`static`
Template:
`file(File)`
Mode and number of proofs:
`file(+atom)` - `zero_or_one`

### `directory/1`

Scans all entities in all loaded files from a given directory for dead code.

Compilation flags:
`static`
Template:
`directory(Directory)`
Mode and number of proofs:
`directory(+atom)` - `one`

### `rdirectory/1`

Scans all entities in all loaded files from a given directory and its sub-directories for dead code.

Compilation flags:
`static`
Template:
`rdirectory(Directory)`
Mode and number of proofs:
`rdirectory(+atom)` - `one`

### `library/1`

Scans all entities in all loaded files from a given library for dead code.

Compilation flags:
`static`
Template:
`library(Library)`
Mode and number of proofs:
`library(+atom)` - `one`

### `rlibrary/1`

Scans all entities in all loaded files in a loaded library and its sub-libraries for dead code.

Compilation flags:
`static`
Template:
`rlibrary(Library)`
Mode and number of proofs:
`rlibrary(+atom)` - `one`

### `all/0`

Scans all entities for dead code.

Compilation flags:
`static`
Mode and number of proofs:
`all` - `one`

### `predicates/2`

Returns an ordered set of local predicates (and non-terminals) that are not used, directly or indirectly, by scoped predicates for a loaded entity.

Compilation flags:
`static`
Template:
`predicates(Entity,Predicates)`
Mode and number of proofs:
`predicates(+entity_identifier,-list(predicate_indicator))` - `one`

### `predicate/2`

Enumerates, by backtracking, local predicates (and non-terminals) that are not used, directly or indirectly, by scoped predicates for a loaded entity.

Compilation flags:
`static`
Template:
`predicate(Entity,Predicate)`
Mode and number of proofs:
`predicate(+entity_identifier,?predicate_indicator)` - `zero_or_more`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)