Switch debugging mode on/off. If debug mode is activated the system
traps encountered spy points (see spy/1)
and trace points (see trace/1).
In addition, last-call optimisation is disabled and the system is more
conservative in destroying choice points to simplify debugging.
Disabling these optimisations can cause the system to run out of
memory on programs that behave correctly if debug mode is off.
Fixed to swi. The code below is a reliable and portable way
to detect SWI-Prolog.
is_dialect(swi) :-
catch(current_prolog_flag(dialect, swi), _, fail).
When true (default false), enforce mitigation
against the
Spectre
timing-based security vulnerability. Spectre based attacks can extract
information from memory owned by the process that should remain
invisible, such as passwords or the private key of a web server. The
attacks work by causing speculative access to sensitive data, and
leaking the data via side-channels such as differences in the duration
of successive instructions. An example of a potentially vulnerable
application is SWISH.
SWISH allows users to run Prolog code while the swish server must
protect the privacy of other users as well as its HTTPS private keys,
cookies and passwords.
Currently, enabling this flag reduces the resolution of get_time/1
and
statistics/2
CPU time to 20.
WARNING: Although a coarser timer makes a successful attack of
this type harder, it does not reliably prevent such attacks in general.
Full mitigation may require compiler support to disable speculative
access to sensitive data.
If true, compile in optimised mode. The initial value is
true if Prolog was started with the -O
command line option. The optimise
flag is scoped to a source file.
Currently optimised compilation implies compilation of arithmetic,
and deletion of redundant true/0
that may result from expand_goal/2.
Later versions might imply various other optimisations such as
integrating small predicates into their callers, eliminating constant
expressions and other predictable constructs. Source code optimisation
is never applied to predicates that are declared dynamic (see
dynamic/1).
Only provided if the system is compiled with unbounded and rational
arithmetic support (see bounded).
If true, prefer arithmetic to produce rational numbers over
floats. This implies:
- Division (//2) of
two integers produces a rational number.
- Power (^/2) of two
integers produces a rational number, also if the second operant
is a negative number. For example,
2^(-2) evaluates to
1/4.
Using true can create excessively large rational
numbers. The Prolog flag max_rational_size
can be used to detect and act on this tripwire.
If false, rational numbers can only be created using the
functions rational/1, rationalize/1
and
rdiv/2 or by reading
them. See also
rational_syntax, section
2.16.1.6 and
section 4.26.2.2.
The current default is false. We consider changing this
to
true in the future. Users are strongly encouraged to set
this flag to true and report issues this may cause.
Determines the read and write syntax for rational numbers. Possible
values are natural (e.g., 1/3) or compatibility
(e.g., 1r3). The compatibility syntax is
always accepted. This flag is module sensitive.
The default for this flag is currently compatibility,
which reads and writes rational numbers as e.g., 1R3.21There
is still some discussion on the separating character. See section
2.16.1.6. We will consider natural as a
default in the future. Users are strongly encouraged to set this flag to
natural and report issues this may cause.
If backtracking (default), the toplevel backtracks after
completing a query. If recursive, the toplevel is
implemented as a recursive loop. This implies that global variables set
using
b_setval/2
are maintained between queries. In recursive mode, answers to
toplevel variables (see section
2.9) are kept in backtrackable global variables and thus not
copied. In
backtracking mode answers to toplevel variables are kept in the
recorded database (see section
4.13.2).
The recursive mode has been added for interactive usage of CHR (see
section 9),22Suggested
by Falco Nogatz which maintains the global constraint store
in backtrackable global variables.
If true (default false) show the internal
sharing of subterms in the answer substitution. The example below
reveals internal sharing of leaf nodes in red-black trees as
implemented by the
library(rbtrees) predicate rb_new/1 :
?- set_prolog_flag(toplevel_print_factorized, true).
?- rb_new(X).
X = t(_S1, _S1), % where
_S1 = black('', _G387, _G388, '').
If this flag is false, the % where notation
is still used to indicate cycles as illustrated below. This example also
shows that the implementation reveals the internal cycle length, and not
the minimal cycle length. Cycles of different length are
indistinguishable in Prolog (as illustrated by S == R).
?- S = s(S), R = s(s(R)), S == R.
S = s(S),
R = s(s(R)).
If true (default false), garbage collections
and stack-shifts will be reported on the terminal. May be changed.
Values are reported in bytes as G+T, where G
is the global stack value and T the trail stack value.‘Gained'
describes the number of bytes reclaimed.‘used' the number of bytes
on the stack after GC and‘free' the number of bytes allocated, but
not in use. Below is an example output.
% GC: gained 236,416+163,424 in 0.00 sec;
used 13,448+5,808; free 72,568+47,440
0 
