kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/prolog_evaluable.pl

@@ -0,0 +1,234 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        jan@swi-prolog.org
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2023, 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_evaluable,
+          [ evaluable_property/2
+          ]).
+:- autoload(library(prolog_code), [most_general_goal/2]).
+:- autoload(library(error), [must_be/2]).
+
+/** <module> Inspect properties of evaluable functions
+*/
+
+%!  evaluable_property(?Function, ?Property) is nondet.
+%
+%   True when Property is a property of the evaluable function Function.
+%   _Evaluable functions_ are expressions processed   by  the arithmetic
+%   predicates is/2, </2, =</2, =:=/2, >/2  and >=/2. Defined properties
+%   are:
+%
+%     - built_in
+%       Function is built-in. The proposal defines additional properties
+%       for systems that allow defining new functions at runtime.
+%       SWI-Prolog provides library(arithmetic) for this, which rewrites
+%       the source as interleaved predicate calls and built-in function
+%       evaluation.
+%     - iso
+%       Function is part of the ISO standard. This does, for SWI-Prolog,
+%       __not__ imply that the implementation satisfies the ISO
+%       standard.  It implies that it implements the same mathematical
+%       operation as specified by the standard.  The returned type may
+%       be more precise and may, depending on Prolog flags, return
+%       non-normal floats where the ISO standard demands an exception.
+%     - template(Function, Return)
+%       Type support.  Types used are `integer`, `rational` and `float`.
+%       Functions that copy the type to the output use a variable to
+%       indicate this, e.g., template(-Type, Type).  A function may
+%       have multiple type templates.
+%
+%   Future versions may provide this predicate as a built-in.
+%
+%   @compat discussed by several implementors, initiated by Paulo Moura.
+%   @arg Function is a variable or _callable_ term.  If it is a callable
+%   term, only the name and arity are considered to denote the
+%   evaluable.
+
+evaluable_property(Templ, built_in), nonvar(Templ), \+ callable(Templ) =>
+    must_be(callable, Templ).
+evaluable_property(Templ, built_in) =>
+    current_arithmetic_function(Templ).
+evaluable_property(Templ, iso) =>
+    iso_function(Templ).
+evaluable_property(Templ, template(Term, Ret)) =>
+    most_general_goal(Templ, Term),
+    eval_type(Term, Ret).
+evaluable_property(Templ, Prop), var(Prop) =>
+    eval_prop(Prop),
+    evaluable_property(Templ, Prop).
+evaluable_property(_, _) =>             % fail on unknown properties.
+    fail.                               % Proposal demands a domain_error.
+
+eval_prop(built_in).
+eval_prop(template(_,_)).
+eval_prop(iso).
+
+eval_type(float*_,float).
+eval_type(_*float,float).
+eval_type(rational*rational,rational).
+eval_type(float**_,float).
+eval_type(_**float,float).
+eval_type(rational**rational,rational).
+eval_type(rational**rational,float).
+eval_type(+Type,Type).
+eval_type(float+_,float).
+eval_type(_+float,float).
+eval_type(rational+rational,rational).
+eval_type(-Type,Type).
+eval_type(float-_,float).
+eval_type(_-float,float).
+eval_type(rational-rational,rational).
+eval_type(float/_,float).
+eval_type(_/float,float).
+eval_type(rational/rational,rational).
+eval_type(rational/rational,float).
+eval_type(_//_,integer).
+eval_type(integer/\integer,integer).
+eval_type(integer<<integer,integer).
+eval_type(integer>>integer,integer).
+eval_type(\integer,integer).
+eval_type(integer\/integer,integer).
+eval_type(float^_,float).
+eval_type(_^float,float).
+eval_type(rational^rational,rational).
+eval_type(rational^rational,float).
+eval_type(abs(Type),Type).
+eval_type(acos(_),float).
+eval_type(acosh(_),float).
+eval_type(asin(_),float).
+eval_type(asinh(_),float_).
+eval_type(atan(_),float).
+eval_type(atan(_,_),float).
+eval_type(atan2(_,_),float).
+eval_type(atanh(_),float).
+eval_type(ceil(_),integer).
+eval_type(ceiling(_),integer).
+eval_type(cmpr(_,_),integer).
+eval_type(copysign(Type,_),Type).
+eval_type(cos(_),float).
+eval_type(cosh(_),float).
+eval_type(cputime,float).
+eval_type(denominator(rational),integer).
+eval_type(_ div _,integer).
+eval_type(e,float).
+eval_type(epsilon,float).
+eval_type(erf(_),float).
+eval_type(erfc(_),float).
+eval_type(eval(Type),Type).
+eval_type(exp(_),float).
+eval_type(float(_),float).
+eval_type(float_fractional_part(Type),Type).
+eval_type(float_integer_part(Type),Type).
+eval_type(floor(_),integer).
+eval_type(gcd(integer,integer),integer).
+eval_type(getbit(integer,integer),integer).
+eval_type(inf,float).
+eval_type(integer(_),integer).
+eval_type(lcm(integer,integer),integer).
+eval_type(lgamma(_),float).
+eval_type(log(_),float).
+eval_type(log10(_),float).
+eval_type(lsb(integer),integer).
+eval_type(max(Type,_),Type).
+eval_type(max(_,Type),Type).
+eval_type(maxr(Type,_),Type).
+eval_type(maxr(_,Type),Type).
+eval_type(min(Type,_),Type).
+eval_type(min(_,Type),Type).
+eval_type(minr(Type,_),Type).
+eval_type(minr(_,Type),Type).
+eval_type(integer mod integer,integer).
+eval_type(msb(integer),integer).
+eval_type(nan,float).
+eval_type(nexttoward(_,_),float).
+eval_type(numerator(rational),integer).
+eval_type(pi,float).
+eval_type(popcount(integer),integer).
+eval_type(powm(integer,integer,integer),integer).
+eval_type(random(integer),integer).
+eval_type(random_float,float).
+eval_type(rational(_),rational).
+eval_type(rationalize(_),rational).
+eval_type(rational rdiv rational,rational).
+eval_type(integer rem integer,integer).
+eval_type(round(_),integer).
+eval_type(roundtoward(_,_),float).
+eval_type(sign(_),integer).
+eval_type(sin(_),float).
+eval_type(sinh(_),float).
+eval_type(sqrt(_),float).
+eval_type(tan(_),float).
+eval_type(tanh(_),float).
+eval_type(truncate(_),integer).
+eval_type(integer xor integer,integer_).
+
+% ISO core
+iso_function(_+_).
+iso_function(_-_).
+iso_function(_*_).
+iso_function(_//_).
+iso_function(_/_).
+iso_function(rem(_,_)).
+iso_function(mod(_,_)).
+iso_function(-_).
+iso_function(abs(_)).
+iso_function(sign(_)).
+iso_function(float_integer_part(_)).
+iso_function(float_fractional_part(_)).
+iso_function(float(_)).
+iso_function(floor(_)).
+iso_function(truncate(_)).
+iso_function(round(_)).
+iso_function(ceiling(_)).
+iso_function(_**_).
+iso_function(sin(_)).
+iso_function(cos(_)).
+iso_function(atan(_)).
+iso_function(exp(_)).
+iso_function(log(_)).
+iso_function(sqrt(_)).
+iso_function(_>>_).
+iso_function(_<<_).
+iso_function(_/\_).
+iso_function(_\/_).
+iso_function(\_).
+% Correndum 2
+iso_function(max(_,_)).
+iso_function(min(_,_)).
+iso_function(_^_).
+iso_function(asin(_)).
+iso_function(acos(_)).
+iso_function(atan(_,_)).
+iso_function(tan(_)).
+iso_function(pi).
+iso_function(xor(_,_)).

package/lib/swipl/library/prolog_format.pl

@@ -0,0 +1,219 @@
+/*  Part of SWI-Prolog
+
+    Author:        Michael Hendricks
+    E-mail:        michael@ndrix.org
+    WWW:           http://www.swi-prolog.org
+    Copyright (C): 2013,2020, Michael Hendricks
+    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 HOLDER 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_format,
+          [ format_spec/2,                      % +Format, -Spec
+            format_spec//1,                     % -Spec
+            format_types/2                      % +Format, -Types
+          ]).
+:- autoload(library(error),[existence_error/2]).
+:- autoload(library(dcg/basics),[eos//0,string_without//2,integer//1]).
+
+
+/** <module> Analyse format specifications
+
+This library parses the format specification  used by format/1, format/2
+and format/3. The parsed  specification  can   be  used  to validate the
+consistency of the  format  string  and   the  provided  arguments.  For
+example:
+
+  ==
+  ?- format_types('~d bottles of beer', Types).
+  Types = [integer].
+  ==
+
+@tbd    The current implementation does not support format_predicate/2.
+@see    http://www.swi-prolog.org/pack/list?p=format_spec
+@author Michael Hendricks
+*/
+
+%%  format_spec(+Format, -Spec:list) is det.
+%
+%   Parse a format string. Each element of Spec is one of the following:
+%
+%    * text(Text)
+%    Text sent to the output as is
+%    * escape(Num,Colon,Action)
+%    A format escape. Num represents the optional numeric portion of
+%    an esape. Colon represents the optional colon in an escape.
+%    Action is an atom representing the action to be take by this
+%    escape.
+
+format_spec(Format, Spec) :-
+    (   is_list(Format)
+    ->  Codes = Format
+    ;   string_codes(Format, Codes)
+    ),
+    phrase(format_spec(Spec), Codes).
+
+%%  format_spec(-Spec)// is det.
+%
+%   DCG for parsing format  strings.  It   doesn't  yet  generate format
+%   strings from a spec. See format_spec/2 for details.
+
+format_spec([escape(Numeric,Modifier,Action)|Rest]) -->
+    "~",
+    !,
+    numeric_argument(Numeric),
+    modifier_argument(Modifier),
+    action(Action),
+    format_spec(Rest).
+format_spec([text(String)|Rest]) -->
+    string_without("~", Codes),
+    { Codes \== [],
+      !,
+      string_codes(String, Codes)
+    },
+    format_spec(Rest).
+format_spec([]) -->
+    [].
+
+%%  format_types(+Format:text, -Types:list) is det.
+%
+%   True when Format requires an argument list   with  terms of the type
+%   specified by Types. The  length  of  this   list  is  the  number of
+%   arguments required. Each value of Types is   a  type as described by
+%   error:has_type/2.
+
+format_types(Format, Types) :-
+    format_spec(Format, Spec),
+    spec_types(Spec, Types).
+
+%%  spec_types(+FormatSpec, -Types:list(type)) is det.
+%
+%   True if FormatSpec requires format/2  to   have  arguments of Types.
+%   Each value of Types is a type as described by error:has_type/2. This
+%   notion of types is compatible with library(mavis).
+
+spec_types(Spec, Types) :-
+    phrase(spec_types(Spec), Types).
+
+spec_types([]) -->
+    [].
+spec_types([Item|Items]) -->
+    item_types(Item),
+    spec_types(Items).
+
+item_types(text(_)) -->
+    [].
+item_types(escape(Numeric,_,Action)) -->
+    numeric_types(Numeric),
+    action_types(Action).
+
+numeric_types(number(_)) -->
+    [].
+numeric_types(character(_)) -->
+    [].
+numeric_types(star) -->
+    [number].
+numeric_types(nothing) -->
+    [].
+
+action_types(Action) -->
+    { atom_codes(Action, [Code]) },
+    { action_types(Code, Types) },
+    phrase(Types).
+
+numeric_argument(number(N)) -->
+    integer(N),
+    !.
+numeric_argument(character(C)) -->
+    "`",
+    !,
+    [C].
+numeric_argument(star) -->
+    "*",
+    !.
+numeric_argument(nothing) -->
+    "".
+
+modifier_argument(colon) -->
+    ":".
+modifier_argument(no_colon) -->
+    \+ ":".
+
+action(Char) -->
+    [C],
+    { char_code(Char, C),
+      (   is_action(C)
+      ->  true
+      ;   existence_error(format_character, Char)
+      )
+    }.
+
+%%  is_action(+Action:integer) is semidet.
+%%  is_action(-Action:integer) is multi.
+%
+%   True if Action is a valid   format/2  action character. Iterates all
+%   acceptable action characters, if Action is unbound.
+
+is_action(Action) :-
+    action_types(Action, _).
+
+%%  action_types(?Action:integer, ?Types:list(type))
+%
+%   True if Action consumes arguments matching   Types.  An action (like
+%   `~`), which consumes no arguments, has `Types=[]`. For example,
+%
+%       ?- action_types(0'~, Types).
+%       Types = [].
+%       ?- action_types(0'a, Types).
+%       Types = [atom].
+
+action_types(0'~, []).
+action_types(0'a, [atom]).
+action_types(0'c, [integer]).  % specifically, a code
+action_types(0'd, [integer]).
+action_types(0'D, [integer]).
+action_types(0'e, [float]).
+action_types(0'E, [float]).
+action_types(0'f, [float]).
+action_types(0'g, [float]).
+action_types(0'G, [float]).
+action_types(0'i, [any]).
+action_types(0'I, [integer]).
+action_types(0'k, [any]).
+action_types(0'n, []).
+action_types(0'N, []).
+action_types(0'p, [any]).
+action_types(0'q, [any]).
+action_types(0'r, [integer]).
+action_types(0'R, [integer]).
+action_types(0's, [text]).
+action_types(0'@, [callable]).
+action_types(0't, []).
+action_types(0'|, []).
+action_types(0'+, []).
+action_types(0'w, [any]).
+action_types(0'W, [any, list]).

package/lib/swipl/library/prolog_history.pl

@@ -0,0 +1,161 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2011-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(prolog_history,
+          [ prolog_history/1
+          ]).
+:- autoload(library(base32),[base32/2]).
+
+:- multifile
+    prolog:history/2.
+
+/** <module> Per-directory persistent commandline history
+
+This module implements  persistency  of   the  commandline  history over
+Prolog sessions on Prolog  installations  that   are  based  on  the GNU
+readline library (default for the development version on Unix systems).
+
+The history is stored  in   the  directory ``<config>/dir-history``. For
+each directory for which it keeps the  history, there is file whose name
+is the base32 encoding of the directory path.
+
+This file is normally loaded when Prolog is started if =user_input= is a
+terminal and the system supports history.
+*/
+
+:- create_prolog_flag(save_history, true, [type(boolean)]).
+
+%!  history_directory(-Dir) is semidet.
+%
+%   Dir is the directory where   the per-directory history databases
+%   are stored.
+
+history_directory(Dir) :-
+    absolute_file_name(user_app_config('dir-history'),
+                       Dir,
+                       [ access(write),
+                         file_type(directory),
+                         file_errors(fail)
+                       ]),
+    !.
+history_directory(Dir) :-
+    absolute_file_name(user_app_config('.'),
+                       ConfigDir,
+                       [ access(write),
+                         file_type(directory),
+                         file_errors(fail)
+                       ]),
+    atom_concat(ConfigDir, '/dir-history', Dir),
+    (   exists_directory(Dir)
+    ->  '$my_file'(Dir)
+    ;   file_directory_name(Dir, Parent),
+        '$my_file'(Parent),
+        make_directory(Dir)
+    ).
+
+%!  dir_history_file(+Dir, -File) is det.
+%!  dir_history_file(?Dir, ?File) is nondet.
+%
+%   File is the history file for a Prolog session running in Dir.
+
+dir_history_file(Dir, File) :-
+    nonvar(Dir),
+    !,
+    history_directory(Base),
+    absolute_file_name(Dir, Path),
+    base32(Path, Encoded),
+    atomic_list_concat([Base, Encoded], /, File).
+dir_history_file(Dir, File) :-
+    history_directory(HDir),
+    directory_files(HDir, Files),
+    '$member'(Base32, Files),
+    base32(Dir, Base32),
+    !,
+    atomic_list_concat([Dir, Base32], /, File).
+
+write_history(File) :-
+    current_prolog_flag(save_history, true),
+    catch(prolog:history(user_input, save(File)), _, true), !.
+write_history(_).
+
+
+%!  prolog_history(+Action) is det.
+%
+%   Execute Action on  the  history.   Action is one of
+%
+%     - enable
+%       Enable history. First loads history for the current directory.
+%       Loading the history is done at most once.
+%     - disable
+%       Sets the Prolog flag `save_history` to `false`, such that the
+%       history is not saved on halt.
+%     - save
+%       If there is a history loaded from a file, save the current
+%       history back into that file if `save_history` is `true`
+
+:- thread_local history_loaded/1.
+
+load_dir_history(File) :-
+    (   exists_file(File),
+        prolog:history(user_input, load(File))
+    ->  assertz(history_loaded(File))
+    ;   true
+    ).
+
+prolog_history(enable) =>
+    (   history_loaded(_)
+    ->  true
+    ;   catch(dir_history_file('.', File), E,
+              (print_message(warning, E),fail)),
+        catch(load_dir_history(File), E,
+              print_message(warning, E))
+    ->  (   thread_self(main)
+        ->  at_halt(write_history(File))
+        ;   history_loaded(File)
+        ->  true
+        ;   assertz(history_loaded(File))
+        ),
+        set_prolog_flag(save_history, true)
+    ;   true
+    ).
+prolog_history(disable) =>
+    set_prolog_flag(save_history, false).
+prolog_history(save) =>
+    (   history_loaded(File)
+    ->  write_history(File)
+    ;   true
+    ).
+