The interactive top-level shell

Shell invocation and startup

When invoked, the shell responds with a message of identification and the prompt ?- as soon as it is ready to accept input.

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

Fast start, do not load any initialization file.

-q

Quiet, do not show banner.

-i

Force interactive even if stdin is not a pseudo-terminal.

-l File

Look for initialization file File instead of ~/.ciaorc. If it does not exist, include the default package.

-u File

Use module File on startup.

-p Prompt

Set Prompt as prompt.

-e Query

Call Query on startup.

Shell interaction

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:

• If the execution failed (or produced an error), the answer is no.

• If the execution was successful and bindings where made (or constraints where imposed) on answer variables, then the shell outputs the values of answer variables, as a sequence of bindings (or constraints), and then prints a ? 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).

• If the execution was successful, but no answer variable was bound or constrained, the answer is simply yes. This behavior can be changed by setting the prolog flag prompt_alternatives_no_bindings to on, so that if there are more solutions the user will be consulted as explained in the previous point (useful if the solutions produce side effects).

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
?-

Entering recursive (conjunctive) shell levels

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 = 'stream_utils.po' ? ,

1 ?- file_property(F, mod_time(T)).

F = 'stream_utils.po',
T = 923497679 ? 

yes
1 ?- up.

F = 'stream_utils.po' ? ;

F = 'stream_utils.pl' ? ;

F = 'stream_utils.itf' ? ,

1 ?- file_property(F, mod_time(T)).

F = 'stream_utils.itf',
T = 923497679 ? 

yes
1 ?- ^D
F = 'stream_utils.itf' ? 

yes
?-

Usage and interface

Documentation on exports

Documentation on internals

sourcenames(File) :-
    sourcename(File).
sourcenames(Files) :-
    list(sourcename,Files).

Documentation on imports

• System library modules:
  toplevel, libpaths, compiler, exemaker, c_itf, debugger.
• Packages:
  prelude, initial, condcomp, assertions, assertions/assertions_basic.