kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/codesio.pl

@@ -0,0 +1,182 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2011-2015, University of Amsterdam
+                              VU University Amsterdam
+    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(codesio,
+          [ format_to_codes/3,          % +Format, +Args, -Codes
+            format_to_codes/4,          % +Format, +Args, -Codes, ?Tail
+            write_to_codes/2,           % +Term, -Codes
+            write_to_codes/3,           % +Term, -Codes, ?Tail
+            write_term_to_codes/3,      % +Term, -Codes, +Options
+            write_term_to_codes/4,      % +Term, -Codes, ?Tail, +Options
+                                        % read predicates
+            read_from_codes/2,          % +Codes, -Term
+            read_term_from_codes/3,     % +Codes, -Term, +Options
+            open_codes_stream/2,        % +Codes, -Stream
+            with_output_to_codes/2,     % :Goal, -Codes
+            with_output_to_codes/3,     % :Goal, -Codes, ?Tail
+            with_output_to_codes/4      % :Goal, -Stream, -Codes, ?Tail
+          ]).
+
+:- meta_predicate
+    with_output_to_codes(0, -),
+    with_output_to_codes(0, -, ?),
+    with_output_to_codes(0, -, -, ?).
+
+:- predicate_options(read_term_from_codes/3, 3,
+                     [pass_to(system:read_term/3, 3)]).
+:- predicate_options(write_term_to_codes/3, 3,
+                     [pass_to(system:write_term/3, 3)]).
+:- predicate_options(write_term_to_codes/4, 4,
+                     [pass_to(system:write_term/3, 3)]).
+
+/** <module> I/O on Lists of Character Codes
+
+This module emulates the SICStus  library   codesio.pl  for  reading and
+writing from/to lists of character codes.   Most of these predicates are
+straight calls into similar SWI-Prolog primitives.
+
+This library is based on library(charsio)   that originates from Quintus
+Prolog. The naming is updated to reflect  the ISO naming conventions and
+the ISO predicates atom_codes/2, etc  are  obviously  removed  from this
+library.
+
+@compat SICStus 4
+*/
+
+%!  format_to_codes(+Format, +Args, -Codes) is det.
+%
+%   Use format/2 to write to a list of character codes.
+
+format_to_codes(Format, Args, Codes) :-
+    format(codes(Codes), Format, Args).
+
+%!  format_to_codes(+Format, +Args, -Codes, ?Tail) is det.
+%
+%   Use format/2 to write to a difference list of character codes.
+
+format_to_codes(Format, Args, Codes, Tail) :-
+    format(codes(Codes, Tail), Format, Args).
+
+%!  write_to_codes(+Term, -Codes)
+%
+%   Codes is a list of character codes produced by write/1 on Term.
+
+write_to_codes(Term, Codes) :-
+    format(codes(Codes), '~w', [Term]).
+
+%!  write_to_codes(+Term, -Codes, ?Tail)
+%
+%   Codes is a difference-list of character codes produced by write/1 on Term.
+
+write_to_codes(Term, Codes, Tail) :-
+    format(codes(Codes, Tail), '~w', [Term]).
+
+%!  write_term_to_codes(+Term, -Codes, +Options) is det.
+%
+%   True  when  Codes  is  a  string  that  matches  the  output  of
+%   write_term/3 using Options.
+
+write_term_to_codes(Term, Codes, Options) :-
+    format(codes(Codes), '~W', [Term, Options]).
+
+%!  write_term_to_codes(+Term, -Codes, ?Tail, +Options) is det.
+%
+%   True  when  Codes\Tail  is  a  difference  list  containing  the
+%   character codes that matches the   output  of write_term/3 using
+%   Options.
+
+write_term_to_codes(Term, Codes, Tail, Options) :-
+    format(codes(Codes, Tail), '~W', [Term, Options]).
+
+%!  read_from_codes(+Codes, -Term) is det.
+%
+%   Read Codes into Term.
+%
+%   @compat The SWI-Prolog version does not require Codes to end
+%           in a full-stop.
+
+read_from_codes([], Term) :-
+    !,
+    Term = end_of_file.
+read_from_codes(List, Term) :-
+    atom_to_term(List, Term, _).
+
+%!  read_term_from_codes(+Codes, -Term, +Options) is det.
+%
+%   Read Codes into Term.  Options are processed by read_term/3.
+%
+%   @compat sicstus
+
+read_term_from_codes(Codes, Term, Options) :-
+    read_term_from_atom(Codes, Term, Options).
+
+%!  open_codes_stream(+Codes, -Stream) is det.
+%
+%   Open Codes as an input stream.
+%
+%   @see open_string/2.
+
+open_codes_stream(Codes, Stream) :-
+    open_string(Codes, Stream).
+
+%!  with_output_to_codes(:Goal, Codes) is det.
+%
+%   Run Goal with as once/1.  Output written to =current_output=
+%   is collected in Codes.
+
+with_output_to_codes(Goal, Codes) :-
+    with_output_to(codes(Codes), Goal).
+
+%!  with_output_to_codes(:Goal, -Codes, ?Tail) is det.
+%
+%   Run Goal with as once/1.  Output written to =current_output=
+%   is collected in Codes\Tail.
+
+with_output_to_codes(Goal, Codes, Tail) :-
+    with_output_to(codes(Codes, Tail), Goal).
+
+%!  with_output_to_codes(:Goal, -Stream, -Codes, ?Tail) is det.
+%
+%   As  with_output_to_codes/3,  but  Stream  is  unified  with  the
+%   temporary  stream.  This  predicate   exists  for  compatibility
+%   reasons. In SWI-Prolog, the temporary   stream is also available
+%   as `current_output`.
+
+with_output_to_codes(Goal, Stream, Codes, Tail) :-
+    with_output_to(codes(Codes, Tail), with_stream(Stream, Goal)).
+
+with_stream(Stream, Goal) :-
+    current_output(Stream),
+    call(Goal).

