kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/nb_set.pl

@@ -0,0 +1,203 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2005-2025, VU University Amsterdam
+                              CWI, 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(nb_set,
+          [ empty_nb_set/1,		 % -EmptySet
+            add_nb_set/2,		 % +Key, !Set
+            add_nb_set/3,		 % +Key, !Set, ?New
+            size_nb_set/2,		 % +Set, -Size
+            nb_set_to_list/2,		 % +Set, -List
+            gen_nb_set/2                 % +Set, -Key
+          ]).
+:- autoload(library(terms), [term_factorized/3]).
+:- use_module(library(debug), [assertion/1]).
+
+/** <module> Non-backtrackable sets
+
+This library provides  a  non-backtrackabe  _set_   of  terms  that  are
+variants of each other. It is primarily intended to implement distinct/1
+from library(solution_sequences). The set is implemented as a hash table
+that is built using non-backtrackable primitives, notably nb_setarg/3.
+
+The original version of this library   used  binary trees which provides
+immediate ordering. As the trees were   not  balanced, performance could
+get   really   poor.   The   complexity   of   balancing   trees   using
+non-backtrackable primitives is too high. The  next iteration used _open
+hash tables_, while the current incarnation   uses _closed hash tables_,
+providing better perfomance and less space usage.
+
+@author Jan Wielemaker
+*/
+
+initial_capacity(4).                       % initial hash-table size
+
+%!  empty_nb_set(-Set)
+%
+%   Create an empty non-backtrackable set.
+
+empty_nb_set(NbSet) :-
+    initial_capacity(Capacity),
+    Empty = empty(1),
+    '$filled_array'(Buckets, buckets, Capacity, Empty),
+    NbSet = nb_set(Empty, Capacity, 0, Buckets).
+
+%!  add_nb_set(+Key, !Set) is det.
+%!  add_nb_set(+Key, !Set, ?New) is semidet.
+%
+%   Insert Key into the set. If  a   variant  (see  =@=/2) of Key is
+%   already in the set, the set is unchanged and New is unified with
+%   `false`. Otherwise, New is unified with   `true` and a _copy of_
+%   Key is added to the set.
+%
+%   @tbd    Computing the hash for cyclic terms is performed with
+%           the help of term_factorized/3, which performs rather
+%           poorly.
+
+add_nb_set(Key, Set) :-
+    add_nb_set(Key, Set, _).
+add_nb_set(Key, Set, New) :-
+    Set = nb_set(Empty, Capacity, Size, Buckets),
+    key_hash(Key, Hash),
+    index(Hash, Capacity, KIndex),
+        arg(KIndex, Buckets, StoredKey),
+        (   same_term(StoredKey, Empty)
+        ->  !,
+            New = true,
+            nb_setarg(KIndex, Buckets, Key),
+            NSize is Size+1,
+            nb_setarg(3, Set, NSize),
+            (   NSize > Capacity//2
+            ->  rehash(Set)
+            ;   true
+            )
+        ;   Key =@= StoredKey
+        ->  !,
+            New = false
+        ).
+
+%!  index(+Hash, +Capacity, -Index) is nondet.
+%
+%   Generate  candidate  values  for  Index,  starting  from  `Hash  mod
+%   Capacity`, round tripping to 1 when Capacity is reached.
+
+index(Hash, Capacity, KIndex) :-
+    KIndex0 is (Hash mod Capacity) + 1,
+    next(KIndex0, Capacity, KIndex).
+
+next(KIndex, _, KIndex).
+next(KIndex0, Capacity, KIndex) :-
+    KIndex1 is 1+(KIndex0 mod Capacity),
+    next(KIndex1, Capacity, KIndex).
+
+rehash(Set) :-
+    Set = nb_set(Empty, Capacity, Size, Buckets),
+    NCapacity is Capacity*2,
+    '$filled_array'(NBuckets, buckets, NCapacity, Empty),
+    nb_setarg(2, Set, NCapacity),
+    nb_setarg(3, Set, 0),
+    nb_linkarg(4, Set, NBuckets),
+    forall(between(1, Capacity, I),
+           reinsert(I, Empty, Buckets, Set)),
+    arg(3, Set, NewSize),
+    assertion(NewSize == Size).
+
+:- det(reinsert/4).
+reinsert(KIndex, Empty, Buckets, Set) :-
+    arg(KIndex, Buckets, Key),
+    (   same_term(Key, Empty)
+    ->  true
+    ;   add_nb_set(Key, Set, true)
+    ).
+
+%!  hash_key(+Key, -Hash:integer) is det.
+%
+%   Compute a hash for Term. Note that variant_hash/2 currently does
+%   not handle cyclic terms, so use  term_factorized/3 to get rid of
+%   the cycles. This means that  this   library  is rather slow when
+%   cyclic terms are involved.
+
+:- if(catch((A = f(A), variant_hash(A,_)), _, fail)).
+key_hash(Key, Hash) :-
+    variant_hash(Key, Hash).
+:- else.
+key_hash(Key, Hash) :-
+    acyclic_term(Key),
+    !,
+    variant_hash(Key, Hash).
+key_hash(Key, Hash) :-
+    term_factorized(Key, Skeleton, Substiution),
+    variant_hash(Skeleton+Substiution, Hash).
+:- endif.
+
+%!  nb_set_to_list(+NBSet, -OrdSet) is det.
+%!  nb_set_to_list(-NBSet, +List) is det.
+%
+%   Get the elements of a an nb_set.   OrdSet  is sorted to the standard
+%   order of terms, providing a set representation that is compatible to
+%   library(ordsets).
+
+nb_set_to_list(NBSet, Set),
+    NBSet = nb_set(Empty, Capacity, _Size, Buckets) =>
+    buckets_to_list(1, Empty, Capacity, Buckets, List0),
+    sort(List0, Set).
+
+buckets_to_list(KIndex, Empty, Capacity, Buckets, List) :-
+    (   arg(KIndex, Buckets, Key)
+    ->  (   same_term(Empty, Key)
+        ->  KIndex1 is KIndex+1,
+            buckets_to_list(KIndex1, Empty, Capacity, Buckets, List)
+        ;   List = [Key|List1],
+            KIndex1 is KIndex+1,
+            buckets_to_list(KIndex1, Empty, Capacity, Buckets, List1)
+        )
+    ;   List = []
+    ).
+
+%!  gen_nb_set(+Set, -Key) is nondet.
+%
+%   Enumerate the members of a set in the standard order of terms.
+
+gen_nb_set(nb_set(Empty, Capacity, _Size, Buckets), Key) =>
+    between(1, Capacity, KIndex),
+    arg(KIndex, Buckets, Key),
+    \+ same_term(Empty, Key).
+
+%!  size_nb_set(+Set, -Size) is det.
+%
+%   Unify Size with the number of elements in the set
+
+size_nb_set(nb_set(_Empty, _Capacity, Sz, _Buckets), Size) =>
+    Size = Sz.

