[ Predicate Database and Compiler | Reference Manual | Alphabetic Index ]

get_flag(++PredSpec, ?Flag, -Value)

Succeeds if the flag Flag of the procedure specified by PredSpec has the value Value.
Expression of the form Atom/Integer.
Atom or variable.
Atom, integer, compound_term or variable.


Used to get the value Value of the flag Flag of the procedure specified by PredSpec. The values of certain flags may be set using set_flag/3. It can also be used to test if a procedure with a given functor exists or has certain properties.

The possible flags, their values and their meanings are:

    Flags              Values           Description
    auxiliary          on,off           predicate is a compiler auxiliary

    break_lines        list of          list of predicate source File:Line
                       atom:integer     that currently have breakpoints set

    call_type          prolog,          predicate calling external convention

    code_size          an integer       size of abstract machine
                                        code in words (32/64 bits)

    debugged           on, off          compiled in debugging mode

    declared           on, off          predicate was declared

    defined            on, off          predicate code exists

    definition_module  an atom          where the procedure is defined

    demon              on, off          predicate is a demon

    deprecated         on, off          predicate is deprecated,
                                        warning on use

    leash              stop,print,      see below

    meta_predicate     pred(Prop1,...)  the meta-arguments of the predicate
                                        (from a meta_predicate/1 declaration)

    mode               pred(Mode1,...)  the mode of the predicate (from a
                                        mode/1 or meta_predicate/1 declaration)

    parallel           on, off          clauses may be executed in parallel

    port_calls         list of          list of DefModule:Name/Arity for
                       atom:atom/int    the predicate's body goals where 
                                        breakpoints can be added. The 
                                        port_lines option returns the source
                                        information for these ports, in the 
                                        same order

    port_lines         list of          list of predicate source File:Line
                       atom:integer     where breakpoints can be added. The
                                        port_calls option returns the goal
                                        information for these ports, in the 
                                        same order 

    priority           1..12            waking priority

    run_priority       1..12            execution priority when woken

    skip               on, off          procedure will be traced,
                                        but its children will not

    spy                on, off          procedure has a spypoint

    stability          static,dynamic   is the procedure dynamic?

    tool               on, off          tool property

    type               built-in,user    type of predicate

    visibility         local,exported   module scope

    source_file        an atom          the file where defined

    source_line        an integer       starting line number in the file

    source_offset      an integer       byte offset at which the procedure
                                        definition starts in its source file
The possible values of leash and their meanings are:

   | Values   Description                               |
   |--------------------------------------------------  |
   | stop     procedure ports are printed and the       |
   |          debugger stops on them                    |
   | print    procedure ports are printed and the       |
   |          debugger does not stop on them            |
   | notrace  procedure ports will not be shown, but    |
   |          its childrens's ports will                |

Modes and Determinism


This predicate is sensitive to its module context (tool predicate, see @/2).

Fail Conditions

Fails if the flag Flag of the procedure specified by PredSpec does not have the value Value, if its value is unknown or if the procedure does not exist


(4) instantiation fault
PredSpec is not instantiated
(5) type error
PredSpec is not an expression of the form Atom/Integer.
(5) type error
Flag is instantiated but not to an atom.
(5) type error
Value is not an atom.


    [eclipse]: get_flag(member/2, F, V),
            printf("%-20s%w\n", [F, V]), fail.

    mode                member(?, ?)
    visibility          imported
    definition_module   sepia_kernel
    declared            on
    defined             on
    autoload            off
    auxiliary           off
    call_type           prolog
    demon               off
    deprecated          off
    parallel            off
    priority            2
    run_priority        2
    stability           static
    tool                off
    type                built_in
    debugged            off
    leash               stop
    skip                off
    spy                 off
    start_tracing       off
    source_file         Kernel/lib/kernel.pl
    code_size           14

    get_flag(true/0, defined, off).
    get_flag(undef/0, F, V).
    get_flag(X, spy, on).           (Error 4).
    get_flag("a", spy, on).         (Error 5).

See Also

pred / 1, set_flag / 3, current_module_predicate / 2