215 lines
6.1 KiB
TeX
215 lines
6.1 KiB
TeX
@c -*- mode: texinfo; coding: utf-8; -*-
|
|
|
|
@node Run, Syntax, Install, Top
|
|
@chapter Running YAP
|
|
|
|
@menu
|
|
* Running YAP Interactively:: Interacting with YAP
|
|
* Running Prolog Files:: Running Prolog files as scripts
|
|
@end menu
|
|
|
|
@cindex booting
|
|
We next describe how to invoke YAP in Unix systems.
|
|
|
|
@node Running YAP Interactively, ,Running Prolog Files,Run
|
|
@section Running YAP Interactively
|
|
|
|
Most often you will want to use YAP in interactive mode. Assuming that
|
|
YAP is in the user's search path, the top-level can be invoked under
|
|
Unix with the following command:
|
|
|
|
@example
|
|
yap [-s n] [-h n] [-a n] [-c IP_HOST port ] [filename]
|
|
@end example
|
|
|
|
@noindent
|
|
All the arguments and flags are optional and have the following meaning:
|
|
@table @code
|
|
@item -?
|
|
print a short error message.
|
|
@item -s@var{Size}
|
|
allocate @var{Size} KBytes for local and global stacks. The user may
|
|
specify @t{M} bytes.
|
|
@item -h@var{Size}
|
|
allocate @var{Size} KBytes for heap and auxiliary stacks
|
|
@item -t@var{Size}
|
|
allocate @var{Size} KBytes for the trail stack
|
|
@item -L@var{Size}
|
|
SWI-compatible option to allocate @var{Size} K bytes for local and global stacks, the local stack
|
|
cannot be expanded. To avoid confusion with the load option, @var{Size}
|
|
must immediately follow the letter @code{L}.
|
|
@item -G@var{Size}
|
|
SWI-compatible option to allocate @var{Size} K bytes for local and global stacks; the global
|
|
stack cannot be expanded
|
|
@item -T@var{Size}
|
|
SWI-compatible option to allocate @var{Size} K bytes for the trail stack; the trail cannot be expanded.
|
|
@item -l @var{YAP_FILE}
|
|
compile the Prolog file @var{YAP_FILE} before entering the top-level.
|
|
@item -L @var{YAP_FILE}
|
|
compile the Prolog file @var{YAP_FILE} and then halt. This option is
|
|
useful for implementing scripts.
|
|
@item -g @var{Goal}
|
|
run the goal @var{Goal} before top-level. The goal is converted from
|
|
an atom to a Prolog term.
|
|
@item -z @var{Goal}
|
|
run the goal @var{Goal} as top-level. The goal is converted from
|
|
an atom to a Prolog term.
|
|
@item -b @var{BOOT_FILE}
|
|
boot code is in Prolog file @var{BOOT_FILE}. The filename must define
|
|
the predicate @code{'$live'/0}.
|
|
@item -c @t{IP_HOST} @t{port}
|
|
connect standard streams to host @t{IP_HOST} at port @t{port}
|
|
@item filename
|
|
restore state saved in the given file
|
|
@item -f
|
|
do not consult initial files
|
|
@item -q
|
|
do not print informational messages
|
|
@item --
|
|
separator for arguments to Prolog code. These arguments are visible
|
|
through the @code{unix/1} built-in predicate.
|
|
@end table
|
|
|
|
Note that YAP will output an error message on the following conditions:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
a file name was given but the file does not exist or is not a saved
|
|
YAP state;
|
|
@item
|
|
the necessary amount of memory could not be allocated;
|
|
@item
|
|
the allocated memory is not enough to restore the state.
|
|
@end itemize
|
|
|
|
When restoring a saved state, YAP will allocate the
|
|
same amount of memory as that in use when the state was saved, unless a
|
|
different amount is specified by flags in the command line. By default,
|
|
YAP restores the file @file{startup.yss} from the current directory or from
|
|
the YAP library.
|
|
@cindex environment variables
|
|
|
|
@findex YAPBINDIR
|
|
@itemize @bullet
|
|
@item
|
|
YAP usually boots from a saved state. The saved state will use the default
|
|
installation directory to search for the YAP binary unless you define
|
|
the environment variable YAPBINDIR.
|
|
|
|
@findex YAPLIBDIR
|
|
@item
|
|
YAP always tries to find saved states from the current directory
|
|
first. If it cannot it will use the environment variable YAPLIBDIR, if
|
|
defined, or search the default library directory.
|
|
|
|
@findex YAPSHAREDIR
|
|
@item
|
|
YAP will try to find library files from the YAPSHAREDIR/library
|
|
directory.
|
|
@end itemize
|
|
|
|
@node Running Prolog Files, Running YAP Interactively, , Run
|
|
@section Running Prolog Files
|
|
|
|
YAP can also be used to run Prolog files as scripts, at least in
|
|
Unix-like environments. A simple example is shown next (do not forget
|
|
that the shell comments are very important):
|
|
|
|
@example
|
|
@cartouche
|
|
#!/usr/local/bin/yap -L --
|
|
#
|
|
# Hello World script file using YAP
|
|
#
|
|
# put a dot because of syntax errors .
|
|
|
|
:- write('Hello World'), nl.
|
|
|
|
@end cartouche
|
|
@end example
|
|
|
|
The @code{#!} characters specify that the script should call the binary
|
|
file YAP. Notice that many systems will require the complete path to the
|
|
YAP binary. The @code{-L} flag indicates that YAP should consult the
|
|
current file when booting and then halt. The remaining arguments are
|
|
then passed to YAP. Note that YAP will skip the first lines if they
|
|
start with @code{#} (the comment sign for Unix's shell). YAP will
|
|
consult the file and execute any commands.
|
|
|
|
A slightly more sophisticated example is:
|
|
|
|
@example
|
|
@cartouche
|
|
#!/usr/bin/yap -L --
|
|
#
|
|
# Hello World script file using YAP
|
|
# .
|
|
|
|
:- initialization(main).
|
|
|
|
main :- write('Hello World'), nl.
|
|
|
|
@end cartouche
|
|
@end example
|
|
|
|
The @code{initialization} directive tells YAP to execute the goal main
|
|
after consulting the file. Source code is thus compiled and @code{main}
|
|
executed at the end. The @code{.} is useful while debugging the script
|
|
as a Prolog program: it guarantees that the syntax error will not
|
|
propagate to the Prolog code.
|
|
|
|
Notice that the @code{--} is required so that the shell passes the extra
|
|
arguments to YAP. As an example, consider the following script
|
|
@code{dump_args}:
|
|
|
|
@example
|
|
@cartouche
|
|
#!/usr/bin/yap -L --
|
|
#.
|
|
|
|
main( [] ).
|
|
main( [H|T] ) :-
|
|
write( H ), nl,
|
|
main( T ).
|
|
|
|
:- unix( argv(AllArgs) ), main( AllArgs ).
|
|
|
|
@end cartouche
|
|
@end example
|
|
|
|
If you this run this script with the arguments:
|
|
@example
|
|
./dump_args -s 10000
|
|
@end example
|
|
@noindent
|
|
the script will start an YAP process with stack size @code{10MB}, and
|
|
the list of arguments to the process will be empty.
|
|
|
|
Often one wants to run the script as any other program, and for this it
|
|
is convenient to ignore arguments to YAP. This is possible by using
|
|
@code{L --} as in the next version of @code{dump_args}:
|
|
|
|
@example
|
|
@cartouche
|
|
#!/usr/bin/yap -L --
|
|
|
|
main( [] ).
|
|
main( [H|T] ) :-
|
|
write( H ), nl,
|
|
main( T ).
|
|
|
|
:- unix( argv(AllArgs) ), main( AllArgs ).
|
|
|
|
@end cartouche
|
|
@end example
|
|
|
|
The @code{--} indicates the next arguments are not for YAP. Instead,
|
|
they must be sent directly to the @code{argv} built-in. Hence, running
|
|
@example
|
|
./dump_args test
|
|
@end example
|
|
@noindent
|
|
will write @code{test} on the standard output.
|
|
|
|
|