package/lib/swipl/library/obfuscate.pl

@@ -0,0 +1,115 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2018, 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(obfuscate, []).
+
+/** <module> Code obfuscating
+
+This       module       provides       an       implementation       for
+prolog:obfuscate_identifiers/1, a hook into   library(qsave) that allows
+mapping atoms to other atoms while creating a saved state.
+
+This library is  used  by  qsave_program/2   and  the  `-c`  option. The
+following is good way to create a binary  version of your code that runs
+on a machine with the same version of SWI-Prolog installed.
+
+    swipl -o myprog -O --autoload=false --obfuscate=true -c load.pl
+
+This implementation is overly conservative: atoms   are  only renamed if
+they are used once. This is  verified   by  checking  the atom reference
+count. If this is `1`, the  atom  is   _only_  used  in the functor that
+defines the predicate.
+
+@tbd Using the current obfuscation scheme we  must verify that all usage
+of an atom refers to a predicate   name. Right now, declarations such as
+=|:- dynamic p/1.|= ensure `p` is used in   `p/1`  and p(_) and thus has
+two references.
+*/
+
+:- dynamic
+    nomap/1.
+
+prolog:obfuscate_identifiers(_) :-
+    print_message(informational, obfuscate(start)),
+    flag('$obfuscate_id', Old, 1),
+    forall(module_property(M, class(user)),
+           obfuscate_module(M)),
+    flag('$obfuscate_id', End, Old),
+    Obfuscated is End-Old,
+    print_message(informational, obfuscate(done(Obfuscated))).
+
+obfuscate_module(M) :-
+    forall(private_predicate(M:P),
+           obfuscate_predicate(M:P)).
+
+private_predicate(M:Head) :-
+    current_predicate(M:Name/Arity),
+    functor(Head, Name, Arity),
+    \+ predicate_property(M:Head, imported_from(_)),
+%   \+ predicate_property(M:Head, exported),
+    \+ predicate_property(M:Head, foreign),
+    \+ predicate_property(M:Head, public).
+
+obfuscate_predicate(_M:P) :-
+    functor(P, Name, _Arity),
+    '$atom_references'(Name, 1),
+    !,
+    flag('$obfuscate_id', Id, Id+1),
+    atom_concat('$P$', Id, Name2),
+    (   nomap(Name)
+    ->  true
+    ;   catch('$map_id'(Name, Name2), _, fail)
+    ->  print_message(silent, obfuscate(map(Name, Name2)))
+    ;   '$unmap_id'(Name),
+        asserta(nomap(Name))
+    ).
+obfuscate_predicate(_).
+
+
+		 /*******************************
+		 *            MESSAGES		*
+		 *******************************/
+
+:- multifile
+    prolog:message//1.
+
+prolog:message(obfuscate(Msg)) -->
+    message(Msg).
+
+message(start) -->
+    [ 'Obfuscating predicates names (conservative) ...'-[] ].
+message(done(Count)) -->
+    [ 'Obfuscated ~D predicate names'-[Count] ].
+message(map(From, To)) -->
+    [ 'Obfuscating ~q as ~q'-[From, To] ].

