preddyns.yap

Go to the documentation of this file.

                                % The next predicates are applicable only
                                % to dynamic code
 
/** @file preddyns.yap */
 
/**
 * @addtogroup Database
 * @{
 
Next follow the main operations on dynamic predicates.
 
*/
 
/** @pred  asserta(+ _C_) is iso
 
 
Adds clause  _C_ to the beginning of the program. If the predicate is
undefined, it is declared  dynamic (see dynamic/1).
 
*/
asserta(Clause) :-
    '$assert'(Clause, asserta, _Ref).
 
 
/** @pred  assertz(+ _C_) is iso
 
 
Adds clause  _C_ to the end of the program. If the predicate is
undefined, it is declared  dynamic (see dynamic/1).
 
Most Prolog systems only allow asserting clauses for dynamic
predicates. This is also as specified in the ISO standard. YAP also allows
asserting clauses for static predicates, under the restriction that the static predicate may not be live in the stacks.
*/
assertz(Clause) :-
    '$assert'(Clause, assertz, _).
 
/** @pred  assert(+ _C_)
 
Same as assertz/1. Adds clause  _C_ to the program. If the predicate is undefined,
declare it as dynamic. New code should use assertz/1 for better portability.
 
Most Prolog systems only allow asserting clauses for dynamic
predicates. This is also as specified in the ISO standard. YAP allows
asserting clauses for static predicates, as long as the predicate is not
in use and the language flag is <tt>cprolog</tt>. Note that this feature is
deprecated, if you want to assert clauses for static procedures you
should use assert_static/1.
 
*/
assert(Clause) :-
    '$assert'(Clause, assertz, _).
 
'$assert'(Clause, Where, R) :-
    '$yap_strip_clause'(Clause, M, MH, H, B),
    '$mk_dynamic'(MH:H),
    '$mk_dynamic',
    (M==MH->MB=B;MB=M:B),
    '$compile'((H :-MB), Where, (H :-MB), MH, R).
'$assert'(Clause, Where, R) :-
    '$expand_clause'(Clause,C,C0),    
    '$$compile'(C, Where, C0, R).
 
/** @pred  asserta(+ _C_,- _R_)
 
The same as `asserta(C)` but unifying  _R_ with
the  database reference that identifies the new clause, in a
one-to-one way. Note that `asserta/2` only works for dynamic
predicates. If the predicate is undefined, it will automatically be
declared dynamic.
 
*/
    asserta(Clause, Ref) :-
    '$assert'(Clause, asserta, Ref).
 
 
 
/** @pred  assertz(+ _C_,- _R_)
 
The same as `assertz(C)` but unifying  _R_ with
the  database reference that identifies the new clause, in a
one-to-one way. Note that `asserta/2` only works for dynamic
predicates. If the predicate is undefined, it will automatically be
declared dynamic.
 
 
*/
assertz(Clause, Ref) :-
    '$assert'(Clause, assertz, Ref).
 
/** @pred  assert(+ _C_,- _R_)
 
The same as `assert(C)` ( (see Modifying the Database)) but
unifies  _R_ with the  database reference that identifies the new
clause, in a one-to-one way. Note that `asserta/2` o>ly works for dynamic
predicates. If the predicate is undefined, it will automatically be
declared dynamic.
 
 
*/
assert(Clause, Ref) :-
    '$assert'(Clause, assertz, Ref).
    
 
'$assertz_dynamic'(X, C, C0, Mod) :-
    (X/\4)=:=0,
    ,
    '$head_and_body'(C,H,B),
    '$assertat_d'(assertz,H,B,C0,Mod,_).
'$assertz_dynamic'(X,C,C0,Mod) :-
    '$head_and_body'(C,H,B),
    functor(H,N,A),
    ('$check_if_reconsulted'(N,A) ->
     '$check_if_reconsulted'
    ;
     (X/\8)=:=0 ->
     '$inform_as_reconsulted'(N,A),
     '$remove_all_d_clauses'(H,Mod)
    ;
     '$remove_all_d_clauses'
    ),
    '$assertat_d'(assertz,H,B,C0,Mod,_).
 
 
'$remove_all_d_clauses'(H,M) :-
    '$is_multifile'(H, M), '$is_multifile',
    functor(H, Na, A),
    '$erase_all_mf_dynamic'(Na,A,M).
'$remove_all_d_clauses'(H,M) :-
    '$recordedp'(M:H,_,R), erase(R), erase.
'$remove_all_d_clauses'(_,_).
 
