kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/dialect/iso/iso_predicates.pl

@@ -0,0 +1,277 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker & Paulo Moura
+    E-mail:        J.Wielemaker@cs.vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2007-2012, University of Amsterdam,
+                              Paulo Moura,
+                              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(iso_predicates,
+	  [ iso_builtin_predicate/1,	% ?Term
+	    iso_builtin_function/1	% ?Term
+	  ]).
+
+/** <module> Define ISO builtin predicates
+
+This module describes the ISO  core   standard  built-in  predicates. It
+originates from Logtalk. Note that, although  the artistic license would
+allow redistribution under a new name and   interface  using the GPL, we
+preserve the original license.
+
+@author  Paulo Moura
+@author  Jan Wielemaker
+@see	 predicate_property/2, property =iso=.
+*/
+
+%%	iso_builtin_predicate(?Head:callable) is nondet.
+%
+%	True if Head describes  a  builtin   defined  by  the ISO Prolog
+%	standard (ISO/IEC 1321 l-l).
+
+iso_builtin_predicate(true).
+iso_builtin_predicate(fail).
+iso_builtin_predicate(call(_)).
+iso_builtin_predicate(!).
+iso_builtin_predicate((Goal; _)) :-
+	(   var(Goal)
+	->  true
+	;   Goal \= '*->'(_,_)		% exclude SWI's soft-cut.
+	).
+iso_builtin_predicate((_, _)).
+iso_builtin_predicate((_ -> _)).
+iso_builtin_predicate(catch(_, _, _)).
+iso_builtin_predicate(throw(_)).
+
+iso_builtin_predicate((_ = _)).
+iso_builtin_predicate((_ \= _)).
+iso_builtin_predicate(unify_with_occurs_check(_, _)).
+
+iso_builtin_predicate(var(_)).
+iso_builtin_predicate(nonvar(_)).
+iso_builtin_predicate(atom(_)).
+iso_builtin_predicate(atomic(_)).
+iso_builtin_predicate(number(_)).
+iso_builtin_predicate(integer(_)).
+iso_builtin_predicate(float(_)).
+iso_builtin_predicate(compound(_)).
+
+iso_builtin_predicate((_ @=< _)).
+iso_builtin_predicate((_ @< _)).
+iso_builtin_predicate((_ @>= _)).
+iso_builtin_predicate((_ @> _)).
+iso_builtin_predicate((_ == _)).
+iso_builtin_predicate((_ \== _)).
+
+iso_builtin_predicate(functor(_, _, _)).
+iso_builtin_predicate(arg(_, _, _)).
+iso_builtin_predicate(_ =.. _).
+iso_builtin_predicate(copy_term(_, _)).
+
+iso_builtin_predicate(_ is _).
+
+iso_builtin_predicate((_ =< _)).
+iso_builtin_predicate((_ < _)).
+iso_builtin_predicate((_ >= _)).
+iso_builtin_predicate((_ > _)).
+iso_builtin_predicate((_ =:= _)).
+iso_builtin_predicate((_ =\= _)).
+
+iso_builtin_predicate(clause(_, _)).
+iso_builtin_predicate(current_predicate(_)).
+
+iso_builtin_predicate(asserta(_)).
+iso_builtin_predicate(assertz(_)).
+iso_builtin_predicate(retract(_)).
+iso_builtin_predicate(abolish(_)).
+
+iso_builtin_predicate(findall(_, _, _)).
+iso_builtin_predicate(bagof(_, _, _)).
+iso_builtin_predicate(setof(_, _, _)).
+
+iso_builtin_predicate(current_input(_)).
+iso_builtin_predicate(current_output(_)).
+iso_builtin_predicate(set_input(_)).
+iso_builtin_predicate(set_output(_)).
+iso_builtin_predicate(open(_, _, _, _)).
+iso_builtin_predicate(open(_, _, _)).
+iso_builtin_predicate(close(_, _)).
+iso_builtin_predicate(close(_)).
+iso_builtin_predicate(flush_output(_)).
+iso_builtin_predicate(flush_output).
+iso_builtin_predicate(stream_property(_, _)).
+iso_builtin_predicate(at_end_of_stream).
+iso_builtin_predicate(at_end_of_stream(_)).
+iso_builtin_predicate(set_stream_position(_, _)).
+
+iso_builtin_predicate(get_char(_, _)).
+iso_builtin_predicate(get_char(_)).
+iso_builtin_predicate(get_code(_, _)).
+iso_builtin_predicate(get_code(_)).
+iso_builtin_predicate(peek_char(_, _)).
+iso_builtin_predicate(peek_char(_)).
+iso_builtin_predicate(peek_code(_, _)).
+iso_builtin_predicate(peek_code(_)).
+iso_builtin_predicate(put_char(_, _)).
+iso_builtin_predicate(put_char(_)).
+iso_builtin_predicate(put_code(_, _)).
+iso_builtin_predicate(put_code(_)).
+iso_builtin_predicate(nl).
+iso_builtin_predicate(nl(_)).
+
+iso_builtin_predicate(get_byte(_, _)).
+iso_builtin_predicate(get_byte(_)).
+iso_builtin_predicate(peek_byte(_, _)).
+iso_builtin_predicate(peek_byte(_)).
+iso_builtin_predicate(put_byte(_, _)).
+iso_builtin_predicate(put_byte(_)).
+
+iso_builtin_predicate(read_term(_, _, _)).
+iso_builtin_predicate(read_term(_, _)).
+iso_builtin_predicate(read(_)).
+iso_builtin_predicate(read(_, _)).
+iso_builtin_predicate(write_term(_, _, _)).
+iso_builtin_predicate(write_term(_, _)).
+iso_builtin_predicate(write(_)).
+iso_builtin_predicate(write(_, _)).
+iso_builtin_predicate(writeq(_)).
+iso_builtin_predicate(writeq(_, _)).
+iso_builtin_predicate(write_canonical(_)).
+iso_builtin_predicate(write_canonical(_, _)).
+iso_builtin_predicate(op(_, _, _)).
+iso_builtin_predicate(current_op(_, _, _)).
+iso_builtin_predicate(char_conversion(_, _)).
+iso_builtin_predicate(current_char_conversion(_, _)).
+
+iso_builtin_predicate(\+ _).
+iso_builtin_predicate(once(_)).
+iso_builtin_predicate(repeat).
+
+iso_builtin_predicate(atom_length(_, _)).
+iso_builtin_predicate(atom_concat(_, _, _)).
+iso_builtin_predicate(sub_atom(_, _, _, _, _)).
+iso_builtin_predicate(atom_chars(_, _)).
+iso_builtin_predicate(atom_codes(_, _)).
+iso_builtin_predicate(char_code(_, _)).
+iso_builtin_predicate(number_chars(_, _)).
+iso_builtin_predicate(number_codes(_, _)).
+
+iso_builtin_predicate(set_prolog_flag(_, _)).
+iso_builtin_predicate(current_prolog_flag(_, _)).
+iso_builtin_predicate(halt).
+iso_builtin_predicate(halt(_)).
+
+%	ISO wg17 proposal on threads
+%	Note that the list below only contains the predicates that are
+%	-in my opinion- beyond discussion.
+
+iso_builtin_predicate(thread_create(_,_,_)).
+iso_builtin_predicate(thread_self(_)).
+iso_builtin_predicate(thread_join(_,_)).
+iso_builtin_predicate(thread_detach(_)).
+iso_builtin_predicate(thread_signal(_,_)).
+iso_builtin_predicate(thread_property(_,_)).
+iso_builtin_predicate(mutex_create(_,_)).
+iso_builtin_predicate(mutex_destroy(_)).
+iso_builtin_predicate(with_mutex(_,_)).
+iso_builtin_predicate(mutex_lock(_)).
+iso_builtin_predicate(mutex_unlock(_)).
+iso_builtin_predicate(mutex_trylock(_)).
+iso_builtin_predicate(mutex_property(_,_)).
+iso_builtin_predicate(message_queue_create(_,_)).
+iso_builtin_predicate(message_queue_destroy(_)).
+iso_builtin_predicate(message_queue_property(_,_)).
+iso_builtin_predicate(thread_send_message(_,_)).
+iso_builtin_predicate(thread_get_message(_)).
+iso_builtin_predicate(thread_get_message(_,_)).
+iso_builtin_predicate(thread_peek_message(_)).
+iso_builtin_predicate(thread_peek_message(_,_)).
+
+%	Predicates from ISO/IEC DTR 13211-1:2006
+%	Note that predicates not supported yet by YAP are not in here.
+
+%iso_builtin_predicate(subsumes(_,_)).
+iso_builtin_predicate(callable(_)).
+iso_builtin_predicate(ground(_)).
+iso_builtin_predicate(compare(_, _, _)).
+iso_builtin_predicate(numbervars(_,_,_)).
+iso_builtin_predicate(predicate_property(_,_)).
+iso_builtin_predicate(retractall(_)).
+%iso_builtin_predicate(forall(_,_)).
+iso_builtin_predicate(call(_,_)).
+iso_builtin_predicate(call(_,_,_)).
+iso_builtin_predicate(call(_,_,_,_)).
+%iso_builtin_predicate(call_cleanup(_,_)).
+%iso_builtin_predicate(append(_,_,_)).
+iso_builtin_predicate(length(_,_)).
+%iso_builtin_predicate(member(_,_)).
+iso_builtin_predicate(sort(_,_)).
+iso_builtin_predicate(keysort(_,_)).
+
+%%	iso_builtin_function(?Head:callable) is nondet.
+%
+%	True if Head describes a builtin  arithmetic function as defined
+%	by the ISO Prolog standard (ISO/IEC 1321 l-l).
+
+iso_builtin_function(_ + _).
+iso_builtin_function(_ - _).
+iso_builtin_function(_ * _).
+iso_builtin_function(_ // _).
+iso_builtin_function(_ / _).
+iso_builtin_function(_ rem _).
+iso_builtin_function(_ mod _).
+iso_builtin_function(_ ** _).
+iso_builtin_function(_ >> _).
+iso_builtin_function(_ << _).
+iso_builtin_function(_ /\ _).
+iso_builtin_function(_ \/ _).
+iso_builtin_function(- _).
+iso_builtin_function(+ _).
+iso_builtin_function(min(_,_)).
+iso_builtin_function(max(_,_)).
+iso_builtin_function(abs(_)).
+iso_builtin_function(sign(_)).
+iso_builtin_function(float_integer_part(_)).
+iso_builtin_function(float_fractional_part(_)).
+iso_builtin_function(float(_)).
+iso_builtin_function(floor(_)).
+iso_builtin_function(truncate(_)).
+iso_builtin_function(round(_)).
+iso_builtin_function(ceiling(_)).
+iso_builtin_function(sin(_)).
+iso_builtin_function(cos(_)).
+iso_builtin_function(asin(_)).
+iso_builtin_function(acos(_)).
+iso_builtin_function(atan(_)).
+iso_builtin_function(atan2(_,_)).
+iso_builtin_function(exp(_)).
+iso_builtin_function(log(_)).
+iso_builtin_function(sqrt(_)).
+iso_builtin_function(\(_)).

package/lib/swipl/library/dialect/sicstus/README.TXT

@@ -0,0 +1 @@
+SISCtus compatibility library.

package/lib/swipl/library/dialect/sicstus/arrays.pl

@@ -0,0 +1,121 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2010-2011, University of 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(arrays,
+	  [ new_array/1,		% -Array
+	    is_array/1,			% +Term
+	    aref/3,			% +Index, +Array, -Element
+	    arefa/3,			% +Index, +Array, -ArrayElement
+	    arefl/3,			% +Index, +Array, -ListElement
+	    array_to_list/2,		% +Array, -List
+	    aset/4			% +Index, +Array, +Element, -NewArray
+	  ]).
+:- use_module(library(rbtrees)).
+
+/** <module> SICStus 3-compatible library(arrays).
+
+@deprecated library(arrays) has been removed in SICStus 4.
+@compat	    This library builds on library(rbtrees) and therefore the
+	    internal representation differs from the SICStus implementation.
+@see	    https://sicstus.sics.se/sicstus/docs/3.12.11/html/sicstus/Arrays.html
+*/
+
+
+%%	new_array(-Array) is det.
+%
+%	@compat SICStus-3
+
+new_array(array(Array)) :-
+	rb_empty(Array).
+
+%%	is_array(@Term) is semidet.
+%
+%	True if Term is an array
+%
+%	@compat SICStus-3
+
+is_array(Var) :-
+	var(Var), !, fail.
+is_array(array(Tree)) :-
+	is_rbtree(Tree).
+
+%%	aref(+Index, +Array, -Element) is semidet.
+%
+%	True if Element is the current element in Array at Index.
+%
+%	@compat SICStus-3
+
+aref(Index, array(Tree), Element) :-
+	rb_lookup(Index, array(Tree), Element).
+
+%%	arefa(+Index, +Array, -ArrayElement) is det.
+%
+%	As aref/3, but succeeds with an empty   array  of the element is
+%	not set.
+%
+%	@compat SICStus-3
+
+arefa(Index, array(Tree), ArrayElement) :-
+	rb_lookup(Index, array(Tree), ArrayElement), !.
+arefa(_, _, Array) :-
+	new_array(Array).
+
+%%	arefl(+Index, +Array, -ListElement) is det.
+%
+%	As aref/3, but succeeds with an empty list of the element is not
+%	set.
+%
+%	@compat SICStus-3
+
+arefl(Index, array(Tree), ListElement) :-
+	rb_lookup(Index, array(Tree), ListElement), !.
+arefl(_, _, []).
+
+%%	array_to_list(+Array, -Pairs) is det.
+%
+%	@compat SICStus-3
+
+array_to_list(array(Tree), Pairs) :-
+	rb_visit(Tree, Pairs).
+
+%%	aset(+Index, +Array, +Element, -NewArray) is det.
+%
+%	NewArray is Array with Element added/updated at Index.
+%
+%	@compat SICStus-3
+
+aset(Index, array(Tree), Element, array(NewTree)) :-
+	rb_update(Tree, Index, Element, NewTree), !.
+aset(Index, array(Tree), Element, array(NewTree)) :-
+	rb_insert_new(Tree, Index, Element, NewTree).

package/lib/swipl/library/dialect/sicstus/block.pl

@@ -0,0 +1,278 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2010-2024, 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(block_directive,
+          [ (block)/1,                  % +Heads
+            op(1150, fx, (block))
+          ]).
+:- use_module(library(prolog_wrap), []). % make sure it is loaded
+:- autoload(library(error), [instantiation_error/1, domain_error/2]).
+:- autoload(swi(library/lists), [append/3]).
+
+/** <module> Block: declare suspending predicates
+
+This module provides SICStus  Prolog-compatible   ``:-  block BlockSpec,
+...`` declarations for delaying predicate calls if certain arguments are
+unbound.
+
+@see    https://sicstus.sics.se/sicstus/docs/3.12.11/html/sicstus/Block-Declarations.html
+*/
+
+:- op(1150, fx, user:(block)).
+
+:- multifile
+    user:term_expansion/2,
+    block_declaration/2.            % Head, Module
+
+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
+    ).
+
+
+%!  block(+Heads).
+%
+%   Declare predicates to suspend on  certain   modes.  The argument is,
+%   like   meta_predicate/1,   a   comma-separated     list   of   modes
+%   (_BlockSpecs_). Calls to the predicate is  suspended if at least one
+%   of the conditions implies by  a   blockspec  evaluated  to `true`. A
+%   blockspec evaluated to `true` iff all arguments specified as `-' are
+%   unbound.
+%
+%   Multiple BlockSpecs for a single predicate can appear in one or more
+%   `:- block` declarations. The predicate is  suspended untill all mode
+%   patterns that apply to it are satisfied.
+%
+%   The implementation is realised by creating a wrapper that checks the
+%   block conditions and either calls the original predicate immediately
+%   (if none of the  block  conditions   were  true)  or uses attributed
+%   variables to delay re-evaluating the block   condition  until any of
+%   the arguments in question are bound.
+%
+%   @compat SICStus Prolog
+
+block(Spec) :-
+    throw(error(context_error(nodirective, block(Spec)), _)).
+
+expand_block_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_head(Head),
+      functor(Head, Name, Arity),
+      functor(GenHead, Name, Arity),
+      Clause = '$block_pred'(Head)
+    },
+    (   { current_predicate(Module:'$block_pred'/1) }
+    ->  []
+    ;   [ (:- discontiguous('$block_pred'/1)),
+          (:- public('$block_pred'/1))
+        ]
+    ),
+    (   { prolog_load_context(module, Module) }
+    ->  [ Clause ]
+    ;   [ Module:Clause ]
+    ),
+    [ block_directive:block_declaration(GenHead, Module) ].
+
+valid_head(Head) :-
+    callable(Head),
+    forall(arg(_, Head, A), block_arg(A)).
+
+block_arg(A) :-
+    var(A),
+    !,
+    instantiation_error(A).
+block_arg(-) :- !.
+block_arg(+) :- !.
+block_arg(?) :- !.
+block_arg(A) :-
+    domain_error(block_argument, A).
+
+%!  block_wrapper_clauses(+Module, +Head, -Clauses) is det.
+%
+%   Build a list of clauses that define a block wrapper around predicate
+%   Head in Module. If a wrapper  for   this  predicate has already been
+%   defined, Clauses is an empty list.
+
+block_wrapper_clauses(Module, Head, Clauses) :-
+    functor(Head, Name, Arity),
+    atom_concat('$block_helper$', Name, HelperName),
+    functor(HelperHead, HelperName, Arity),
+    (   current_predicate(_, Module:HelperHead)
+    ->  Clauses = []
+    ;   findall(Wrapper,
+                block_wrapper_clause(Module, Name, HelperHead, Wrapper),
+                Clauses)
+    ).
+
+%!  block_wrapper_clause(+Module, +Name, +HelperHead, -Clause) is nondet.
+%
+%   Generate the clauses for the wrapper.  The blockspecs are translated
+%   into  a  helper  predicate,  where  each  clause  checks  one  block
+%   condition. If a block condition is true, attributes are added to all
+%   arguments marked as `-`, so that  once   any  of them are bound, the
+%   predicate is called again and the block conditions are re-evaluated.
+%   If no block condition was true, the helper predicate fails.
+%
+%   Finally, an initialization clause is  generated   that  sets  up the
+%   actual wrapper. This wrapper first  calls   the  helper predicate to
+%   check all block conditions and delay the   call if necessary. If the
+%   helper predicate fails (i. e.  no   block  condition  was true), the
+%   wrapped predicate is called immediately.
+%
+%   The wrapper must be set up in   an  initialization clause and not as
+%   part of the term expansion,   because  wrap_predicate/4 wrappers are
+%   not retained in saved states, which   would cause block declarations
+%   to break when loading a saved state.
+
+block_wrapper_clause(Module, Name, HelperHead, (HelperHead :- GenBody)) :-
+    HelperHead =.. [_|HelperArgs],
+    length(HelperArgs, Arity),
+    functor(BlockHead, Name, Arity),
+    Module:'$block_pred'(BlockHead),
+    BlockHead =.. [_|BlockArgs],
+    find_args_to_block_on(BlockArgs, HelperArgs, ToBlockOn),
+    args_to_var_conditions(ToBlockOn, GenBody, GenBody1),
+    GenBody1 = (!, GenBody2),
+    MainHead =.. [Name|HelperArgs],
+    args_to_suspend_calls(ToBlockOn, _IsAlreadyUnblocked, Module:MainHead, GenBody2, true).
+block_wrapper_clause(Module, Name, HelperHead, (:- initialization WrapCall)) :-
+    HelperHead =.. [_|HelperArgs],
+    ToWrapHead =.. [Name|HelperArgs],
+    atom_concat('$block_wrapper$', Name, WrapperName),
+    WrapCall = @(prolog_wrap:wrap_predicate(ToWrapHead, WrapperName, Wrapped,
+					    (HelperHead -> true ; Wrapped)),
+		 Module).
+
+%!  find_args_to_block_on(+BlockArgs, +HeadArgs, -ArgsToBlockOn) is semidet.
+%
+%   Collect into ArgsToBlockOn all arguments from HeadArgs for which
+%   the corresponding argument in BlockArgs is `-`, indicating that
+%   the argument is part of the block condition.
+
+find_args_to_block_on([], [], []) :- !.
+find_args_to_block_on([-|MoreBlockArgs], [Arg|MoreHeadArgs], [Arg|MoreToBlockOn]) :-
+    !,
+    find_args_to_block_on(MoreBlockArgs, MoreHeadArgs, MoreToBlockOn).
+find_args_to_block_on([_|MoreBlockArgs], [_|MoreHeadArgs], ToBlockOn) :-
+    find_args_to_block_on(MoreBlockArgs, MoreHeadArgs, ToBlockOn).
+
+%!  args_to_var_conditions(+ArgsToBlockOn, -Conditions, ?ConditionsTail) is semidet.
+%
+%   Convert a list of arguments into a  conjunction of var/1 checks that
+%   succeeds if all arguments are unbound variables.
+%
+%   This effectively generates an  unrolled   version  of  `maplist(var,
+%   ArgsToBlockOn), ConditionsTail`.
+
+args_to_var_conditions([], Tail, Tail) :- !.
+args_to_var_conditions([Arg|MoreArgs], Conditions, Tail) :-
+    Conditions = (var(Arg), MoreConditions),
+    args_to_var_conditions(MoreArgs, MoreConditions, Tail).
+
+%!  args_to_suspend_calls(+ArgsToBlockOn, -IsAlreadyUnblocked, +BlockedGoal, -SuspendCalls, +Tail) is semidet.
+%
+%   Build a sequence of calls that delays BlockedGoal until any variable
+%   in ArgsToBlockOn is bound. IsAlreadyUnblocked   should be an unbound
+%   fresh variable - it is passed directly to unblock/2, which will bind
+%   the variable so that the same blocked   goal  is not called again by
+%   another unblock/2 call from the same group.
+
+args_to_suspend_calls([], _, _, Tail, Tail) :- !.
+args_to_suspend_calls([Arg|MoreArgs], IsAlreadyUnblocked, BlockedGoal, SuspendCalls, Tail) :-
+    SuspendCalls = ('$suspend'(Arg, block_directive, block_directive:unblock(IsAlreadyUnblocked, BlockedGoal)), MoreSuspendCalls),
+    args_to_suspend_calls(MoreArgs, IsAlreadyUnblocked, BlockedGoal, MoreSuspendCalls, Tail).
+
+
+attr_unify_hook(call(ThisGoals), NewVar) :-
+    var(NewVar),
+    !,
+    (   get_attr(NewVar, block_directive, call(OtherGoals))
+    ->  put_attr(NewVar, block_directive, call((ThisGoals, OtherGoals)))
+    ;   put_attr(NewVar, block_directive, call(ThisGoals))
+    ).
+attr_unify_hook(call(Goals), _) :- Goals.
+
+:- public unblock/2.
+unblock(IsAlreadyUnblocked, _) :- IsAlreadyUnblocked == (-), !.
+unblock(-, BlockedGoal) :- BlockedGoal.
+
+attribute_goals(Var) -->
+    {get_attr(Var, block_directive, call(Goals))},
+    !,
+    render_block_goals(Goals).
+
+render_block_goals((Left, Right)) -->
+    render_block_goals(Left),
+    render_block_goals(Right).
+render_block_goals(block_directive:unblock(IsAlreadyUnblocked, BlockedGoal)) -->
+    (   {IsAlreadyUnblocked == (-)}
+    ->  []
+    ;   [BlockedGoal]
+    ).
+
+                 /*******************************
+                 *        EXPANSION HOOKS       *
+                 *******************************/
+
+system:term_expansion((:- block(Spec)), Clauses) :-
+    expand_block_declaration(Spec, Clauses).
+system:term_expansion(Term, Clauses) :-
+    head(Term, Module:Head),
+    block_declaration(Head, Module),
+    block_wrapper_clauses(Module, Head, WrapperClauses),
+    append(WrapperClauses, [Term], Clauses).
+