1674 lines
53 KiB
Prolog
1674 lines
53 KiB
Prolog
/*************************************************************************
|
|
* *
|
|
* YAP Prolog *
|
|
* *
|
|
* Yap Prolog was developed at NCCUP - Universidade do Porto *
|
|
* *
|
|
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
|
|
* *
|
|
**************************************************************************
|
|
* *
|
|
* File: modules.pl *
|
|
* Last rev: *
|
|
* mods: *
|
|
* comments: module support *
|
|
* *
|
|
*************************************************************************/
|
|
|
|
/**
|
|
|
|
\defgroup YAPModules The YAP Module system
|
|
|
|
@ingroup YAPLoading
|
|
|
|
The YAP module system is based on the Quintus/SISCtus module
|
|
system. In this design, modules are named collections of predicates,
|
|
and all predicates belong to a single module. Predicates are only
|
|
visible within a module, or _private_ to that module, but the module
|
|
will most often will also define a list of predicates that are
|
|
_exported_, that is, visible to other modules.
|
|
|
|
The main predicates in the module system are:
|
|
|
|
* module/2 associates a source file to a module. It has two arguments: the name of the new module, and a list of predicates exported by the module.
|
|
|
|
* use_module/1 and use_module/2 can be used to load a module. They take as first argument the source file for the module. Whereas use_module/1 loads all exported predicates, use_module/2 only takes the ones given by the second argument.
|
|
|
|
YAP pre-defines a number of modules. Most system predicates belong to
|
|
the module `prolog`. Predicates from the module `prolog` are
|
|
automatically visible to every module. The `system` module was
|
|
introduced for SWI-Prolog compatibility, and in YAP mostly acts as an
|
|
alias to `prolog`.
|
|
|
|
YAP is always associated to a module, the current <em>source
|
|
module</em> or <em>type-in module</em>. By default, all predicates
|
|
read-in and all calls to a goal will be made to predicates visible to
|
|
the current source module, Initially, the source module for YAP is the
|
|
module `user`. Thus Prolog programs that do not define modules will
|
|
operate within the `user` module. In this case, all predicates will be
|
|
visible to all source files.
|
|
|
|
YAP also includes a number of libraries and packages, most of them
|
|
defining their own modules. Note that there is no system mechanism to
|
|
avoid clashes between module names, so it is up to the programmer to
|
|
carefully choose the names for her own program modules.
|
|
|
|
The main mechanism to change the current type-in module is by using
|
|
the module/2 declaration.This declaration sets the source module when
|
|
it starts consulting a file, and resets it at the end. One can set
|
|
the type-in module permanently by using the built-in `module/1`.
|
|
|
|
\subsection Explicit Naming
|
|
|
|
The module system allows one to _explicitly_ specify the source mode for
|
|
a clause by prefixing a clause with its module, say:
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
user:(a :- b).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
it is also possible to type
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
|
|
user:a :- user:b.
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
both formulations describe the same clause, independently of the
|
|
current type-in module.
|
|
|
|
In fact, it is sufficient to specify the source mode for the clause's
|
|
head:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
user:a :- b.
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
if the current type-in module is `m`, the clause could also be written as:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
user:a :- m:b.
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
The compiler rewrites the source clauses to ensure that explicit calls
|
|
are respected, and that implicit calls are made to the current source
|
|
module.
|
|
|
|
A goal should refer to a predicate visible within the current type-in
|
|
module. Thus, if a goal appears in a text file with a module
|
|
declaration, the goal refers to that module's context (but see the
|
|
initialization/1 directive for more details).
|
|
|
|
Again, one can override this rule by prefixing a goal with a module to
|
|
be consulted. The following query:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
?- nasa:launch(apollo,13).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
invokes the goal `launch(apollo,13)` as if the current source
|
|
module was `nasa`.
|
|
|
|
YAP and other Prolog systems allow the module prefix to see all
|
|
predicates visible in the module, including predicates private to the
|
|
module. This rule allows maximum flexibility, but it also breaks
|
|
encapsulation and should be used with care. The ciao language proposes
|
|
a different approach to this problem, see \cite .
|
|
|
|
Modules are not always associated with a source-file. They
|
|
may range over several files, by using the
|
|
`include`directive. Moreover, they may not be associated to any source
|
|
file. As an example,
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
?- assert( nasa:launch(apollo,13) ).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
will create a module `nasa`, if does not already exist. In fact it is
|
|
sufficient to call a predicate from a module to implicitly create the
|
|
module. Hence after this call:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
?- nasa:launch(apollo,13).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
there will be a `nasa`module in the system, even if nasa:launch/2 is
|
|
not at all defined.
|
|
|
|
\{
|
|
|
|
**/
|
|
:- system_module( '$_modules', [abolish_module/1,
|
|
add_import_module/3,
|
|
current_module/1,
|
|
current_module/2,
|
|
delete_import_module/2,
|
|
expand_goal/2,
|
|
export/1,
|
|
export_list/2,
|
|
export_resource/1,
|
|
import_module/2,
|
|
ls_imports/0,
|
|
module/1,
|
|
module_property/2,
|
|
set_base_module/1,
|
|
source_module/1,
|
|
use_module/1,
|
|
use_module/2,
|
|
use_module/3], ['$add_to_imports'/3,
|
|
'$clean_cuts'/2,
|
|
'$convert_for_export'/7,
|
|
'$do_import'/3,
|
|
'$extend_exports'/3,
|
|
'$get_undefined_pred'/4,
|
|
'$imported_pred'/4,
|
|
'$meta_expansion'/6,
|
|
'$meta_predicate'/2,
|
|
'$meta_predicate'/4,
|
|
'$module'/3,
|
|
'$module'/4,
|
|
'$module_expansion'/6,
|
|
'$module_transparent'/2,
|
|
'$module_transparent'/4]).
|
|
|
|
:- use_system_module( '$_arith', ['$c_built_in'/3]).
|
|
|
|
:- use_system_module( '$_consult', ['$lf_opt'/3,
|
|
'$load_files'/3]).
|
|
|
|
:- use_system_module( '$_debug', ['$skipeol'/1]).
|
|
|
|
:- use_system_module( '$_errors', ['$do_error'/2]).
|
|
|
|
:- use_system_module( '$_eval', ['$full_clause_optimisation'/4]).
|
|
|
|
:- '$purge_clauses'(module(_,_), prolog).
|
|
:- '$purge_clauses'('$module'(_,_), prolog).
|
|
:- '$purge_clauses'(use_module(_), prolog).
|
|
:- '$purge_clauses'(use_module(_,_), prolog).
|
|
%
|
|
% start using default definition of module.
|
|
%
|
|
|
|
/**
|
|
\pred use_module( +Files ) is directive
|
|
loads a module file
|
|
|
|
This predicate loads the file specified by _Files_, importing all
|
|
their public predicates into the current type-in module. It is
|
|
implemented as if by:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
use_module(F) :-
|
|
load_files(F, [if(not_loaded),must_be_module(true)]).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Notice that _Files_ may be a single file, or a list with a number
|
|
files. The _Files_ are loaded in YAP only once, even if they have been
|
|
updated meanwhile. YAP should also verify whether the files actually
|
|
define modules. Please consult load_files/3 for other options when
|
|
loading a file.
|
|
|
|
Predicate name clashes between two different modules may arise, either
|
|
when trying to import predicates that are also defined in the current
|
|
type-in module, or by trying to import the same predicate from two
|
|
different modules.
|
|
|
|
In the first case, the local predicate is considered to have priority
|
|
and use_module/1 simply gives a warning. As an example, if the file
|
|
`a.pl` contains:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
:- module( a, [a/1] ).
|
|
|
|
:- use_module(b).
|
|
|
|
a(1).
|
|
a(X) :- b(X).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
and the file `b.pl` contains:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
:- module( b, [a/1,b/1] ).
|
|
|
|
a(2).
|
|
|
|
b(1).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
YAP will execute as follows:
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
?- [a].
|
|
% consulting .../a.pl...
|
|
% consulting .../b.pl...
|
|
% consulted .../b.pl in module b, 0 msec 0 bytes
|
|
% consulted .../a.pl in module a, 1 msec 0 bytes
|
|
true.
|
|
?- a(X).
|
|
X = 1 ? ;
|
|
X = 1.
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
The example shows that the query `a(X)`has a single answer, the one
|
|
defined in `a.pl`. Calls to `a(X)`succeed in the top-level, because
|
|
the module `a` was loaded into `user`. On the other hand, `b(X)`is not
|
|
exported by `a.pl`, and is not available to calls, although it can be
|
|
accessed as a predicate in the module 'a' by using the `:` operator.
|
|
|
|
Next, consider the three files `c.pl`, `d1.pl`, and `d2.pl`:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
% c.pl
|
|
:- module( c, [a/1] ).
|
|
|
|
:- use_module([d1, d2]).
|
|
|
|
a(X) :-
|
|
b(X).
|
|
a(X) :-
|
|
c(X).
|
|
a(X) :-
|
|
d(X).
|
|
|
|
% d1.pl
|
|
:- module( d1, [b/1,c/1] ).
|
|
|
|
b(2).
|
|
c(3).
|
|
|
|
|
|
% d2.pl
|
|
:- module( d2, [b/1,d/1] ).
|
|
|
|
b(1).
|
|
d(4).
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
The result is as follows:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
./yap -l c
|
|
YAP 6.3.4 (x86_64-darwin13.3.0): Tue Jul 15 10:42:11 CDT 2014
|
|
|
|
ERROR!!
|
|
at line 3 in o/d2.pl,
|
|
PERMISSION ERROR- loading .../c.pl: modules d1 and d2 both define b/1
|
|
?- a(X).
|
|
X = 2 ? ;
|
|
ERROR!!
|
|
EXISTENCE ERROR- procedure c/1 is undefined, called from context prolog:$user_call/2
|
|
Goal was c:c(_131290)
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
The state of the module system after this error is undefined.
|
|
|
|
|
|
**/
|
|
|
|
use_module(F) :- '$load_files'(F,
|
|
[if(not_loaded),must_be_module(true)], use_module(F)).
|
|
|
|
|
|
|
|
/**
|
|
\pred use_module(+Files, +Imports)
|
|
loads a module file but only imports the named predicates
|
|
|
|
|
|
This predicate loads the file specified by _Files_, importing their
|
|
public predicates specified by _Imports_ into the current type-in
|
|
module. It is implemented as if by:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
use_module(Files, Imports) :-
|
|
load_files(Files, [if(not_loaded),must_be_module(true),imports(Imports)]).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
The _Imports_ argument may be use to specify which predicates one
|
|
wants to load. It can also be used to give the predicates a different name. As an example,
|
|
the graphs library is implemented on top of the red-black trees library, and some predicates are just aliases:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pl
|
|
:- use_module(library(rbtrees), [
|
|
rb_min/3 as min_assoc,
|
|
rb_max/3 as max_assoc,
|
|
|
|
...]).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Unfortunately it is still not possible to change argument order.
|
|
|
|
**/
|
|
use_module(F,Is) :-
|
|
'$load_files'(F, [if(not_loaded),must_be_module(true),imports(Is)], use_module(F,Is)).
|
|
|
|
/**
|
|
\pred module(+M) is det
|
|
set the type-in module
|
|
|
|
|
|
Defines _M_ to be the current working or type-in module. All files
|
|
which are not bound to a module are assumed to belong to the working
|
|
module (also referred to as type-in module). To compile a non-module
|
|
file into a module which is not the working one, prefix the file name
|
|
with the module name, in the form ` _Module_: _File_`, when
|
|
loading the file.
|
|
|
|
**/
|
|
module(N) :-
|
|
var(N),
|
|
'$do_error'(instantiation_error,module(N)).
|
|
module(N) :-
|
|
atom(N), !,
|
|
% set it as current module.
|
|
'$current_module'(_,N).
|
|
module(N) :-
|
|
'$do_error'(type_error(atom,N),module(N)).
|
|
|
|
/**
|
|
\pred module(+ Module:atom, +ExportList:list) is directive
|
|
define a new module
|
|
|
|
This directive defines the file where it appears as a _module file_;
|
|
it must be the first declaration in the file. _Module_ must be an
|
|
atom specifying the module name; _ExportList_ must be a list
|
|
containing the module's public predicates specification, in the form
|
|
`[predicate_name/arity,...]`. The _ExportList_ can include
|
|
operator declarations for operators that are exported by the module.
|
|
|
|
The public predicates of a module file can be made accessible to other
|
|
files through loading the source file, using the directives
|
|
use_module/1 or use_module/2,
|
|
ensure_loaded/1 and the predicates
|
|
consult/1 or reconsult/1. The
|
|
non-public predicates of a module file are not supposed to be visible
|
|
to other modules; they can, however, be accessed by prefixing the module
|
|
name with the `:/2` operator.
|
|
|
|
**/
|
|
'$module_dec'(N, Ps) :-
|
|
source_location(F, _),
|
|
b_getval( '$source_file', F0 ),
|
|
'$add_module_on_file'(N, F, F0, Ps),
|
|
'$current_module'(_,N).
|
|
|
|
'$module'(_,N,P) :-
|
|
'$module_dec'(N,P).
|
|
|
|
/**
|
|
\pred module(+ M:atom,+ L:list ) is directive
|
|
the current file defines module _M_ with exports _L_. The list may include
|
|
|
|
+ predicate indicators
|
|
|
|
+ operator definitions that look like calls to op/3.
|
|
|
|
The list _L_ may include predicates imported from other modules. If
|
|
you want to fully reexport a module, or a sub-set, also consider reexport/1.
|
|
|
|
Similar to module/2, this directive defines the file where it
|
|
appears in as a module file; it must be the first declaration in the file.
|
|
_M_ must be an atom specifying the module name; _L_ must be a
|
|
list containing the module's public predicates specification, in the
|
|
form `[predicate_name/arity,...]`.
|
|
|
|
The last argument _Options_ must be a list of options, which can be:
|
|
+ <b>filename</b>
|
|
the filename for a module to import into the current module.
|
|
|
|
+ <b>library( +File )</b>
|
|
a library file to import into the current module.
|
|
|
|
+ <b>hide( +Opt)</b>
|
|
if _Opt_ is `false`, keep source code for current module, if `true`, disable.
|
|
|
|
+ <b>export(+PredicateIndicator )</b>
|
|
Add predicates to the public list of the context module. This implies
|
|
the predicate will be imported into another module if this module
|
|
is imported with use_module/1 and use_module/2.
|
|
|
|
+ <b>export_list(? _Mod_,? _ListOfPredicateIndicator_)</b>
|
|
The list _ListOfPredicateIndicator_ contains all predicates
|
|
exported by module _Mod_
|
|
|
|
Note that predicates are normally exported using the directive
|
|
`module/2`. The `export/1` argumwnt is meant to allow export from
|
|
dynamically created modules. The directive argument may also be a list
|
|
of predicates.
|
|
|
|
**/
|
|
'$module'(O,N,P,Opts) :- !,
|
|
'$module'(O,N,P),
|
|
'$process_module_decls_options'(Opts,module(Opts,N,P)).
|
|
|
|
|
|
'$process_module_decls_options'(Var,Mod) :-
|
|
var(Var), !,
|
|
'$do_error'(instantiation_error,Mod).
|
|
'$process_module_decls_options'([],_) :- !.
|
|
'$process_module_decls_options'([H|L],M) :- !,
|
|
'$process_module_decls_option'(H,M),
|
|
'$process_module_decls_options'(L,M).
|
|
'$process_module_decls_options'(T,M) :-
|
|
'$do_error'(type_error(list,T),M).
|
|
|
|
'$process_module_decls_option'(Var,M) :-
|
|
var(Var),
|
|
'$do_error'(instantiation_error,M).
|
|
'$process_module_decls_option'(At,M) :-
|
|
atom(At), !,
|
|
use_module(M:At).
|
|
'$process_module_decls_option'(library(L),M) :- !,
|
|
use_module(M:library(L)).
|
|
'$process_module_decls_option'(hidden(Bool),M) :- !,
|
|
'$process_hidden_module'(Bool, M).
|
|
'$process_module_decls_option'(Opt,M) :-
|
|
'$do_error'(domain_error(module_decl_options,Opt),M).
|
|
|
|
'$process_hidden_module'(TNew,M) :-
|
|
'$convert_true_off_mod3'(TNew, New, M),
|
|
source_mode(Old, New),
|
|
'$prepare_restore_hidden'(Old,New).
|
|
|
|
'$convert_true_off_mod3'(true, off, _) :- !.
|
|
'$convert_true_off_mod3'(false, on, _) :- !.
|
|
'$convert_true_off_mod3'(X, _, M) :-
|
|
'$do_error'(domain_error(module_decl_options,hidden(X)),M).
|
|
|
|
'$prepare_restore_hidden'(Old,Old) :- !.
|
|
'$prepare_restore_hidden'(Old,New) :-
|
|
recorda('$system_initialisation', source_mode(New,Old), _).
|
|
|
|
'$add_module_on_file'(DonorMod, DonorF, SourceF, Exports) :-
|
|
recorded('$module','$module'(OtherF, DonorMod, _, _, _),R),
|
|
% the module has been found, are we reconsulting?
|
|
(
|
|
DonorF \= OtherF
|
|
->
|
|
'$do_error'(permission_error(module,redefined,DonorMod, OtherF, DonorF),module(DonorMod,Exports))
|
|
;
|
|
recorded('$module','$module'(DonorF,DonorMod, SourceF, _, _), R),
|
|
erase( R ),
|
|
fail
|
|
).
|
|
'$add_module_on_file'(DonorM, DonorF, SourceF, Exports) :-
|
|
'$current_module'( HostM ),
|
|
( recorded('$module','$module'( HostF, HostM, _, _, _),_) -> true ; HostF = user_input ),
|
|
% first build the initial export tablee
|
|
'$convert_for_export'(all, Exports, DonorM, HostM, TranslationTab, AllExports0, load_files),
|
|
sort( AllExports0, AllExports ),
|
|
( source_location(_, Line) -> true ; Line = 0 ),
|
|
'$add_to_imports'(TranslationTab, DonorM, DonorM), % insert ops, at least for now
|
|
% last, export everything to the host: if the loading crashed you didn't actually do
|
|
% no evil.
|
|
recorda('$module','$module'(DonorF,DonorM,SourceF, AllExports, Line),_).
|
|
|
|
'$extend_exports'(HostF, Exports, DonorF ) :-
|
|
( recorded('$module','$module'( DonorF, DonorM, _,DonorExports, _),_) -> true ; DonorF = user_input ),
|
|
( recorded('$module','$module'( HostF, HostM, SourceF, _, _),_) -> true ; HostF = user_input ),
|
|
recorded('$module','$module'(HostF, HostM, _, AllExports, _Line), R), erase(R),
|
|
'$convert_for_export'(Exports, DonorExports, DonorM, HostM, _TranslationTab, AllReExports, reexport(DonorF, Exports)),
|
|
lists:append( AllReExports, AllExports, Everything0 ),
|
|
sort( Everything0, Everything ),
|
|
( source_location(_, Line) -> true ; Line = 0 ),
|
|
recorda('$module','$module'(HostF,HostM,SourceF, Everything, Line),_).
|
|
|
|
'$module_produced by'(M, M0, N, K) :-
|
|
recorded('$import','$import'(M,M0,_,_,N,K),_), !.
|
|
'$module_produced by'(M, M0, N, K) :-
|
|
recorded('$import','$import'(MI,M0,G1,_,N,K),_),
|
|
functor(G1, N1, K1),
|
|
'$module_produced by'(M,MI,N1,K1).
|
|
|
|
|
|
/** \pred current_module( ? Mod:atom) is nondet
|
|
: _Mod_ is any user-visible module.
|
|
|
|
*/
|
|
/** @pred current_module( _M_)
|
|
|
|
|
|
Succeeds if _M_ are defined modules. A module is defined as soon as some
|
|
predicate defined in the module is loaded, as soon as a goal in the
|
|
module is called, or as soon as it becomes the current type-in module.
|
|
|
|
|
|
*/
|
|
current_module(Mod) :-
|
|
'$all_current_modules'(Mod),
|
|
\+ '$system_module'(Mod).
|
|
|
|
/** \pred current_module( ? Mod:atom, ? File : file ) is nondet
|
|
: _Mod_ is any user-visible module and _File_ its source file, or `user` if none exists.
|
|
|
|
*/
|
|
/** @pred current_module( _M_, _F_)
|
|
|
|
Succeeds if _M_ are current modules associated to the file _F_.
|
|
|
|
|
|
|
|
|
|
*/
|
|
current_module(Mod,TFN) :-
|
|
'$all_current_modules'(Mod),
|
|
( recorded('$module','$module'(TFN,Mod,_,_Publics, _),_) -> true ; TFN = user ).
|
|
|
|
/** \pred source_module( - Mod:atom ) is nondet
|
|
: _Mod_ is the current read-in or source module.
|
|
|
|
*/
|
|
source_module(Mod) :-
|
|
'$current_module'(Mod).
|
|
|
|
|
|
% expand module names in a clause (interface predicate).
|
|
% A1: Input Clause
|
|
% A2: Output Class to Compiler (lives in module HM)
|
|
% A3: Output Class to clause/2 and listing (lives in module HM)
|
|
%
|
|
% modules:
|
|
% A4: module for body of clause (this is the one used in looking up predicates)
|
|
% A5: context module (this is the current context
|
|
% A6: head module (this is the one used in compiling and accessing).
|
|
%
|
|
%
|
|
'$module_expansion'(H, H, H, _HM, _BM, _SM) :- var(H), !.
|
|
'$module_expansion'((H:-B), (H:-B1), (H:-BOO), HM, BM, SM) :- !,
|
|
'$is_mt'(HM, H, SM, B, IB, NSM),
|
|
'$module_u_vars'(H,UVars,HM), % collect head variables in
|
|
% expanded positions
|
|
'$expand_modules'(IB, B1, BO, HM, BM, NSM, UVars),
|
|
('$full_clause_optimisation'(H, NSM, BO, BOO) ->
|
|
true
|
|
;
|
|
BO = BOO
|
|
).
|
|
% do not expand bodyless clauses.
|
|
'$module_expansion'(H,H,H,_,_,_).
|
|
|
|
|
|
'$trace_module'(X) :-
|
|
telling(F),
|
|
tell('P0:debug'),
|
|
write(X),nl,
|
|
tell(F), fail.
|
|
'$trace_module'(_).
|
|
|
|
'$trace_module'(X,Y) :- X==Y, !.
|
|
'$trace_module'(X,Y) :-
|
|
telling(F),
|
|
tell('~/.dbg.modules'),
|
|
write('***************'), nl,
|
|
portray_clause(X),
|
|
portray_clause(Y),
|
|
tell(F),fail.
|
|
'$trace_module'(_,_).
|
|
|
|
|
|
% expand module names in a body
|
|
% args are:
|
|
% goals to expand
|
|
% code to pass to listing
|
|
% code to pass to compiler
|
|
% current module for looking up preds M
|
|
% source module SM
|
|
% head module HM
|
|
%
|
|
% to understand the differences, you can consider:
|
|
%
|
|
% a:(d:b(X) :- g:c(X), d(X), user:hello(X)).
|
|
%
|
|
% when we process meta-predicate c, HM=d, DM=a, BM=a, M=g and we should get:
|
|
%
|
|
% d:b(X) :- g:c(g:X), a:d(X), user:hello(X).
|
|
%
|
|
% on the other hand,
|
|
%
|
|
% a:(d:b(X) :- c(X), d(X), d:e(X)).
|
|
%
|
|
% will give
|
|
%
|
|
% d:b(X) :- a:c(a:X), a:d(X), e(X).
|
|
%
|
|
%
|
|
% head variab'$expand_modules'(M:G,G1,GO,HM,_M,_SM,HVars)les.
|
|
% goals or arguments/sub-arguments?
|
|
% I cannot use call here because of format/3
|
|
% modules:
|
|
% A4: module for body of clause (this is the one used in looking up predicates)
|
|
% A5: context module (this is the current context
|
|
% A6: head module (this is the one used in compiling and accessing).
|
|
%
|
|
%
|
|
%'$expand_modules'(V,NG,NG,_,_,SM,HVars):-l writeln(V), fail.
|
|
'$expand_modules'(V,NG,NG,_,_,SM,HVars) :-
|
|
var(V), !,
|
|
( '$not_in_vars'(V,HVars)
|
|
->
|
|
NG = call(SM:V),
|
|
( atom(SM) -> NGO = '$execute_in_mod'(V,SM) ; NGO = NG )
|
|
;
|
|
NG = call(V)
|
|
).
|
|
'$expand_modules'(depth_bound_call(G,D),
|
|
depth_bound_call(G1,D),
|
|
('$set_depth_limit_for_next_call'(D),GO),
|
|
HM,BM,SM,HVars) :-
|
|
'$expand_modules'(G,G1,GO,HM,BM,SM,HVars),
|
|
'$composed_built_in'(GO), !.
|
|
'$expand_modules'((A,B),(A1,B1),(AO,BO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars).
|
|
'$expand_modules'((A;B),(A1;B1),(AO;BO),HM,BM,SM,HVars) :- var(A), !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars).
|
|
'$expand_modules'((A*->B;C),(A1*->B1;C1),(yap_hacks:current_choicepoint(DCP),AO,yap_hacks:cut_at(DCP),BO; CO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AOO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AOO, AO),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars),
|
|
'$expand_modules'(C,C1,CO,HM,BM,SM,HVars).
|
|
'$expand_modules'((A;B),(A1;B1),(AO;BO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars).
|
|
'$expand_modules'((A|B),(A1|B1),(AO|BO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars).
|
|
'$expand_modules'((A->B),(A1->B1),(AO->BO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AOO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AOO, AO),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars).
|
|
'$expand_modules'(\+G,\+G,A\=B,_HM,_BM,_SM,_HVars) :-
|
|
nonvar(G),
|
|
G = (A = B),
|
|
!.
|
|
'$expand_modules'(\+A,\+A1,(AO-> false;true),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars).
|
|
'$expand_modules'(once(A),once(A1),
|
|
(yap_hacks:current_choice_point(CP),AO,'$$cut_by'(CP)),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, CP, AO).
|
|
'$expand_modules'(ignore(A),ignore(A1),
|
|
(AO -> true ; true),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, AO).
|
|
'$expand_modules'(forall(A,B),forall(A1,B1),
|
|
((AO, ( BO-> false ; true)) -> false ; true),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, AO).
|
|
'$expand_modules'(not(A),not(A1),(AO -> fail; true),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO,HM,BM,SM,HVars).
|
|
'$expand_modules'(if(A,B,C),if(A1,B1,C1),
|
|
(yap_hacks:current_choicepoint(DCP),AO,yap_hacks:cut_at(DCP),BO; CO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars),
|
|
'$expand_modules'(C,C1,CO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, DCP, AO).
|
|
'$expand_modules'((A*->B;C),(A1*->B1;C1),
|
|
(yap_hacks:current_choicepoint(DCP),AO,yap_hacks:cut_at(DCP),BO; CO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars),
|
|
'$expand_modules'(C,C1,CO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, DCP, AO).
|
|
'$expand_modules'((A*->B),(A1*->B1),
|
|
(yap_hacks:current_choicepoint(DCP),AO,BO),HM,BM,SM,HVars) :- !,
|
|
'$expand_modules'(A,A1,AO0,HM,BM,SM,HVars),
|
|
'$expand_modules'(B,B1,BO,HM,BM,SM,HVars),
|
|
'$clean_cuts'(AO0, DCP, AO).
|
|
'$expand_modules'(true,true,true,_,_,_,_) :- !.
|
|
'$expand_modules'(fail,fail,fail,_,_,_,_) :- !.
|
|
'$expand_modules'(false,false,false,_,_,_,_) :- !.
|
|
% if I don't know what the module is, I cannot do anything to the goal,
|
|
% so I just put a call for later on.
|
|
'$expand_modules'(M:G,call(M:G),'$execute_wo_mod'(G,M),_,_,_,_) :- var(M), !.
|
|
'$expand_modules'(M:G,G1,GO,HM,_M,_SM,HVars) :- !,
|
|
'$expand_modules'(G,G1,GO,HM,M,M,HVars).
|
|
'$expand_modules'(G, G1, GO, HM, BM, SM, HVars) :-
|
|
% is this imported from some other module M1?
|
|
'$imported_pred'(G, BM, GG, M1),
|
|
!,
|
|
'$expand_modules'(GG, G1, GO, HM, M1, SM, HVars).
|
|
'$expand_modules'(G, G1, GO, HM, BM, SM, HVars) :-
|
|
'$meta_expansion'(G, HM, BM, SM, GI, HVars), !,
|
|
'$complete_goal_expansion'(GI, HM, BM, SM, G1, GO, HVars).
|
|
'$expand_modules'(G, G1, GO, HM, BM, SM, HVars) :-
|
|
'$complete_goal_expansion'(G, HM, BM, SM, G1, GO, HVars).
|
|
|
|
expand_goal(G, G) :-
|
|
var(G), !.
|
|
expand_goal(M:G, M:NG) :-
|
|
'$do_expand'(G, M, prolog, [], NG), !.
|
|
expand_goal(G, NG) :-
|
|
'$current_module'(Mod),
|
|
'$do_expand'(G, Mod, prolog, [], NG), !.
|
|
expand_goal(G, G).
|
|
|
|
'$do_expand'(G, _HM, _BM, _SM, _, G) :- var(G), !.
|
|
'$do_expand'(M:G, HM, _BM, _SM, HVars, M:GI) :- !,
|
|
nonvar(M),
|
|
'$do_expand'(G, HM, M, M, HVars, GI).
|
|
'$do_expand'(G, _HM, _BM, SM, _HVars, GI) :-
|
|
(
|
|
'$pred_exists'(goal_expansion(G,GI), SM),
|
|
call(SM:goal_expansion(G, GI))
|
|
->
|
|
true
|
|
;
|
|
'$pred_exists'(goal_expansion(G,GI), system),
|
|
system:goal_expansion(G, GI)
|
|
->
|
|
true
|
|
;
|
|
user:goal_expansion(G, SM, GI)
|
|
->
|
|
true
|
|
;
|
|
user:goal_expansion(G, GI)
|
|
), !.
|
|
'$do_expand'(G, HM, BM, SM, HVars, NG) :-
|
|
'$is_metapredicate'(G,BM), !,
|
|
functor(G, Name, Arity),
|
|
prolog:'$meta_predicate'(Name,BM,Arity,PredDef),
|
|
G =.. [Name|GArgs],
|
|
PredDef =.. [Name|GDefs],
|
|
'$expand_args'(GArgs, HM, BM, SM, GDefs, HVars, NGArgs),
|
|
NG =.. [Name|NGArgs].
|
|
|
|
'$expand_args'([], _, _, _, [], _, []).
|
|
'$expand_args'([A|GArgs], HM, BM, SM, [0|GDefs], HVars, [NA|NGArgs]) :-
|
|
'$do_expand'(A, HM, BM, SM, HVars, NA), !,
|
|
'$expand_args'(GArgs, HM, BM, SM, GDefs, HVars, NGArgs).
|
|
'$expand_args'([A|GArgs], HM, BM, SM, [_|GDefs], HVars, [A|NGArgs]) :-
|
|
'$expand_args'(GArgs, HM, BM, SM, GDefs, HVars, NGArgs).
|
|
|
|
% args are:
|
|
% goal to expand
|
|
% current module for looking up pred
|
|
% current module from head of clause
|
|
% context module
|
|
% :- module(m, []). o:p :- n:(g, l).
|
|
% would be o, n, m.
|
|
% goal to pass to listing
|
|
% goal to pass to compiler
|
|
% head variables.
|
|
'$complete_goal_expansion'(G, HM, BM, SM, G1, GO, HVars) :-
|
|
% '$pred_goal_expansion_on',
|
|
'$do_expand'(G, HM, BM, SM, HVars, GI),
|
|
GI \== G, !,
|
|
'$expand_modules'(GI, G1, GO, HM, BM, SM, HVars).
|
|
'$complete_goal_expansion'(G, HM, BM, SM, G1, G2, _HVars) :-
|
|
'$all_system_predicate'(G, BM, BM0), !,
|
|
% make built-in processing transparent.
|
|
'$match_mod'(G, HM, BM0, SM, G1),
|
|
'$c_built_in'(G1, SM, G2).
|
|
'$complete_goal_expansion'(G, HM, BM, SM, NG, NG, _) :-
|
|
'$match_mod'(G, HM, BM, SM, NG).
|
|
|
|
%'$match_mod'(G, GMod, GMod, NG) :- !,
|
|
% NG = G.
|
|
'$match_mod'(G, _, M, _, G) :-
|
|
nonvar(G),
|
|
'$system_predicate'(G,prolog),
|
|
% \+ '$is_metapredicate'(G, prolog),
|
|
\+ '$is_multifile'(G,M),
|
|
!. % prolog: needs no module info.
|
|
% same module as head, and body goal (I cannot get rid of qualifier before
|
|
% meta-call.
|
|
'$match_mod'(G, HMod, BM, _HM, G) :- HMod == BM, !.
|
|
'$match_mod'(G, _, GMod, _, GMod:G).
|
|
|
|
|
|
% be careful here not to generate an undefined exception.
|
|
'$imported_pred'(G, ImportingMod, G0, ExportingMod) :-
|
|
'$enter_undefp',
|
|
'$undefined'(G, ImportingMod),
|
|
'$get_undefined_pred'(G, ImportingMod, G0, ExportingMod),
|
|
ExportingMod \= ImportingMod, !,
|
|
'$exit_undefp'.
|
|
'$imported_pred'(_G, _ImportingMod, _, _) :-
|
|
'$exit_undefp',
|
|
fail.
|
|
|
|
% This predicate should be bidirectional: both
|
|
% a consumer and a generator.
|
|
'$get_undefined_pred'(G, ImportingMod, G0, ExportingMod) :-
|
|
recorded('$import','$import'(ExportingModI,ImportingMod,G0I,G,_,_),_),
|
|
'$continue_imported'(ExportingMod, ExportingModI, G0, G0I).
|
|
% SWI builtin
|
|
'$get_undefined_pred'(G, _ImportingMod, G0, ExportingMod) :-
|
|
recorded('$dialect',Dialect,_),
|
|
Dialect \= yap,
|
|
functor(G, Name, Arity),
|
|
call(Dialect:index(Name,Arity,ExportingModI,_)), !,
|
|
'$continue_imported'(ExportingMod, ExportingModI, G0, G).
|
|
% autoload
|
|
'$get_undefined_pred'(G, _ImportingMod, G0, ExportingMod) :-
|
|
yap_flag(autoload, V),
|
|
V = true,
|
|
'$autoloader_find_predicate'(G,ExportingModI),
|
|
'$continue_imported'(ExportingMod, ExportingModI, G0, G).
|
|
% parent module mechanism
|
|
'$get_undefined_pred'(G, ImportingMod, G0, ExportingMod) :-
|
|
prolog:'$parent_module'(ImportingMod,ExportingModI),
|
|
'$continue_imported'(ExportingMod, ExportingModI, G0, G).
|
|
|
|
|
|
'$autoloader_find_predicate'(G,ExportingModI) :-
|
|
'$nb_getval'('$autoloader_set', true, fail), !,
|
|
autoloader:find_predicate(G,ExportingModI).
|
|
'$autoloader_find_predicate'(G,ExportingModI) :-
|
|
'$exit_undefp',
|
|
yap_flag(autoload, false),
|
|
load_files([library(autoloader),
|
|
autoloader:library('INDEX'),
|
|
swi:library('dialect/swi/INDEX')],
|
|
[autoload(true),if(not_loaded)]),
|
|
nb_setval('$autoloader_set', true),
|
|
yap_flag(autoload, true),
|
|
'$enter_undefp',
|
|
autoloader:find_predicate(G,ExportingModI).
|
|
|
|
|
|
'$continue_imported'(Mod,Mod,Pred,Pred) :-
|
|
\+ '$undefined'(Pred, Mod), !.
|
|
'$continue_imported'(FM,Mod,FPred,Pred) :-
|
|
recorded('$import','$import'(IM,Mod,IPred,Pred,_,_),_), !,
|
|
'$continue_imported'(FM, IM, FPred, IPred).
|
|
'$continue_imported'(FM,Mod,FPred,Pred) :-
|
|
prolog:'$parent_module'(Mod,IM),
|
|
'$continue_imported'(FM, IM, FPred, Pred).
|
|
|
|
|
|
/**
|
|
|
|
\defgroup YAPMetaPredicates Using Meta-Calls with Modules
|
|
\ingroup YAPModules
|
|
|
|
@{
|
|
|
|
\pred meta_predicate(_G1_,...., _Gn) is directive
|
|
|
|
Declares that this predicate manipulates references to predicates.
|
|
Each _Gi_ is a mode specification.
|
|
|
|
If the argument is `:`, it does not refer directly to a predicate
|
|
but must be module expanded. If the argument is an integer, the argument
|
|
is a goal or a closure and must be expanded. Otherwise, the argument is
|
|
not expanded. Note that the system already includes declarations for all
|
|
built-ins.
|
|
|
|
For example, the declaration for call/1 and setof/3 are:
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
:- meta_predicate call(0), setof(?,0,?).
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
meta_predicate declaration
|
|
implemented by asserting $meta_predicate(SourceModule,Functor,Arity,Declaration)
|
|
|
|
*/
|
|
|
|
|
|
% directive now meta_predicate Ps :- $meta_predicate(Ps).
|
|
|
|
:- dynamic('$meta_predicate'/4).
|
|
|
|
:- multifile '$meta_predicate'/4.
|
|
|
|
'$meta_predicate'(P, M) :-
|
|
var(P),
|
|
'$do_error'(instantiation_error,module(M)).
|
|
'$meta_predicate'((P,Ps), M) :- !,
|
|
'$meta_predicate'(P, M),
|
|
'$meta_predicate'(Ps, M).
|
|
'$meta_predicate'(M:D, _) :- !,
|
|
'$meta_predicate'(D, M).
|
|
'$meta_predicate'(P, M1) :-
|
|
'$install_meta_predicate'(P, M1).
|
|
|
|
|
|
'$install_meta_predicate'(P, M1) :-
|
|
functor(P,F,N),
|
|
( M1 = prolog -> M = _ ; M1 = M),
|
|
( retractall(prolog:'$meta_predicate'(F,M,N,_)), fail ; true),
|
|
asserta(prolog:'$meta_predicate'(F,M,N,P)),
|
|
'$flags'(P, M1, Fl, Fl),
|
|
NFlags is Fl \/ 0x200000,
|
|
'$flags'(P, M1, Fl, NFlags).
|
|
|
|
% return list of vars in expanded positions on the head of a clause.
|
|
%
|
|
% these variables should not be expanded by meta-calls in the body of the goal.
|
|
%
|
|
'$module_u_vars'(H,UVars,M) :-
|
|
functor(H,F,N),
|
|
'$meta_predicate'(F,M,N,D), !,
|
|
'$module_u_vars'(N,D,H,UVars).
|
|
'$module_u_vars'(_,[],_).
|
|
|
|
'$module_u_vars'(0,_,_,[]) :- !.
|
|
'$module_u_vars'(I,D,H,LF) :-
|
|
arg(I,D,X), ( X=':' ; integer(X)),
|
|
arg(I,H,A), '$uvar'(A, LF, L), !,
|
|
I1 is I-1,
|
|
'$module_u_vars'(I1,D,H,L).
|
|
'$module_u_vars'(I,D,H,L) :-
|
|
I1 is I-1,
|
|
'$module_u_vars'(I1,D,H,L).
|
|
|
|
'$uvar'(Y, [Y|L], L) :- var(Y), !.
|
|
% support all/3
|
|
'$uvar'(same( G, _), LF, L) :-
|
|
'$uvar'(G, LF, L).
|
|
'$uvar'('^'( _, G), LF, L) :-
|
|
'$uvar'(G, LF, L).
|
|
|
|
% expand arguments of a meta-predicate
|
|
% $meta_expansion(ModuleWhereDefined,CurrentModule,Goal,ExpandedGoal,MetaVariables)
|
|
|
|
|
|
'$meta_expansion'(G, HM, BM, SM, G1,HVars) :-
|
|
functor(G,F,N),
|
|
'$meta_predicate'(F,BM,N,D), !, % we're in an argument
|
|
% format(user_error,'[ ~w (~a, ~a, ~a)',[G, HM, BM, SM]),
|
|
functor(G1,F,N),
|
|
'$meta_expansion_loop'(N, D, G, G1, HVars, HM, BM, SM).
|
|
% format(user_error,' gives ~w]~n',[G1]).
|
|
|
|
|
|
% expand argument
|
|
'$meta_expansion_loop'(0,_,_,_,_,_,_,_) :- !.
|
|
'$meta_expansion_loop'(I,D,G,NG,HVars, HM, BM, SM) :-
|
|
arg(I,D,X),
|
|
(X==':' -> true ; integer(X)),
|
|
arg(I,G,A),
|
|
'$should_expand'(A,HVars),
|
|
!,
|
|
( X ==0 ->
|
|
'$values'('$c_arith',Old, false),
|
|
'$meta_expansion0'(A, HM, BM, SM, NA, HVars),
|
|
'$values'('$c_arith', _False, Old)
|
|
;
|
|
NA = SM:A
|
|
),
|
|
arg(I,NG,NA),
|
|
I1 is I-1,
|
|
'$meta_expansion_loop'(I1, D, G, NG, HVars, HM, BM, SM).
|
|
'$meta_expansion_loop'(I, D, G, NG, HVars, HM, BM, SM) :-
|
|
arg(I,G,A),
|
|
arg(I,NG,A),
|
|
I1 is I-1,
|
|
'$meta_expansion_loop'(I1, D, G, NG, HVars, HM, BM, SM).
|
|
|
|
'$meta_expansion0'(G, _HM, _BM, SM, SM:G, _HVars) :-
|
|
var(G), !.
|
|
'$meta_expansion0'(M:G, _HM, _BM, _SM, G1, _HVars) :-
|
|
var(M), !,
|
|
G1 = '$execute_wo_mod'(G,M).
|
|
% support for all/3
|
|
'$meta_expansion0'(same(G, P), HM, BM, SM, same(G1, P),HVars) :- !,
|
|
'$meta_expansion0'(G, HM, BM, SM, G1,HVars).
|
|
'$meta_expansion0'(G, _HM, _BM, SM, M1:G1,_HVars) :-
|
|
strip_module(SM:G,M1,G1).
|
|
|
|
|
|
% check if an argument should be expanded
|
|
'$should_expand'(V,HVars) :- var(V), !, '$not_in_vars'(V,HVars).
|
|
'$should_expand'(_:_,_) :- !, fail.
|
|
'$should_expand'(_,_).
|
|
|
|
'$not_in_vars'(_,[]).
|
|
'$not_in_vars'(V,[X|L]) :- X\==V, '$not_in_vars'(V,L).
|
|
|
|
/*
|
|
\pred module_transparent( + _Preds_ ) is directive
|
|
_Preds_ is a list of predicates that can access the calling context.
|
|
|
|
_Preds_ is a comma separated sequence of name/arity predicate
|
|
indicators (like in dynamic/1). Each goal associated with a
|
|
transparent declared predicate will inherit the context module from
|
|
its parent goal.
|
|
|
|
*/
|
|
:- dynamic('$module_transparent'/4).
|
|
|
|
'$module_transparent'((P,Ps), M) :- !,
|
|
'$module_transparent'(P, M),
|
|
'$module_transparent'(Ps, M).
|
|
'$module_transparent'(M:D, _) :- !,
|
|
'$module_transparent'(D, M).
|
|
'$module_transparent'(F/N, M) :-
|
|
'$module_transparent'(F,M,N,_), !.
|
|
'$module_transparent'(F/N, M) :-
|
|
functor(P,F,N),
|
|
asserta(prolog:'$module_transparent'(F,M,N,P)),
|
|
'$flags'(P, M, Fl, Fl),
|
|
NFlags is Fl \/ 0x200004,
|
|
'$flags'(P, M, Fl, NFlags).
|
|
|
|
%% handle module transparent predicates by defining a
|
|
%% new context module.
|
|
'$is_mt'(M, H, _, B, (context_module(CM),B), CM) :-
|
|
'$module_transparent'(_, M, _, H), !.
|
|
'$is_mt'(_M, _H, CM, B, B, CM).
|
|
|
|
% comma has its own problems.
|
|
:- '$install_meta_predicate'(','(0,0), prolog).
|
|
|
|
|
|
:- meta_predicate
|
|
abolish(:),
|
|
abolish(:,+),
|
|
all(?,0,-),
|
|
assert(:),
|
|
assert(:,+),
|
|
assert_static(:),
|
|
asserta(:),
|
|
asserta(:,+),
|
|
asserta_static(:),
|
|
assertz(:),
|
|
assertz(:,+),
|
|
assertz_static(:),
|
|
at_halt(0),
|
|
bagof(?,0,-),
|
|
bb_get(:,-),
|
|
bb_put(:,+),
|
|
bb_delete(:,?),
|
|
bb_update(:,?,?),
|
|
call(0),
|
|
call(1,?),
|
|
call(2,?,?),
|
|
call(3,?,?,?),
|
|
call_with_args(0),
|
|
call_with_args(1,?),
|
|
call_with_args(2,?,?),
|
|
call_with_args(3,?,?,?),
|
|
call_with_args(4,?,?,?,?),
|
|
call_with_args(5,?,?,?,?,?),
|
|
call_with_args(6,?,?,?,?,?,?),
|
|
call_with_args(7,?,?,?,?,?,?,?),
|
|
call_with_args(8,?,?,?,?,?,?,?,?),
|
|
call_with_args(9,?,?,?,?,?,?,?,?,?),
|
|
call_cleanup(0,0),
|
|
call_cleanup(0,?,0),
|
|
call_residue(0,?),
|
|
call_residue_vars(0,?),
|
|
call_shared_object_function(:,+),
|
|
catch(0,?,0),
|
|
clause(:,?),
|
|
clause(:,?,?),
|
|
compile(:),
|
|
consult(:),
|
|
current_predicate(:),
|
|
current_predicate(?,:),
|
|
db_files(:),
|
|
depth_bound_call(0,+),
|
|
discontiguous(:),
|
|
ensure_loaded(:),
|
|
exo_files(:),
|
|
findall(?,0,-),
|
|
findall(?,0,-,?),
|
|
forall(0,0),
|
|
format(+,:),
|
|
format(+,+,:),
|
|
freeze(?,0),
|
|
hide_predicate(:),
|
|
if(0,0,0),
|
|
ignore(0),
|
|
incore(0),
|
|
multifile(:),
|
|
nospy(:),
|
|
not(0),
|
|
notrace(0),
|
|
once(0),
|
|
phrase(2,?),
|
|
phrase(2,?,+),
|
|
predicate_property(:,?),
|
|
predicate_statistics(:,-,-,-),
|
|
on_exception(+,0,0),
|
|
qsave_program(+,:),
|
|
reconsult(:),
|
|
retract(:),
|
|
retract(:,?),
|
|
retractall(:),
|
|
reconsult(:),
|
|
setof(?,0,-),
|
|
setup_call_cleanup(0,0,0),
|
|
setup_call_catcher_cleanup(0,0,?,0),
|
|
spy(:),
|
|
stash_predicate(:),
|
|
use_module(:),
|
|
use_module(:,?),
|
|
use_module(?,:,?),
|
|
when(+,0),
|
|
with_mutex(+,0),
|
|
with_output_to(?,0),
|
|
'->'(0 , 0),
|
|
'*->'(0 , 0),
|
|
';'(0 , 0),
|
|
','(0 , 0),
|
|
^(+,0),
|
|
{}(0,?,?),
|
|
','(2,2,?,?),
|
|
;(2,2,?,?),
|
|
'|'(2,2,?,?),
|
|
->(2,2,?,?),
|
|
\+(2,?,?),
|
|
\+( 0 ).
|
|
|
|
/**
|
|
|
|
@}
|
|
|
|
@{
|
|
\defgroup YAPDynamicYAPModules Dynamic Modules
|
|
\ingroup YAPModules
|
|
|
|
YAP (in the footsteps of SWI-Prolog) allows to create modules that
|
|
are not bound to files. One application is in Inductive Logic Programming,
|
|
where dynamic modules can be used to represent training examples. YAP now include
|
|
built-ins to create a module. manipulate its interface, and eventually abolish the
|
|
module, releasing all the data therein.
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
\pred declare_module(+Module, +Super, +File, +Line, +Redefine) is det
|
|
declare explicitely a module
|
|
|
|
Start a new (source-)module _Module_ that inherits all exports from
|
|
_Super_. The module is as if defined in file _File_ and _Line_ and if _Redefine_
|
|
holds true may
|
|
be associated to a new file.
|
|
|
|
\param[in] _Module_ is the name of the module to declare
|
|
\param[in] _MSuper_ is the name of the context module. Use `prolog`or `system`
|
|
if you do not need a context.
|
|
\param[in] _File_ is the canonical name of the file from which the module is loaded
|
|
\param[in] Line is the line-number of the :- module/2 directive.
|
|
\param[in] If _Redefine_ `true`, allow associating the module to a new file
|
|
*/
|
|
|
|
'$declare_module'(Name, _Super, Context, _File, _Line) :-
|
|
add_import_module(Name, Context, start).
|
|
|
|
|
|
/**
|
|
\pred abolish_module( + Mod) is det
|
|
get rid of a module and of all predicates included in the module.
|
|
*/
|
|
abolish_module(Mod) :-
|
|
recorded('$module','$module'(_,Mod,_,_,_),R), erase(R),
|
|
fail.
|
|
abolish_module(Mod) :-
|
|
recorded('$import','$import'(Mod,_,_,_,_,_),R), erase(R),
|
|
fail.
|
|
abolish_module(Mod) :-
|
|
'$current_predicate'(Na,Mod,S,_),
|
|
functor(S, Na, Ar),
|
|
abolish(Mod:Na/Ar),
|
|
fail.
|
|
abolish_module(_).
|
|
|
|
export(Resource) :-
|
|
var(Resource),
|
|
'$do_error'(instantiation_error,export(Resource)).
|
|
export([]) :- !.
|
|
export([Resource| Resources]) :- !,
|
|
export_resource(Resource),
|
|
export(Resources).
|
|
export(Resource) :-
|
|
export_resource(Resource).
|
|
|
|
export_resource(Resource) :-
|
|
var(Resource), !,
|
|
'$do_error'(instantiation_error,export(Resource)).
|
|
export_resource(P) :-
|
|
P = F/N, atom(F), number(N), N >= 0, !,
|
|
'$current_module'(Mod),
|
|
( recorded('$module','$module'(File,Mod,SourceF,ExportedPreds,Line),R) ->
|
|
erase(R),
|
|
recorda('$module','$module'(File,Mod,SourceF,[P|ExportedPreds],Line),_)
|
|
; prolog_load_context(file, File) ->
|
|
recorda('$module','$module'(File,Mod,SourceF,[P],Line),_)
|
|
; recorda('$module','$module'(user_input,Mod,user_input,[P],1),_)
|
|
).
|
|
export_resource(P0) :-
|
|
P0 = F//N, atom(F), number(N), N >= 0, !,
|
|
N1 is N+2, P = F/N1,
|
|
'$current_module'(Mod),
|
|
( recorded('$module','$module'(File,Mod,SourceF,ExportedPreds,Line),R) ->
|
|
erase(R),
|
|
recorda('$module','$module'(File,Mod,SourceF,[P|ExportedPreds],Line ),_)
|
|
; prolog_load_context(file, File) ->
|
|
recorda('$module','$module'(File,Mod,SourceF,[P],Line),_)
|
|
; recorda('$module','$module'(user_input,Mod,user_input,[P],1),_)
|
|
).
|
|
export_resource(op(Prio,Assoc,Name)) :- !,
|
|
op(Prio,Assoc,prolog:Name).
|
|
export_resource(Resource) :-
|
|
'$do_error'(type_error(predicate_indicator,Resource),export(Resource)).
|
|
|
|
export_list(Module, List) :-
|
|
recorded('$module','$module'(_,Module,_,List,_),_).
|
|
|
|
'$convert_for_export'(all, Exports, _Module, _ContextModule, Tab, MyExports, _) :-
|
|
'$simple_conversion'(Exports, Tab, MyExports).
|
|
'$convert_for_export'([], Exports, Module, ContextModule, Tab, MyExports, Goal) :-
|
|
'$clean_conversion'([], Exports, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$convert_for_export'([P1|Ps], Exports, Module, ContextModule, Tab, MyExports, Goal) :-
|
|
'$clean_conversion'([P1|Ps], Exports, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$convert_for_export'(except(Excepts), Exports, Module, ContextModule, Tab, MyExports, Goal) :-
|
|
'$neg_conversion'(Excepts, Exports, Module, ContextModule, MyExports, Goal),
|
|
'$simple_conversion'(MyExports, Tab, _).
|
|
|
|
'$simple_conversion'([], [], []).
|
|
'$simple_conversion'([F/N|Exports], [F/N-F/N|Tab], [F/N|E]) :-
|
|
'$simple_conversion'(Exports, Tab, E).
|
|
'$simple_conversion'([F//N|Exports], [F/N2-F/N2|Tab], [F/N2|E]) :-
|
|
N2 is N+1,
|
|
'$simple_conversion'(Exports, Tab, E).
|
|
'$simple_conversion'([F/N as NF|Exports], [F/N-NF/N|Tab], [NF/N|E]) :-
|
|
'$simple_conversion'(Exports, Tab, E).
|
|
'$simple_conversion'([F//N as NF|Exports], [F/N2-NF/N2|Tab], [NF/N2|E]) :-
|
|
N2 is N+1,
|
|
'$simple_conversion'(Exports, Tab, E).
|
|
'$simple_conversion'([op(Prio,Assoc,Name)|Exports], [op(Prio,Assoc,Name)|Tab], [op(Prio,Assoc,Name)|E]) :-
|
|
'$simple_conversion'(Exports, Tab, E).
|
|
|
|
'$clean_conversion'([], _, _, _, [], [], _).
|
|
'$clean_conversion'([(N1/A1 as N2)|Ps], List, Module, ContextModule, [N1/A1-N2/A1|Tab], [N2/A1|MyExports], Goal) :- !,
|
|
( lists:memberchk(N1/A1, List)
|
|
->
|
|
true
|
|
;
|
|
'$bad_export'((N1/A1 as N2), Module, ContextModule)
|
|
),
|
|
'$clean_conversion'(Ps, List, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$clean_conversion'([N1/A1|Ps], List, Module, ContextModule, [N1/A1-N1/A1|Tab], [N1/A1|MyExports], Goal) :- !,
|
|
(
|
|
lists:memberchk(N1/A1, List)
|
|
->
|
|
true
|
|
;
|
|
'$bad_export'(N1/A1, Module, ContextModule)
|
|
),
|
|
'$clean_conversion'(Ps, List, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$clean_conversion'([N1//A1|Ps], List, Module, ContextModule, [N1/A2-N1/A2|Tab], [N1/A2|MyExports], Goal) :- !,
|
|
A2 is A1+2,
|
|
(
|
|
lists:memberchk(N1/A2, List)
|
|
->
|
|
true
|
|
;
|
|
'$bad_export'(N1//A1, Module, ContextModule)
|
|
|
|
),
|
|
'$clean_conversion'(Ps, List, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$clean_conversion'([N1//A1 as N2|Ps], List, Module, ContextModule, [N2/A2-N1/A2|Tab], [N2/A2|MyExports], Goal) :- !,
|
|
A2 is A1+2,
|
|
(
|
|
lists:memberchk(N2/A2, List)
|
|
->
|
|
true
|
|
;
|
|
'$bad_export'((N1//A1 as A2), Module, ContextModule)
|
|
),
|
|
'$clean_conversion'(Ps, List, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$clean_conversion'([op(Prio,Assoc,Name)|Ps], List, Module, ContextModule, [op(Prio,Assoc,Name)|Tab], [op(Prio,Assoc,Name)|MyExports], Goal) :- !,
|
|
(
|
|
lists:memberchk(op(Prio,Assoc,Name), List)
|
|
->
|
|
true
|
|
;
|
|
'$bad_export'(op(Prio,Assoc,Name), Module, ContextModule)
|
|
),
|
|
'$clean_conversion'(Ps, List, Module, ContextModule, Tab, MyExports, Goal).
|
|
'$clean_conversion'([P|_], _List, _, _, _, _, Goal) :-
|
|
'$do_error'(domain_error(module_export_predicates,P), Goal).
|
|
|
|
'$bad_export'(_, _Module, _ContextModule) :- !.
|
|
'$bad_export'(Name/Arity, Module, ContextModule) :-
|
|
functor(P, Name, Arity),
|
|
predicate_property(Module:P, _), !,
|
|
print_message(warning, declaration(Name/Arity, Module, ContextModule, private)).
|
|
'$bad_export'(Name//Arity, Module, ContextModule) :-
|
|
Arity2 is Arity+2,
|
|
functor(P, Name, Arity2),
|
|
predicate_property(Module:P, _), !,
|
|
print_message(warning, declaration(Name/Arity, Module, ContextModule, private)).
|
|
'$bad_export'(Indicator, Module, ContextModule) :- !,
|
|
print_message(warning, declaration( Indicator, Module, ContextModule, undefined)).
|
|
|
|
'$neg_conversion'([], Exports, _, _, Exports, _).
|
|
'$neg_conversion'([N1/A1|Ps], List, Module, ContextModule, MyExports, Goal) :- !,
|
|
(
|
|
lists:delete(List, N1/A1, RList)
|
|
->
|
|
'$neg_conversion'(Ps, RList, Module, ContextModule, MyExports, Goal)
|
|
;
|
|
'$bad_export'(N1/A1, Module, ContextModule)
|
|
).
|
|
'$neg_conversion'([N1//A1|Ps], List, Module, ContextModule, MyExports, Goal) :- !,
|
|
A2 is A1+2,
|
|
(
|
|
lists:delete(List, N1/A2, RList)
|
|
->
|
|
'$neg_conversion'(Ps, RList, Module, ContextModule, MyExports, Goal)
|
|
;
|
|
'$bad_export'(N1//A1, Module, ContextModule)
|
|
).
|
|
'$neg_conversion'([op(Prio,Assoc,Name)|Ps], List, Module, ContextModule, MyExports, Goal) :- !,
|
|
(
|
|
lists:delete(List, op(Prio,Assoc,Name), RList)
|
|
->
|
|
'$neg_conversion'(Ps, RList, Module, ContextModule, MyExports, Goal)
|
|
;
|
|
'$bad_export'(op(Prio,Assoc,Name), Module, ContextModule)
|
|
).
|
|
'$clean_conversion'([P|_], _List, _, _, _, Goal) :-
|
|
'$do_error'(domain_error(module_export_predicates,P), Goal).
|
|
|
|
|
|
'$add_to_imports'([], _, _).
|
|
% no need to import from the actual module
|
|
'$add_to_imports'([T|Tab], Module, ContextModule) :-
|
|
'$do_import'(T, Module, ContextModule),
|
|
'$add_to_imports'(Tab, Module, ContextModule).
|
|
|
|
'$do_import'(op(Prio,Assoc,Name), _Mod, ContextMod) :-
|
|
op(Prio,Assoc,ContextMod:Name).
|
|
'$do_import'(N0/K0-N0/K0, Mod, Mod) :- !.
|
|
'$do_import'(_N/K-N1/K, _Mod, ContextMod) :-
|
|
recorded('$module','$module'(_F, ContextMod, _SourceF, MyExports,_),_),
|
|
once(lists:member(N1/K, MyExports)),
|
|
functor(S, N1, K),
|
|
% reexport predicates if they are undefined in the current module.
|
|
\+ '$undefined'(S,ContextMod), !.
|
|
'$do_import'( N/K-N1/K, Mod, ContextMod) :-
|
|
functor(G,N,K),
|
|
'$follow_import_chain'(Mod,G,M0,G0),
|
|
G0=..[_N0|Args],
|
|
G1=..[N1|Args],
|
|
( '$check_import'(M0,ContextMod,N1,K) ->
|
|
( ContextMod = user ->
|
|
( recordzifnot('$import','$import'(M0,user,G0,G1,N1,K),_) -> true ; true)
|
|
;
|
|
( recordaifnot('$import','$import'(M0,ContextMod,G0,G1,N1,K),_) -> true ; true )
|
|
)
|
|
;
|
|
true
|
|
).
|
|
|
|
'$follow_import_chain'(M,G,M0,G0) :-
|
|
recorded('$import','$import'(M1,M,G1,G,_,_),_), M \= M1, !,
|
|
'$follow_import_chain'(M1,G1,M0,G0).
|
|
'$follow_import_chain'(M,G,M,G).
|
|
|
|
% trying to import Mod:N/K into ContextM
|
|
'$check_import'(Mod, ContextM, N, K) :-
|
|
recorded('$import','$import'(MI, ContextM, _, _, N,K),_R),
|
|
% dereference MI to M1, in order to find who
|
|
% is actually generating
|
|
( '$module_produced by'(M1, MI, N, K) -> true ; MI = M1 ),
|
|
( '$module_produced by'(M2, Mod, N, K) -> true ; Mod = M2 ),
|
|
M2 \= M1, !,
|
|
b_getval('$lf_status', TOpts),
|
|
'$lf_opt'(redefine_module, TOpts, Action),
|
|
'$redefine_action'(Action, M1, M2, Mod, ContextM, N/K).
|
|
'$check_import'(_,_,_,_).
|
|
|
|
'$redefine_action'(ask, M1, M2, M, _, N/K) :-
|
|
stream_property(user_input,tty(true)), !,
|
|
format(user_error,'NAME CLASH: ~w was already imported to module ~w;~n',[M1:N/K,M2]),
|
|
format(user_error,' Do you want to import it from ~w ? [y, n, e or h] ',M),
|
|
'$mod_scan'(C),
|
|
( C == e -> halt(1) ;
|
|
C == y ).
|
|
'$redefine_action'(true, M1, _, _, _, _) :- !,
|
|
recorded('$module','$module'(F, M1, _, _MyExports,_Line),_),
|
|
unload_file(F).
|
|
'$redefine_action'(false, M1, M2, _M, ContextM, N/K) :-
|
|
recorded('$module','$module'(F, ContextM, _, _MyExports,_Line),_),
|
|
'$current_module'(_, M2),
|
|
'$do_error'(permission_error(import,M1:N/K,redefined,M2),F).
|
|
|
|
'$mod_scan'(C) :-
|
|
get_char(C),
|
|
'$skipeol'(C),
|
|
(C == y -> true; C == n).
|
|
|
|
% I assume the clause has been processed, so the
|
|
% var case is long gone! Yes :)
|
|
'$clean_cuts'(G,(yap_hacks:current_choicepoint(DCP),NG)) :-
|
|
'$conj_has_cuts'(G,DCP,NG,OK), OK == ok, !.
|
|
'$clean_cuts'(G,G).
|
|
|
|
'$clean_cuts'(G,DCP,NG) :-
|
|
'$conj_has_cuts'(G,DCP,NG,OK), OK == ok, !.
|
|
'$clean_cuts'(G,_,G).
|
|
|
|
'$conj_has_cuts'(V,_,V, _) :- var(V), !.
|
|
'$conj_has_cuts'(!,DCP,'$$cut_by'(DCP), ok) :- !.
|
|
'$conj_has_cuts'((G1,G2),DCP,(NG1,NG2), OK) :- !,
|
|
'$conj_has_cuts'(G1, DCP, NG1, OK),
|
|
'$conj_has_cuts'(G2, DCP, NG2, OK).
|
|
'$conj_has_cuts'((G1;G2),DCP,(NG1;NG2), OK) :- !,
|
|
'$conj_has_cuts'(G1, DCP, NG1, OK),
|
|
'$conj_has_cuts'(G2, DCP, NG2, OK).
|
|
'$conj_has_cuts'((G1->G2),DCP,(G1;NG2), OK) :- !,
|
|
% G1: the system must have done it already
|
|
'$conj_has_cuts'(G2, DCP, NG2, OK).
|
|
'$conj_has_cuts'((G1*->G2),DCP,(G1;NG2), OK) :- !,
|
|
% G1: the system must have done it already
|
|
'$conj_has_cuts'(G2, DCP, NG2, OK).
|
|
'$conj_has_cuts'(if(G1,G2,G3),DCP,if(G1,NG2,NG3), OK) :- !,
|
|
% G1: the system must have done it already
|
|
'$conj_has_cuts'(G2, DCP, NG2, OK),
|
|
'$conj_has_cuts'(G3, DCP, NG3, OK).
|
|
'$conj_has_cuts'(G,_,G, _).
|
|
|
|
/**
|
|
set_base_module( +ExportingModule ) is det
|
|
All exported predicates from _ExportingModule_ are automatically available to the
|
|
current source module.
|
|
|
|
This built-in was introduced by SWI-Prolog. In YAP, by default, modules only
|
|
inherit from `prolog`. This extension allows predicates in the current
|
|
module (see module/2 and module/1) to inherit from `user` or other modules.
|
|
|
|
*/
|
|
set_base_module(ExportingModule) :-
|
|
var(ExportingModule),
|
|
'$do_error'(instantiation_error,set_base_module(ExportingModule)).
|
|
set_base_module(ExportingModule) :-
|
|
atom(ExportingModule), !,
|
|
'$current_module'(Mod),
|
|
retractall(prolg:'$parent_module'(Mod,_)),
|
|
asserta(prolog:'$parent_module'(Mod,ExportingModule)).
|
|
set_base_module(ExportingModule) :-
|
|
'$do_error'(type_error(atom,ExportingModule),set_base_module(ExportingModule)).
|
|
|
|
/**
|
|
import_module( +ImportingModule, +ExportingModule ) is det
|
|
All exported predicates from _ExportingModule_ are automatically available to the
|
|
source module _ImportModule_.
|
|
|
|
This innovation was introduced by SWI-Prolog. By default, modules only
|
|
inherit from `prolog`. This extension allows predicates in any module
|
|
to inherit from `user`oe other modules.
|
|
|
|
*/
|
|
import_module(Mod, ImportModule) :-
|
|
var(Mod),
|
|
'$do_error'(instantiation_error,import_module(Mod, ImportModule)).
|
|
import_module(Mod, ImportModule) :-
|
|
atom(Mod), !,
|
|
prolog:'$parent_module'(Mod,ImportModule).
|
|
import_module(Mod, EM) :-
|
|
'$do_error'(type_error(atom,Mod),import_module(Mod, EM)).
|
|
|
|
|
|
/** add_import_module( + _Module_, + _ImportModule_ , +_Pos_) is det
|
|
Add all exports in _ImportModule_ as available to _Module_.
|
|
|
|
|
|
All exported predicates from _ExportModule_ are made available to the
|
|
source module _ImportModule_. If _Position_ is bound to `start` the
|
|
module _ImportModule_ is tried first, if _Position_ is bound to `end`,
|
|
the module is consulted last.
|
|
|
|
*/
|
|
add_import_module(Mod, ImportModule, Pos) :-
|
|
var(Mod),
|
|
'$do_error'(instantiation_error,add_import_module(Mod, ImportModule, Pos)).
|
|
add_import_module(Mod, ImportModule, Pos) :-
|
|
var(Pos),
|
|
'$do_error'(instantiation_error,add_import_module(Mod, ImportModule, Pos)).
|
|
add_import_module(Mod, ImportModule, start) :-
|
|
atom(Mod), !,
|
|
retractall(prolog:'$parent_module'(Mod,ImportModule)),
|
|
asserta(prolog:'$parent_module'(Mod,ImportModule)).
|
|
add_import_module(Mod, ImportModule, end) :-
|
|
atom(Mod), !,
|
|
retractall(prolog:'$parent_module'(Mod,ImportModule)),
|
|
assertz(prolog:'$parent_module'(Mod,ImportModule)).
|
|
add_import_module(Mod, ImportModule, Pos) :-
|
|
\+ atom(Mod), !,
|
|
'$do_error'(type_error(atom,Mod),add_import_module(Mod, ImportModule, Pos)).
|
|
add_import_module(Mod, ImportModule, Pos) :-
|
|
'$do_error'(domain_error(start_end,Pos),add_import_module(Mod, ImportModule, Pos)).
|
|
|
|
/** delete_import_module( + _ExportModule_, + _ImportModule_ ) is det
|
|
Exports in _ImportModule_ are no longer available to _Module_.
|
|
|
|
|
|
All exported predicates from _ExportModule_ are discarded from the
|
|
ones used vy the source module _ImportModule_.
|
|
|
|
*/
|
|
delete_import_module(Mod, ImportModule) :-
|
|
var(Mod),
|
|
'$do_error'(instantiation_error,delete_import_module(Mod, ImportModule)).
|
|
delete_import_module(Mod, ImportModule) :-
|
|
var(ImportModule),
|
|
'$do_error'(instantiation_error,delete_import_module(Mod, ImportModule)).
|
|
delete_import_module(Mod, ImportModule) :-
|
|
atom(Mod),
|
|
atom(ImportModule), !,
|
|
retractall(prolog:'$parent_module'(Mod,ImportModule)).
|
|
delete_import_module(Mod, ImportModule) :-
|
|
\+ atom(Mod), !,
|
|
'$do_error'(type_error(atom,Mod),delete_import_module(Mod, ImportModule)).
|
|
delete_import_module(Mod, ImportModule) :-
|
|
'$do_error'(type_error(atom,ImportModule),delete_import_module(Mod, ImportModule)).
|
|
|
|
'$set_source_module'(Source0, SourceF) :-
|
|
prolog_load_context(module, Source0), !,
|
|
module(SourceF).
|
|
'$set_source_module'(Source0, SourceF) :-
|
|
current_module(Source0, SourceF).
|
|
|
|
/** module_property( + _Module_, ? _Property_ ) is nondet
|
|
Enumerate non-deterministically the main properties of _Module_ .
|
|
|
|
Reports the following properties of _Module_:
|
|
|
|
+ `class`( ?_Class_ ): whether it is a `system`, `library`, or `user` module.
|
|
|
|
+ `line_count`(?_Ls_): number of lines in source file.
|
|
|
|
+ `file`(?_F_): source file for _Module_.
|
|
|
|
+ `exports`(-Es): list of all predicate symbols and
|
|
operator symbols exported or re-exported by this module.
|
|
|
|
*/
|
|
module_property(Mod, class(L)) :-
|
|
'$module_class'(Mod, L).
|
|
module_property(Mod, line_count(L)) :-
|
|
recorded('$module','$module'(_F,Mod,_,_,L),_).
|
|
module_property(Mod, file(F)) :-
|
|
recorded('$module','$module'(F,Mod,_,_,_),_).
|
|
module_property(Mod, exports(Es)) :-
|
|
recorded('$module','$module'(_,Mod,_,Es,_),_).
|
|
|
|
'$module_class'(Mod, system) :- '$system_module'( Mod ).
|
|
'$module_class'(Mod, library) :- '$library_module'( Mod ).
|
|
'$module_class'(Mod, user) :- '$user_module'( Mod ).
|
|
'$module_class'(_, temporary) :- fail.
|
|
'$module_class'(_, test) :- fail.
|
|
'$module_class'(_, development) :- fail.
|
|
|
|
'$library_module'(M1) :-
|
|
recorded('$module','$module'(F, M1, _, _MyExports,_Line),_),
|
|
user:library_directory(D),
|
|
sub_atom(F, 0, _, _, D).
|
|
|
|
'$user_module'( Mod ) :-
|
|
\+ '$library_module'( Mod),
|
|
\+ '$system_module'( Mod).
|
|
|
|
ls_imports :-
|
|
recorded('$import','$import'(M0,M,G0,G,_N,_K),_R),
|
|
numbervars(G0+G, 0, _),
|
|
format('~a:~w <- ~a:~w~n', [M, G, M0, G0]),
|
|
fail.
|
|
ls_imports.
|
|
|
|
|
|
'$system_module'('$swi').
|
|
'$system_module'('$win_menu').
|
|
'$system_module'('prolog').
|
|
'$system_module'('system').
|
|
'$system_module'('$attributes').
|
|
|
|
unload_module(Mod) :-
|
|
clause( '$meta_predicate'(_F,Mod,_N,_P), _, R),
|
|
erase(R),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
recorded('$multifile_defs','$defined'(_FileName,_Name,_Arity,Mod), R),
|
|
erase(R),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
recorded( '$foreign', Mod:_Foreign, R),
|
|
erase(R),
|
|
fail.
|
|
% remove imported modules
|
|
unload_module(Mod) :-
|
|
setof( M, recorded('$import',_G0^_G^_N^_K^_R^'$import'(Mod,M,_G0,_G,_N,_K),_R), Ms),
|
|
recorded('$module','$module'( _, Mod, _, _, Exports), _),
|
|
lists:member(M, Ms),
|
|
current_op(X, Y, M:Op),
|
|
lists:member( op(X, Y, Op), Exports ),
|
|
op(X, 0, M:Op),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
recorded('$module','$module'( _, Mod, _, _, Exports), _),
|
|
lists:member( op(X, _Y, Op), Exports ),
|
|
op(X, 0, Mod:Op),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
current_predicate(Mod:P),
|
|
abolish(P),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
recorded('$import','$import'(Mod,_M,_G0,_G,_N,_K),R),
|
|
erase(R),
|
|
fail.
|
|
unload_module(Mod) :-
|
|
recorded('$module','$module'( _, Mod, _, _, _), R),
|
|
erase(R),
|
|
fail.
|
|
/**
|
|
|
|
@}
|
|
|
|
@}
|
|
|
|
**/
|