Changeset 4412

Timestamp:

07/31/08 02:54:42 (5 months ago)

Author:

pmoura

Message:

Added support for using Prolog use_module/2 directives in objects and categories. This allows module predicates to be called using implicit qualification, improving readability.

Location:

trunk

Files:

• compiler/logtalk.pl (modified) (12 diffs)
• manuals/index.html (modified) (1 diff)
• manuals/migration/index.html (modified) (2 diffs)
• RELEASE_NOTES.txt (modified) (1 diff)

trunk/compiler/logtalk.pl

@@ -201 +201 @@
 :- dynamic('$lgt_pp_uses_'/1).                  % '$lgt_pp_uses_'(Obj)
 :- dynamic('$lgt_pp_uses_'/3).                  % '$lgt_pp_uses_'(Obj, Predicate, Alias)
+:- dynamic('$lgt_pp_use_module_'/3).            % '$lgt_pp_use_module_'(Module, Predicate, Alias)
 :- dynamic('$lgt_pp_calls_'/1).                 % '$lgt_pp_calls_'(Entity)
 :- dynamic('$lgt_pp_info_'/1).                  % '$lgt_pp_info_'(List)
@@ -1826 +1827 @@
     \+ '$lgt_current_flag_'(Flag, _).
 
-current_logtalk_flag(version, version(2, 32, 2)).
+current_logtalk_flag(version, version(2, 33, 0)).
 
 
@@ -4833 +4834 @@
     retractall('$lgt_pp_uses_'(_)),
     retractall('$lgt_pp_uses_'(_, _, _)),
+    retractall('$lgt_pp_use_module_'(_, _, _)),
     retractall('$lgt_pp_calls_'(_)),
     retractall('$lgt_pp_info_'(_)),
@@ -5445 +5447 @@
 
 
+'$lgt_tr_directive'(use_module, [Module, _], _, _) :-
+    var(Module),
+    throw(instantiation_error).
+
+'$lgt_tr_directive'(uses, [Module, _], _, _) :-
+    \+ callable(Module),
+    throw(type_error(module_identifier, Module)).
+
 '$lgt_tr_directive'(use_module, [Module, Preds], Input, Output) :-  % module directive
     (   atom(Module) ->
@@ -5450 +5460 @@
     ;   arg(1, Module, Name)
     ),
-    '$lgt_tr_directive'(uses, [Name, Preds], Input, Output).
+    (   '$lgt_pp_module_'(_) ->                                     % we're compiling a module
+        '$lgt_tr_directive'(uses, [Name, Preds], Input, Output)     % as an object
+    ;   '$lgt_tr_use_module_preds'(Preds, Name)
+    ).
 
 
@@ -5896 +5909 @@
     ;   throw(domain_error(arity_mismatch(Original, Alias)))
     ),
