rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perform goal expansion in call/N (#788, #797)

Browse Source
This commit is contained in:
Mark Thom
2021-02-04 16:59:16 -07:00
parent a9e0a51059
commit 75a52f032b
9 changed files with 835 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/clause_types.rs
View File

@@ -863,7 +863,7 @@ impl ClauseType {
pub fn name(&self) -> ClauseName {
match self {
&ClauseType::BuiltIn(ref built_in) => built_in.name(),
&ClauseType::CallN => clause_name!("call"),
&ClauseType::CallN => clause_name!("$call"),
&ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()),
&ClauseType::Op(ref name, ..) => name.clone(),
&ClauseType::Named(ref name, ..) => name.clone(),
@@ -882,7 +882,7 @@ impl ClauseType {
.unwrap_or_else(|| {
if let Some(spec) = spec {
ClauseType::Op(name, spec, CodeIndex::default())
} else if name.as_str() == "call" {
} else if name.as_str() == "$call" {
ClauseType::CallN
} else {
ClauseType::Named(name, arity, CodeIndex::default())

31
src/lib/builtins.pl
View File

@@ -4,9 +4,10 @@
abolish/1, asserta/1, assertz/1,
at_end_of_stream/0, at_end_of_stream/1,
atom_chars/2, atom_codes/2, atom_concat/3,
atom_length/2, bagof/3, catch/3, char_code/2,
clause/2, close/1, close/2, current_input/1,
current_output/1, current_op/3,
atom_length/2, bagof/3, call/1, call/2, call/3,
call/4, call/5, call/6, call/7, call/8, call/9,
catch/3, char_code/2, clause/2, close/1, close/2,
current_input/1, current_output/1, current_op/3,
current_predicate/1, current_prolog_flag/2,
fail/0, false/0, findall/3, findall/4,
flush_output/0, flush_output/1, get_byte/1,
@@ -38,6 +39,30 @@ true.
false :- '$fail'.
% These are stub versions of call/{1-9} defined for bootstrapping.
% Once Scryer is bootstrapped, each is replaced with a version that
% uses expand_goal to pass the expanded goal along to '$call'.
call(G) :- '$call'(G).
call(G, A) :- '$call'(G, A).
call(G, A, B) :- '$call'(G, A, B).
call(G, A, B, C) :- '$call'(G, A, B, C).
call(G, A, B, C, D) :- '$call'(G, A, B, C, D).
call(G, A, B, C, D, E) :- '$call'(G, A, B, C, D, E).
call(G, A, B, C, D, E, F) :- '$call'(G, A, B, C, D, E, F).
call(G, A, B, C, D, E, F, G) :- '$call'(G, A, B, C, D, E, F, G).
call(G, A, B, C, D, E, F, G, H) :- '$call'(G, A, B, C, D, E, F, G, H).
Module : Predicate :-
( atom(Module) ->
'$module_call'(Module, Predicate)

2
src/lib/ops_and_meta_predicates.pl
View File

@@ -125,3 +125,5 @@
:- meta_predicate call(61, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
:- meta_predicate call(62, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
:- meta_predicate call(63, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
:- meta_predicate call(64, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).
:- meta_predicate call(65, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?).

751
src/loader.pl
View File

@@ -18,14 +18,14 @@
'$print_message_and_fail'(Error, Culprit) :-
% writeq(error(Error, Culprit)),
% nl,
% writeq(error(Error, Culprit)),
% nl,
'$fail'.
expand_term(Term, ExpandedTerm) :-
( catch(user:term_expansion(Term, ExpandedTerm0),
( catch('$call'(user:term_expansion(Term, ExpandedTerm0)),
E,
loader:'$print_message_and_fail'(E, user:term_expansion)) ->
'$call'(loader:'$print_message_and_fail'(E, user:term_expansion))) ->
( var(ExpandedTerm0) ->
error:instantiation_error(term_expansion/2)
; ExpandedTerm0 = [_|_] ->
@@ -50,9 +50,9 @@ term_expansion_list([Term|Terms], ExpandedTermsHead, ExpandedTermsTail) :-
goal_expansion(Goal, Module, ExpandedGoal) :-
( catch(Module:goal_expansion(Goal, ExpandedGoal0),
( catch('$call'(Module:goal_expansion(Goal, ExpandedGoal0)),
E,
loader:'$print_message_and_fail'(E, Module:goal_expansion)) ->
'$call'(loader:'$print_message_and_fail'(E, Module:goal_expansion))) ->
( var(ExpandedGoal0) ->
error:instantiation_error(goal_expansion/2)
; goal_expansion(ExpandedGoal0, Module, ExpandedGoal)
@@ -195,8 +195,7 @@ compile_dispatch_or_clause(Term, Evacuable, VNs) :-
compile_dispatch((:- Declaration), Evacuable, _VNs) :-
( var(Declaration) ->
instantiation_error(load/1)
;
compile_declaration(Declaration, Evacuable)
; compile_declaration(Declaration, Evacuable)
).
compile_dispatch(term_expansion(Term, Terms), Evacuable, VNs) :-
'$add_term_expansion_clause'(term_expansion(Term, Terms), Evacuable, VNs).
@@ -224,13 +223,13 @@ compile_declaration(use_module(Module, Exports), Evacuable) :-
( Exports == [] ->
'$remove_module_exports'(Module, Evacuable) % TODO: implement this.
;
use_module(Module, Exports, Evacuable)
use_module(Module, Exports, Evacuable)
).
compile_declaration(module(Module, Exports), Evacuable) :-
( atom(Module) ->
'$declare_module'(Module, Exports, Evacuable)
;
type_error(atom, Module, load/1)
type_error(atom, Module, load/1)
).
compile_declaration(dynamic(Name/Arity), Evacuable) :-
must_be(atom, Name),
@@ -291,7 +290,7 @@ use_module(Module, Exports) :-
( Exports == [] ->
'$remove_module_exports'(Module, Evacuable)
;
use_module(Module, Exports, Evacuable)
use_module(Module, Exports, Evacuable)
).
@@ -301,7 +300,7 @@ load_context_path(Module, Path) :-
( prolog_load_context(directory, CurrentDir) ->
atom_concat(CurrentDir, Path, Module)
;
Module = Path
Module = Path
).
@@ -313,14 +312,14 @@ use_module(Module, Exports, Evacuable) :-
( '$load_compiled_library'(Library, Evacuable) -> %% TODO: What about Exports?
true
;
'$load_library_as_stream'(Library, Stream, Path),
file_load(Stream, Path, Subevacuable),
'$use_module'(Evacuable, Subevacuable, Exports)
'$load_library_as_stream'(Library, Stream, Path),
file_load(Stream, Path, Subevacuable),
'$use_module'(Evacuable, Subevacuable, Exports)
)
; var(Library) ->
instantiation_error(load/1)
;
type_error(atom, Library, load/1)
type_error(atom, Library, load/1)
)
; atom(Module) ->
load_context_path(Module, Path),
@@ -328,7 +327,7 @@ use_module(Module, Exports, Evacuable) :-
file_load(Stream, Path, Subevacuable),
'$use_module'(Evacuable, Subevacuable, Exports)
;
type_error(atom, Library, load/1)
type_error(atom, Library, load/1)
).
@@ -345,6 +344,12 @@ extract_predicate_property(Property, PropertyType) :-
; functor(Property, PropertyType, _)
).
load_context(Module) :-
( prolog_load_context(module, Module) ->
true
; Module = user
).
predicate_property(Callable, Property) :-
( var(Callable) ->
instantiation_error(load/1)
@@ -355,10 +360,7 @@ predicate_property(Callable, Property) :-
check_predicate_property(PropertyType, Module, Name, Arity, Property)
; functor(Callable, Name, Arity),
extract_predicate_property(Property, PropertyType),
( prolog_load_context(module, Module) ->
true
; Module = user
),
load_context(Module),
check_predicate_property(PropertyType, Module, Name, Arity, Property)
).
@@ -498,3 +500,710 @@ thread_goals(Goals0, Goals1, Hole, Functor) :-
; Goals1 =.. [Functor, Goals0, Hole]
)
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% call/{1-64} with dynamic goal expansion.
%
% The program used to generate the call/N predicates:
%
%
% :- use_module(library(between)).
% :- use_module(library(error)).
% :- use_module(library(lists)).
% :- use_module(library(format)).
%
% call_form_generator(N) :-
% length(Args, N),
% CallHead =.. [call, G | Args],
% N1 is N + 1,
% Form = (CallHead :- ( var(G) ->
% instantiation_error(call/N1)
% ; call_clause(G, Args, N1, G0) ->
% '$call'(G0)
% ; type_error(callable, G, call/N1)
% )),
% portray_clause(Form).
%
% generate_call_forms :-
% between(1, 64, N),
% call_form_generator(N),
% nl,
% false.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
call_clause(M:G1, G0) :-
functor(G1, F, _),
atom(F),
atom(M),
F \== [],
!,
expand_goal(M:G1, M, G0).
% The '$call' functor is an escape hatch from goal expansion. So far,
% it is used only to avoid infinite recursion into expand_goal/3.
call_clause('$call'(G), G0) :-
( var(G),
instantiation_error(call/1)
; G = M:G1,
!,
functor(G1, F, _),
atom(F),
atom(M),
F \== [],
G0 = M:G1
; !,
functor(G, F, _),
atom(F),
F \== [],
load_context(M),
G0 = M:G
).
call_clause(G, G0) :-
functor(G, F, _),
atom(F),
F \== [],
load_context(M),
expand_goal(M:G, M, G0).
call(G) :-
( var(G) ->
instantiation_error(call/1)
; call_clause(G, G0) ->
'$call'(G0)
; type_error(callable, G, call/1)
).
call_clause(M:G1, Args, _, G0) :-
atom(M),
G1 =.. [F | As],
atom(F),
F \== [],
!,
append(As, Args, As1),
G2 =.. [F | As1],
expand_goal(M:G2, M, G0).
call_clause('$call'(G1), Args, N, G0) :-
( var(G1),
instantiation_error(call/N)
; G1 = M:G2,
!,
atom(M),
G2 =.. [F | As],
atom(F),
F \== [],
append(As, Args, As1),
G3 =.. [F | As1],
G0 = M:G3
; !,
G1 =.. [F | As],
atom(F),
F \== [],
load_context(M),
append(As, Args, As1),
G2 =.. [F | As1],
G0 = M:G2
).
call_clause(G, Args, _, G0) :-
G =.. [F | As],
atom(F),
F \== [],
load_context(M),
append(As, Args, As1),
G2 =.. [F | As1],
expand_goal(M:G2, M, G0).
call(A,B) :-
( var(A) ->
instantiation_error(call/2)
; ( call_clause(A,[B],2,C) ->
'$call'(C)
; type_error(callable,A,call/2)
)
).
call(A,B,C) :-
( var(A) ->
instantiation_error(call/3)
; ( call_clause(A,[B,C],3,D) ->
'$call'(D)
; type_error(callable,A,call/3)
)
).
call(A,B,C,D) :-
( var(A) ->
instantiation_error(call/4)
; ( call_clause(A,[B,C,D],4,E) ->
'$call'(E)
; type_error(callable,A,call/4)
)
).
call(A,B,C,D,E) :-
( var(A) ->
instantiation_error(call/5)
; ( call_clause(A,[B,C,D,E],5,F) ->
'$call'(F)
; type_error(callable,A,call/5)
)
).
call(A,B,C,D,E,F) :-
( var(A) ->
instantiation_error(call/6)
; ( call_clause(A,[B,C,D,E,F],6,G) ->
'$call'(G)
; type_error(callable,A,call/6)
)
).
call(A,B,C,D,E,F,G) :-
( var(A) ->
instantiation_error(call/7)
; ( call_clause(A,[B,C,D,E,F,G],7,H) ->
'$call'(H)
; type_error(callable,A,call/7)
)
).
call(A,B,C,D,E,F,G,H) :-
( var(A) ->
instantiation_error(call/8)
; ( call_clause(A,[B,C,D,E,F,G,H],8,I) ->
'$call'(I)
; type_error(callable,A,call/8)
)
).
call(A,B,C,D,E,F,G,H,I) :-
( var(A) ->
instantiation_error(call/9)
; ( call_clause(A,[B,C,D,E,F,G,H,I],9,J) ->
'$call'(J)
; type_error(callable,A,call/9)
)
).
call(A,B,C,D,E,F,G,H,I,J) :-
( var(A) ->
instantiation_error(call/10)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J],10,K) ->
'$call'(K)
; type_error(callable,A,call/10)
)
).
call(A,B,C,D,E,F,G,H,I,J,K) :-
( var(A) ->
instantiation_error(call/11)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K],11,L) ->
'$call'(L)
; type_error(callable,A,call/11)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L) :-
( var(A) ->
instantiation_error(call/12)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L],12,M) ->
'$call'(M)
; type_error(callable,A,call/12)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M) :-
( var(A) ->
instantiation_error(call/13)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M],13,N) ->
'$call'(N)
; type_error(callable,A,call/13)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N) :-
( var(A) ->
instantiation_error(call/14)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N],14,O) ->
'$call'(O)
; type_error(callable,A,call/14)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) :-
( var(A) ->
instantiation_error(call/15)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O],15,P) ->
'$call'(P)
; type_error(callable,A,call/15)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) :-
( var(A) ->
instantiation_error(call/16)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P],16,Q) ->
'$call'(Q)
; type_error(callable,A,call/16)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q) :-
( var(A) ->
instantiation_error(call/17)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q],17,R) ->
'$call'(R)
; type_error(callable,A,call/17)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :-
( var(A) ->
instantiation_error(call/18)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R],18,S) ->
'$call'(S)
; type_error(callable,A,call/18)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S) :-
( var(A) ->
instantiation_error(call/19)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S],19,T) ->
'$call'(T)
; type_error(callable,A,call/19)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T) :-
( var(A) ->
instantiation_error(call/20)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T],20,U) ->
'$call'(U)
; type_error(callable,A,call/20)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U) :-
( var(A) ->
instantiation_error(call/21)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U],21,V) ->
'$call'(V)
; type_error(callable,A,call/21)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V) :-
( var(A) ->
instantiation_error(call/22)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V],22,W) ->
'$call'(W)
; type_error(callable,A,call/22)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W) :-
( var(A) ->
instantiation_error(call/23)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W],23,X) ->
'$call'(X)
; type_error(callable,A,call/23)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X) :-
( var(A) ->
instantiation_error(call/24)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X],24,Y) ->
'$call'(Y)
; type_error(callable,A,call/24)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y) :-
( var(A) ->
instantiation_error(call/25)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y],25,Z) ->
'$call'(Z)
; type_error(callable,A,call/25)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z) :-
( var(A) ->
instantiation_error(call/26)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z],26,A1) ->
'$call'(A1)
; type_error(callable,A,call/26)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1) :-
( var(A) ->
instantiation_error(call/27)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1],27,B1) ->
'$call'(B1)
; type_error(callable,A,call/27)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1) :-
( var(A) ->
instantiation_error(call/28)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1],28,C1) ->
'$call'(C1)
; type_error(callable,A,call/28)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1) :-
( var(A) ->
instantiation_error(call/29)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1],29,D1) ->
'$call'(D1)
; type_error(callable,A,call/29)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1) :-
( var(A) ->
instantiation_error(call/30)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1],30,E1) ->
'$call'(E1)
; type_error(callable,A,call/30)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1) :-
( var(A) ->
instantiation_error(call/31)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1],31,F1) ->
'$call'(F1)
; type_error(callable,A,call/31)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1) :-
( var(A) ->
instantiation_error(call/32)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1],32,G1) ->
'$call'(G1)
; type_error(callable,A,call/32)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1) :-
( var(A) ->
instantiation_error(call/33)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1],33,H1) ->
'$call'(H1)
; type_error(callable,A,call/33)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1) :-
( var(A) ->
instantiation_error(call/34)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1],34,I1) ->
'$call'(I1)
; type_error(callable,A,call/34)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1) :-
( var(A) ->
instantiation_error(call/35)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1],35,J1) ->
'$call'(J1)
; type_error(callable,A,call/35)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1) :-
( var(A) ->
instantiation_error(call/36)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1],36,K1) ->
'$call'(K1)
; type_error(callable,A,call/36)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1) :-
( var(A) ->
instantiation_error(call/37)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1],37,L1) ->
'$call'(L1)
; type_error(callable,A,call/37)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1) :-
( var(A) ->
instantiation_error(call/38)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1],38,M1) ->
'$call'(M1)
; type_error(callable,A,call/38)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1) :-
( var(A) ->
instantiation_error(call/39)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1],39,N1) ->
'$call'(N1)
; type_error(callable,A,call/39)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1) :-
( var(A) ->
instantiation_error(call/40)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1],40,O1) ->
'$call'(O1)
; type_error(callable,A,call/40)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1) :-
( var(A) ->
instantiation_error(call/41)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1],41,P1) ->
'$call'(P1)
; type_error(callable,A,call/41)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1) :-
( var(A) ->
instantiation_error(call/42)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1],42,Q1) ->
'$call'(Q1)
; type_error(callable,A,call/42)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1) :-
( var(A) ->
instantiation_error(call/43)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1],43,R1) ->
'$call'(R1)
; type_error(callable,A,call/43)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1) :-
( var(A) ->
instantiation_error(call/44)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1],44,S1) ->
'$call'(S1)
; type_error(callable,A,call/44)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1) :-
( var(A) ->
instantiation_error(call/45)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1],45,T1) ->
'$call'(T1)
; type_error(callable,A,call/45)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1) :-
( var(A) ->
instantiation_error(call/46)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1],46,U1) ->
'$call'(U1)
; type_error(callable,A,call/46)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1) :-
( var(A) ->
instantiation_error(call/47)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1],47,V1) ->
'$call'(V1)
; type_error(callable,A,call/47)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1) :-
( var(A) ->
instantiation_error(call/48)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1],48,W1) ->
'$call'(W1)
; type_error(callable,A,call/48)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1) :-
( var(A) ->
instantiation_error(call/49)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1],49,X1) ->
'$call'(X1)
; type_error(callable,A,call/49)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1) :-
( var(A) ->
instantiation_error(call/50)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1],50,Y1) ->
'$call'(Y1)
; type_error(callable,A,call/50)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1) :-
( var(A) ->
instantiation_error(call/51)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1],51,Z1) ->
'$call'(Z1)
; type_error(callable,A,call/51)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1) :-
( var(A) ->
instantiation_error(call/52)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1],52,A2) ->
'$call'(A2)
; type_error(callable,A,call/52)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2) :-
( var(A) ->
instantiation_error(call/53)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2],53,B2) ->
'$call'(B2)
; type_error(callable,A,call/53)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2) :-
( var(A) ->
instantiation_error(call/54)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2],54,C2) ->
'$call'(C2)
; type_error(callable,A,call/54)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2) :-
( var(A) ->
instantiation_error(call/55)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2],55,D2) ->
'$call'(D2)
; type_error(callable,A,call/55)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2) :-
( var(A) ->
instantiation_error(call/56)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2],56,E2) ->
'$call'(E2)
; type_error(callable,A,call/56)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2) :-
( var(A) ->
instantiation_error(call/57)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2],57,F2) ->
'$call'(F2)
; type_error(callable,A,call/57)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2) :-
( var(A) ->
instantiation_error(call/58)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2],58,G2) ->
'$call'(G2)
; type_error(callable,A,call/58)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2) :-
( var(A) ->
instantiation_error(call/59)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2],59,H2) ->
'$call'(H2)
; type_error(callable,A,call/59)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2) :-
( var(A) ->
instantiation_error(call/60)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2],60,I2) ->
'$call'(I2)
; type_error(callable,A,call/60)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2) :-
( var(A) ->
instantiation_error(call/61)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2],61,J2) ->
'$call'(J2)
; type_error(callable,A,call/61)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2) :-
( var(A) ->
instantiation_error(call/62)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2],62,K2) ->
'$call'(K2)
; type_error(callable,A,call/62)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2) :-
( var(A) ->
instantiation_error(call/63)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2],63,L2) ->
'$call'(L2)
; type_error(callable,A,call/63)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2) :-
( var(A) ->
instantiation_error(call/64)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2],64,M2) ->
'$call'(M2)
; type_error(callable,A,call/64)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2) :-
( var(A) ->
instantiation_error(call/65)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2],65,N2) ->
'$call'(N2)
; type_error(callable,A,call/65)
)
).
call(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2) :-
( var(A) ->
instantiation_error(call/65)
; ( call_clause(A,[B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O1,P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,A2,B2,C2,D2,E2,F2,G2,H2,I2,J2,K2,L2,M2],65,N2) ->
'$call'(N2)
; type_error(callable,A,call/65)
)
).

