kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/prolog_trace.pl

@@ -0,0 +1,365 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        jan@swi-prolog.org
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2019-2024, 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_trace,
+          [ trace/1,                            % :Spec
+            trace/2,                            % :Spec, +Ports
+            tracing/2,                          % :Spec, -Ports
+            list_tracing/0,
+            notraceall/0
+          ]).
+:- autoload(library(apply),[maplist/2]).
+:- autoload(library(error),[instantiation_error/1]).
+:- autoload(library(prolog_wrap),[wrap_predicate/4]).
+:- autoload(library(prolog_code), [pi_head/2]).
+
+
+/** <module> Print access to predicates
+
+This library prints accesses to  specified   predicates  by wrapping the
+predicate.
+
+@see  library(debug)  for  adding  conditional  print  statements  to  a
+program.
+*/
+
+:- meta_predicate
+    trace(:),
+    trace(:, +),
+    tracing(:, -).
+
+:- dynamic tracing_mask/2 as volatile.          % :Head, Bitmask
+:- dynamic trace_condition/3 as volatile.       % :Head, Port, Cond
+
+%!  trace(:Pred) is det.
+%!  trace(:Pred, +PortSpec) is det.
+%
+%   Print passes through _ports_ of  specified   predicates.  Pred is a,
+%   possible partial, specification of a predicate as it is also used be
+%   spy/1 and similar predicates. Where   a full predicate specification
+%   is of the shape `Module:Name/Arity` (or `//Arity for non-terminals),
+%   both the module and arity may be   omitted in which case Pred refers
+%   to all matching  predicates.  PortSpec  is   either  a  single  port
+%   (`call`, `exit`, `fail` or `redo`), preceded with   `+`  or `-` or a
+%   list  of  these.  The   predicate    modifies   the   current  trace
+%   specification and then installs a suitable wrapper for the predicate
+%   using wrap_predicate/4.  For example:
+%
+%   ```
+%   ?- trace(append).
+%   %     lists:append/2: [all]
+%   %     lists:append/3: [all]
+%   %     append/1: [all]
+%   true.
+%
+%   ?- append([a,b], [c], L).
+%    T [10] Call: lists:append([a, b], [c], _18032)
+%    T [19] Call: lists:append([b], [c], _19410)
+%    T [28] Call: lists:append([], [c], _20400)
+%    T [28 +0.1ms] Exit: lists:append([], [c], [c])
+%    T [19 +0.2ms] Exit: lists:append([b], [c], [b, c])
+%    T [10 +0.5ms] Exit: lists:append([a, b], [c], [a, b, c])
+%   L = [a, b, c].
+%
+%   ?- trace(append, -all).
+%   %     lists:append/2: Not tracing
+%   %     lists:append/3: Not tracing
+%   %     append/1: Not tracing
+%   ```
+%
+%   The text between [] indicates the call  depth (first number) and for
+%   all ports except the `call` port  the   _wall_  time since the start
+%   (call port) in milliseconds. Note that the instrumentation and print
+%   time is included in the time. In   the example above the actual time
+%   is about 0.00001ms on todays hardware.
+%
+%   In addition, __conditions__ may be specified.   In this case the the
+%   specification takes the shape ``trace(:Head, Port(Condition))``. For
+%   example:
+%
+%       ?- trace(current_prolog_flag(Flag, Value), call(var(Flag))).
+%       ?- list_tracing.
+%       % Trace points (see trace/1,2) on:
+%       %     system:current_prolog_flag(A,_): [call(var(A))]
+%
+%   This specification will only  print  the   goal  if  the  registered
+%   condition succeeds. Note that we can use  the condition for its side
+%   effect and then fail to avoid printing the event. Clearing the trace
+%   event  on  all  relevant  ports  removes  the  condition.  There  is
+%   currently no way to modify the  condition without clearing the trace
+%   point first.
+
+trace(Pred) :-
+    trace(Pred, +all).
+
+trace(Pred, Spec) :-
+    Pred = Ctx:_,
+    '$find_predicate'(Pred, Preds),
+    Preds \== [],
+    maplist(set_trace_pi(Spec, Pred, Ctx), Preds).
+
+set_trace_pi(Spec, PredSpec, Ctx, Pred) :-
+    pi_head(Pred, Head0),
+    resolve_predicate(Head0, Head),
+    bind_head(PredSpec, Head),
+    set_trace(Spec, Head, Ctx).
+
+bind_head(Head, Head) :- !.
+bind_head(_:Head, _:Head) :- !.
+bind_head(_, _).
+
+set_trace(Spec, Head, Ctx) :-
+    (   tracing_mask(Head, Spec0)
+    ->  true
+    ;   Spec0 = 0
+    ),
+    modify(Spec, Head, Spec0, Spec1, Ctx),
+    retractall(tracing_mask(Head, _)),
+    (   Spec1 == [] ; Spec1 == 0
+    ->  true
+    ;   asserta(tracing_mask(Head, Spec1))
+    ),
+    mask_ports(Spec1, Ports),
+    (   Spec1 == 0
+    ->  unwrap_predicate(Head, trace),
+        print_message(informational, trace(Head, Ports))
+    ;   wrapper(Spec1, Head, Wrapped, Wrapper),
+        wrap_predicate(Head, trace, Wrapped, Wrapper),
+        print_message(informational, trace(Head, Ports))
+    ).
+
+resolve_predicate(Head0, Head) :-
+    (   predicate_property(Head0, imported_from(M))
+    ->  requalify(Head0, M, Head)
+    ;   Head = Head0
+    ).
+
+requalify(Term, M, M:Plain) :-
+    strip_module(Term, _, Plain).
+
+modify(Var, _, _, _, _) :-
+    var(Var),
+    !,
+    instantiation_error(Var).
+modify([], _, Spec, Spec, _) :-
+    !.
+modify([H|T], Head, Spec0, Spec, Ctx) :-
+    !,
+    modify(H, Head, Spec0, Spec1, Ctx),
+    modify(T, Head, Spec1, Spec, Ctx).
+modify(+PortSpec, Head, Spec0, Spec, Ctx) :-
+    !,
+    port_spec(PortSpec, Head, Port, Ctx),
+    port_mask(Port, Mask),
+    Spec is Spec0 \/ Mask.
+modify(-Port, Head, Spec0, Spec, _) :-
+    !,
+    port_mask(Port, Mask),
+    remove_condition(Head, Mask),
+    Spec is Spec0 /\ \Mask.
+modify(Port, Head, Spec0, Spec, Ctx) :-
+    modify(+Port, Head, Spec0, Spec, Ctx).
+
+port_spec(Spec, _, Port, _), atom(Spec) =>
+    Port = Spec.
+port_spec(Spec, Head, Port, Ctx),
+    compound(Spec),
+    compound_name_arguments(Spec, Name, [Cond]) =>
+    Port = Name,
+    port_mask(Port, Mask),
+    strip_module(Ctx:Cond, M, PCond),
+    (   predicate_property(M:PCond, iso)
+    ->  TheCond = PCond
+    ;   TheCond = M:PCond
+    ),
+    asserta(trace_condition(Head, Mask, TheCond)).
+
+remove_condition(Head, Mask) :-
+    (   trace_condition(Head, TraceMask, TheCond),
+        Mask /\ TraceMask =:= TraceMask,
+        retractall(trace_condition(Head, TraceMask, TheCond)),
+        fail
+    ;   true
+    ).
+
+port_mask(all,  0x0f).
+port_mask(call, 0x01).
+port_mask(exit, 0x02).
+port_mask(redo, 0x04).
+port_mask(fail, 0x08).
+
+mask_ports(0, []) :-
+    !.
+mask_ports(Pattern, [H|T]) :-
+    is_masked(Pattern, H, Pattern1),
+    mask_ports(Pattern1, T).
+
+%!  wrapper(+Ports:integer, :Head, -Wrapped, -Wrapper) is det.
+%!  wrapper(+Ports:integer, :Head, +Id, -Wrapped, -Wrapper) is det.
+%
+%   Adds calls to
+%
+%      print_message(debug, frame(Head, trace(Port, Id)))
+%
+%   @arg Id is a term  `#{frame:Frame, level:Level, start:Start}`, where
+%   `Frame` is the (fragile) frame  identifier,   `Level`  is  the stack
+%   depth and `Start` is the wall-time when the call was started.
+
+wrapper(Ports, Head, Wrapped, Wrapper) :-
+    wrapper(Ports, Head,
+            #{frame:Frame, level:Level, start:Start},
+            Wrapped, Wrapped1),
+    Wrapper = (   prolog_current_frame(Frame),
+                  prolog_frame_attribute(Frame, level, Level),
+                  get_time(Start),
+                  Wrapped1
+              ).
+
+wrapper(0, _, _, Wrapped, Wrapped) :-
+    !.
+wrapper(Pattern, Head, Id, Wrapped, Call) :-
+    is_masked(Pattern, call, Pattern1),
+    !,
+    wrapper(Pattern1, Head, Id, Wrapped, Call0),
+    Call = (   prolog_trace:on_port(call, Head, Id),
+               Call0
+           ).
+wrapper(Pattern, Head, Id, Wrapped, Call) :-
+    is_masked(Pattern, exit, Pattern1),
+    !,
+    wrapper(Pattern1, Head, Id, Wrapped, Call0),
+    Call = (   Call0,
+               prolog_trace:on_port(exit, Head, Id)
+           ).
+wrapper(Pattern, Head, Id, Wrapped, Call) :-
+    is_masked(Pattern, redo, Pattern1),
+    !,
+    wrapper(Pattern1, Head, Id, Wrapped, Call0),
+    Call = (   call_cleanup(Call0, Det = true),
+               (   Det == true
+               ->  true
+               ;   true
+               ;   prolog_trace:on_port(redo, Head, Id),
+                   fail
+               )
+           ).
+wrapper(Pattern, Head, Id, Wrapped, Call) :-
+    is_masked(Pattern, fail, Pattern1),
+    !,
+    wrapper(Pattern1, Head, Id, Wrapped, Call0),
+    Call = call((   call_cleanup(Call0, Det = true),
+                    (   Det == true
+                    ->  !
+                    ;   true
+                    )
+                ;   prolog_trace:on_port(fail, Head, Id),
+                    fail
+                )).
+
+is_masked(Pattern0, Port, Pattern) :-
+    port_mask(Port, Mask),
+    Pattern0 /\ Mask =:= Mask,
+    !,
+    Pattern is Pattern0 /\ \Mask.
+
+%   on_port(+Port, +Head, +Id)
+%
+%   Called on the various ports. Succeeds on the `call` and `exit` ports
+%   and fails otherwise.
+
+:- public on_port/3.
+on_port(Port, Head, Id) :-
+    (   do_trace(Port, Head)
+    ->  print_message(debug, frame(Head, trace(Port, Id)))
+    ;   true
+    ),
+    success_port(Port).
+
+do_trace(Port, Head) :-
+    forall(active_trace_condition(Port, Head, Cond),
+           Cond).
+
+active_trace_condition(Port, Head, Cond) :-
+    trace_condition(Head, Mask, Cond),
+    port_mask(Port, PortMask),
+    Mask /\ PortMask =\= 0.
+
+success_port(call).                     % on the other ports we must fail.
+success_port(exit).
+
+%!  tracing(:Spec, -Ports)
+%
+%   True if Spec is traced using Ports.   Spec is a fully qualified head
+%   term.
+
+tracing(Spec, Ports) :-
+    tracing_mask(Spec, Mask),
+    mask_ports(Mask, Ports0),
+    maplist(add_condition(Spec), Ports0, Ports).
+
+add_condition(Head, Port, PortCond) :-
+    trace_condition(Head, Mask, Cond),
+    port_mask(Port, PortMask),
+    Mask /\ PortMask =\= 0,
+    !,
+    PortCond =.. [Port,Cond].
+add_condition(_, Port, Port).
+
+
+%!  list_tracing.
+%
+%   List predicates we are currently tracing
+
+list_tracing :-
+    Head = _:_,
+    findall(trace(Head, Ports), tracing(Head, Ports), Tracing),
+    print_message(informational, tracing(Tracing)).
+
+:- multifile
+    prolog_debug_tools:debugging_hook/1.
+
+prolog_debug_tools:debugging_hook(_DebugMode) :-
+    (   tracing(_:_, _)
+    ->  list_tracing
+    ).
+
+
+%!  notraceall is det.
+%
+%   Remove all trace points
+
+notraceall :-
+    forall(tracing(M:Spec, _Ports),
+           trace(M:Spec, -all)).

package/lib/swipl/library/prolog_versions.pl

@@ -0,0 +1,347 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        jan@swi-prolog.org
+    WWW:           https://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_versions,
+          [ require_prolog_version/2,   % +Required, +Features:list
+            require_version/3,          % +Component, +Available, +Required
+            cmp_versions/3              % ?Cmp, +Version1, +Version2
+          ]).
+:- autoload(library(apply), [maplist/2, maplist/3]).
+:- autoload(library(error), [domain_error/2, existence_error/2, type_error/2]).
+
+/** <module> Demand specific (Prolog) versions
+
+This library is provided to make  it   easier  to  reason about software
+versions, in particular require that that   hosting  Prolog system is of
+the right version and provides the features   required by the library or
+application.
+
+@tbd Not only provide a minimal version but a more version ranges,
+     exclude certain versions, etc.
+@tbd More features and better messages to help the user resolving
+     problems.
+*/
+
+%!  require_prolog_version(+Required, +Features:list) is det.
+%
+%   Claim that the running Prolog version   is at least version Required
+%   and provides the requested Features. Required   is  an expression of
+%   versions. At the lowest level, a version   is an atom or string that
+%   provides the version as
+%
+%	Major.Minor[[.Patch][[-GitRev],-GitHash]]]
+%
+%   Example     strings     are     '8.5',      '8.5.0',     '8.5.0-50',
+%   '8.5.0-69-gad38e8ad8`. The last two  require   fetching  the sources
+%   from git or using the Windows daily builds.
+%
+%   Versions may be embedded in a   comparison operator (`<`, `=<`, `=`,
+%   `>=` or `>`), e.g., `=<('9.1')`. Versions  are considered to compare
+%   equal only on the components of  the Required version. I.e., `'9.1'`
+%   compares equal to `'9.1.2'`.
+%
+%   Version expressions can be  constructed   from  the Prolog operators
+%   ','/2, ';'/2 and '\+'/1. An example   of a complicated expression is
+%   below, which demands major  version  9,   but  considers  9.1.2  not
+%   suitable.
+%
+%       (>=('9'), \+(=('9.1.2')))
+%
+%   Features is a list of  required   or  preferred features. Individual
+%   features are:
+%
+%     - warning(Feature)
+%       Only print a warning instead of throwing an error.
+%     - library(Lib)
+%       Demand library(Lib) to be present.  Thde library not being
+%       there may indicate an incomplete installation.  For example
+%       library(pce) to demand xpce graphics support.
+%     - Flag
+%       Demand current_prolog_flag(Flag, true) to be true.
+%     - FlagValue
+%       If FlagValue is Flag(Value), demand current_prolog_flag(Flag,
+%       Value) to be true.
+%
+%    @error version_error('SWI-Prolog', PrologVersion, Cmp, Required)
+%    @error existence_error(prolog_feature, Feature)
+
+require_prolog_version(Required, Features) :-
+    require_prolog_version(Required),
+    maplist(check_feature, Features).
+
+require_prolog_version(Required) :-
+    prolog_version(Available),
+    require_version('SWI-Prolog', Available, Required).
+
+prolog_version(Version) :-
+    current_prolog_flag(version_git, Version),
+    !.
+prolog_version(Version) :-
+    current_prolog_flag(version_data, swi(Major, Minor, Patch, _)),
+    VNumbers = [Major, Minor, Patch],
+    atomic_list_concat(VNumbers, '.', Version).
+
+%!  require_version(+Component, +Available, +CmpRequired) is det.
+%
+%   Require Component to have version   CmpRequired,  while Component is
+%   know to have version Available.
+%
+%   @error version_error(Component, Required, Cmp, Available)
+
+require_version(Component, Available, CmpRequired) :-
+    parse_version(Available, AvlNumbers, AvlGit),
+    (   require_version_(AvlNumbers, AvlGit, CmpRequired)
+    ->  true
+    ;   throw(error(version_error(Component, Available, CmpRequired), _))
+    ).
+
+require_version_(AvlNumbers, AvlGit, (V1;V2)) =>
+    (   require_version_(AvlNumbers, AvlGit, V1)
+    ->  true
+    ;   require_version_(AvlNumbers, AvlGit, V2)
+    ).
+require_version_(AvlNumbers, AvlGit, (V1,V2)) =>
+    (   require_version_(AvlNumbers, AvlGit, V1)
+    ;   require_version_(AvlNumbers, AvlGit, V2)
+    ).
+require_version_(AvlNumbers, AvlGit, \+V1) =>
+    \+ require_version_(AvlNumbers, AvlGit, V1).
+require_version_(AvlNumbers, AvlGit, Required) =>
+    parse_version(Required,  ReqNumbers, ReqGit, Cmp, _),
+    cmp_versions(Cmp, AvlNumbers, AvlGit, ReqNumbers, ReqGit).
+
+%!  cmp_versions(?Cmp, +V1, +V2) is semidet.
+%
+%   Compare to versions. Cmp is one of `<`,   `=<`, `=`, `>=` or `>`. If
+%   Cmp is unbound we check whether `<` or  `>` hold or else bind Cmp to
+%   `=`.
+%
+%   When comparing for equality (`=`), the versions are considered equal
+%   if they compare equal up to the detail level of the least specified.
+%   E.g, '9.1.2' is considered equal to '9.1'.
+
+cmp_versions(Cmp, V1, V2) :-
+    parse_version(V1, V1_Numbers, V1_Git),
+    parse_version(V2, V2_Numbers, V2_Git),
+    (   nonvar(Cmp)
+    ->  cmp_versions(Cmp, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ;   cmp_versions(<, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ->  Cmp = (<)
+    ;   cmp_versions(>, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ->  Cmp = (<)
+    ;   Cmp = (=)
+    ).
+
+cmp_versions(=<, V1_Numbers, V1_Git, V2_Numbers, V2_Git) =>
+    (   cmp_versions(<, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ->  true
+    ;   cmp_versions(=, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ).
+cmp_versions(>=, V1_Numbers, V1_Git, V2_Numbers, V2_Git) =>
+    (   cmp_versions(>, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ->  true
+    ;   cmp_versions(=, V1_Numbers, V1_Git, V2_Numbers, V2_Git)
+    ).
+cmp_versions(<, V1_Numbers, V1_Git, V2_Numbers, V2_Git) =>
+    (   cmp_num_version(<, V1_Numbers, V2_Numbers)
+    ->  true
+    ;   V1_Numbers == V2_Numbers,
+        cmp_git_version(<, V1_Git, V2_Git)
+    ).
+cmp_versions(>, V1_Numbers, V1_Git, V2_Numbers, V2_Git) =>
+    (   cmp_num_version(>, V1_Numbers, V2_Numbers)
+    ->  true
+    ;   V1_Numbers == V2_Numbers,
+        cmp_git_version(>, V1_Git, V2_Git)
+    ).
+cmp_versions(=, V1_Numbers, V1_Git, V2_Numbers, V2_Git) =>
+    cmp_num_version(=, V1_Numbers, V2_Numbers),
+    cmp_git_version(=, V1_Git, V2_Git).
+
+cmp_num_version(Cmp, V1_Numbers, V2_Numbers) :-
+    shortest(V1_Numbers, V2_Numbers, V1, V2),
+    compare(Cmp, V1, V2).
+
+shortest([H1|T1], [H2|T2], [H1|R1], [H2|R2]) :-
+    !,
+    shortest(T1, T2, R1, R2).
+shortest(_,_, [], []).
+
+
+cmp_git_version(<, -, -) => fail.
+cmp_git_version(>, -, -) => fail.
+cmp_git_version(=, -, -) => true.
+cmp_git_version(<, _, -) => true.
+cmp_git_version(>, -, _) => true.
+cmp_git_version(=, -, _) => true.
+cmp_git_version(=, _, -) => true.
+cmp_git_version(=, git(V,-), git(V,_)) => true.
+cmp_git_version(=, git(V,_), git(V,-)) => true.
+cmp_git_version(<, git(V1, _V1_Hash), git(V2, _V2_Hash)) =>
+    V1 < V2.
+cmp_git_version(>, git(V1, _V1_Hash), git(V2, _V2_Hash)) =>
+    V1 > V2.
+cmp_git_version(=, V1, V2) => V1 == V2.
+
+%!  parse_version(+Spec, -Version:list(integer), -GIT, -Cmp, -Plain) is det.
+
+parse_version(Spec, VNumbers, GitVersion, Cmp, VString) :-
+    spec_cmp_version(Spec, Cmp, VString),
+    parse_version(VString, VNumbers, GitVersion).
+
+spec_cmp_version(Spec, Cmp, Version),
+    compound(Spec), compound_name_arity(Spec, Cmp, 1) =>
+    (   is_cmp(Cmp)
+    ->  true
+    ;   domain_error(comparison_operator, Cmp)
+    ),
+    arg(1, Spec, Version).
+spec_cmp_version(Spec, Cmp, Version), atom(Spec) =>
+    Cmp = (>=),
+    Version = Spec.
+spec_cmp_version(Spec, Cmp, Version), string(Spec) =>
+    Cmp = (>=),
+    atom_string(Version, Spec).
+spec_cmp_version(Spec, _Cmp, _Version) =>
+    type_error(version, Spec).
+
+is_cmp(=<).
+is_cmp(<).
+is_cmp(>=).
+is_cmp(>).
+is_cmp(=).
+is_cmp(>=).
+
+parse_version(String, VNumbers, VGit) :-
+    (   parse_version_(String, VNumbers, VGit)
+    ->  true
+    ;   domain_error(version_string, String)
+    ).
+
+parse_version_(String, VNumbers, git(GitRev, GitHash)) :-
+    split_string(String, "-", "", [NumberS,GitRevS|Hash]),
+    !,
+    split_string(NumberS, ".", "", List),
+    maplist(number_string, VNumbers, List),
+    (   GitRevS == "DIRTY"
+    ->  GitRev = 0,
+        GitHash = 'DIRTY'
+    ;   number_string(GitRev, GitRevS),
+        (   Hash = [HashS]
+        ->  atom_string(GitHash, HashS)
+        ;   GitHash = '-'
+        )
+    ).
+parse_version_(String, VNumbers, -) :-
+    split_string(String, ".", "", List),
+    maplist(number_string, VNumbers, List).
+
+%!  check_feature(+Feature) is det.
+%
+%   Verify that the running Prolog process has a certain feature.
+
+check_feature(warning(Flag)) :-
+    !,
+    (   has_feature(Flag)
+    ->  true
+    ;   print_message(
+            warning,
+            error(existence_error(prolog_feature, warning(Flag)), _))
+    ).
+check_feature(Flag) :-
+    has_feature(Flag),
+    !.
+check_feature(Flag) :-
+    existence_error(prolog_feature, Flag).
+
+has_feature(rational) =>
+    current_prolog_flag(bounded, false).
+has_feature(library(Lib)) =>
+    exists_source(library(Lib)).
+has_feature(Flag), atom(Flag) =>
+    current_prolog_flag(Flag, true).
+has_feature(Flag), Flag =.. [Name|Arg] =>
+    current_prolog_flag(Name, Arg).
+
+		 /*******************************
+		 *           MESSAGES		*
+		 *******************************/
+
+:- multifile
+    prolog:error_message//1.
+
+prolog:error_message(version_error(Component, Found, Required)) -->
+    { current_prolog_flag(executable, Exe) },
+    [ 'Application requires ~w '-[Component] ], req_msg(Required),
+    [ ',', nl, '   ',
+      ansi(code, '~w', [Exe]), ' has version ',
+      ansi(code, '~w', [Found])
+    ].
+prolog:error_message(existence_error(prolog_feature, Feature)) -->
+    missing_feature(Feature).
+
+req_msg((A,B)) --> req_msg(A), [' and '], req_msg(B).
+req_msg((A;B)) --> req_msg(A), [' or '], req_msg(B).
+req_msg(\+(A)) --> ['not '], req_msg(A).
+req_msg(V) --> { spec_cmp_version(V, Cmp, Version) }, !, cmp_msg(Cmp), [' '],
+    [ ansi(code, '~w', [Version]) ].
+
+cmp_msg(<)  --> ['before'].
+cmp_msg(=<) --> ['at most'].
+cmp_msg(=)  --> ['exactly'].
+cmp_msg(>=) --> ['at least'].
+cmp_msg(>)  --> ['after'].
+
+missing_feature(warning(Feature)) -->
+    [ 'This version of SWI-Prolog does not optimally support your \c
+       application because',
+      nl, '   '
+    ],
+    missing_feature_(Feature).
+missing_feature(warning(Feature)) -->
+    [ 'This version of SWI-Prolog cannot run your application because',
+      nl, '   '
+    ],
+    missing_feature_(Feature).
+
+missing_feature_(threads) -->
+    [ 'multi-threading is not available' ].
+missing_feature_(rational) -->
+    [ 'it has no support for rational numbers' ].
+missing_feature_(bounded(false)) -->
+    [ 'it has no support for unbounded arithmetic' ].
+missing_feature_(library(Lib)) -->
+    [ 'it does not provide library(~q)'-[Lib] ].
+missing_feature_(Feature) -->
+    [ 'it does not support ~p'-[Feature] ].