-    (   \+ '$lgt_pp_uses_'(_, _, TAlias) ->
+    (   \+ '$lgt_pp_uses_'(_, _, TAlias),
+        \+ '$lgt_pp_use_module_'(_, _, TAlias) ->
         TOriginal =.. [_| Args], TAlias =.. [_| Args],  % unify args of TOriginal and TAlias
         assertz('$lgt_pp_uses_'(Obj, TOriginal, TAlias))
@@ -5903 +5917 @@
     ),
     '$lgt_tr_uses_preds'(Preds, Obj).
+
+
+
+% '$lgt_tr_use_module_preds'(+list, +module_identifier)
+%
+% auxiliary predicate for translating use_module/2 directives in objects or categories
+
+'$lgt_tr_use_module_preds'([], _).
+
+'$lgt_tr_use_module_preds'([Pred| Preds], Module) :-
+    (   nonvar(Pred) ->
+        true
+    ;   throw(instantiation_error)
+    ),
+    (   Pred = (Original::Alias) ->
+        true
+    ;   (Original, Alias) = (Pred, Pred)
+    ),
+    (   (nonvar(Original), nonvar(Alias)) ->
+        true
+    ;   throw(instantiation_error)
+    ),
+    (   '$lgt_valid_pred_ind'(Original, OFunctor, OArity) ->
+        functor(TOriginal, OFunctor, OArity)
+    ;   throw(type_error(predicate_indicator, Original))
+    ),
+    (   '$lgt_valid_pred_ind'(Alias, AFunctor, AArity) ->
+        functor(TAlias, AFunctor, AArity)
+    ;   throw(type_error(predicate_indicator, Alias))
+    ),
+    (   OArity =:= AArity ->
+        true
+    ;   throw(domain_error(arity_mismatch(Original, Alias)))
+    ),
+    (   \+ '$lgt_pp_uses_'(_, _, TAlias),
+        \+ '$lgt_pp_use_module_'(_, _, TAlias) ->
+        TOriginal =.. [_| Args], TAlias =.. [_| Args],  % unify args of TOriginal and TAlias
+        assertz('$lgt_pp_use_module_'(Module, TOriginal, TAlias))
+    ;   functor(TAlias, Functor, Arity),
+        throw(permission_error(modify, uses_module_predicate, Functor/Arity))
+    ),
+    '$lgt_tr_use_module_preds'(Preds, Module).
 
 
@@ -6423 +6479 @@
     functor(Alias, Functor, Arity),
     throw(permission_error(modify, uses_object_predicate, Functor/Arity)).
+
+
+% conflict with a predicate specified in a use_module/2 directive
+
+'$lgt_tr_head'(Alias, _, _, _) :-
+    '$lgt_pp_use_module_'(_, _, Alias),
+    functor(Alias, Functor, Arity),
+    throw(permission_error(modify, uses_module_predicate, Functor/Arity)).
 
 
@@ -7313 +7377 @@
     !,
     '$lgt_tr_body'(Obj::Pred, TPred, DPred, Ctx).
+
+
+% predicates specified in use_module/2 directives
+
+'$lgt_tr_body'(Alias, ':'(Module, Pred), ':'(Module, Pred), _) :-
+    '$lgt_pp_use_module_'(Module, Pred, Alias),
+    !.
 
 
@@ -7346 +7417 @@
 
 
-% Logtalk and Prolog built-in (meta-)predicates
+% remember non-portable predicate calls
 
 '$lgt_tr_body'(Pred, _, _, _) :-
@@ -7358 +7429 @@
     assertz('$lgt_non_portable_call_'(Functor, Arity)),
     fail.
+
+
+% Logtalk and Prolog built-in (meta-)predicates
 
 '$lgt_tr_body'(Pred, TPred, DPred, Ctx) :-
@@ -10396 +10470 @@
     functor(Pred, Functor, Arity),
     \+ '$lgt_pp_redefined_built_in_'(Pred, _, _, _, _).
+
+'$lgt_non_portable_call'(':'(Module, Functor/Arity)) :-
+    '$lgt_pp_use_module_'(Module, Pred, _),
+    functor(Pred, Functor, Arity).
 
 

trunk/manuals/index.html

@@ -32 +32 @@
     <div class="copyright">
         <span>Copyright &copy; <a href="mailto:pmoura@logtalk.org">Paulo Moura</a> &mdash; <a href="http://logtalk.org">Logtalk.org</a></span><br/> 
-        <span>Last updated on: July 27, 2008</span>
+        <span>Last updated on: July 31, 2008</span>
     </div>
     <div class="navbottom">

trunk/manuals/migration/index.html

@@ -195 +195 @@
 
 
-<h2>Calling Prolog module predicates using message sending<a id="calling"></a></h2>
-
-<p>
-Logtalk allows you to send a message to a module in order to call one of its predicates. This is usually not advised as it implies a performance penalty when compared to just using the <code>Module:Call</code> notation (encapsulating the call between curly brackets when sending the message from inside an object). Note that this only works if there is no object with the same name as the module you are targeting.
-</p>
-<p>
-This feature is needed to properly support compilation of modules containing <code>use_module/2</code> directives as objects. If the modules specified in the <code>use_module/2</code> directives are not compiled as objects but are instead loaded as-is by Prolog, the exported predicates would need to be called using the <code>Module:Call</code> notation but the converted module will be calling them through message sending. Thus, this feature ensures that, on a module compiled as an object, any predicate calling other module predicates will work as expected either these other modules are loaded as-is or also compiled as objects.
+<h2>Calling Prolog module predicates<a id="calling"></a></h2>
+
+<p>
+Logtalk allows you to send a message to a module in order to call one of its predicates. This is usually not advised as it implies a performance penalty when compared to just using the <code>Module:Call</code> notation. Note that this only works if there is no object with the same name as the module you are targeting. This feature is needed to properly support compilation of modules containing <code>use_module/2</code> directives as objects. If the modules specified in the <code>use_module/2</code> directives are not compiled as objects but are instead loaded as-is by Prolog, the exported predicates would need to be called using the <code>Module:Call</code> notation but the converted module will be calling them through message sending. Thus, this feature ensures that, on a module compiled as an object, any predicate calling other module predicates will work as expected either these other modules are loaded as-is or also compiled as objects.
+</p>
+<p>
+Logtalk supports the use of <code>use_module/2</code> directives in object and categories. In this case, these directives are parsed in a similar way to Logtalk <a title="Consult reference manual" href="../refman/directives/uses2.html"><code>uses/2</code></a> directives, with calls to the specified module predicates being automatically translated to <code>Module:Goal</code> calls. For example, assume a <code>clpfd</code> Prolog module implementing a finite domain constraint solver. You could write:
+</p>
+<pre>
+:- object(puzzle).
+
+    :- public(puzzle/1).
+
+    :- use_module(clpfd, [all_different/1, ins/2, label/1, (#=)/2, (#\=)/2]).
+
+    :- initialization((puzzle(As+Bs=Cs), label(As), write(As+Bs=Cs), nl)).
+
+    puzzle([S,E,N,D] + [M,O,R,E] = [M,O,N,E,Y]) :-
+        Vars = [S,E,N,D,M,O,R,Y],
+        Vars ins 0..9,
+        all_different(Vars),
+                  S*1000 + E*100 + N*10 + D +
+                  M*1000 + O*100 + R*10 + E #=
+        M*10000 + O*1000 + N*100 + E*10 + Y,
+        M #\= 0, S #\= 0.
+
+:- end_object.
+</pre>
+<p>
+As a general rule, the Prolog modules should be loaded (e.g. in the auxiliary Logtalk loader files) before compiling objects that make use of module predicates. This is mandatory whenever the module exports operator declarations that you want to use in your objects and categories (as in the example above).
 </p>
 
@@ -207 +230 @@
     <div class="copyright">
         <span>Copyright &copy; <a href="mailto:pmoura@logtalk.org">Paulo Moura</a> &mdash; <a href="http://logtalk.org">Logtalk.org</a></span><br/> 
-        <span>Last updated on: July 1, 2008</span>
+        <span>Last updated on: July 31, 2008</span>
     </div>
     <div class="navbottom">

trunk/RELEASE_NOTES.txt

@@ -12 +12 @@
 RELEASE NOTES
 =============
+
+
+2.33.0 - August ??, 2008
+
+    Added support for using Prolog use_module/2 directives in objects and 
+    categories. This allows module predicates to be called using implicit 
+    qualification, improving readability.