When Common Prolog execution enters a debugging command loop, the user has many options, which may be listed with ?, for example:
|==> (spy member)
|
|((MEMBER 2))
|YES.
|OK.
|
|==> (member 3 ?x)
|
|[1] CALL: (MEMBER 3 ?0)? ? <- user types ?
|
|(c)reep - turn on exhaustive tracing
|(s)kip - skip until another port is
| reached for this goal
|(l)eap - turn off tracing until a spy
| point or this goal is reached
|(b)reak - enter a recursive
| read/query/print loop
|(d)isplay - display a listing for the
| current goal
|(q)uit - quit to top level
|(r)etry - try to satisfy this goal again
|(f)ail - cause the current goal to fail
|(a)bort - exit Common Prolog
|? - display this information
|
|?
|
|In a little more detail...
|
|creep - causes exhaustive tracing of the
| next goal
|skip - ignores spy points and executes
| without displaying anything until
| this goal is reached again
| either at an exit, fail,
| or redo port
|leap - turns off exhaustive tracing until
| a spy point or this goal is
| reached
|break - enters a recursive interpreter loop
| so that the user may query
| values, redefine a predicate, etc.
|display - uses "listing" to display the
| listing of the current goal
|quit - returns to the top level interpreter
| loop
|retry - causes execution to return to the
| call port of this goal as if
| this goal had just been reached for
| the first time.
|fail - causes execution to jump to the fail
| port of this goal
|abort - completely exit Common Prolog
|d <- user selects display
|
|Compiled procedure:
|
|(DEFREL MEMBER
| ((MEMBER ?X (?X . ?)))
| ((MEMBER ?X (? . ?Y)) (MEMBER ?X ?Y))) ? c
| ...user selects creep
|[1] EXIT: (MEMBER 3 (3 . ?0))? r
| ...user selects retry
|
|[1] CALL: (MEMBER 3 ?0)? f <-user selects fail
|
|[1] FAIL: (MEMBER 3 ?0)? r <- one more time
|
|[1] CALL: (MEMBER 3 ?0)? s <- skip
|
|[1] EXIT: (MEMBER 3 (3 . ?0))? l <- leap
|?X = (3 . ?0); <- more solutions
|
|[1] REDO: (MEMBER 3 (3 . ?0))? c <- creep
|
|[2] CALL: (MEMBER 3 ?0)? b <- break
|
|
|==> (nospy)
|
|NIL <- current spylist
|YES.
|OK.
|
|==> (halt) <- return to original execution
|? l <- leap
|
|?X = (?0 3 . ?1)<cr>
|
|OK.
|==> (defrel reverse
| ((reverse () ()))
| ((reverse (?x . ?y) ?z)
| (reverse ?y ?w)
| (append ?w (?x) ?z)))
|<noise..>
|
|?X = ?0
|?Y = ?1
|?Z = ?2
|?W = ?3
|
|OK.
|==> (defrel append
| ((append () ?x ?x))
| ((append (?u . ?x) ?y (?u . ?z))
| (append ?x ?y ?z)))
|<noise..>
|?X = ?0
|?U = ?1
|?Y = ?2
|?Z = ?3
|
|OK.
|==> (unleash)
|
|YES.
|OK.
|
|==> (trace)
|
|YES.
|OK.
|==> (reverse (1 2 3) ?x)
|
|[1] CALL: (REVERSE (1 2 3) ?0)
|[2] CALL: (REVERSE (2 3) ?0)
|[3] CALL: (REVERSE (3) ?0)
|[4] CALL: (REVERSE NIL ?0)
|[4] EXIT: (REVERSE NIL NIL)
|[5] CALL: (APPEND NIL (3) ?0)
|[5] EXIT: (APPEND NIL (3) (3))
|[3] EXIT: (REVERSE (3) (3))
|[6] CALL: (APPEND (3) (2) ?0)
|[7] CALL: (APPEND NIL (2) ?0)
|[7] EXIT: (APPEND NIL (2) (2))
|[6] EXIT: (APPEND (3) (2) (3 2))
|[2] EXIT: (REVERSE (2 3) (3 2))
|[8] CALL: (APPEND (3 2) (1) ?0)
|[9] CALL: (APPEND (2) (1) ?0)
|[10] CALL: (APPEND NIL (1) ?0)
|[10] EXIT: (APPEND NIL (1) (1))
|[9] EXIT: (APPEND (2) (1) (2 1))
|[8] EXIT: (APPEND (3 2) (1) (3 2 1))
|[1] EXIT: (REVERSE (1 2 3) (3 2 1))
|?X = (3 2 1);
|[1] REDO: (REVERSE (1 2 3) (3 2 1))
|[8] REDO: (APPEND (3 2) (1) (3 2 1))
|[9] REDO: (APPEND (2) (1) (2 1))
|[10] REDO: (APPEND NIL (1) (1))
|[10] FAIL: (APPEND NIL (1) ?0)
|[9] FAIL: (APPEND (2) (1) ?0)
|[8] FAIL: (APPEND (3 2) (1) ?0)
|[2] REDO: (REVERSE (2 3) (3 2))
|[6] REDO: (APPEND (3) (2) (3 2))
|[7] REDO: (APPEND NIL (2) (2))
|[7] FAIL: (APPEND NIL (2) ?0)
|[6] FAIL: (APPEND (3) (2) ?0)
|[3] REDO: (REVERSE (3) (3))
|[5] REDO: (APPEND NIL (3) (3))
|[5] FAIL: (APPEND NIL (3) ?0)
|[4] REDO: (REVERSE NIL NIL)
|[4] FAIL: (REVERSE NIL ?0)
|[3] FAIL: (REVERSE (3) ?0)
|[2] FAIL: (REVERSE (2 3) ?0)
|[1] FAIL: (REVERSE (1 2 3) ?0)
|NO.
KnowledgeWorks and Prolog User Guide (Unix version) - 26 Feb 2015