Modules are identified via a unique handle. The following functions
are available to query and manipulate modules.
- module_t PL_context()
- Return the module identifier of the context module of the currently
active foreign predicate. If there is no currently active predicate it
returns a handle to the
user module.
- bool PL_strip_module(term_t
+raw, module_t *m, term_t -plain)
- Utility function. If raw is a term, possibly holding the
module construct <module>
:<rest>,
this function will make
plain a reference to <rest> and fill module
* with <module>. For further nested module
constructs the innermost module is returned via module *. If raw
is not a module construct, raw will simply be put in plain.
The value pointed to by m must be initialized before calling PL_strip_module(),
either to the default module or to NULL. A NULL
value is replaced by the current context module if raw
carries no module. The following example shows how to obtain the plain
term and module if the default module is the user module:
{ module m = PL_new_module(PL_new_atom("user"));
term_t plain = PL_new_term_ref();
PL_strip_module(term, &m, plain);
...
}
Returns TRUE on success and FALSE on error,
leaving an exception. Currently the only exception condition is raw
to be a cyclic term.
- atom_t PL_module_name(module_t
module)
- Return the name of module as an atom.
- module_t PL_new_module(atom_t
name)
- Find an existing module or create a new module with the name name.
Currently aborts the process with a fatal error on failure.
Future versions may raise a resource exception and return
(module_t)0.
