From: Mark Thom Date: Thu, 4 Feb 2021 23:59:16 +0000 (-0700) Subject: perform goal expansion in call/N (#788, #797) X-Git-Tag: v0.9.0~150^2~65^2~20 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=75a52f032b95fc74c1c3fa93996fd0f61775c28f;p=scryer-prolog.git perform goal expansion in call/N (#788, #797) --- diff --git a/src/clause_types.rs b/src/clause_types.rs index 4c39d5d6..435e1182 100644 --- a/src/clause_types.rs +++ b/src/clause_types.rs @@ -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()) diff --git a/src/lib/builtins.pl b/src/lib/builtins.pl index 3aba986b..fa3844cb 100644 --- a/src/lib/builtins.pl +++ b/src/lib/builtins.pl @@ -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) diff --git a/src/lib/ops_and_meta_predicates.pl b/src/lib/ops_and_meta_predicates.pl index 2d78c615..59a324d4 100644 --- a/src/lib/ops_and_meta_predicates.pl +++ b/src/lib/ops_and_meta_predicates.pl @@ -125,3 +125,5 @@ :- meta_predicate call(61, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?). :- meta_predicate call(62, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?). :- meta_predicate call(63, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?). +:- meta_predicate call(64, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?). +:- meta_predicate call(65, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?). diff --git a/src/loader.pl b/src/loader.pl index 06fe2ef2..853842fb 100644 --- a/src/loader.pl +++ b/src/loader.pl @@ -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) + ) + ). diff --git a/src/machine/attributed_variables.pl b/src/machine/attributed_variables.pl index 3cd4c0f1..b5049e3a 100644 --- a/src/machine/attributed_variables.pl +++ b/src/machine/attributed_variables.pl @@ -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([], _). diff --git a/src/machine/load_state.rs b/src/machine/load_state.rs index 1d5526a5..bef493b5 100644 --- a/src/machine/load_state.rs +++ b/src/machine/load_state.rs @@ -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, diff --git a/src/machine/loader.rs b/src/machine/loader.rs index d29fe3dc..6687b545 100644 --- a/src/machine/loader.rs +++ b/src/machine/loader.rs @@ -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> { diff --git a/src/machine/mod.rs b/src/machine/mod.rs index 9a75837c..9c6acbb3 100644 --- a/src/machine/mod.rs +++ b/src/machine/mod.rs @@ -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!() } diff --git a/src/machine/preprocessor.rs b/src/machine/preprocessor.rs index a6e3f1e3..ab82b1f9 100644 --- a/src/machine/preprocessor.rs +++ b/src/machine/preprocessor.rs @@ -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)