Predicates controlling the interactive debugger

Author(s): A. Ciepielewski, M. Carlsson, T. Chikayama, K. Shen, D. Cabeza, M. Rodriguez.

Version: 1.5#118 (2000/4/19, 18:13:43 CEST)

Version of last change: 1.5#107 (2000/4/5, 9:55:16 CEST)

This library implements predicates which are normally used in the interactive top-level shell to debug programs. A subset of them are available in the embeddable debugger.

• Usage and interface (debugger)
• Documentation on exports (debugger)
• Documentation on internals (debugger)

Usage and interface (debugger)

Documentation on exports (debugger)

PREDICATE: debug_module/1:

Usage: debug_module(Module)

• Description: The debugger will take into acount module Module (assuming it is loaded in interpreted mode). When issuing this command at the toplevel shell, the compiler is instructed also to set to interpret the loading mode of files defining that module and also to mark it as 'modified' so that (re)loading this file or a main file that uses this module will force it to be reloaded for source-level debugging.
• The following properties should hold at call time: Module is an atom. (basic_props:atm/1)

PREDICATE: nodebug_module/1:

Usage: nodebug_module(Module)

• Description: The debugger will not take into acount module Module. When issuing this command at the toplevel shell, the compiler is instructed also to set to compile the loading mode of files defining that module.
• The following properties should hold at call time: Module is an atom. (basic_props:atm/1)

PREDICATE: debug_module_source/1:

Usage: debug_module_source(Module)

• Description: The debugger will take into acount module Module (assuming it is is loaded in source-level debug mode). When issuing this command at the toplevel shell, the compiler is instructed also to set to interpret the loading mode of files defining that module and also to mark it as 'modified' so that (re)loading this file or a main file that uses this module will force it to be reloaded for source-level debugging.
• The following properties should hold at call time: Module is an atom. (basic_props:atm/1)

PREDICATE: debug/0:

Usage:

• Description: Switches the debugger on. The interpreter will stop at all ports of procedure boxes of spied predicates.

PREDICATE: nodebug/0:

Usage:

• Description: Switches the debugger off. If there are any spy-points set then they will be kept but disabled.

PREDICATE: trace/0:

Usage:

• Description: Start tracing, switching the debugger on if needed. The interpreter will stop at all leashed ports of procedure boxes of predicates either belonging to debugged modules or called from clauses of debugged modules. A message is printed at each stop point, expecting input from the user (write h to see the available options).

PREDICATE: notrace/0:

Usage:

• Description: Equivalent to nodebug/0.

PREDICATE: spy/1:

Usage: spy(PredSpec)

• Description: Set spy-points on predicates belonging to debugged modules and which match PredSpec, switching the debugger on if needed. This predicate is defined as a prefix operator by the toplevel.
• The following properties should hold at call time: PredSpec is a sequence of multpredspecs. (basic_props:sequence/2)

PREDICATE: nospy/1:

Usage: nospy(PredSpec)

• Description: Remove spy-points on predicates belonging to debugged modules which match PredSpec. This predicate is defined as a prefix operator by the toplevel.
• The following properties should hold at call time: PredSpec is a sequence of multpredspecs. (basic_props:sequence/2)

PREDICATE: nospyall/0:

Usage:

• Description: Remove all spy-points.

PREDICATE: breakpt/6:

Usage: breakpt(Pred,Src,Ln0,Ln1,Number,RealLine)

• Description: Set a breakpoint in file Src between lines Ln0 and Ln1 at the literal corresponding to the Number'th occurence of (predicate) name Pred. The complication comes from the fact that the reader only gives the start and end line numbers for the predicate. The rest of the arguments provide enough information to be able to locate the exact predicate that the RealLine line refers to. This is normally not issued by users but rather by the emacs mode, which automatically computes the different argument after selecting a point in the source file.
• The following properties should hold at call time: Pred is an atom. (basic_props:atm/1) Src is a source name. (streams_basic:sourcename/1) Ln0 is an integer. (basic_props:int/1) Ln1 is an integer. (basic_props:int/1) Number is an integer. (basic_props:int/1) RealLine is an integer. (basic_props:int/1)

PREDICATE: nobreakpt/6:

Usage: nobreakpt(Pred,Src,Ln0,Ln1,Number,RealLine)

• Description: Remove a breakpoint in file Src between lines Ln0 and Ln1 at the Number'th occurence of (predicate) name Pred (see breakpt/6). Also normally used from de emacs mode.
• The following properties should hold at call time: Pred is an atom. (basic_props:atm/1) Src is a source name. (streams_basic:sourcename/1) Ln0 is an integer. (basic_props:int/1) Ln1 is an integer. (basic_props:int/1) Number is an integer. (basic_props:int/1) RealLine is an integer. (basic_props:int/1)

PREDICATE: nobreakall/0:

Usage:

• Description: Remove all breakpoints.

PREDICATE: list_breakpt/0:

Usage:

• Description: Prints out the location of all breakpoints. The location of the breakpoints is showed usual by referring to the source file, the lines between which the predicate can be found, the predicate name and the number of ocurrence of the predicate name of the literal.

PREDICATE: debugging/0:

Usage:

• Description: Display debugger state.

PREDICATE: leash/1:

Usage: leash(Ports)

• Description: Leash on ports Ports, some of call, exit, redo, fail. By default, all ports are on leash.
• The following properties should hold at call time: Ports is a list of ports. (basic_props:list/2)

PREDICATE: maxdepth/1:

Usage: maxdepth(MaxDepth)

• Description: Set maximum invocation depth in debugging to MaxDepth. Calls to compiled predicates are not included in the computation of the depth.
• The following properties should hold at call time: MaxDepth is an integer. (basic_props:int/1)

PREDICATE: call_in_module/2:

Usage: call_in_module(Module,Predicate)

• Description: Calls predicate Predicate belonging to module Module, even if that module does not export the predicate. This only works for modules which are in debug (interpreted) mode (i.e., they are not optimized).
• The following properties should hold at call time: Module is an atom. (basic_props:atm/1) Predicate is a term which represents a goal, i.e., an atom or a structure. (basic_props:callable/1)

Documentation on internals (debugger)

PROPERTY: multpredspec/1:

A property, defined as follows:

multpredspec(Mod:Spec) :-
        atm(Mod),
        multpredspec(Spec).
multpredspec(Name/Low-High) :-
        atm(Name),
        int(Low),
        int(High).
multpredspec(Name/(Low-High)) :-
        atm(Name),
        int(Low),
        int(High).
multpredspec(Name/Arity) :-
        atm(Name),
        int(Arity).
multpredspec(Name) :-
        atm(Name).

Go to the first, previous, next, last section, table of contents.