package/lib/swipl/library/coinduction.pl

@@ -0,0 +1,183 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2010-2011, VU University Amsterdam
+    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(coinduction,
+          [ (coinductive)/1,
+            op(1150, fx, (coinductive))
+          ]).
+:- autoload(library(error),[instantiation_error/1,must_be/2]).
+
+
+/** <module> Co-Logic Programming
+
+This simple module implements the   directive coinductive/1 as described
+in "Co-Logic Programming: Extending Logic  Programming with Coinduction"
+by Luke Simon et al. The idea behind coinduction is that a goal succeeds
+if it unifies to a parent goal.  This enables some interesting programs,
+notably on infinite trees (cyclic terms).
+
+    ==
+    :- use_module(library(coinduction)).
+
+    :- coinductive p/1.
+
+    p([1|T]) :- p(T).
+    ==
+
+This predicate is  true  for  any   cyclic  list  containing  only  1-s,
+regardless of the cycle-length.
+
+@bug    Programs mixing normal predicates and coinductive predicates must
+        be _stratified_.  The theory does not apply to normal Prolog calling
+        coinductive predicates, calling normal Prolog predicates, etc.
+
+        Stratification is not checked or enforced in any other way and thus
+        left as a responsibility to the user.
+@see    "Co-Logic Programming: Extending Logic  Programming with Coinduction"
+        by Luke Simon et al.
+*/
+
+:- multifile
+    system:term_expansion/2,
+    coinductive_declaration/2.      % Head, Module
+
+%!  head(+Term, -QHead) is semidet.
+%
+%   Must be first to allow reloading!
+
+head(Var, _) :-
+    var(Var), !, fail.
+head((H:-_B), Head) :-
+    !,
+    head(H, Head).
+head(H, Head) :-
+    (   H = _:_
+    ->  Head = H
+    ;   prolog_load_context(module, M),
+        Head = M:H
+    ).
+
+%!  coinductive(:Spec)
+%
+%   The  declaration  :-   coinductive    name/arity,   ...  defines
+%   predicates as _coinductive_. The predicate definition is wrapped
+%   such that goals unify with their  ancestors. This directive must
+%   precede all clauses of the predicate.
+
+coinductive(Spec) :-
+    throw(error(context_error(nodirective, coinductive(Spec)), _)).
+
+expand_coinductive_declaration(Spec, Clauses) :-
+    prolog_load_context(module, Module),
+    phrase(expand_specs(Spec, Module), Clauses).
+
+expand_specs(Var, _) -->
+    { var(Var),
+      !,
+      instantiation_error(Var)
+    }.
+expand_specs(M:Spec, _) -->
+    !,
+    expand_specs(Spec, M).
+expand_specs((A,B), Module) -->
+    !,
+    expand_specs(A, Module),
+    expand_specs(B, Module).
+expand_specs(Head, Module) -->
+    { valid_pi(Head, Name, Arity),
+      functor(GenHead, Name, Arity)
+    },
+    [ coinduction:coinductive_declaration(GenHead, Module) ].
+
+
+valid_pi(Name/Arity, Name, Arity) :-
+    must_be(atom, Name),
+    must_be(integer, Arity).
+
+
+%!  wrap_coinductive(+Head, +Term, -Clauses) is det.
+%
+%   Create a wrapper. The first clause deal   with the case where we
+%   already created the wrapper. The second  creates the wrapper and
+%   the first clause.
+
+wrap_coinductive(Pred, Term, Clause) :-
+    current_predicate(_, Pred),
+    !,
+    rename_clause(Term, 'coinductive ', Clause).
+wrap_coinductive(Pred, Term, [Wrapper_1,Wrapper_2,FirstClause]) :-
+    Pred = M:Head,
+    functor(Head, Name, Arity),
+    length(Args, Arity),
+    GenHead =.. [Name|Args],
+    atom_concat('coinductive ', Name, WrappedName),
+    WrappedHead =.. [WrappedName|Args],
+    Wrapper_1 = (GenHead :-
+                    prolog_current_frame(F),
+                    prolog_frame_attribute(F, parent, FP),
+                    prolog_frame_attribute(FP, parent_goal, M:GenHead)),
+    Wrapper_2 = (GenHead :- WrappedHead, coinduction:no_lco),
+    rename_clause(Term, 'coinductive ', FirstClause).
+
+:- public no_lco/0.
+
+no_lco.                                 % true, but do not optimize away
+
+%!  rename_clause(+Clause, +Prefix, -Renamed) is det.
+%
+%   Rename a clause by prefixing its old name wit h Prefix.
+
+rename_clause((Head :- Body), Prefix, (NewHead :- Body)) :-
+    !,
+    rename_clause(Head, Prefix, NewHead).
+rename_clause(M:Head, Prefix, M:NewHead) :-
+    rename_clause(Head, Prefix, NewHead).
+rename_clause(Head, Prefix, NewHead) :-
+    Head =.. [Name|Args],
+    atom_concat(Prefix, Name, WrapName),
+    NewHead =.. [WrapName|Args].
+
+
+                 /*******************************
+                 *        EXPANSION HOOKS       *
+                 *******************************/
+
+system:term_expansion((:- coinductive(Spec)), Clauses) :-
+    expand_coinductive_declaration(Spec, Clauses).
+system:term_expansion(Term, Wrapper) :-
+    head(Term, Module:Head),
+    coinductive_declaration(Head, Module),
+    wrap_coinductive(Module:Head, Term, Wrapper).
+
+