package/lib/swipl/library/occurs.pl

@@ -0,0 +1,241 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2001-2020, University of 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(occurs,
+          [ contains_term/2,            % +SubTerm, +Term
+            contains_var/2,             % +SubTerm, +Term
+            free_of_term/2,             % +SubTerm, +Term
+            free_of_var/2,              % +SubTerm, +Term
+            occurrences_of_term/3,      % +SubTerm, +Term, ?Tally
+            occurrences_of_var/3,       % +SubTerm, +Term, ?Tally
+            sub_term/2,                 % -SubTerm, +Term
+            sub_var/2,                  % -SubTerm, +Term (SWI extra)
+            sub_term_shared_variables/3 % +Sub, +Term, -Vars
+          ]).
+
+/** <module> Finding and counting sub-terms
+
+This  is  a  SWI-Prolog  implementation  of  the  corresponding  Quintus
+library, based on the generalised arg/3 predicate of SWI-Prolog.
+
+@see library(terms) provides similar predicates and is probably
+     more wide-spread than this library.
+*/
+
+%!  contains_term(+Sub, +Term) is semidet.
+%
+%   Succeeds if Sub is contained in Term (=, deterministically)
+
+contains_term(X, X) :- !.
+contains_term(X, Term) :-
+    compound(Term),
+    arg(_, Term, Arg),
+    contains_term(X, Arg),
+    !.
+
+
+%!  contains_var(+Sub, +Term) is semidet.
+%
+%   Succeeds if Sub is contained in Term (==, deterministically)
+
+contains_var(X0, X1) :-
+    X0 == X1,
+    !.
+contains_var(X, Term) :-
+    compound(Term),
+    arg(_, Term, Arg),
+    contains_var(X, Arg),
+    !.
+
+%!  free_of_term(+Sub, +Term) is semidet.
+%
+%   Succeeds of Sub does not unify to any subterm of Term
+
+free_of_term(Sub, Term) :-
+    \+ contains_term(Sub, Term).
+
+%!  free_of_var(+Sub, +Term) is semidet.
+%
+%   Succeeds of Sub is not equal (==) to any subterm of Term
+
+free_of_var(Sub, Term) :-
+    \+ contains_var(Sub, Term).
+
+%!  occurrences_of_term(@SubTerm, @Term, ?Count) is det.
+%
+%   Count the number of SubTerms in Term   that _unify_ with SubTerm. As
+%   this predicate is implemented using   backtracking, SubTerm and Term
+%   are not further instantiated. Possible constraints are enforced. For
+%   example, we can count the integers in Term using
+%
+%       ?- freeze(S, integer(S)), occurrences_of_term(S, f(1,2,a), C).
+%       C = 2,
+%       freeze(S, integer(S)).
+%
+%   @see occurrences_of_var/3 for an equality (==/2) based variant.
+
+occurrences_of_term(Sub, Term, Count) :-
+    count(sub_term(Sub, Term), Count).
+
+%!  occurrences_of_var(@SubTerm, @Term, ?Count) is det.
+%
+%   Count the number of SubTerms in Term   that  are _equal_ to SubTerm.
+%   Equality is tested using ==/2. Can be  used to count the occurrences
+%   of a particular variable in Term.
+%
+%   @see occurrences_of_term/3 for a unification (=/2) based variant.
+
+occurrences_of_var(Sub, Term, Count) :-
+    count(sub_var(Sub, Term), Count).
+
+%!  sub_term(-Sub, +Term)
+%
+%   Generates (on backtracking) all subterms of Term.
+
+sub_term(X, X).
+sub_term(X, Term) :-
+    compound(Term),
+    arg(_, Term, Arg),
+    sub_term(X, Arg).
+
+%!  sub_var(-Sub, +Term)
+%
+%   Generates (on backtracking) all subterms (==) of Term.
+
+sub_var(X0, X1) :-
+    X0 == X1.
+sub_var(X, Term) :-
+    compound(Term),
+    arg(_, Term, Arg),
+    sub_var(X, Arg).
+
+
+%!  sub_term_shared_variables(+Sub, +Term, -Vars) is det.
+%
+%   If Sub is a sub term of Term, Vars is bound to the list of variables
+%   in Sub that also appear  outside  Sub   in  Term.  Note  that if Sub
+%   appears twice in Term, its variables are all considered shared.
+%
+%   An  example  use-case  is  refactoring  a    large  clause  body  by
+%   introducing intermediate predicates. This predicate   can be used to
+%   find the arguments that must be passed to the new predicate.
+
+sub_term_shared_variables(Sub, Term, Vars) :-
+    term_replace_first(Term, Sub, true, Term2),
+    term_variables(Term2, AllVars),
+    term_variables(Sub, SubVars),
+    intersection_eq(SubVars, AllVars, Vars).
+
+term_replace_first(TermIn, From, To, TermOut) :-
+    term_replace_(TermIn, From, To, TermOut, done(_)).
+
+%term_replace(TermIn, From, To, TermOut) :-
+%    term_replace_(TermIn, From, To, TermOut, all).
+
+%!  term_replace_(+From, +To, +TermIn, -TermOut, +Done)
+%
+%   Replace instances (==/2) of From inside TermIn by To.
+
+term_replace_(TermIn, _From, _To, TermOut, done(Done)) :-
+    Done == true,
+    !,
+    TermOut = TermIn.
+term_replace_(TermIn, From, To, TermOut, Done) :-
+    From == TermIn,
+    !,
+    TermOut = To,
+    (   Done = done(Var)
+    ->  Var = true
+    ;   true
+    ).
+term_replace_(TermIn, From, To, TermOut, Done) :-
+    compound(TermIn),
+    compound_name_arity(TermIn, Name, Arity),
+    Arity > 0,
+    !,
+    compound_name_arity(TermOut, Name, Arity),
+    term_replace_compound(1, Arity, TermIn, From, To, TermOut, Done).
+term_replace_(Term, _, _, Term, _).
+
+term_replace_compound(I, Arity, TermIn, From, To, TermOut, Done) :-
+    I =< Arity,
+    !,
+    arg(I, TermIn, A1),
+    arg(I, TermOut, A2),
+    term_replace_(A1, From, To, A2, Done),
+    I2 is I+1,
+    term_replace_compound(I2, Arity, TermIn, From, To, TermOut, Done).
+term_replace_compound(_I, _Arity, _TermIn, _From, _To, _TermOut, _).
+
+%!  intersection_eq(+Small, +Big, -Shared) is det.
+%
+%   Shared are the variables in Small that   also appear in Big. The
+%   variables in Shared are in the same order as Small.
+
+intersection_eq([], _, []).
+intersection_eq([H|T0], L, List) :-
+    (   member_eq(H, L)
+    ->  List = [H|T],
+        intersection_eq(T0, L, T)
+    ;   intersection_eq(T0, L, List)
+    ).
+
+member_eq(E, [H|T]) :-
+    (   E == H
+    ->  true
+    ;   member_eq(E, T)
+    ).
+
+
+                 /*******************************
+                 *              UTIL            *
+                 *******************************/
+
+%!  count(:Goal, -Count)
+%
+%   Count number of times Goal succeeds.
+
+:- meta_predicate count(0,-).
+
+count(Goal, Count) :-
+    State = count(0),
+    (   Goal,
+        arg(1, State, N0),
+        N is N0 + 1,
+        nb_setarg(1, State, N),
+        fail
+    ;   arg(1, State, Count)
+    ).
+