kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/boot/toplevel.pl

@@ -0,0 +1,2248 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  1985-2026, University of Amsterdam
+                              VU University Amsterdam
+                              SWI-Prolog Solutions b.v.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module('$toplevel',
+          [ '$initialise'/0,            % start Prolog
+            '$toplevel'/0,              % Prolog top-level (re-entrant)
+            '$compile'/0,               % `-c' toplevel
+            '$config'/0,                % --dump-runtime-variables toplevel
+            initialize/0,               % Run program initialization
+            version/0,                  % Write initial banner
+            version/1,                  % Add message to the banner
+            prolog/0,                   % user toplevel predicate
+            '$query_loop'/0,            % toplevel predicate
+            '$execute_query'/3,         % +Query, +Bindings, -Truth
+            residual_goals/1,           % +Callable
+            (initialization)/1,         % initialization goal (directive)
+            '$thread_init'/0,           % initialise thread
+            (thread_initialization)/1   % thread initialization goal
+            ]).
+
+
+                 /*******************************
+                 *         VERSION BANNER       *
+                 *******************************/
+
+:- dynamic prolog:version_msg/1.
+:- multifile prolog:version_msg/1.
+
+%!  version is det.
+%
+%   Print the Prolog banner message and messages registered using
+%   version/1.
+
+version :-
+    print_message(banner, welcome).
+
+%!  version(+Message) is det.
+%
+%   Add message to version/0
+
+:- multifile
+    system:term_expansion/2.
+
+system:term_expansion((:- version(Message)),
+                      prolog:version_msg(Message)).
+
+version(Message) :-
+    (   prolog:version_msg(Message)
+    ->  true
+    ;   assertz(prolog:version_msg(Message))
+    ).
+
+
+                /********************************
+                *         INITIALISATION        *
+                *********************************/
+
+%!  load_init_file(+ScriptMode) is det.
+%
+%   Load the user customization file. This can  be done using ``swipl -f
+%   file`` or simply using ``swipl``. In the   first  case we search the
+%   file both directly and over  the   alias  `user_app_config`.  In the
+%   latter case we only use the alias.
+
+load_init_file(_) :-
+    '$cmd_option_val'(init_file, OsFile),
+    !,
+    prolog_to_os_filename(File, OsFile),
+    load_init_file(File, explicit).
+load_init_file(prolog) :-
+    !,
+    load_init_file('init.pl', implicit).
+load_init_file(none) :-
+    !,
+    load_init_file('init.pl', implicit).
+load_init_file(_).
+
+%!  loaded_init_file(?Base, ?AbsFile)
+%
+%   Used by prolog_load_context/2 to confirm we are loading a script.
+
+:- dynamic
+    loaded_init_file/2.             % already loaded init files
+
+load_init_file(none, _) :- !.
+load_init_file(Base, _) :-
+    loaded_init_file(Base, _),
+    !.
+load_init_file(InitFile, explicit) :-
+    exists_file(InitFile),
+    !,
+    ensure_loaded(user:InitFile).
+load_init_file(Base, _) :-
+    absolute_file_name(user_app_config(Base), InitFile,
+                       [ access(read),
+                         file_errors(fail)
+                       ]),
+    !,
+    asserta(loaded_init_file(Base, InitFile)),
+    load_files(user:InitFile,
+               [ scope_settings(false)
+               ]).
+load_init_file('init.pl', implicit) :-
+    (   current_prolog_flag(windows, true),
+        absolute_file_name(user_profile('swipl.ini'), InitFile,
+                           [ access(read),
+                             file_errors(fail)
+                           ])
+    ;   expand_file_name('~/.swiplrc', [InitFile]),
+        exists_file(InitFile)
+    ),
+    !,
+    print_message(warning, backcomp(init_file_moved(InitFile))).
+load_init_file(_, _).
+
+'$load_system_init_file' :-
+    loaded_init_file(system, _),
+    !.
+'$load_system_init_file' :-
+    '$cmd_option_val'(system_init_file, Base),
+    Base \== none,
+    current_prolog_flag(home, Home),
+    file_name_extension(Base, rc, Name),
+    atomic_list_concat([Home, '/', Name], File),
+    absolute_file_name(File, Path,
+                       [ file_type(prolog),
+                         access(read),
+                         file_errors(fail)
+                       ]),
+    asserta(loaded_init_file(system, Path)),
+    load_files(user:Path,
+               [ silent(true),
+                 scope_settings(false)
+               ]),
+    !.
+'$load_system_init_file'.
+
+'$load_script_file' :-
+    loaded_init_file(script, _),
+    !.
+'$load_script_file' :-
+    '$cmd_option_val'(script_file, OsFiles),
+    load_script_files(OsFiles).
+
+load_script_files([]).
+load_script_files([OsFile|More]) :-
+    prolog_to_os_filename(File, OsFile),
+    (   absolute_file_name(File, Path,
+                           [ file_type(prolog),
+                             access(read),
+                             file_errors(fail)
+                           ])
+    ->  asserta(loaded_init_file(script, Path)),
+        load_files(user:Path),
+        load_files(user:More)
+    ;   throw(error(existence_error(script_file, File), _))
+    ).
+
+
+                 /*******************************
+                 *       AT_INITIALISATION      *
+                 *******************************/
+
+:- meta_predicate
+    initialization(0).
+
+:- '$iso'((initialization)/1).
+
+%!  initialization(:Goal)
+%
+%   Runs Goal after loading the file in which this directive
+%   appears as well as after restoring a saved state.
+%
+%   @see initialization/2
+
+initialization(Goal) :-
+    Goal = _:G,
+    prolog:initialize_now(G, Use),
+    !,
+    print_message(warning, initialize_now(G, Use)),
+    initialization(Goal, now).
+initialization(Goal) :-
+    initialization(Goal, after_load).
+
+:- multifile
+    prolog:initialize_now/2,
+    prolog:message//1.
+
+prolog:initialize_now(load_foreign_library(_),
+                      'use :- use_foreign_library/1 instead').
+prolog:initialize_now(load_foreign_library(_,_),
+                      'use :- use_foreign_library/2 instead').
+
+prolog:message(initialize_now(Goal, Use)) -->
+    [ 'Initialization goal ~p will be executed'-[Goal],nl,
+      'immediately for backward compatibility reasons', nl,
+      '~w'-[Use]
+    ].
+
+'$run_initialization' :-
+    '$set_prolog_file_extension',
+    '$run_initialization'(_, []),
+    '$thread_init'.
+
+%!  initialize
+%
+%   Run goals registered with `:-  initialization(Goal, program).`. Stop
+%   with an exception if a goal fails or raises an exception.
+
+initialize :-
+    forall('$init_goal'(when(program), Goal, Ctx),
+           run_initialize(Goal, Ctx)).
+
+run_initialize(Goal, Ctx) :-
+    (   catch(Goal, E, true),
+        (   var(E)
+        ->  true
+        ;   throw(error(initialization_error(E, Goal, Ctx), _))
+        )
+    ;   throw(error(initialization_error(failed, Goal, Ctx), _))
+    ).
+
+
+                 /*******************************
+                 *     THREAD INITIALIZATION    *
+                 *******************************/
+
+:- meta_predicate
+    thread_initialization(0).
+:- dynamic
+    '$at_thread_initialization'/1.
+
+%!  thread_initialization(:Goal)
+%
+%   Run Goal now and everytime a new thread is created.
+
+thread_initialization(Goal) :-
+    assert('$at_thread_initialization'(Goal)),
+    call(Goal),
+    !.
+
+%!  '$thread_init'
+%
+%   Called by start_thread() from pl-thread.c before the thread's goal.
+
+'$thread_init' :-
+    set_prolog_flag(toplevel_thread, false),
+    (   '$at_thread_initialization'(Goal),
+        (   call(Goal)
+        ->  fail
+        ;   fail
+        )
+    ;   true
+    ).
+
+
+                 /*******************************
+                 *     FILE SEARCH PATH (-p)    *
+                 *******************************/
+
+%!  '$set_file_search_paths' is det.
+%
+%   Process -p PathSpec options.
+
+'$set_file_search_paths' :-
+    '$cmd_option_val'(search_paths, Paths),
+    (   '$member'(Path, Paths),
+        atom_chars(Path, Chars),
+        (   phrase('$search_path'(Name, Aliases), Chars)
+        ->  '$reverse'(Aliases, Aliases1),
+            forall('$member'(Alias, Aliases1),
+                   asserta(user:file_search_path(Name, Alias)))
+        ;   print_message(error, commandline_arg_type(p, Path))
+        ),
+        fail ; true
+    ).
+
+'$search_path'(Name, Aliases) -->
+    '$string'(NameChars),
+    [=],
+    !,
+    {atom_chars(Name, NameChars)},
+    '$search_aliases'(Aliases).
+
+'$search_aliases'([Alias|More]) -->
+    '$string'(AliasChars),
+    path_sep,
+    !,
+    { '$make_alias'(AliasChars, Alias) },
+    '$search_aliases'(More).
+'$search_aliases'([Alias]) -->
+    '$string'(AliasChars),
+    '$eos',
+    !,
+    { '$make_alias'(AliasChars, Alias) }.
+
+path_sep -->
+    { current_prolog_flag(path_sep, Sep) },
+    [Sep].
+
+'$string'([]) --> [].
+'$string'([H|T]) --> [H], '$string'(T).
+
+'$eos'([], []).
+
+'$make_alias'(Chars, Alias) :-
+    catch(term_to_atom(Alias, Chars), _, fail),
+    (   atom(Alias)
+    ;   functor(Alias, F, 1),
+        F \== /
+    ),
+    !.
+'$make_alias'(Chars, Alias) :-
+    atom_chars(Alias, Chars).
+
+
+                 /*******************************
+                 *   LOADING ASSIOCIATED FILES  *
+                 *******************************/
+
+%!  argv_prolog_files(-Files, -ScriptMode) is det.
+%
+%   Update the Prolog flag `argv`, extracting  the leading script files.
+%   This is called after the C based  parser removed Prolog options such
+%   as ``-q``, ``-f none``, etc.  These   options  are available through
+%   '$cmd_option_val'/2.
+%
+%   Our task is to update the Prolog flag   `argv`  and return a list of
+%   the files to be loaded.   The rules are:
+%
+%     - If we find ``--`` all remaining options must go to `argv`
+%     - If we find *.pl files, these are added to Files and possibly
+%       remaining arguments are "script" arguments.
+%     - If we find an existing file, this is Files and possibly
+%       remaining arguments are "script" arguments.
+%     - File we find [search:]name, find search(name) as Prolog file,
+%       make this the content of `Files` and pass the remainder as
+%       options to `argv`.
+%
+%   @arg ScriptMode is one of
+%
+%     - exe
+%       Program is a saved state
+%     - prolog
+%       One or more *.pl files on commandline
+%     - script
+%       Single existing file on commandline
+%     - app
+%       [path:]cli-name on commandline
+%     - none
+%       Normal interactive session
+
+argv_prolog_files([], exe) :-
+    current_prolog_flag(saved_program_class, runtime),
+    !,
+    clean_argv.
+argv_prolog_files(Files, ScriptMode) :-
+    current_prolog_flag(argv, Argv),
+    no_option_files(Argv, Argv1, Files, ScriptMode),
+    (   (   nonvar(ScriptMode)
+        ;   Argv1 == []
+        )
+    ->  (   Argv1 \== Argv
+        ->  set_prolog_flag(argv, Argv1)
+        ;   true
+        )
+    ;   '$usage',
+        halt(1)
+    ).
+
+no_option_files([--|Argv], Argv, [], ScriptMode) :-
+    !,
+    (   ScriptMode = none
+    ->  true
+    ;   true
+    ).
+no_option_files([Opt|_], _, _, ScriptMode) :-
+    var(ScriptMode),
+    sub_atom(Opt, 0, _, _, '-'),
+    !,
+    '$usage',
+    halt(1).
+no_option_files([OsFile|Argv0], Argv, [File|T], ScriptMode) :-
+    file_name_extension(_, Ext, OsFile),
+    user:prolog_file_type(Ext, prolog),
+    !,
+    ScriptMode = prolog,
+    prolog_to_os_filename(File, OsFile),
+    no_option_files(Argv0, Argv, T, ScriptMode).
+no_option_files([OsScript|Argv], Argv, [Script], ScriptMode) :-
+    var(ScriptMode),
+    !,
+    prolog_to_os_filename(PlScript, OsScript),
+    (   exists_file(PlScript)
+    ->  Script = PlScript,
+        ScriptMode = script
+    ;   cli_script(OsScript, Script)
+    ->  ScriptMode = app,
+        set_prolog_flag(app_name, OsScript)
+    ;   '$existence_error'(file, PlScript)
+    ).
+no_option_files(Argv, Argv, [], ScriptMode) :-
+    (   ScriptMode = none
+    ->  true
+    ;   true
+    ).
+
+cli_script(CLI, Script) :-
+    (   sub_atom(CLI, Pre, _, Post, ':')
+    ->  sub_atom(CLI, 0, Pre, _, SearchPath),
+        sub_atom(CLI, _, Post, 0, Base),
+        Spec =.. [SearchPath, Base]
+    ;   Spec = app(CLI)
+    ),
+    absolute_file_name(Spec, Script,
+                       [ file_type(prolog),
+                         access(exist),
+                         file_errors(fail)
+                       ]).
+
+clean_argv :-
+    (   current_prolog_flag(argv, [--|Argv])
+    ->  set_prolog_flag(argv, Argv)
+    ;   true
+    ).
+
+%!  win_associated_files(+Files)
+%
+%   If SWI-Prolog is started as <exe> <file>.<ext>, where <ext> is
+%   the extension registered for associated files, set the Prolog
+%   flag associated_file, switch to the directory holding the file
+%   and -if possible- adjust the window title.
+
+win_associated_files(Files) :-
+    (   Files = [File|_]
+    ->  absolute_file_name(File, AbsFile),
+        set_prolog_flag(associated_file, AbsFile),
+        forall(prolog:set_app_file_config(Files), true)
+    ;   true
+    ).
+
+:- multifile
+    prolog:set_app_file_config/1.               % +Files
+
+%!  start_pldoc
+%
+%   If the option ``--pldoc[=port]`` is given, load the PlDoc system.
+
+start_pldoc :-
+    '$cmd_option_val'(pldoc_server, Server),
+    (   Server == ''
+    ->  call((doc_server(_), doc_browser))
+    ;   catch(atom_number(Server, Port), _, fail)
+    ->  call(doc_server(Port))
+    ;   print_message(error, option_usage(pldoc)),
+        halt(1)
+    ).
+start_pldoc.
+
+
+%!  load_associated_files(+Files)
+%
+%   Load Prolog files specified from the commandline.
+
+load_associated_files(Files) :-
+    load_files(user:Files).
+
+hkey('HKEY_CURRENT_USER/Software/SWI/Prolog').
+hkey('HKEY_LOCAL_MACHINE/Software/SWI/Prolog').
+
+'$set_prolog_file_extension' :-
+    current_prolog_flag(windows, true),
+    hkey(Key),
+    catch(win_registry_get_value(Key, fileExtension, Ext0),
+          _, fail),
+    !,
+    (   atom_concat('.', Ext, Ext0)
+    ->  true
+    ;   Ext = Ext0
+    ),
+    (   user:prolog_file_type(Ext, prolog)
+    ->  true
+    ;   asserta(user:prolog_file_type(Ext, prolog))
+    ).
+'$set_prolog_file_extension'.
+
+
+                /********************************
+                *        TOPLEVEL GOALS         *
+                *********************************/
+
+%!  '$initialise' is semidet.
+%
+%   Called from PL_initialise()  to  do  the   Prolog  part  of  the
+%   initialization. If an exception  occurs,   this  is  printed and
+%   '$initialise' fails.
+
+'$initialise' :-
+    catch(initialise_prolog, E, initialise_error(E)).
+
+initialise_error(unwind(abort)) :- !.
+initialise_error(unwind(halt(_))) :- !.
+initialise_error(E) :-
+    print_message(error, initialization_exception(E)),
+    fail.
+
+initialise_prolog :-
+    apply_defines,
+    init_optimise,
+    '$run_initialization',
+    '$load_system_init_file',                   % -F file
+    set_toplevel,                               % set `toplevel_goal` flag from -t
+    '$set_file_search_paths',                   % handle -p alias=dir[:dir]*
+    init_debug_flags,
+    setup_app,
+    start_pldoc,                                % handle --pldoc[=port]
+    main_thread_init.
+
+%!  main_thread_init
+%
+%   Deal with the _Epilog_ toplevel. If  the   flag  `epilog` is set and
+%   xpce is around, create an epilog window   and complete the user part
+%   of the initialization in the epilog thread.
+
+:- if(current_prolog_flag(threads, true)).
+main_thread_init :-
+    current_prolog_flag(epilog, true),
+    thread_self(main),
+    current_prolog_flag(xpce, true),
+    exists_source(library(epilog)),
+    !,
+    setup_theme,
+    catch(setup_backtrace, E, print_message(warning, E)),
+    use_module(library(epilog)),
+    set_thread(main, class(system)),
+    call(epilog([ init(user_thread_init),
+                  main(true)
+                ])).
+main_thread_init :-
+    set_thread(main, class(console)),
+    setup_theme,
+    user_thread_init.
+:- else.
+main_thread_init :-
+    setup_theme,
+    user_thread_init.
+:- endif.
+
+
+%!  user_thread_init
+%
+%   Complete the toplevel startup.  This may run in a separate thread.
+
+user_thread_init :-
+    opt_attach_packs,
+    argv_prolog_files(Files, ScriptMode),
+    load_init_file(ScriptMode),                 % -f file
+    catch(setup_colors, E, print_message(warning, E)),
+    win_associated_files(Files),                % swipl-win: cd and update title
+    '$load_script_file',                        % -s file (may be repeated)
+    load_associated_files(Files),
+    '$cmd_option_val'(goals, Goals),            % -g goal (may be repeated)
+    (   ScriptMode == app
+    ->  run_program_init,                       % initialization(Goal, program)
+        run_main_init(true)
+    ;   Goals == [],
+        \+ '$init_goal'(when(_), _, _)          % no -g or -t or initialization(program)
+    ->  version                                 % default interactive run
+    ;   run_init_goals(Goals),                  % run -g goals
+        (   load_only                           % used -l to load
+        ->  version
+        ;   run_program_init,                   % initialization(Goal, program)
+            run_main_init(false)                % initialization(Goal, main)
+        )
+    ).
+
+%!  setup_theme
+
+:- multifile
+    prolog:theme/1.
+
+setup_theme :-
+    current_prolog_flag(theme, Theme),
+    exists_source(library(theme/Theme)),
+    !,
+    use_module(library(theme/Theme)).
+setup_theme.
+
+%!  apply_defines
+%
+%   Handle -Dflag[=value] options
+
+apply_defines :-
+    '$cmd_option_val'(defines, Defs),
+    apply_defines(Defs).
+
+apply_defines([]).
+apply_defines([H|T]) :-
+    apply_define(H),
+    apply_defines(T).
+
+apply_define(Def) :-
+    sub_atom(Def, B, _, A, '='),
+    !,
+    sub_atom(Def, 0, B, _, Flag),
+    sub_atom(Def, _, A, 0, Value0),
+    (   '$current_prolog_flag'(Flag, Value0, _Scope, Access, Type)
+    ->  (   Access \== write
+        ->  '$permission_error'(set, prolog_flag, Flag)
+        ;   text_flag_value(Type, Value0, Value)
+        ),
+	set_prolog_flag(Flag, Value)
+    ;   (   atom_number(Value0, Value)
+	->  true
+	;   Value = Value0
+	),
+	set_defined(Flag, Value)
+    ).
+apply_define(Def) :-
+    atom_concat('no-', Flag, Def),
+    !,
+    set_user_boolean_flag(Flag, false).
+apply_define(Def) :-
+    set_user_boolean_flag(Def, true).
+
+set_user_boolean_flag(Flag, Value) :-
+    current_prolog_flag(Flag, Old),
+    !,
+    (   Old == Value
+    ->  true
+    ;   set_prolog_flag(Flag, Value)
+    ).
+set_user_boolean_flag(Flag, Value) :-
+    set_defined(Flag, Value).
+
+text_flag_value(integer, Text, Int) :-
+    atom_number(Text, Int),
+    !.
+text_flag_value(float, Text, Float) :-
+    atom_number(Text, Float),
+    !.
+text_flag_value(term, Text, Term) :-
+    term_string(Term, Text, []),
+    !.
+text_flag_value(_, Value, Value).
+
+set_defined(Flag, Value) :-
+    define_options(Flag, Options), !,
+    create_prolog_flag(Flag, Value, Options).
+
+%!  define_options(+Flag, -Options)
+%
+%   Define the options with which to create   Flag. This can be used for
+%   known flags to control -for example- their type.
+
+define_options('SDL_VIDEODRIVER', []).
+define_options(_, [warn_not_accessed(true)]).
+
+%!  init_optimise
+%
+%   Load library(apply_macros) if ``-O`` is effective.
+
+init_optimise :-
+    current_prolog_flag(optimise, true),
+    !,
+    use_module(user:library(apply_macros)).
+init_optimise.
+
+opt_attach_packs :-
+    current_prolog_flag(packs, true),
+    !,
+    attach_packs.
+opt_attach_packs.
+
+set_toplevel :-
+    '$cmd_option_val'(toplevel, TopLevelAtom),
+    catch(term_to_atom(TopLevel, TopLevelAtom), E,
+          (print_message(error, E),
+           halt(1))),
+    create_prolog_flag(toplevel_goal, TopLevel, [type(term)]).
+
+load_only :-
+    current_prolog_flag(os_argv, OSArgv),
+    memberchk('-l', OSArgv),
+    current_prolog_flag(argv, Argv),
+    \+ memberchk('-l', Argv).
+
+%!  run_init_goals(+Goals) is det.
+%
+%   Run registered initialization goals  on  order.   If  a  goal fails,
+%   execution is halted.
+
+run_init_goals([]).
+run_init_goals([H|T]) :-
+    run_init_goal(H),
+    run_init_goals(T).
+
+run_init_goal(Text) :-
+    catch(term_to_atom(Goal, Text), E,
+          (   print_message(error, init_goal_syntax(E, Text)),
+              halt(2)
+          )),
+    run_init_goal(Goal, Text).
+
+%!  run_program_init is det.
+%
+%   Run goals registered using
+
+run_program_init :-
+    forall('$init_goal'(when(program), Goal, Ctx),
+           run_init_goal(Goal, @(Goal,Ctx))).
+
+run_main_init(_) :-
+    findall(Goal-Ctx, '$init_goal'(when(main), Goal, Ctx), Pairs),
+    '$last'(Pairs, Goal-Ctx),
+    !,
+    (   current_prolog_flag(toplevel_goal, default)
+    ->  set_prolog_flag(toplevel_goal, halt)
+    ;   true
+    ),
+    run_init_goal(Goal, @(Goal,Ctx)).
+run_main_init(true) :-
+    '$existence_error'(initialization, main).
+run_main_init(_).
+
+run_init_goal(Goal, Ctx) :-
+    (   catch_with_backtrace(user:Goal, E, true)
+    ->  (   var(E)
+        ->  true
+        ;   init_goal_failed(E, Ctx)
+        )
+    ;   (   current_prolog_flag(verbose, silent)
+        ->  Level = silent
+        ;   Level = error
+        ),
+        print_message(Level, init_goal_failed(failed, Ctx)),
+        halt(1)
+    ).
+
+init_goal_failed(E, Ctx) :-
+    print_message(error, init_goal_failed(E, Ctx)),
+    init_goal_failed(E).
+
+init_goal_failed(_) :-
+    thread_self(main),
+    !,
+    halt(2).
+init_goal_failed(_).
+
+%!  init_debug_flags is det.
+%
+%   Initialize the various Prolog flags that   control  the debugger and
+%   toplevel.
+
+init_debug_flags :-
+    Keep = [keep(true)],
+    create_prolog_flag(answer_write_options,
+                       [ quoted(true), portray(true), max_depth(10),
+                         spacing(next_argument)], Keep),
+    create_prolog_flag(prompt_alternatives_on, determinism, Keep),
+    create_prolog_flag(toplevel_extra_white_line, true, Keep),
+    create_prolog_flag(toplevel_print_factorized, false, Keep),
+    create_prolog_flag(print_write_options,
+                       [ portray(true), quoted(true), numbervars(true) ],
+                       Keep),
+    create_prolog_flag(toplevel_residue_vars, false, Keep),
+    create_prolog_flag(toplevel_list_wfs_residual_program, true, Keep),
+    '$set_debugger_write_options'(print).
+
+%!  setup_backtrace
+%
+%   Initialise printing a backtrace.
+
+setup_backtrace :-
+    (   \+ current_prolog_flag(backtrace, false),
+        load_setup_file(library(prolog_stack))
+    ->  true
+    ;   true
+    ).
+
+%!  setup_colors is det.
+%
+%   Setup  interactive  usage  by  enabling    colored   output.
+
+setup_colors :-
+    (   \+ current_prolog_flag(color_term, false),
+        stream_property(user_input, tty(true)),
+        stream_property(user_error, tty(true)),
+        stream_property(user_output, tty(true)),
+        \+ getenv('TERM', dumb),
+        load_setup_file(user:library(ansi_term))
+    ->  true
+    ;   true
+    ).
+
+%!  setup_history
+%
+%   Enable per-directory persistent history.
+
+setup_history :-
+    (   \+ current_prolog_flag(save_history, false),
+        stream_property(user_input, tty(true)),
+        \+ current_prolog_flag(readline, false),
+        load_setup_file(library(prolog_history))
+    ->  prolog_history(enable)
+    ;   true
+    ).
+
+%!  setup_readline
+%
+%   Setup line editing.
+
+setup_readline :-
+    (   stream_property(user_input, tty(true)),
+        current_prolog_flag(tty_control, true),
+        \+ getenv('TERM', dumb),
+        (   current_prolog_flag(readline, ReadLine)
+        ->  true
+        ;   ReadLine = true
+        ),
+        readline_library(ReadLine, Library),
+        (   load_setup_file(library(Library))
+        ->  true
+        ;   current_prolog_flag(epilog, true),
+            print_message(warning,
+                          error(existence_error(library, library(Library)),
+                                _)),
+            fail
+        )
+    ->  set_prolog_flag(readline, Library)
+    ;   set_prolog_flag(readline, false)
+    ).
+
+readline_library(true, Library) :-
+    !,
+    preferred_readline(Library).
+readline_library(false, _) :-
+    !,
+    fail.
+readline_library(Library, Library).
+
+preferred_readline(editline).
+
+%!  load_setup_file(+File) is semidet.
+%
+%   Load a file and fail silently if the file does not exist.
+
+load_setup_file(File) :-
+    catch(load_files(File,
+                     [ silent(true),
+                       if(not_loaded)
+                     ]), error(_,_), fail).
+
+
+%!  setup_app is det.
+%
+%   When running as an "app", behave as such. The behaviour depends on
+%   the platform.
+%
+%     - Windows
+%       If Prolog is started using --win_app, try to change directory
+%       to <My Documents>\Prolog.
+
+:- if(current_prolog_flag(windows,true)).
+
+setup_app :-
+    current_prolog_flag(associated_file, _),
+    !.
+setup_app :-
+    '$cmd_option_val'(win_app, true),
+    !,
+    catch(my_prolog, E, print_message(warning, E)).
+setup_app.
+
+my_prolog :-
+    win_folder(personal, MyDocs),
+    atom_concat(MyDocs, '/Prolog', PrologDir),
+    (   ensure_dir(PrologDir)
+    ->  working_directory(_, PrologDir)
+    ;   working_directory(_, MyDocs)
+    ).
+
+ensure_dir(Dir) :-
+    exists_directory(Dir),
+    !.
+ensure_dir(Dir) :-
+    catch(make_directory(Dir), E, (print_message(warning, E), fail)).
+
+:- elif(current_prolog_flag(apple, true)).
+use_app_settings(true).                        % Indicate we need app settings
+
+setup_app :-
+    apple_set_locale,
+    current_prolog_flag(associated_file, _),
+    !.
+setup_app :-
+    current_prolog_flag(bundle, true),
+    current_prolog_flag(executable, Exe),
+    file_base_name(Exe, 'SWI-Prolog'),
+    !,
+    setup_macos_app.
+setup_app.
+
+apple_set_locale :-
+    (   getenv('LC_CTYPE', 'UTF-8'),
+        apple_current_locale_identifier(LocaleID),
+        atom_concat(LocaleID, '.UTF-8', Locale),
+        catch(setlocale(ctype, _Old, Locale), _, fail)
+    ->  setenv('LANG', Locale),
+        unsetenv('LC_CTYPE')
+    ;   true
+    ).
+
+setup_macos_app :-
+    restore_working_directory,
+    !.
+setup_macos_app :-
+    expand_file_name('~/Prolog', [PrologDir]),
+    (   exists_directory(PrologDir)
+    ->  true
+    ;   catch(make_directory(PrologDir), MkDirError,
+              print_message(warning, MkDirError))
+    ),
+    catch(working_directory(_, PrologDir), CdError,
+          print_message(warning, CdError)),
+    !.
+setup_macos_app.
+
+:- elif(current_prolog_flag(emscripten, true)).
+setup_app.
+:- else.
+use_app_settings(true).                        % Indicate we need app settings
+
+% Other (Unix-like) platforms.
+setup_app :-
+    running_as_app,
+    restore_working_directory,
+    !.
+setup_app.
+
+%!  running_as_app is semidet.
+%
+%   True if we were started from the dock.
+
+running_as_app :-
+%   getenv('FLATPAK_SANDBOX_DIR', _),
+    current_prolog_flag(epilog, true),
+    stream_property(In, file_no(0)),
+    \+ stream_property(In, tty(true)),
+    !.
+
+:- endif.
+
+
+:- if((current_predicate(use_app_settings/1),
+       use_app_settings(true))).
+
+
+                /*******************************
+                *    APP WORKING DIRECTORY     *
+                *******************************/
+
+save_working_directory :-
+    working_directory(WD, WD),
+    app_settings(Settings),
+    (   Settings.get(working_directory) == WD
+    ->  true
+    ;   app_save_settings(Settings.put(working_directory, WD))
+    ).
+
+restore_working_directory :-
+    at_halt(save_working_directory),
+    app_settings(Settings),
+    WD = Settings.get(working_directory),
+    catch(working_directory(_, WD), _, fail),
+    !.
+
+                /*******************************
+                *           SETTINGS           *
+                *******************************/
+
+%!  app_settings(-Settings:dict) is det.
+%
+%   Get a dict holding the persistent application settings.
+
+app_settings(Settings) :-
+    app_settings_file(File),
+    access_file(File, read),
+    catch(setup_call_cleanup(
+              open(File, read, In, [encoding(utf8)]),
+              read_term(In, Settings, []),
+              close(In)),
+          Error,
+          (print_message(warning, Error), fail)),
+    !.
+app_settings(#{}).
+
+%!  app_save_settings(+Settings:dict) is det.
+%
+%   Save the given application settings dict.
+
+app_save_settings(Settings) :-
+    app_settings_file(File),
+    catch(setup_call_cleanup(
+              open(File, write, Out, [encoding(utf8)]),
+              write_term(Out, Settings,
+                         [ quoted(true),
+                           module(system), % default operators
+                           fullstop(true),
+                           nl(true)
+                         ]),
+              close(Out)),
+          Error,
+          (print_message(warning, Error), fail)).
+
+
+app_settings_file(File) :-
+    absolute_file_name(user_app_config('app_settings.pl'), File,
+                       [ access(write),
+                         file_errors(fail)
+                       ]).
+:- endif.% app_settings
+
+                /*******************************
+                *           TOPLEVEL           *
+                *******************************/
+
+:- '$hide'('$toplevel'/0).              % avoid in the GUI stacktrace
+
+%!  '$toplevel'
+%
+%   Called from PL_toplevel()
+
+'$toplevel' :-
+    '$runtoplevel',
+    print_message(informational, halt).
+
+%!  '$runtoplevel'
+%
+%   Actually run the toplevel. The values   `default`  and `prolog` both
+%   start the interactive toplevel, where `prolog` implies the user gave
+%   =|-t prolog|=.
+%
+%   @see prolog/0 is the default interactive toplevel
+
+'$runtoplevel' :-
+    current_prolog_flag(toplevel_goal, TopLevel0),
+    toplevel_goal(TopLevel0, TopLevel),
+    user:TopLevel.
+
+:- dynamic  setup_done/0.
+:- volatile setup_done/0.
+
+toplevel_goal(default, '$query_loop') :-
+    !,
+    setup_interactive.
+toplevel_goal(prolog, '$query_loop') :-
+    !,
+    setup_interactive.
+toplevel_goal(Goal, Goal).
+
+setup_interactive :-
+    setup_done,
+    !.
+setup_interactive :-
+    asserta(setup_done),
+    catch(setup_backtrace, E, print_message(warning, E)),
+    catch(setup_readline,  E, print_message(warning, E)),
+    catch(setup_history,   E, print_message(warning, E)).
+
+%!  '$compile'
+%
+%   Toplevel called when invoked with -c option.
+
+'$compile' :-
+    (   catch('$compile_', E, (print_message(error, E), halt(1)))
+    ->  true
+    ;   print_message(error, error(goal_failed('$compile'), _)),
+        halt(1)
+    ),
+    halt.                               % set exit code
+
+'$compile_' :-
+    '$load_system_init_file',
+    catch(setup_colors, _, true),
+    '$set_file_search_paths',
+    init_debug_flags,
+    '$run_initialization',
+    opt_attach_packs,
+    use_module(library(qsave)),
+    qsave:qsave_toplevel.
+
+%!  '$config'
+%
+%   Toplevel when invoked with --dump-runtime-variables
+
+'$config' :-
+    '$load_system_init_file',
+    '$set_file_search_paths',
+    init_debug_flags,
+    '$run_initialization',
+    load_files(library(prolog_config)),
+    (   catch(prolog_dump_runtime_variables, E,
+              (print_message(error, E), halt(1)))
+    ->  true
+    ;   print_message(error, error(goal_failed(prolog_dump_runtime_variables),_))
+    ).
+
+
+                /********************************
+                *    USER INTERACTIVE LOOP      *
+                *********************************/
+
+%!  prolog:repl_loop_hook(+BeginEnd, +BreakLevel) is nondet.
+%
+%   Multifile  hook  that  allows  acting    on   starting/stopping  the
+%   interactive REPL loop. Called as
+%
+%       forall(prolog:repl_loop_hook(BeginEnd, BreakLevel), true)
+%
+%   @arg BeginEnd is one of `begin` or `end`
+%   @arg BreakLevel is 0 for the normal toplevel, -1 when
+%   non-interactive and >0 for _break environments_.
+
+:- multifile
+    prolog:repl_loop_hook/2.
+
+%!  prolog
+%
+%   Run the Prolog toplevel. This is now  the same as break/0, which
+%   pretends  to  be  in  a  break-level    if  there  is  a  parent
+%   environment.
+
+prolog :-
+    break.
+
+:- create_prolog_flag(toplevel_mode, backtracking, []).
+
+%!  '$query_loop'
+%
+%   Run the normal Prolog query loop.  Note   that  the query is not
+%   protected by catch/3. Dealing with  unhandled exceptions is done
+%   by the C-function query_loop().  This   ensures  that  unhandled
+%   exceptions are really unhandled (in Prolog).
+
+'$query_loop' :-
+    break_level(BreakLev),
+    setup_call_cleanup(
+        notrace(call_repl_loop_hook(begin, BreakLev, IsToplevel)),
+        '$query_loop'(BreakLev),
+        notrace(call_repl_loop_hook(end, BreakLev, IsToplevel))).
+
+call_repl_loop_hook(begin, BreakLev, IsToplevel) =>
+    (   current_prolog_flag(toplevel_thread, IsToplevel)
+    ->  true
+    ;   IsToplevel = false
+    ),
+    set_prolog_flag(toplevel_thread, true),
+    call_repl_loop_hook_(begin, BreakLev).
+call_repl_loop_hook(end, BreakLev, IsToplevel) =>
+    set_prolog_flag(toplevel_thread, IsToplevel),
+    call_repl_loop_hook_(end, BreakLev).
+
+call_repl_loop_hook_(BeginEnd, BreakLev) :-
+    forall(prolog:repl_loop_hook(BeginEnd, BreakLev), true).
+
+
+'$query_loop'(BreakLev) :-
+    current_prolog_flag(toplevel_mode, recursive),
+    !,
+    read_expanded_query(BreakLev, Query, Bindings),
+    (   Query == end_of_file
+    ->  print_message(query, query(eof))
+    ;   '$call_no_catch'('$execute_query'(Query, Bindings, _)),
+        (   current_prolog_flag(toplevel_mode, recursive)
+        ->  '$query_loop'(BreakLev)
+        ;   '$switch_toplevel_mode'(backtracking),
+            '$query_loop'(BreakLev)     % Maybe throw('$switch_toplevel_mode')?
+        )
+    ).
+'$query_loop'(BreakLev) :-
+    repeat,
+        read_expanded_query(BreakLev, Query, Bindings),
+        (   Query == end_of_file
+        ->  !, print_message(query, query(eof))
+        ;   '$execute_query'(Query, Bindings, _),
+            (   current_prolog_flag(toplevel_mode, recursive)
+            ->  !,
+                '$switch_toplevel_mode'(recursive),
+                '$query_loop'(BreakLev)
+            ;   fail
+            )
+        ).
+
+break_level(BreakLev) :-
+    (   current_prolog_flag(break_level, BreakLev)
+    ->  true
+    ;   BreakLev = -1
+    ).
+
+read_expanded_query(BreakLev, ExpandedQuery, ExpandedBindings) :-
+    '$current_typein_module'(TypeIn),
+    (   stream_property(user_input, tty(true))
+    ->  '$system_prompt'(TypeIn, BreakLev, Prompt),
+        prompt(Old, '|    ')
+    ;   Prompt = '',
+        prompt(Old, '')
+    ),
+    trim_stacks,
+    trim_heap,
+    repeat,
+      (   catch(read_query(Prompt, Query, Bindings),
+                error(io_error(_,_),_), fail)
+      ->  prompt(_, Old),
+          catch(call_expand_query(Query, ExpandedQuery,
+                                  Bindings, ExpandedBindings),
+                Error,
+                (print_message(error, Error), fail))
+      ;   set_prolog_flag(debug_on_error, false),
+          thread_exit(io_error)
+      ),
+    !.
+
+
+%!  read_query(+Prompt, -Goal, -Bindings) is det.
+%
+%   Read the next query. The first  clause   deals  with  the case where
+%   !-based history is enabled. The second is   used  if we have command
+%   line editing.
+
+:- multifile
+    prolog:history/2.
+
+:- if(current_prolog_flag(emscripten, true)).
+read_query(_Prompt, Goal, Bindings) :-
+    '$can_yield',
+    !,
+    await(query, GoalString),
+    term_string(Goal, GoalString, [variable_names(Bindings)]).
+:- endif.
+read_query(Prompt, Goal, Bindings) :-
+    prolog:history(current_input, enabled),
+    !,
+    read_term_with_history(
+        Goal,
+        [ show(h),
+          help('!h'),
+          no_save([trace]),
+          prompt(Prompt),
+          variable_names(Bindings)
+        ]).
+read_query(Prompt, Goal, Bindings) :-
+    remove_history_prompt(Prompt, Prompt1),
+    repeat,                                 % over syntax errors
+    prompt1(Prompt1),
+    read_query_line(user_input, Line),
+    '$current_typein_module'(TypeIn),
+    catch(read_term_from_atom(Line, Goal,
+                              [ variable_names(Bindings),
+                                module(TypeIn)
+                              ]), E,
+          (   print_message(error, E),
+              fail
+          )),
+    !.
+
+%!  read_query_line(+Input, -Query:atom) is det.
+%
+%   Read a query as an atom. If Query is '$silent'(Goal), execute `Goal`
+%   in module `user` and read the   next  query. This supports injecting
+%   goals in some GNU-Emacs modes.
+
+read_query_line(Input, Line) :-
+    stream_property(Input, error(true)),
+    !,
+    Line = end_of_file.
+read_query_line(Input, Line) :-
+    catch(read_term_as_atom(Input, Line0), Error, true),
+    save_debug_after_read,
+    (   var(Error)
+    ->  (   catch(term_string(Goal, Line0), error(_,_), fail),
+            Goal = '$silent'(SilentGoal)
+        ->  Error = error(_,_),
+            catch_with_backtrace(ignore(SilentGoal), Error,
+                                 print_message(error, Error)),
+            read_query_line(Input, Line)
+        ;   Line = Line0
+        )
+    ;   catch(print_message(error, Error), _, true),
+        (   Error = error(syntax_error(_),_)
+        ->  fail
+        ;   throw(Error)
+        )
+    ).
+
+%!  read_term_as_atom(+Input, -Line)
+%
+%   Read the next term as an  atom  and   skip  to  the newline or a
+%   non-space character.
+
+read_term_as_atom(In, Line) :-
+    '$raw_read'(In, Line),
+    (   Line == end_of_file
+    ->  true
+    ;   skip_to_nl(In)
+    ).
+
+%!  skip_to_nl(+Input) is det.
+%
+%   Read input after the term. Skips   white  space and %... comment
+%   until the end of the line or a non-blank character.
+
+skip_to_nl(In) :-
+    repeat,
+    peek_char(In, C),
+    (   C == '%'
+    ->  skip(In, '\n')
+    ;   char_type(C, space)
+    ->  get_char(In, _),
+        C == '\n'
+    ;   true
+    ),
+    !.
+
+remove_history_prompt('', '') :- !.
+remove_history_prompt(Prompt0, Prompt) :-
+    atom_chars(Prompt0, Chars0),
+    clean_history_prompt_chars(Chars0, Chars1),
+    delete_leading_blanks(Chars1, Chars),
+    atom_chars(Prompt, Chars).
+
+clean_history_prompt_chars([], []).
+clean_history_prompt_chars(['~', !|T], T) :- !.
+clean_history_prompt_chars([H|T0], [H|T]) :-
+    clean_history_prompt_chars(T0, T).
+
+delete_leading_blanks([' '|T0], T) :-
+    !,
+    delete_leading_blanks(T0, T).
+delete_leading_blanks(L, L).
+
+
+                 /*******************************
+                 *        TOPLEVEL DEBUG        *
+                 *******************************/
+
+%!  save_debug_after_read
+%
+%   Called right after the toplevel read to save the debug status if
+%   it was modified from the GUI thread using e.g.
+%
+%     ==
+%     thread_signal(main, gdebug)
+%     ==
+%
+%   @bug Ideally, the prompt would change if debug mode is enabled.
+%        That is hard to realise with all the different console
+%        interfaces supported by SWI-Prolog.
+
+save_debug_after_read :-
+    current_prolog_flag(debug, true),
+    !,
+    save_debug.
+save_debug_after_read.
+
+save_debug :-
+    (   tracing,
+        notrace
+    ->  Tracing = true
+    ;   Tracing = false
+    ),
+    current_prolog_flag(debug, Debugging),
+    set_prolog_flag(debug, false),
+    create_prolog_flag(query_debug_settings,
+                       debug(Debugging, Tracing), []).
+
+restore_debug :-
+    current_prolog_flag(query_debug_settings, debug(Debugging, Tracing)),
+    set_prolog_flag(debug, Debugging),
+    (   Tracing == true
+    ->  trace
+    ;   true
+    ).
+
+:- initialization
+    create_prolog_flag(query_debug_settings, debug(false, false), []).
+
+
+                /********************************
+                *            PROMPTING          *
+                ********************************/
+
+'$system_prompt'(Module, BrekLev, Prompt) :-
+    current_prolog_flag(toplevel_prompt, PAtom),
+    atom_codes(PAtom, P0),
+    (    Module \== user
+    ->   '$substitute'('~m', [Module, ': '], P0, P1)
+    ;    '$substitute'('~m', [], P0, P1)
+    ),
+    (    BrekLev > 0
+    ->   '$substitute'('~l', ['[', BrekLev, '] '], P1, P2)
+    ;    '$substitute'('~l', [], P1, P2)
+    ),
+    current_prolog_flag(query_debug_settings, debug(Debugging, Tracing)),
+    (    Tracing == true
+    ->   '$substitute'('~d', ['[trace] '], P2, P3)
+    ;    Debugging == true
+    ->   '$substitute'('~d', ['[debug] '], P2, P3)
+    ;    '$substitute'('~d', [], P2, P3)
+    ),
+    atom_chars(Prompt, P3).
+
+'$substitute'(From, T, Old, New) :-
+    atom_codes(From, FromCodes),
+    phrase(subst_chars(T), T0),
+    '$append'(Pre, S0, Old),
+    '$append'(FromCodes, Post, S0) ->
+    '$append'(Pre, T0, S1),
+    '$append'(S1, Post, New),
+    !.
+'$substitute'(_, _, Old, Old).
+
+subst_chars([]) -->
+    [].
+subst_chars([H|T]) -->
+    { atomic(H),
+      !,
+      atom_codes(H, Codes)
+    },
+    Codes,
+    subst_chars(T).
+subst_chars([H|T]) -->
+    H,
+    subst_chars(T).
+
+
+                /********************************
+                *           EXECUTION           *
+                ********************************/
+
+%!  '$execute_query'(Goal, Bindings, -Truth) is det.
+%
+%   Execute Goal using Bindings.
+
+'$execute_query'(Var, _, true) :-
+    var(Var),
+    !,
+    print_message(informational, var_query(Var)).
+'$execute_query'(Goal, Bindings, Truth) :-
+    '$current_typein_module'(TypeIn),
+    '$dwim_correct_goal'(TypeIn:Goal, Bindings, Corrected),
+    !,
+    setup_call_cleanup(
+        '$set_source_module'(M0, TypeIn),
+        expand_goal(Corrected, Expanded),
+        '$set_source_module'(M0)),
+    print_message(silent, toplevel_goal(Expanded, Bindings)),
+    '$execute_goal2'(Expanded, Bindings, Truth).
+'$execute_query'(_, _, false) :-
+    notrace,
+    print_message(query, query(no)).
+
+'$execute_goal2'(Goal, Bindings, true) :-
+    restore_debug,
+    '$current_typein_module'(TypeIn),
+    residue_vars(TypeIn:Goal, Vars, TypeIn:Delays, Chp),
+    deterministic(Det),
+    (   save_debug
+    ;   restore_debug, fail
+    ),
+    flush_output(user_output),
+    (   Det == true
+    ->  DetOrChp = true
+    ;   DetOrChp = Chp
+    ),
+    call_expand_answer(Goal, Bindings, NewBindings),
+    (    \+ \+ write_bindings(NewBindings, Vars, Delays, DetOrChp)
+    ->   !
+    ).
+'$execute_goal2'(_, _, false) :-
+    save_debug,
+    print_message(query, query(no)).
+
+residue_vars(Goal, Vars, Delays, Chp) :-
+    current_prolog_flag(toplevel_residue_vars, true),
+    !,
+    '$wfs_call'(call_residue_vars(stop_backtrace(Goal, Chp), Vars), Delays).
+residue_vars(Goal, [], Delays, Chp) :-
+    '$wfs_call'(stop_backtrace(Goal, Chp), Delays).
+
+stop_backtrace(Goal, Chp) :-
+    toplevel_call(Goal),
+    prolog_current_choice(Chp).
+
+toplevel_call(Goal) :-
+    call(Goal),
+    no_lco.
+
+no_lco.
+
+%!  write_bindings(+Bindings, +ResidueVars, +Delays, +DetOrChp)
+%!	is semidet.
+%
+%   Write   bindings   resulting   from   a     query.    The   flag
+%   prompt_alternatives_on determines whether the   user is prompted
+%   for alternatives. =groundness= gives   the  classical behaviour,
+%   =determinism= is considered more adequate and informative.
+%
+%   Succeeds if the user accepts the answer and fails otherwise.
+%
+%   @arg ResidueVars are the residual constraints and provided if
+%        the prolog flag `toplevel_residue_vars` is set to
+%        `project`.
+
+write_bindings(Bindings, ResidueVars, Delays, DetOrChp) :-
+    '$current_typein_module'(TypeIn),
+    translate_bindings(Bindings, Bindings1, ResidueVars, TypeIn:Residuals),
+    omit_qualifier(Delays, TypeIn, Delays1),
+    write_bindings2(Bindings, Bindings1, Residuals, Delays1, DetOrChp).
+
+write_bindings2(OrgBindings, [], Residuals, Delays, _) :-
+    current_prolog_flag(prompt_alternatives_on, groundness),
+    !,
+    name_vars(OrgBindings, [], t(Residuals, Delays)),
+    print_message(query, query(yes(Delays, Residuals))).
+write_bindings2(OrgBindings, Bindings, Residuals, Delays, true) :-
+    current_prolog_flag(prompt_alternatives_on, determinism),
+    !,
+    name_vars(OrgBindings, Bindings, t(Residuals, Delays)),
+    print_message(query, query(yes(Bindings, Delays, Residuals))).
+write_bindings2(OrgBindings, Bindings, Residuals, Delays, Chp) :-
+    repeat,
+        name_vars(OrgBindings, Bindings, t(Residuals, Delays)),
+        print_message(query, query(more(Bindings, Delays, Residuals))),
+        get_respons(Action, Chp),
+    (   Action == redo
+    ->  !, fail
+    ;   Action == show_again
+    ->  fail
+    ;   !,
+        print_message(query, query(done))
+    ).
+
+%!  name_vars(+OrgBinding, +Bindings, +Term) is det.
+%
+%   Give a name ``_[A-Z][0-9]*`` to all variables   in Term, that do not
+%   have a name due to Bindings. Singleton   variables in Term are named
+%   `_`. The behavior depends on these Prolog flags:
+%
+%     - toplevel_name_variables
+%       Only act when `true`, else name_vars/3 is a no-op.
+%     - toplevel_print_anon
+%
+%   Variables are named by unifying them to `'$VAR'(Name)`
+%
+%   @arg Bindings is a list Name=Value
+
+name_vars(OrgBindings, Bindings, Term) :-
+    current_prolog_flag(toplevel_name_variables, true),
+    answer_flags_imply_numbervars,
+    !,
+    '$term_multitons'(t(Bindings,Term), Vars),
+    bindings_var_names(OrgBindings, Bindings, VarNames),
+    name_vars_(Vars, VarNames, 0),
+    term_variables(t(Bindings,Term), SVars),
+    anon_vars(SVars).
+name_vars(_OrgBindings, _Bindings, _Term).
+
+name_vars_([], _, _).
+name_vars_([H|T], Bindings, N) :-
+    name_var(Bindings, Name, N, N1),
+    H = '$VAR'(Name),
+    name_vars_(T, Bindings, N1).
+
+anon_vars([]).
+anon_vars(['$VAR'('_')|T]) :-
+    anon_vars(T).
+
+%!  name_var(+Reserved, -Name, +N0, -N) is det.
+%
+%   True when Name is a valid name for   a new variable where the search
+%   is guided by the number N0. Name may not appear in Reserved.
+
+name_var(Reserved, Name, N0, N) :-
+    between(N0, infinite, N1),
+    I is N1//26,
+    J is 0'A + N1 mod 26,
+    (   I == 0
+    ->  format(atom(Name), '_~c', [J])
+    ;   format(atom(Name), '_~c~d', [J, I])
+    ),
+    \+ memberchk(Name, Reserved),
+    !,
+    N is N1+1.
+
+%!  bindings_var_names(+OrgBindings, +TransBindings, -VarNames) is det.
+%
+%   Find the joined set of variable names   in the original bindings and
+%   translated bindings. When generating new names,  we better also omit
+%   names  that  appear  in  the  original  bindings  (but  not  in  the
+%   translated bindigns).
+
+bindings_var_names(OrgBindings, TransBindings, VarNames) :-
+    phrase(bindings_var_names_(OrgBindings), VarNames0, Tail),
+    phrase(bindings_var_names_(TransBindings), Tail, []),
+    sort(VarNames0, VarNames).
+
+%!  bindings_var_names_(+Bindings)// is det.
+%
+%   Produce a list of variable names that appear in Bindings. This deals
+%   both with the single and joined representation of bindings.
+
+bindings_var_names_([]) --> [].
+bindings_var_names_([H|T]) -->
+    binding_var_names(H),
+    bindings_var_names_(T).
+
+binding_var_names(binding(Vars,_Value,_Subst)) ==>
+    var_names(Vars).
+binding_var_names(Name=_Value) ==>
+    [Name].
+
+var_names([]) --> [].
+var_names([H|T]) --> [H], var_names(T).
+
+
+%!  answer_flags_imply_numbervars
+%
+%   True when the answer will be  written recognising '$VAR'(N). If this
+%   is not the case we should not try to name the variables.
+
+answer_flags_imply_numbervars :-
+    current_prolog_flag(answer_write_options, Options),
+    numbervars_option(Opt),
+    memberchk(Opt, Options),
+    !.
+
+numbervars_option(portray(true)).
+numbervars_option(portrayed(true)).
+numbervars_option(numbervars(true)).
+
+%!  residual_goals(:NonTerminal)
+%
+%   Directive that registers NonTerminal as a collector for residual
+%   goals.
+
+:- multifile
+    residual_goal_collector/1.
+
+:- meta_predicate
+    residual_goals(2).
+
+residual_goals(NonTerminal) :-
+    throw(error(context_error(nodirective, residual_goals(NonTerminal)), _)).
+
+system:term_expansion((:- residual_goals(NonTerminal)),
+                      '$toplevel':residual_goal_collector(M2:Head)) :-
+    \+ current_prolog_flag(xref, true),
+    prolog_load_context(module, M),
+    strip_module(M:NonTerminal, M2, Head),
+    '$must_be'(callable, Head).
+
+%!  prolog:residual_goals// is det.
+%
+%   DCG that collects residual goals that   are  not associated with
+%   the answer through attributed variables.
+
+:- public prolog:residual_goals//0.
+
+prolog:residual_goals -->
+    { findall(NT, residual_goal_collector(NT), NTL) },
+    collect_residual_goals(NTL).
+
+collect_residual_goals([]) --> [].
+collect_residual_goals([H|T]) -->
+    ( call(H) -> [] ; [] ),
+    collect_residual_goals(T).
+
+
+
+%!  prolog:translate_bindings(+Bindings0, -Bindings, +ResidueVars,
+%!                            +ResidualGoals, -Residuals) is det.
+%
+%   Translate the raw variable bindings  resulting from successfully
+%   completing a query into a  binding   list  and  list of residual
+%   goals suitable for human consumption.
+%
+%   @arg    Bindings is a list of binding(Vars,Value,Substitutions),
+%           where Vars is a list of variable names. E.g.
+%           binding(['A','B'],42,[])` means that both the variable
+%           A and B have the value 42. Values may contain terms
+%           '$VAR'(Name) to indicate sharing with a given variable.
+%           Value is always an acyclic term. If cycles appear in the
+%           answer, Substitutions contains a list of substitutions
+%           that restore the original term.
+%
+%   @arg    Residuals is a pair of two lists representing residual
+%           goals. The first element of the pair are residuals
+%           related to the query variables and the second are
+%           related that are disconnected from the query.
+
+:- public
+    prolog:translate_bindings/5.
+:- meta_predicate
+    prolog:translate_bindings(+, -, +, +, :).
+
+prolog:translate_bindings(Bindings0, Bindings, ResVars, ResGoals, Residuals) :-
+    translate_bindings(Bindings0, Bindings, ResVars, ResGoals, Residuals),
+    name_vars(Bindings0, Bindings, t(ResVars, ResGoals, Residuals)).
+
+% should not be required.
+prolog:name_vars(Bindings, Term) :- name_vars([], Bindings, Term).
+prolog:name_vars(Bindings0, Bindings, Term) :- name_vars(Bindings0, Bindings, Term).
+
+translate_bindings(Bindings0, Bindings, ResidueVars, Residuals) :-
+    prolog:residual_goals(ResidueGoals, []),
+    translate_bindings(Bindings0, Bindings, ResidueVars, ResidueGoals,
+                       Residuals).
+
+translate_bindings(Bindings0, Bindings, [], [], _:[]-[]) :-
+    term_attvars(Bindings0, []),
+    !,
+    join_same_bindings(Bindings0, Bindings1),
+    factorize_bindings(Bindings1, Bindings2),
+    bind_vars(Bindings2, Bindings3),
+    filter_bindings(Bindings3, Bindings).
+translate_bindings(Bindings0, Bindings, ResidueVars, ResGoals0,
+                   TypeIn:Residuals-HiddenResiduals) :-
+    project_constraints(Bindings0, ResidueVars),
+    hidden_residuals(ResidueVars, Bindings0, HiddenResiduals0),
+    omit_qualifiers(HiddenResiduals0, TypeIn, HiddenResiduals),
+    copy_term(Bindings0+ResGoals0, Bindings1+ResGoals1, Residuals0),
+    '$append'(ResGoals1, Residuals0, Residuals1),
+    omit_qualifiers(Residuals1, TypeIn, Residuals),
+    join_same_bindings(Bindings1, Bindings2),
+    factorize_bindings(Bindings2, Bindings3),
+    bind_vars(Bindings3, Bindings4),
+    filter_bindings(Bindings4, Bindings).
+
+hidden_residuals(ResidueVars, Bindings, Goal) :-
+    term_attvars(ResidueVars, Remaining),
+    term_attvars(Bindings, QueryVars),
+    subtract_vars(Remaining, QueryVars, HiddenVars),
+    copy_term(HiddenVars, _, Goal).
+
+subtract_vars(All, Subtract, Remaining) :-
+    sort(All, AllSorted),
+    sort(Subtract, SubtractSorted),
+    ord_subtract(AllSorted, SubtractSorted, Remaining).
+
+ord_subtract([], _Not, []).
+ord_subtract([H1|T1], L2, Diff) :-
+    diff21(L2, H1, T1, Diff).
+
+diff21([], H1, T1, [H1|T1]).
+diff21([H2|T2], H1, T1, Diff) :-
+    compare(Order, H1, H2),
+    diff3(Order, H1, T1, H2, T2, Diff).
+
+diff12([], _H2, _T2, []).
+diff12([H1|T1], H2, T2, Diff) :-
+    compare(Order, H1, H2),
+    diff3(Order, H1, T1, H2, T2, Diff).
+
+diff3(<,  H1, T1,  H2, T2, [H1|Diff]) :-
+    diff12(T1, H2, T2, Diff).
+diff3(=, _H1, T1, _H2, T2, Diff) :-
+    ord_subtract(T1, T2, Diff).
+diff3(>,  H1, T1, _H2, T2, Diff) :-
+    diff21(T2, H1, T1, Diff).
+
+
+%!  project_constraints(+Bindings, +ResidueVars) is det.
+%
+%   Call   <module>:project_attributes/2   if   the    Prolog   flag
+%   `toplevel_residue_vars` is set to `project`.
+
+project_constraints(Bindings, ResidueVars) :-
+    !,
+    term_attvars(Bindings, AttVars),
+    phrase(attribute_modules(AttVars), Modules0),
+    sort(Modules0, Modules),
+    term_variables(Bindings, QueryVars),
+    project_attributes(Modules, QueryVars, ResidueVars).
+project_constraints(_, _).
+
+project_attributes([], _, _).
+project_attributes([M|T], QueryVars, ResidueVars) :-
+    (   current_predicate(M:project_attributes/2),
+        catch(M:project_attributes(QueryVars, ResidueVars), E,
+              print_message(error, E))
+    ->  true
+    ;   true
+    ),
+    project_attributes(T, QueryVars, ResidueVars).
+
+attribute_modules([]) --> [].
+attribute_modules([H|T]) -->
+    { get_attrs(H, Attrs) },
+    attrs_modules(Attrs),
+    attribute_modules(T).
+
+attrs_modules([]) --> [].
+attrs_modules(att(Module, _, More)) -->
+    [Module],
+    attrs_modules(More).
+
+
+%!  join_same_bindings(Bindings0, Bindings)
+%
+%   Join variables that are bound to the   same  value. Note that we
+%   return the _last_ value. This is   because the factorization may
+%   be different and ultimately the names will   be  printed as V1 =
+%   V2, ... VN = Value. Using the  last, Value has the factorization
+%   of VN.
+
+join_same_bindings([], []).
+join_same_bindings([Name=V0|T0], [[Name|Names]=V|T]) :-
+    take_same_bindings(T0, V0, V, Names, T1),
+    join_same_bindings(T1, T).
+
+take_same_bindings([], Val, Val, [], []).
+take_same_bindings([Name=V1|T0], V0, V, [Name|Names], T) :-
+    V0 == V1,
+    !,
+    take_same_bindings(T0, V1, V, Names, T).
+take_same_bindings([Pair|T0], V0, V, Names, [Pair|T]) :-
+    take_same_bindings(T0, V0, V, Names, T).
+
+
+%!  omit_qualifiers(+QGoals, +TypeIn, -Goals) is det.
+%
+%   Omit unneeded module qualifiers  from   QGoals  relative  to the
+%   given module TypeIn.
+
+
+omit_qualifiers([], _, []).
+omit_qualifiers([Goal0|Goals0], TypeIn, [Goal|Goals]) :-
+    omit_qualifier(Goal0, TypeIn, Goal),
+    omit_qualifiers(Goals0, TypeIn, Goals).
+
+omit_qualifier(M:G0, TypeIn, G) :-
+    M == TypeIn,
+    !,
+    omit_meta_qualifiers(G0, TypeIn, G).
+omit_qualifier(M:G0, TypeIn, G) :-
+    predicate_property(TypeIn:G0, imported_from(M)),
+    \+ predicate_property(G0, transparent),
+    !,
+    G0 = G.
+omit_qualifier(_:G0, _, G) :-
+    predicate_property(G0, built_in),
+    \+ predicate_property(G0, transparent),
+    !,
+    G0 = G.
+omit_qualifier(M:G0, _, M:G) :-
+    atom(M),
+    !,
+    omit_meta_qualifiers(G0, M, G).
+omit_qualifier(G0, TypeIn, G) :-
+    omit_meta_qualifiers(G0, TypeIn, G).
+
+omit_meta_qualifiers(V, _, V) :-
+    var(V),
+    !.
+omit_meta_qualifiers((QA,QB), TypeIn, (A,B)) :-
+    !,
+    omit_qualifier(QA, TypeIn, A),
+    omit_qualifier(QB, TypeIn, B).
+omit_meta_qualifiers(tnot(QA), TypeIn, tnot(A)) :-
+    !,
+    omit_qualifier(QA, TypeIn, A).
+omit_meta_qualifiers(freeze(V, QGoal), TypeIn, freeze(V, Goal)) :-
+    callable(QGoal),
+    !,
+    omit_qualifier(QGoal, TypeIn, Goal).
+omit_meta_qualifiers(when(Cond, QGoal), TypeIn, when(Cond, Goal)) :-
+    callable(QGoal),
+    !,
+    omit_qualifier(QGoal, TypeIn, Goal).
+omit_meta_qualifiers(G, _, G).
+
+
+%!  bind_vars(+BindingsIn, -Bindings)
+%
+%   Bind variables to '$VAR'(Name), so they are printed by the names
+%   used in the query. Note that by   binding  in the reverse order,
+%   variables bound to one another come out in the natural order.
+
+bind_vars(Bindings0, Bindings) :-
+    bind_query_vars(Bindings0, Bindings, SNames),
+    bind_skel_vars(Bindings, Bindings, SNames, 1, _).
+
+bind_query_vars([], [], []).
+bind_query_vars([binding(Names,Var,[Var2=Cycle])|T0],
+                [binding(Names,Cycle,[])|T], [Name|SNames]) :-
+    Var == Var2,                   % also implies var(Var)
+    !,
+    '$last'(Names, Name),
+    Var = '$VAR'(Name),
+    bind_query_vars(T0, T, SNames).
+bind_query_vars([B|T0], [B|T], AllNames) :-
+    B = binding(Names,Var,Skel),
+    bind_query_vars(T0, T, SNames),
+    (   var(Var), \+ attvar(Var), Skel == []
+    ->  AllNames = [Name|SNames],
+        '$last'(Names, Name),
+        Var = '$VAR'(Name)
+    ;   AllNames = SNames
+    ).
+
+
+
+bind_skel_vars([], _, _, N, N).
+bind_skel_vars([binding(_,_,Skel)|T], Bindings, SNames, N0, N) :-
+    bind_one_skel_vars(Skel, Bindings, SNames, N0, N1),
+    bind_skel_vars(T, Bindings, SNames, N1, N).
+
+%!  bind_one_skel_vars(+Subst, +Bindings, +VarName, +N0, -N)
+%
+%   Give names to the factorized variables that   do not have a name
+%   yet. This introduces names  _S<N>,   avoiding  duplicates.  If a
+%   factorized variable shares with another binding, use the name of
+%   that variable.
+%
+%   @tbd    Consider the call below. We could remove either of the
+%           A = x(1).  Which is best?
+%
+%           ==
+%           ?- A = x(1), B = a(A,A).
+%           A = x(1),
+%           B = a(A, A), % where
+%               A = x(1).
+%           ==
+
+bind_one_skel_vars([], _, _, N, N).
+bind_one_skel_vars([Var=Value|T], Bindings, Names, N0, N) :-
+    (   var(Var)
+    ->  (   '$member'(binding(Names, VVal, []), Bindings),
+            same_term(Value, VVal)
+        ->  '$last'(Names, VName),
+            Var = '$VAR'(VName),
+            N2 = N0
+        ;   between(N0, infinite, N1),
+            atom_concat('_S', N1, Name),
+            \+ memberchk(Name, Names),
+            !,
+            Var = '$VAR'(Name),
+            N2 is N1 + 1
+        )
+    ;   N2 = N0
+    ),
+    bind_one_skel_vars(T, Bindings, Names, N2, N).
+
+
+%!  factorize_bindings(+Bindings0, -Factorized)
+%
+%   Factorize cycles and sharing in the bindings.
+
+factorize_bindings([], []).
+factorize_bindings([Name=Value|T0], [binding(Name, Skel, Subst)|T]) :-
+    '$factorize_term'(Value, Skel, Subst0),
+    (   current_prolog_flag(toplevel_print_factorized, true)
+    ->  Subst = Subst0
+    ;   only_cycles(Subst0, Subst)
+    ),
+    factorize_bindings(T0, T).
+
+
+only_cycles([], []).
+only_cycles([B|T0], List) :-
+    (   B = (Var=Value),
+        Var = Value,
+        acyclic_term(Var)
+    ->  only_cycles(T0, List)
+    ;   List = [B|T],
+        only_cycles(T0, T)
+    ).
+
+
+%!  filter_bindings(+Bindings0, -Bindings)
+%
+%   Remove bindings that must not be printed. There are two of them:
+%   Variables whose name start with '_'  and variables that are only
+%   bound to themselves (or, unbound).
+
+filter_bindings([], []).
+filter_bindings([H0|T0], T) :-
+    hide_vars(H0, H),
+    (   (   arg(1, H, [])
+        ;   self_bounded(H)
+        )
+    ->  filter_bindings(T0, T)
+    ;   T = [H|T1],
+        filter_bindings(T0, T1)
+    ).
+
+hide_vars(binding(Names0, Skel, Subst), binding(Names, Skel, Subst)) :-
+    hide_names(Names0, Skel, Subst, Names).
+
+hide_names([], _, _, []).
+hide_names([Name|T0], Skel, Subst, T) :-
+    (   sub_atom(Name, 0, _, _, '_'),
+        current_prolog_flag(toplevel_print_anon, false),
+        sub_atom(Name, 1, 1, _, Next),
+        char_type(Next, prolog_var_start)
+    ->  true
+    ;   Subst == [],
+        Skel == '$VAR'(Name)
+    ),
+    !,
+    hide_names(T0, Skel, Subst, T).
+hide_names([Name|T0], Skel, Subst, [Name|T]) :-
+    hide_names(T0, Skel, Subst, T).
+
+self_bounded(binding([Name], Value, [])) :-
+    Value == '$VAR'(Name).
+
+%!  get_respons(-Action, +Chp)
+%
+%   Read the continuation entered by the user.
+
+:- if(current_prolog_flag(emscripten, true)).
+get_respons(Action, Chp) :-
+    '$can_yield',
+    !,
+    repeat,
+        await(more, CommandS),
+        atom_string(Command, CommandS),
+        more_action(Command, Chp, Action),
+        (   Action == again
+        ->  print_message(query, query(action)),
+            fail
+        ;   !
+        ).
+:- endif.
+get_respons(Action, Chp) :-
+    repeat,
+        flush_output(user_output),
+        get_single_char(Code),
+        find_more_command(Code, Command, Feedback, Style),
+        (   Style \== '-'
+        ->  print_message(query, if_tty([ansi(Style, '~w', [Feedback])]))
+        ;   true
+        ),
+        more_action(Command, Chp, Action),
+        (   Action == again
+        ->  print_message(query, query(action)),
+            fail
+        ;   !
+        ).
+
+find_more_command(-1, end_of_file, 'EOF', warning) :-
+    !.
+find_more_command(Code, Command, Feedback, Style) :-
+    more_command(Command, Atom, Feedback, Style),
+    '$in_reply'(Code, Atom),
+    !.
+find_more_command(Code, again, '', -) :-
+    print_message(query, no_action(Code)).
+
+more_command(help,        '?h',        '',          -).
+more_command(redo,        ';nrNR \t',  ';',         bold).
+more_command(trace,       'tT',        '; [trace]', comment).
+more_command(continue,    'ca\n\ryY.', '.',         bold).
+more_command(break,       'b',         '',          -).
+more_command(choicepoint, '*',         '',          -).
+more_command(write,       'w',         '[write]',   comment).
+more_command(print,       'p',         '[print]',   comment).
+more_command(depth_inc,   '+',         Change,      comment) :-
+    (   print_depth(Depth0)
+    ->  depth_step(Step),
+        NewDepth is Depth0*Step,
+        format(atom(Change), '[max_depth(~D)]', [NewDepth])
+    ;   Change = 'no max_depth'
+    ).
+more_command(depth_dec,   '-',         Change,      comment) :-
+    (   print_depth(Depth0)
+    ->  depth_step(Step),
+        NewDepth is max(1, Depth0//Step),
+        format(atom(Change), '[max_depth(~D)]', [NewDepth])
+    ;   Change = '[max_depth(10)]'
+    ).
+
+more_action(help, _, Action) =>
+    Action = again,
+    print_message(help, query(help)).
+more_action(redo, _, Action) =>			% Next
+    Action = redo.
+more_action(trace, _, Action) =>
+    Action = redo,
+    trace,
+    save_debug.
+more_action(continue, _, Action) =>             % Stop
+    Action = continue.
+more_action(break, _, Action) =>
+    Action = show_again,
+    break.
+more_action(choicepoint, Chp, Action) =>
+    Action = show_again,
+    print_last_chpoint(Chp).
+more_action(end_of_file, _, Action) =>
+    Action = show_again,
+    halt(0).
+more_action(again, _, Action) =>
+    Action = again.
+more_action(Command, _, Action),
+    current_prolog_flag(answer_write_options, Options0),
+    print_predicate(Command, Options0, Options) =>
+    Action = show_again,
+    set_prolog_flag(answer_write_options, Options).
+
+print_depth(Depth) :-
+    current_prolog_flag(answer_write_options, Options),
+    memberchk(max_depth(Depth), Options),
+    !.
+
+%!  print_predicate(+Action, +Options0, -Options) is semidet.
+%
+%   Modify  the  `answer_write_options`  value  according  to  the  user
+%   command.
+
+print_predicate(write, Options0, Options) :-
+    edit_options([-portrayed(true),-portray(true)],
+                 Options0, Options).
+print_predicate(print, Options0, Options) :-
+    edit_options([+portrayed(true)],
+                 Options0, Options).
+print_predicate(depth_inc, Options0, Options) :-
+    (   '$select'(max_depth(D0), Options0, Options1)
+    ->  depth_step(Step),
+        D is D0*Step,
+        Options = [max_depth(D)|Options1]
+    ;   Options = Options0
+    ).
+print_predicate(depth_dec, Options0, Options) :-
+    (   '$select'(max_depth(D0), Options0, Options1)
+    ->  depth_step(Step),
+        D is max(1, D0//Step),
+        Options = [max_depth(D)|Options1]
+    ;   D = 10,
+        Options = [max_depth(D)|Options0]
+    ).
+
+depth_step(5).
+
+edit_options([], Options, Options).
+edit_options([H|T], Options0, Options) :-
+    edit_option(H, Options0, Options1),
+    edit_options(T, Options1, Options).
+
+edit_option(-Term, Options0, Options) =>
+    (   '$select'(Term, Options0, Options)
+    ->  true
+    ;   Options = Options0
+    ).
+edit_option(+Term, Options0, Options) =>
+    functor(Term, Name, 1),
+    functor(Var, Name, 1),
+    (   '$select'(Var, Options0, Options1)
+    ->  Options = [Term|Options1]
+    ;   Options = [Term|Options0]
+    ).
+
+%!  print_last_chpoint(+Chp) is det.
+%
+%   Print the last choicepoint when an answer is nondeterministic.
+
+print_last_chpoint(Chp) :-
+    current_predicate(print_last_choice_point/0),
+    !,
+    print_last_chpoint_(Chp).
+print_last_chpoint(Chp) :-
+    use_module(library(prolog_stack), [print_last_choicepoint/2]),
+    print_last_chpoint_(Chp).
+
+print_last_chpoint_(Chp) :-
+    print_last_choicepoint(Chp, [message_level(information)]).
+
+
+                 /*******************************
+                 *          EXPANSION           *
+                 *******************************/
+
+:- user:dynamic(expand_query/4).
+:- user:multifile(expand_query/4).
+
+call_expand_query(Goal, Expanded, Bindings, ExpandedBindings) :-
+    (   '$replace_toplevel_vars'(Goal, Expanded0, Bindings, ExpandedBindings0)
+    ->  true
+    ;   Expanded0 = Goal, ExpandedBindings0 = Bindings
+    ),
+    (   user:expand_query(Expanded0, Expanded, ExpandedBindings0, ExpandedBindings)
+    ->  true
+    ;   Expanded = Expanded0, ExpandedBindings = ExpandedBindings0
+    ).
+
+
+:- dynamic
+    user:expand_answer/2,
+    prolog:expand_answer/3.
+:- multifile
+    user:expand_answer/2,
+    prolog:expand_answer/3.
+
+call_expand_answer(Goal, BindingsIn, BindingsOut) :-
+    (   prolog:expand_answer(Goal, BindingsIn, BindingsOut)
+    ->  true
+    ;   user:expand_answer(BindingsIn, BindingsOut)
+    ->  true
+    ;   BindingsOut = BindingsIn
+    ),
+    '$save_toplevel_vars'(BindingsOut),
+    !.
+call_expand_answer(_, Bindings, Bindings).