'$erase_all_mf_dynamic'(Na,A,M) :-
    source_location( F ,  _),
    recorded('$multifile_dynamic'(_,_,_), '$mf'(Na,A,M,F,R), R1),
    erase(R1),
    erase(R),
    erase.
'$erase_all_mf_dynamic'(_,_,_).
 
'$assertat_d'(asserta,Head,Body,C0,Mod,R) :- '$assertat_d',
    '$compile_dynamic'((Head:-Body), asserta, C0, Mod, CR),
    ( get_value('$abol',true)
    ->
      '$predicate_flags'(Head,Mod,Fl,Fl),
      ( Fl /\ 0x20000000 =\= 0 -> '$check_multifile_pred'(Head,Mod,Fl) ; '$check_multifile_pred' )
    ;
      true
    ),
    '$head_and_body'(C0, H0, B0),
    '$recordap'(Mod:Head,(H0 :- B0),R,CR),
    ( '$is_multifile'(Head, Mod) ->
      source_location(F, _, _),
      functor(H0, Na, Ar),
      recorda('$multifile_dynamic'(_,_,_), '$mf'(Na,Ar,Mod,F,R), _)
    ;
      recorda
    ).
'$assertat_d'(assertz,Head,Body,C0,Mod,R) :-
    '$compile_dynamic'((Head:-Body), assertz, C0, Mod, CR),
    ( get_value('$abol',true)
    ->
      '$predicate_flags'(Head,Mod,Fl,Fl),
      ( Fl /\ 0x20000000 =\= 0 -> '$check_multifile_pred'(Head,Mod,Fl) ; '$check_multifile_pred' )
    ;
      true
    ),
    '$head_and_body'(C0, H0, B0),
    '$recordzp'(Mod:Head,(H0 :- B0),R,CR),
    ( '$is_multifile'(H0, Mod) ->
      source_location(F,_),
      functor(H0, Na, Ar),
      recordz('$multifile_dynamic'(_,_,_), '$mf'(Na,Ar,Mod,F,R), _)
    ;
      recordz
    ).
 
/** @pred  retract(+ _C_) is iso
 
 
Erases the first clause in the program that matches  _C_. This
predicate may also be used for the static predicates that have been
compiled when the source mode was `on`. For more information on
source/0 ( (see Setting the Compiler)).
 
 
*/
retract( C ) :-
    strip_module( C, M, C0),
    '$check_head_and_body'(M:C0,M1,H,B,retract(M:C)),
    '$predicate_flags'(H, M1, F, F),
    '$retract2'(F, H, M1, B,_).
 
'$retract2'(F, H, M, B, R) :-
    F /\ 0'$retract2' =:= 0'$retract2', '$retract2',
 
    %   '$is_log_updatable'(H, M), !,
    '$log_update_clause'(H,M,B,R),
    ( F /\ 0x20000000  =:= 0x20000000, recorded('$mf','$mf_clause'(_,_,_,_,R),MR), erase(MR), erase ; erase),
    erase(R).
'$retract2'(F, H, M, B, R) :-
                                %   '$is_dynamic'(H,M), !,
    F /\ 0'$retract2' =:= 0'$retract2', '$retract2',
    '$recordedp'(M:H,(H:-B),R),
    ( F /\ 0x20000000  =:= 0x20000000, recorded('$mf','$mf_clause'(_,_,_,_,MRef),MR), erase(MR), erase(MRef), erase ; erase),
    erase(R).
'$retract2'(_, H,M,_,_) :-
    '$undefined'(H,M), '$undefined',
    functor(H,Na,Ar),
    '$dynamic'(Na/Ar,M),
    '$dynamic'.
'$retract2'(_, H,M,B,_) :-
    functor(H,Na,Ar),
    \+ '$dynamic'(Na/Ar,M),
    '$do_error'(permission_error(modify,static_procedure,Na/Ar),retract(M:(H:-B))).
 
/** @pred  retract(+ _C_,- _R_)
 
Erases from the program the clause  _C_ whose
database reference is  _R_. The predicate must be dynamic.
 
 
 
 
*/
retract(M0C,R) :-
    var(R), var,
    '$check_head_and_body'(M0C,M,H,B,retract(M0C,R)),
    '$retract2'(H, M, B, R).
retract(M0C,R) :- retract,
    db_reference(R),
        '$check_head_and_body'(M0C,M,H,B,retract(M0C,R)),
    dynamic(H,M),
    dynamic,
    instance(R,(H:-B)),
    erase(R).
