Author(s): Daniel Cabeza and the CLIP Group.
Version: 1.10#7 (2006/4/26, 19:22:13 CEST)
Version of last change: 1.7#129 (2001/10/28, 15:38:52 CET)
ciaosh
is the Ciao interactive top-level shell. It provides the user with an interactive programming environment with tools for incrementally building programs, debugging programs by following their executions, and modifying parts of programs without having to start again from scratch. If available, it is strongly recommended to use it with the
emacs interface provided, as it greatly simplifies the operation. This chapter documents general operation in the shell itself. Other chapters document the
When invoked, the shell responds with a message of identification and the prompt ?-
as soon as it is ready to accept input, thus:
Ciao-Prolog X.Y #PP: Thu Mar 25 17:20:55 MET 1999 ?-
When the shell is initialized it looks for a file
.ciaorc
in the HOME directory and makes an include
of it, if it exists. This file is useful for including
use_module/1
declarations for the modules one wants to be loaded by default, changing
prolog flags, etc. (Note that the
.ciaorc
file can only contain directives, not actual code; to load some code at startup put it in a separate file and load it using e.g. a
use_module/1
declaration.) If the initialization file does not exist, the default package
default
is included, to provide more or less what other prologs define by default. Thus, if you want to have available all builtins you had before adding the initialization file, you have to include :- use_package(default)
in it. Two command-line options control the loading of the initialization file:
-f
-l
File
File
instead of ~/.ciaorc
. If it does not exist, include the default package.
After the shell outputs the prompt, it is expecting either an internal command (see the following sections) or a query (a goal or sequence of goals). When typing in the input, which must be a valid prolog term, if the term does not end in the first line, subsequent lines are indented. For example:
?- X = f(a, b). X = f(a,b) ? yes ?-
The queries are executed by the shell as if they appeared in the
user module. Thus, in addition to builtin predicates, predicates available to be executed directly are all predicates defined by loaded user files (files with no module declaration), and imported predicates from modules by the use of use_module
.
The possible answers of the shell, after executing an internal command or query, are:
no
.
yes
. This behavior can be changed by doing set_prolog_flag(prompt_alternatives_no_bindings, on).
, so that in any case the user will be consulted as explained in the next point (useful if the solutions produce side effects).
?
as a prompt. At this point it is expecting an input line from the user. By entering a carriage-return (RET) or any line starting with y
, the query terminates and the shell answer yes
. Entering a `,
' the shell enters a
recursive level (see below). Finally, any other answer forces the system to backtrack and look for the next solution (answering as with the first solution).
To allow using connection variables in queries without having to report their results, variables whose name starts with _
are not considered in answers, the rest being the
answer variables. This example illustrates the previous points:
?- member(a, [b, c]). no ?- member(a, [a, b]). yes ?- member(X, [a|L]). X = a ? ; L = [X|_] ? yes ?- atom_codes(ciao, _C), member(L, _C). L = 99 ? ; L = 105 ? ; L = 97 ? ; L = 111 ? ; no ?-
As stated before, when the user answers with `,
' after a solution is presented, the shell enters a
recursive level, changing its prompt to N ?-
(where N is the recursion level) and keeping the bindings or constraints of the solution (this is inspired by the
LogIn language developed by
H. Ait-Kaci,
P. Lincoln and
Roger Nasr [AKNL86]). Thus, the following queries will be executed within that context, and all variables in the lower level solutions will be reported in subsequent solutions at this level. To exit a recursive level, input an EOF character or the command up
. The last solution after entering the level is repeated, to allow asking for more solutions. Use command top
to exit all recursive levels and return to the top level. Example interaction:
?- directory_files('.',_Fs), member(F,_Fs). F = 'file_utils.po' ? , 1 ?- file_property(F, mod_time(T)). F = 'file_utils.po', T = 923497679 ? yes 1 ?- up. F = 'file_utils.po' ? ; F = 'file_utils.pl' ? ; F = 'file_utils.itf' ? , 1 ?- file_property(F, mod_time(T)). F = 'file_utils.itf', T = 923497679 ? yes 1 ?- ^D F = 'file_utils.itf' ? yes ?-
ciaosh
)ciaosh
)
Usage: use_module(Module)
Module
, importing all the predicates it exports.
Module
is a source name.
(streams_basic:sourcename/1
)
Usage: use_module(Module, Imports)
Module
, importing the predicates in Imports
.
Module
is a source name.
(streams_basic:sourcename/1
)
Imports
is a list of predname
s.
(basic_props:list/2
)
Usage: ensure_loaded(File)
File
, which is user (i.e. non-module) code.
File
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
Usage: make_exec(File, ExecName)
File
, giving it name ExecName
. If ExecName
is a variable, the compiler will choose a default name for the executable and will bind the variable ExecName
to that name. The name is chosen as follows: if the main prolog file has no .pl
extension or we are in Windows, the executable will have extension .cpx
; else the executable will be named as the main prolog file without extension.
File
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
ExecName
is an atom.
(basic_props:atm/1
)
Usage: include(File)
File
are included in the top-level shell. For the moment, it only works with some directives, which are interpreted by the shell, or with normal clauses (which are asserted), if library(dynamic) is loaded beforehand.
File
is a source name.
(streams_basic:sourcename/1
)
Usage: use_package(Package)
Package
)) for each listed file. By now some package contents cannot be handled.
Package
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
Usage: consult(File)
ensure_loaded/1
, but ensuring each listed file is loaded in consult mode (see section The interactive debugger).
File
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
Usage: compile(File)
ensure_loaded/1
, but ensuring each listed file is loaded in compile mode (see section The interactive debugger).
File
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
Usage: .(File, Files)
Usage: make_po(Files)
.po
) files from Files
. Equivalent to executing "ciaoc -c
" on the files.
Files
is a source name or a list of source names.
(ciaosh_doc:sourcenames/1
)
Usage: unload(File)
File
.
File
is a source name.
(streams_basic:sourcename/1
)
Usage: set_debug_mode(File)
File
to consult. See section The interactive debugger.
File
is a source name.
(streams_basic:sourcename/1
)
Usage: set_nodebug_mode(File)
File
to compile. See section The interactive debugger.
File
is a source name.
(streams_basic:sourcename/1
)
Usage: make_actmod(ModuleFile, PublishMod)
ModuleFile
, using address publish module of name PublishMod
(which needs to be in the library paths).
ModuleFile
is a source name.
(streams_basic:sourcename/1
)
PublishMod
is an atom.
(basic_props:atm/1
)
Usage: force_lazy(Module)
Module
to be loaded lazily in the subsequent created executables.
Module
is an atom.
(basic_props:atm/1
)
Usage: undo_force_lazy(Module)
Usage: dynamic_search_path(Name)
Usage: multifile Pred
Pred
as multifile. This is useful at the top-level shell to be able to call multifile predicates of loaded files.
Pred
is a Name/Arity structure denoting a predicate name:
predname(P/A) :- atm(P), nnegint(A).(
basic_props:predname/1
)
ciaosh
)Is defined as follows:
sourcenames(File) :- sourcename(File). sourcenames(Files) :- list(Files,sourcename).
See
sourcename/1
in section Basic file/stream handling
Usage: sourcenames(Files)
Files
is a source name or a list of source names.
Go to the first, previous, next, last section, table of contents.