6.6 Special Compiler Features
6.6.1 Compiling Non-Textual Source
A characteristic feature of Prolog and ECLiPSe is, that programs can
be represented as data structures in a straightforward way.
The compiler therefore provides the
interface, which allows to compile a list of terms. The compiler
interprets these as clauses, directives and queries, similar to program
source being read from a file. For program generators, it is therefore
not necessary to create a textual representation of generated code -
the data structures can be compiled directly.
There are the following minor differences between compilation from
textual sources and term compilation:
A variant of compile_term/2 is
which takes source terms with source position annotations.
This can be used when compiling auxiliary code within inlining/goal
expansions transformations, without losing the source position information
which is needed by the debugger.
Module directives are not supported - to compile code into a certain
module, use the construct compile_term(Clauses,Options)@Module, and use
to create modules beforehand if necessary.
- Include directives do not make sense and are not supported.
- No end-of-compilation events are raised - compile_term/1 behaves more
like the compilation of an included file in this respect. This implies
that discontiguous predicates are not supported.
6.6.2 Mode Declarations
Mode declarations are a way for the user to give some additional
information to the compiler, thus enabling it to do a better job.
The ECLiPSe compiler makes use of the mode information mainly to
improve indexing and to reduce code size.
Mode declarations are optional. They specify the argument instantiation
patterns that a predicate will be called with at runtime, for example:
The possible argument modes and their meaning are:
:- mode p(+), q(-), r(++, ?).
Note that, if the actual instantiation of a predicate call violates
its mode declaration, the behaviour is undefined.
Usually, an unexpected failure occurs in this case.
- - The argument is instantiated, i.e. it is not a variable.
- - The argument is ground.
- - The argument is not instantiated, it must be a free variable
without any constraints, especially it must not occur in any other
argument and it cannot be a suspending variable.
- - The mode is not known or it is neither of the above ones.
To improve efficiency, calls to user-defined predicates can be
preprocessed and transformed at compile time. The directive
arranges for mytranspred/2 to be invoked at compile time for each
call to the predicate mypred/1 before this call is being compiled.
:- inline(mypred/1, mytranspred/2).
The transformation predicate receives the original call to mypred/1
as its first argument, and is expected to return a replacement goal
in its second argument. This replacement goal replaces the original
call in the compiled code. Usually, the replacement goal would be
semantically equivalent, but more efficient than the original goal.
When the transformation predicate fails, the original goal is not
Typically, a predicate would be defined together with the corresponding
inlining transformation predicate, e.g.
All compiled calls to double/2 will now be preprocessed by being passed
E.g. if we now compile the following predicate involving double/2
:- inline(double/2, trans_double/2).
double(X, Y) :-
Y is 2*X.
trans_double(double(X, Y), Y=Result) :-
not nonground(X), % if X already known at compile time:
Result is 2*X. % do calculation at compile time!
the first call to double will be replaced by
double(12,Y), ..., double(Y,Z).
Y=24 while the
second one will be unaffected. The code that the compiler sees and
compiles is therefore
Note that meta-calls (e.g. via
call/1) are never
preprocessed, they always go directly to the definition of double/2.
Y=24, ..., double(Y,Z).
Transformation can be disabled for debugging purposes by adding
to the compiled file, or by setting the global flag
:- set_flag(goal_expansion, off).
6.6.4 Clause Expansion
Before compilation, the compiler also performs clause macro expansion
(macro/3. This includes
the DCG grammar rule expansion (section 12.3).