Saved-states are just a special case of QOF files. The
save_program/[1,2] predicate will save the entire Prolog database into
a QOF file, and then in addition will make that QOF file executable.
Under UNIX, the
QOF file is made executable by making the first line of the file be a
sh(1) script. This script runs the executable that the QOF file was saved
from, telling it to load the QOF file.
So, if a saved-state is created as follows:
| ?- save_program(savedstate).
then if we look at the first line of the file we will see something like the
following. Note that
+L is a Prolog command line option to load a QOF
$0 will be the name of the QOF file and
$* will be any other
arguments given when it is run).
% head -1 savedstate exec /usr/local/quintus/bin3.5/sun4-5/prolog +L $0 $*
This QOF file can then be run from the command line as follows:
In addition to the user's code from the Prolog database, a saved-state
save_program/[1,2] also contains Prolog system
information such as flag settings, debugging information and so forth.
When the saved-state is loaded this system state is also restored,
which is convenient for continued development.
Apart from being made executable, and containing additional Prolog
system information, a saved-state saved through
save_program/[1,2] is just a standard QOF file. This means that
it can be used anywhere you would otherwise use a QOF file, for such
things as loading into Prolog, linking together with other QOF files,
and linking into executables (see sap-srs for information
on these linking capabilities).
A saved-state, or any QOF file, can be restored using the
predicate from within Prolog:
| ?- restore(savedstate).
restore/1 predicate will re-execute the running
executable (using the
execv(3) system call) in order to obtain
a completely new environment, and will then load the QOF file. If the QOF
file was saved with
save_program/[1,2] then this will restore exactly
the same Prolog database state as when the saved-state was saved.
In runtime systems, however, it is the application program's responsibility
to load the file into the restarted executable,
see mpg-ref-restore and sap-srs-sqf.
Note that the executable that will be re-executed by
restore/1 is the
one currently running. This may be different from the one named in the
first line in the QOF file, if that QOF file was saved from some different
executable. To use the executable that originally saved the QOF file you
should return to the command interpreter and run the QOF file directly.
To use the executable you are currently running, you should use
If the loaded QOF file has object file dependencies then those object files will be re-linked and re-loaded as part of loading the QOF file. If the object file cannot be found or linked, then an exception will be raised. Similarly, QOF dependencies are also reloaded at this point.
Under Windows, it is not possible to replace a running executable with another. Under Windows,
restore/1will instead start a new sub-process and then terminate the running process. For more details see the Microsoft documentation for
In a Windows command prompt window, the command interpreter does not wait when a process executes an
execv()library call. Thus after
restore/1, the program gives the appearance of running in the background.
Please note: The QOF file saved by
save_program/2does not contain any of the Prolog code that is statically linked into the executable. Only the Prolog database (both compiled and dynamic) that has been built since the executable started running is saved. This is done to avoid code duplication in the saved-state. However, this does mean that if the QOF-file is loaded into a different executable, then the program may be missing some code that it assumes should be there, because it was present in the original executable. An example would be a saved-state that was saved from an executable containing Quintus' ProWINDOWS add-on product. If that saved-state is loaded into a normal Prolog executable without ProWINDOWS then any calls to ProWINDOWS will not work (they will generate undefined predicate exceptions). The correct thing to do is clearly to make sure that you use either the original executable, or an executable that contains the necessary programs, or you load the necessary programs in addition to loading the saved-state QOF file.
save_program/2 predicate can be used to specify an initial goal
that will be run when the saved-state is re-loaded. This usage of
save_program/2 replaces the most common uses of the old
predicates that are no longer available. For example:
| ?- save_program(saved_state,initial_goal([a,b,c])).
saved_state is loaded
initial_goal/1 will be called. This allows
saved-states to be generated that will immediately start running the user's
program when they are executed. In addition to this
facility there is also a comprehensive facility for programs to set up
initializations to be run when they are loaded or otherwise started. This
is described below in ref-sls-igs.