retract(M0C,_) :-
    '$yap_strip_module'(M0C, M, C),
    '$fetch_predicate_indicator_from_clause'(C, M, PI),
    \+ '$dynamic'(PI),
    '$do_error'(permission_error(modify,static_procedure,PI),retract(M:C)).
 
'$fetch_predicate_indicator_from_clause'((C :- _), M:Na/Ar) :-
'$fetch_predicate_indicator_from_clause',
    '$yap_strip_module'(C, M, C1),
    functor(C1, Na, Ar).
'$fetch_predicate_indicator_from_clause'(C, M:Na/Ar) :-
    '$yap_strip_module'(C, M, C1),
    functor(C1, Na, Ar).
 
 
/** @pred  retractall(+ _G_) is iso
 
 
Retract all the clauses whose head matches the goal  _G_. Goal
 _G_ must be a call to a dynamic predicate.
 
*/
retractall(MT) :- retractall,
    '$yap_strip_module'(MT,M,T),
    must_be_callable(T),
    functor(T,Na,Ar),
    (
    '$is_log_updatable'(T, M) ->
    ( '$is_multifile'(T, M) ->
      '$retractall_lu_mf'(T,M,Na,Ar)
    ;
    '$retractall_lu'(T,M)
    )
    ;
    '$undefined'(T,M) ->
    '$dynamic'(Na/Ar,M), '$dynamic'
    ;
    '$is_dynamic'(T,M) ->
    '$erase_all_clauses_for_dynamic'(T, M)
    ;
    '$do_error'(permission_error(modify,static_procedure,Na/Ar),retractall(T))
    ).
 
'$retractall_lu'(T,M) :-
    '$free_arguments'(T), '$free_arguments',
    ( '$purge_clauses'(T,M), '$purge_clauses' ; '$purge_clauses' ).
'$retractall_lu'(T,M) :-
    '$log_update_clause'(T,M,_,R),
    erase(R),
    erase.
'$retractall_lu'(_,_).
 
'$retractall_lu_mf'(T,M,Na,Ar) :-
    '$log_update_clause'(T,M,_,R),
    functor(M,Na,Ar), 
    ( recorded('$mf','$mf_clause'(_,Na,Ar,M,R),MR), erase(MR), erase ; erase),
    erase(R),
    erase.
'$retractall_lu_mf'(_,_,_,_).
 
'$erase_all_clauses_for_dynamic'(T, M) :-
    '$log_update_clause'(T,M,_,R),
    functor(T,Na,Ar),
    ( recorded('$mf','$mf_clause'(_,Na,Ar,M,R),MR), erase(MR), erase ; erase),
    erase(R),
    erase.
'$erase_all_clauses_for_dynamic'(_,_).
 
/* support for abolish/1 */
'$abolishd'(T, M) :-
    '$is_multifile'(T,M),
    functor(T,Name,Arity),
    recorded('$mf','$mf_clause'(_,Name,Arity,M,Ref),R),
    erase(R),
    erase(Ref),
    erase.
'$abolishd'(T, M) :-
    recorded('$import','$import'(_,M,_,T,_,_),R),
    erase(R),
    erase.
'$abolishd'(T, M) :-
    '$purge_clauses'(T,M), '$purge_clauses'.
'$abolishd'(T, M) :-
    '$kill_dynamic'(T,M), '$kill_dynamic'.
'$abolishd'(_, _).
 
 
/** @pred  dynamic_predicate(+ _P_,+ _Semantics_)
 
 
Declares predicate  _P_ or list of predicates [ _P1_,..., _Pn_]
as a dynamic predicate following either `logical` or
`immediate` semantics.
 
 
*/
dynamic_predicate(P,Sem) :-
    '$bad_if_is_semantics'(Sem, dynamic(P,Sem)).
dynamic_predicate(P,Sem) :-
    '$log_upd'(OldSem),
    ( Sem = logical -> '$switch_log_upd'(1) ; '$switch_log_upd'(0) ),
    '$current_module'(M),
    '$dynamic'(P, M),
    '$switch_log_upd'(OldSem).
 
'$bad_if_is_semantics'(Sem, Goal) :-
    var(Sem), var,
    '$do_error'(instantiation_error,Goal).
'$bad_if_is_semantics'(Sem, Goal) :-
    Sem \= '$bad_if_is_semantics', Sem \= '$bad_if_is_semantics', '$bad_if_is_semantics',
    '$do_error'(domain_error(semantics_indicator,Sem),Goal).