3
src/machine/attributed_variables.pl
View File

@@ -51,7 +51,6 @@ call_goals_0([Module-GoalList | GoalLists]) :-
call_goals_0([]).
call_goals_1([Goal | Goals], Module) :-
expand_goal(Goal, Module, Goal1), % TODO: remove this when goal expansions are added to call/N.
call(Module:Goal1),
call(Module:Goal),
call_goals_1(Goals, Module).
call_goals_1([], _).

13
src/machine/load_state.rs
View File

@@ -528,19 +528,6 @@ impl<'a> LoadState<'a> {
}
}
#[inline]
pub(super)
fn module_name(&self) -> ClauseName {
match self.compilation_target {
CompilationTarget::User => {
clause_name!("user")
}
CompilationTarget::Module(ref module_name) => {
module_name.clone()
}
}
}
pub(super)
fn add_meta_predicate_record(
&mut self,

13
src/machine/loader.rs
View File

@@ -573,6 +573,19 @@ impl CompilationTarget {
fn take(&mut self) -> CompilationTarget {
mem::replace(self, CompilationTarget::User)
}
#[inline]
pub(super)
fn module_name(&self) -> ClauseName {
match self {
CompilationTarget::User => {
clause_name!("user")
}
CompilationTarget::Module(ref module_name) => {
module_name.clone()
}
}
}
}
pub(crate) struct Loader<'a, TermStream> {

114
src/machine/mod.rs
View File

@@ -119,39 +119,6 @@ include!(concat!(env!("OUT_DIR"), "/libraries.rs"));
impl Machine {
/*
fn compile_special_forms(&mut self)
{
let verify_attrs_src = ListingSource::User;
match compile_special_form(
self,
Stream::from(VERIFY_ATTRS),
verify_attrs_src,
)
{
Ok(p) => {
self.machine_st.attr_var_init.verify_attrs_loc = p;
}
Err(_) =>
panic!("Machine::compile_special_forms() failed at VERIFY_ATTRS"),
}
let project_attrs_src = ListingSource::User;
match compile_special_form(
self,
Stream::from(PROJECT_ATTRS),
project_attrs_src,
)
{
Ok(p) => {
self.machine_st.attr_var_init.project_attrs_loc = p;
}
Err(e) =>
panic!("Machine::compile_special_forms() failed at PROJECT_ATTRS: {}", e),
}
}
fn compile_scryerrc(&mut self) {
let mut path = match dirs_next::home_dir() {
Some(path) => path,
@@ -177,7 +144,8 @@ impl Machine {
compile_user_module(self, file_src, rc_src);
}
}
*/
*/
#[cfg(test)]
pub fn reset(&mut self) {
self.current_input_stream = readline::input_stream();
@@ -289,12 +257,62 @@ impl Machine {
self.machine_st[temp_v!(1)] = list_addr;
// WAS:
// self.run_module_predicate(clause_name!("$toplevel"), (clause_name!("$repl"), 1));
self.run_module_predicate(clause_name!("$toplevel"), (clause_name!("repl"), 0));
}
fn configure_modules(&mut self) {
fn update_call_n_indices(loader: &Module, target_module: &mut Module) {
for arity in 1 .. 66 {
let key = (clause_name!("call"), arity);
match loader.code_dir.get(&key).cloned() {
Some(src_code_index) => {
let target_code_index = target_module.code_dir
.entry(key.clone())
.or_insert_with(|| CodeIndex::new(IndexPtr::Undefined));
target_code_index.set(src_code_index.get());
}
None => {
unreachable!();
}
}
}
}
if let Some(loader) = self.indices.modules.swap_remove(&clause_name!("loader")) {
if let Some(builtins) = self.indices.modules.get_mut(&clause_name!("builtins")) {
// Import loader's exports into the builtins module so they will be
// implicitly included in every further module.
load_module(
&mut builtins.code_dir,
&mut builtins.op_dir,
&mut builtins.meta_predicates,
&CompilationTarget::Module(clause_name!("builtins")),
&loader,
);
for export in &loader.module_decl.exports {
builtins.module_decl.exports.push(export.clone());
}
for arity in 10 .. 66 {
builtins.module_decl.exports.push(
ModuleExport::PredicateKey((clause_name!("call"), arity)),
);
}
}
for (_, target_module) in self.indices.modules.iter_mut() {
update_call_n_indices(&loader, target_module);
}
self.indices.modules.insert(clause_name!("loader"), loader);
} else {
unreachable!()
}
}
pub fn new(user_input: Stream, user_output: Stream) -> Self
{
use crate::ref_thread_local::RefThreadLocal;
@@ -356,32 +374,16 @@ impl Machine {
),
).unwrap();
if let Some(loader) = wam.indices.modules.swap_remove(&clause_name!("loader")) {
if let Some(builtins) = wam.indices.modules.get_mut(&clause_name!("builtins")) {
// Import loader's exports into the builtins module so they will be
// implicitly included every further module.
load_module(
&mut builtins.code_dir,
&mut builtins.op_dir,
&mut builtins.meta_predicates,
&CompilationTarget::Module(clause_name!("builtins")),
&loader,
);
for export in &loader.module_decl.exports {
builtins.module_decl.exports.push(export.clone());
}
}
wam.configure_modules();
if let Some(loader) = wam.indices.modules.get(&clause_name!("loader")) {
load_module(
&mut wam.indices.code_dir,
&mut wam.indices.op_dir,
&mut wam.indices.meta_predicates,
&CompilationTarget::User,
&loader,
loader,
);
wam.indices.modules.insert(clause_name!("loader"), loader);
} else {
unreachable!()
}

2
src/machine/preprocessor.rs
View File

@@ -401,7 +401,7 @@ fn setup_meta_predicate<'a>(
}
Term::Clause(_, name, mut terms, _) => {
let (name, meta_specs) = get_name_and_meta_specs(name, &mut terms)?;
Ok((load_state.module_name(), name, meta_specs))
Ok((load_state.compilation_target.module_name(), name, meta_specs))
}
_ => {
Err(CompilationError::InvalidMetaPredicateDecl)