package/lib/swipl/library/console_input.pl

@@ -0,0 +1,289 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        jan@swi-prolog.org
+    WWW:           https://www.swi-prolog.org
+    Copyright (c)  2013-2026, 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(prolog_console_input,
+          [
+          ]).
+:- autoload(library(lists), [reverse/2, append/2]).
+:- autoload(library(dcg/basics), [remainder/3]).
+:- autoload(library(apply), [maplist/3, convlist/3]).
+
+/** <module> Support entering toplevel queries
+
+This module implements prolog:complete_input/4, which is used notably by
+the command line editor  library(edit)  to   perform  context  aware TAB
+completion. It is a seperate library such that other input scenarios can
+reuse this code.
+*/
+
+
+:- multifile
+    prolog:complete_input/4.
+
+%!  prolog:complete_input(+BeforeCursor:string, +AfterCursor:string,
+%!                        -Delete:atom, -Completions:list) is semidet.
+%
+%   Compute    auto    completions    for      the     input    line
+%   BeforeCursor+AfterCursor.  Implemented completions
+%
+%     - Files<br>
+%       - Text starting ``'<prefix>`` (single quotes) is completed as a
+%         file. If there is a single matching file a terminating `'` is
+%         added.
+%       - If the start of the line is ``[<prefix>`` and text can be
+%         a non-quoted atom, look for Prolog files with this name.
+%         Directories can be inserted as `/` (unquoted), as long as
+%         each _segment_ is a valid atom.  If a single ``.pl`` file
+%         is found it is closed with ``]``, _without_ the extension.
+%       - Text starting ``library(<prefix>`` is completed as a
+%         library file using the same rules as ``[<prefix>``, but
+%         looking in all library directories instead of the current
+%         directory.
+%     - Atoms<br>
+%       ``<prefix>`` is used to complete atoms that can be written
+%       without quotes (excluding symbol atoms such as ``-->``) and
+%       are _permanent_, i.e., have references from clauses records,
+%       flags, foreign code, etc.
+%     - Variables<br>
+%       ``<Prefix>`` is completed as an atom if it is a valid variable
+%       name.  It is completed with other atoms from the query being
+%       edited using the same search as Emacs _dabbrev_ (_Dynamic
+%       Abbreviation_). ``$<Prefix>`` expands to saved toplevel
+%       variables.
+%
+%   @arg    Delete is an atom or string representing the text that is
+%           replaced by the completion
+%   @arg    Completions is a list of elements of this shape:
+%
+%             - Atom
+%             Used for a plain completion without comment
+%             - Atom-Comment
+%             Used for a completion with comment.  This will be
+%             used for predicates.
+
+prolog:complete_input(Before, After, Delete, Completions) :-
+    string_codes(Before, Chars),
+    reverse(Chars, BeforeRev),
+    complete(BeforeRev, After, Delete, Completions).
+
+complete(BeforeRev, _After, Prefix, Files) :-   % complete files
+    phrase(file_prefix(Prefix, Type), BeforeRev),
+    !,
+    (   Type = library(Close)
+    ->  complete_library(Prefix, Close, Files)
+    ;   atom_concat(Prefix, '*', Pattern),
+        expand_file_name(Pattern, Files0),
+        finish_file_name(Files0, Type, Files)
+    ).
+complete(BeforeRev, After, Prefix, Completions) :-   % complete atoms
+    phrase(identifier_prefix_r(Prefix, Type), BeforeRev, BeforeRev1),
+    !,
+    identifier_completions(Type, Prefix, BeforeRev1, After, Completions).
+
+identifier_completions(atom, Prefix, _, _, Atoms) :-
+    '$atom_completions'(Prefix, Atoms).
+identifier_completions(var, Prefix, BeforeRev, After, Vars) :-
+    findall(Var, var_starts(Prefix, BeforeRev, After, Var), Vars0),
+    sort(Vars0, Vars).
+
+var_starts(Prefix, [0'$|_], _After, Var) :-        % $Var
+    !,
+    recorded('$topvar', Var = _),
+    sub_atom(Var, 0, _, _, Prefix).
+var_starts(Prefix, BeforeRev, _After, Var) :-        % Backard search
+    phrase((..., nonid_char, identifier_prefix_r(Var, var)),
+           BeforeRev, _),
+    sub_string(Var, 0, _, _, Prefix).
+var_starts(Prefix, _BeforeRev, AfterString, Var) :-  % Forward search
+    string_codes(AfterString, After),
+    phrase((..., nonid_char, identifier_prefix(Var, var)),
+           After, _),
+    sub_string(Var, 0, _, _, Prefix).
+
+... --> [] ; [_], ... .
+
+nonid_char -->
+    [C],
+    { \+ code_type(C, prolog_identifier_continue) }.
+
+%!  identifier_prefix(-Prefix, -Type)   is semidet.
+%!  identifier_prefix_r(-Prefix, -Type) is semidet.
+
+identifier_prefix(Prefix, Type) -->
+    atom_chars(String),
+    { String = [H|_],
+      (   code_type(H, prolog_var_start)
+      ->  Type = var
+      ;   Type = atom
+      ),
+      string_codes(Prefix, String) % do not create an atom
+    }.
+
+identifier_prefix_r(Prefix, Type) -->
+    atom_chars(RevString),
+    { reverse(RevString, String),
+      String = [H|_],
+      (   code_type(H, prolog_var_start)
+      ->  Type = var
+      ;   Type = atom
+      ),
+      string_codes(Prefix, String) % do not create an atom
+    }.
+
+atom_chars([H|T]) --> atom_char(H), !, atom_chars(T).
+atom_chars([]) --> [].
+
+atom_char(C) --> [C], { atom_char(C) }.
+
+atom_char(C) :- code_type(C, prolog_identifier_continue).
+
+%!  file_prefix(-Prefix, -Type)// is semidet.
+%
+%   True when the part before the cursor looks like a file name.
+
+file_prefix(Prefix, file) -->
+    file_chars(RevString, quoted('\'')), "'",
+    !,
+    remainder(_),
+    { reverse(RevString, String),
+      atom_codes(Prefix, String)
+    }.
+file_prefix(Prefix, consult(']')) -->
+    file_chars(RevString, unquoted), "[",
+    !,
+    { reverse(RevString, String),
+      atom_codes(Prefix, String)
+    }.
+file_prefix(Prefix, library(')')) -->
+    file_chars(RevString, unquoted), "(yrarbil",
+    !,
+    remainder(_),
+    { reverse(RevString, String),
+      atom_codes(Prefix, String)
+    }.
+
+file_chars([H|T], Style) --> file_char(H, Style), !, file_chars(T, Style).
+file_chars([], _) --> [].
+
+file_char(C, Style) --> [C], { file_char(C, Style) }.
+
+file_char(C, _) :- code_type(C, csym).
+file_char(0'/, _).
+file_char(C, quoted(_)) :-
+    file_char(C).
+
+file_char(0'.).
+file_char(0'-).
+file_char(0'~).
+:- if(current_prolog_flag(windows,true)).
+file_char(0':).
+file_char(0'\s).
+:- endif.
+
+%!  finish_file_name(+Matches, -Completions) is det.
+%
+%   Add closing quote for a unique file name.
+
+finish_file_name([Dir0], _, [Dir]) :-
+    exists_directory(Dir0),
+    !,
+    atom_concat(Dir0, '/', Dir).
+finish_file_name([File0], Close, [File]) :-
+    exists_file(File0),
+    close_file_name(File0, Close, File),
+    !.
+finish_file_name(Files0, _, Files) :-
+    maplist(tag_dir, Files0, Files).
+
+tag_dir(Dir, DirS) :-
+    exists_directory(Dir),
+    !,
+    atom_concat(Dir, /, DirS).
+tag_dir(File, File).
+
+close_file_name(File0, consult(Close), File) :-
+    file_name_extension(Base, Ext, File0),
+    user:prolog_file_type(Ext, prolog),
+    atom_concat(Base, Close, File).
+close_file_name(File0, quoted(Close), File) :-
+    atom_concat(File0, Close, File).
+
+%!  complete_library(+Prefix:atom, +Close:atom, -Completions:list) is
+%!                   semidet.
+%
+%   Complete to a library entry on "library(Prefix".
+
+complete_library(Prefix, Close, Libraries) :-
+    findall(Pairs, complete_one_libdir(Prefix, Pairs), DirPairs),
+    (   DirPairs = [LibDir-[f(File)]]
+    ->  atom_concat(LibDir, Local, File),
+        atom_concat(Local, Close, Completion),
+        Libraries = [Completion]
+    ;   DirPairs = [LibDir-[d(Dir)]]
+    ->  atom_concat(LibDir, Local, Dir),
+        atom_concat(Local, '/', Completion),
+        Libraries = [Completion]
+    ;   maplist(local_libs, DirPairs, FilesLists),
+        append(FilesLists, Libraries0),
+        sort(Libraries0, Libraries)
+    ).
+
+complete_one_libdir(Prefix, LibdirS-Files) :-
+    absolute_file_name(library(.), LibDir,
+                       [ file_type(directory),
+                         solutions(all)
+                       ]),
+    atom_concat(LibDir, /, LibdirS),
+    atomic_list_concat([LibdirS, Prefix, '*'], Pattern),
+    expand_file_name(Pattern, Entries),
+    convlist(dir_or_source, Entries, Files0),
+    sort(Files0, Files),
+    Files \== [].
+
+local_libs(LibDir-Members, Locals) :-
+    maplist(local_file_name(LibDir), Members, Locals).
+
+local_file_name(LibDir, f(File), Local) :-
+    atom_concat(LibDir, Local, File).
+local_file_name(LibDir, d(Dir), Local) :-
+    atom_concat(LibDir, Local0, Dir),
+    atom_concat(Local0, /, Local).
+
+dir_or_source(Entry, f(Plain)) :-
+    file_name_extension(Plain, Ext, Entry),
+    user:prolog_file_type(Ext, prolog),
+    !.
+dir_or_source(Entry, d(Entry)) :-
+    exists_directory(Entry).