2316 lines
62 KiB
Plaintext
2316 lines
62 KiB
Plaintext
/* Generated by CHR bootstrap compiler
|
|
From: chr_translate_bootstrap1.pl
|
|
Date: Fri Jan 12 13:49:11 2007
|
|
|
|
DO NOT EDIT. EDIT THE CHR FILE INSTEAD
|
|
*/
|
|
|
|
:- module(chr_translate_bootstrap1,
|
|
[ chr_translate/2
|
|
]).
|
|
:- use_module(chr_runtime).
|
|
:- style_check(- (discontiguous)).
|
|
:- use_module(chr_runtime).
|
|
:- style_check(- (discontiguous)).
|
|
:- use_module(library(lists),
|
|
[ append/3,
|
|
member/2,
|
|
permutation/2,
|
|
reverse/2
|
|
]).
|
|
:- use_module(library(ordsets)).
|
|
:- use_module(library(dialect/hprolog)).
|
|
:- use_module(pairlist).
|
|
:- include(chr_op2).
|
|
chr_translate(A, C) :-
|
|
init_chr_pp_flags,
|
|
partition_clauses(A, B, E, D),
|
|
( B==[]
|
|
-> C=D
|
|
; check_rules(E, B),
|
|
unique_analyse_optimise(E, F),
|
|
check_attachments(F),
|
|
set_constraint_indices(B, 1),
|
|
store_management_preds(B, G),
|
|
constraints_code(B, F, H),
|
|
append([D, G, H], C)
|
|
),
|
|
chr_clear.
|
|
store_management_preds(A, E) :-
|
|
generate_attach_detach_a_constraint_all(A, B),
|
|
generate_attach_increment(C),
|
|
generate_attr_unify_hook(D),
|
|
append([B, C, D], E).
|
|
partition_clauses([], [], [], []).
|
|
partition_clauses([A|M], B, C, E) :-
|
|
( rule(A, D)
|
|
-> B=G,
|
|
C=[D|H],
|
|
E=I
|
|
; is_declaration(A, F)
|
|
-> append(F, G, B),
|
|
C=H,
|
|
E=I
|
|
; is_module_declaration(A, J)
|
|
-> target_module(J),
|
|
B=G,
|
|
C=H,
|
|
E=[A|I]
|
|
; A=handler(_)
|
|
-> format('CHR compiler WARNING: ~w.\n', [A]),
|
|
format(' `--> SICStus compatibility: ignoring handler/1 declaration.\n', []),
|
|
B=G,
|
|
C=H,
|
|
E=I
|
|
; A=rules(_)
|
|
-> format('CHR compiler WARNING: ~w.\n', [A]),
|
|
format(' `--> SICStus compatibility: ignoring rules/1 declaration.\n', []),
|
|
B=G,
|
|
C=H,
|
|
E=I
|
|
; A= (:-chr_option(K, L))
|
|
-> handle_option(K, L),
|
|
B=G,
|
|
C=H,
|
|
E=I
|
|
; B=G,
|
|
C=H,
|
|
E=[A|I]
|
|
),
|
|
partition_clauses(M, G, H, I).
|
|
is_declaration(A, D) :-
|
|
A= (:-B),
|
|
( B=..[chr_constraint, C]
|
|
; B=..[chr_constraint, C]
|
|
),
|
|
conj2list(C, D).
|
|
rule(A, D) :-
|
|
A= @(C, B), !,
|
|
rule(B, yes(C), D).
|
|
rule(A, B) :-
|
|
rule(A, no, B).
|
|
rule(A, H, D) :-
|
|
A=pragma(B, C), !,
|
|
is_rule(B, E, F),
|
|
conj2list(C, G),
|
|
D=pragma(E, F, G, H).
|
|
rule(A, E, B) :-
|
|
is_rule(A, C, D),
|
|
B=pragma(C, D, [], E).
|
|
is_rule(A, G, D) :-
|
|
A= ==>(B, F), !,
|
|
conj2list(B, C),
|
|
get_ids(C, E, H),
|
|
D=ids([], E),
|
|
( F= '|'(I,J)
|
|
-> G=rule([], H, I, J)
|
|
; G=rule([], H, true, F)
|
|
).
|
|
is_rule(A, R, M) :-
|
|
A= <=>(G, B), !,
|
|
( B= '|'(C,D)
|
|
-> E=C,
|
|
F=D
|
|
; E=true,
|
|
F=B
|
|
),
|
|
( G= \(H, I)
|
|
-> conj2list(H, J),
|
|
conj2list(I, K),
|
|
get_ids(J, O, P, 0, L),
|
|
get_ids(K, N, Q, L, _),
|
|
M=ids(N, O)
|
|
; conj2list(G, K),
|
|
P=[],
|
|
get_ids(K, N, Q),
|
|
M=ids(N, [])
|
|
),
|
|
R=rule(Q, P, E, F).
|
|
get_ids(A, B, C) :-
|
|
get_ids(A, B, C, 0, _).
|
|
get_ids([], [], [], A, A).
|
|
get_ids([B|D], [A|E], [C|F], A, H) :-
|
|
( B= #(C, A)
|
|
-> true
|
|
; C=B
|
|
),
|
|
G is A+1,
|
|
get_ids(D, E, F, G, H).
|
|
is_module_declaration((:-module(A)), A).
|
|
is_module_declaration((:-module(A, _)), A).
|
|
check_rules(A, B) :-
|
|
check_rules(A, B, 1).
|
|
check_rules([], _, _).
|
|
check_rules([A|D], B, C) :-
|
|
check_rule(A, B, C),
|
|
E is C+1,
|
|
check_rules(D, B, E).
|
|
check_rule(A, F, G) :-
|
|
A=pragma(B, _, H, _),
|
|
B=rule(C, D, _, _),
|
|
append(C, D, E),
|
|
check_head_constraints(E, F, A, G),
|
|
check_pragmas(H, A, G).
|
|
check_head_constraints([], _, _, _).
|
|
check_head_constraints([A|E], D, F, G) :-
|
|
functor(A, B, C),
|
|
( member(B/C, D)
|
|
-> check_head_constraints(E, D, F, G)
|
|
; format('CHR compiler ERROR: Undeclared constraint ~w in head of ~@.\n', [B/C, format_rule(F, G)]),
|
|
format(' `--> Constraint should be on of ~w.\n', [D]),
|
|
fail
|
|
).
|
|
check_pragmas([], _, _).
|
|
check_pragmas([A|D], B, C) :-
|
|
check_pragma(A, B, C),
|
|
check_pragmas(D, B, C).
|
|
check_pragma(A, B, C) :-
|
|
var(A), !,
|
|
format('CHR compiler ERROR: invalid pragma ~w in ~@.\n', [A, format_rule(B, C)]),
|
|
format(' `--> Pragma should not be a variable!\n', []),
|
|
fail.
|
|
check_pragma(passive(B), A, E) :- !,
|
|
A=pragma(_, ids(C, D), _, _),
|
|
( memberchk_eq(B, C)
|
|
-> true
|
|
; memberchk_eq(B, D)
|
|
-> true
|
|
; format('CHR compiler ERROR: invalid identifier ~w in pragma passive in ~@.\n', [B, format_rule(A, E)]),
|
|
fail
|
|
).
|
|
check_pragma(A, B, C) :-
|
|
A=unique(_, _), !,
|
|
format('CHR compiler WARNING: undocumented pragma ~w in ~@.\n', [A, format_rule(B, C)]),
|
|
format(' `--> Only use this pragma if you know what you are doing.\n', []).
|
|
check_pragma(A, B, C) :-
|
|
A=already_in_heads, !,
|
|
format('CHR compiler WARNING: currently unsupported pragma ~w in ~@.\n', [A, format_rule(B, C)]),
|
|
format(' `--> Pragma is ignored. Termination and correctness may be affected \n', []).
|
|
check_pragma(A, B, C) :-
|
|
A=already_in_head(_), !,
|
|
format('CHR compiler WARNING: currently unsupported pragma ~w in ~@.\n', [A, format_rule(B, C)]),
|
|
format(' `--> Pragma is ignored. Termination and correctness may be affected \n', []).
|
|
check_pragma(A, B, C) :-
|
|
format('CHR compiler ERROR: invalid pragma ~w in ~@.\n', [A, format_rule(B, C)]),
|
|
format(' `--> Pragma should be one of passive/1!\n', []),
|
|
fail.
|
|
format_rule(A, D) :-
|
|
A=pragma(_, _, _, B),
|
|
( B=yes(C)
|
|
-> write('rule '),
|
|
write(C)
|
|
; write('rule number '),
|
|
write(D)
|
|
).
|
|
handle_option(A, B) :-
|
|
var(A), !,
|
|
format('CHR compiler ERROR: ~w.\n', [option(A, B)]),
|
|
format(' `--> First argument should be an atom, not a variable.\n', []),
|
|
fail.
|
|
handle_option(B, A) :-
|
|
var(A), !,
|
|
format('CHR compiler ERROR: ~w.\n', [option(B, A)]),
|
|
format(' `--> Second argument should be a nonvariable.\n', []),
|
|
fail.
|
|
handle_option(A, B) :-
|
|
option_definition(A, B, C), !,
|
|
set_chr_pp_flags(C).
|
|
handle_option(A, _) :-
|
|
\+option_definition(A, _, _), !.
|
|
handle_option(A, C) :-
|
|
findall(B, option_definition(A, B, _), D),
|
|
format('CHR compiler ERROR: ~w.\n', [option(A, C)]),
|
|
format(' `--> Invalid value ~w: should be one of ~w.\n', [C, D]),
|
|
fail.
|
|
option_definition(optimize, experimental, A) :-
|
|
A=[unique_analyse_optimise-on, check_unnecessary_active-full, reorder_heads-on, set_semantics_rule-on, check_attachments-on, guard_via_reschedule-on].
|
|
option_definition(optimize, full, A) :-
|
|
A=[unique_analyse_optimise-on, check_unnecessary_active-full, reorder_heads-on, set_semantics_rule-on, check_attachments-on, guard_via_reschedule-on].
|
|
option_definition(optimize, sicstus, A) :-
|
|
A=[unique_analyse_optimise-off, check_unnecessary_active-simplification, reorder_heads-off, set_semantics_rule-off, check_attachments-off, guard_via_reschedule-off].
|
|
option_definition(optimize, off, A) :-
|
|
A=[unique_analyse_optimise-off, check_unnecessary_active-off, reorder_heads-off, set_semantics_rule-off, check_attachments-off, guard_via_reschedule-off].
|
|
option_definition(debug, off, A) :-
|
|
A=[debugable-off].
|
|
option_definition(debug, on, A) :-
|
|
A=[debugable-on].
|
|
option_definition(check_guard_bindings, on, A) :-
|
|
A=[guard_locks-on].
|
|
option_definition(check_guard_bindings, off, A) :-
|
|
A=[guard_locks-off].
|
|
init_chr_pp_flags :-
|
|
chr_pp_flag_definition(A, [B|_]),
|
|
set_chr_pp_flag(A, B),
|
|
fail.
|
|
init_chr_pp_flags.
|
|
set_chr_pp_flags([]).
|
|
set_chr_pp_flags([A-B|C]) :-
|
|
set_chr_pp_flag(A, B),
|
|
set_chr_pp_flags(C).
|
|
set_chr_pp_flag(A, C) :-
|
|
atomic_concat('$chr_pp_', A, B),
|
|
nb_setval(B, C).
|
|
chr_pp_flag_definition(unique_analyse_optimise, [on, off]).
|
|
chr_pp_flag_definition(check_unnecessary_active, [full, simplification, off]).
|
|
chr_pp_flag_definition(reorder_heads, [on, off]).
|
|
chr_pp_flag_definition(set_semantics_rule, [on, off]).
|
|
chr_pp_flag_definition(guard_via_reschedule, [on, off]).
|
|
chr_pp_flag_definition(guard_locks, [on, off]).
|
|
chr_pp_flag_definition(check_attachments, [on, off]).
|
|
chr_pp_flag_definition(debugable, [off, on]).
|
|
chr_pp_flag(A, D) :-
|
|
atomic_concat('$chr_pp_', A, B),
|
|
nb_getval(B, C),
|
|
( C==[]
|
|
-> chr_pp_flag_definition(A, [D|_])
|
|
; C=D
|
|
).
|
|
generate_attach_detach_a_constraint_all([], []).
|
|
generate_attach_detach_a_constraint_all([A|D], F) :-
|
|
( is_attached(A)
|
|
-> generate_attach_a_constraint(A, B),
|
|
generate_detach_a_constraint(A, C)
|
|
; B=[],
|
|
C=[]
|
|
),
|
|
generate_attach_detach_a_constraint_all(D, E),
|
|
append([B, C, E], F).
|
|
generate_attach_a_constraint(A, [B, D]) :-
|
|
generate_attach_a_constraint_empty_list(A, B),
|
|
get_max_constraint_index(C),
|
|
( C==1
|
|
-> generate_attach_a_constraint_1_1(A, D)
|
|
; generate_attach_a_constraint_t_p(A, D)
|
|
).
|
|
generate_attach_a_constraint_empty_list(A/B, E) :-
|
|
atom_concat_list([attach_, A, /, B], C),
|
|
D=[[], _],
|
|
F=..[C|D],
|
|
E= (F:-true).
|
|
generate_attach_a_constraint_1_1(A/B, L) :-
|
|
atom_concat_list([attach_, A, /, B], C),
|
|
D=[[G|E], F],
|
|
M=..[C|D],
|
|
K=..[C, E, F],
|
|
get_target_module(H),
|
|
N= ((get_attr(G, H, I)->J=[F|I], put_attr(G, H, J);put_attr(G, H, [F])), K),
|
|
L= (M:-N).
|
|
generate_attach_a_constraint_t_p(A/B, Z) :-
|
|
atom_concat_list([attach_, A, /, B], C),
|
|
D=[[Q|E], F],
|
|
A1=..[C|D],
|
|
Y=..[C, E, F],
|
|
get_constraint_index(A/B, G),
|
|
or_pattern(G, P),
|
|
get_max_constraint_index(H),
|
|
make_attr(H, K, I, T),
|
|
nth1(G, I, J),
|
|
substitute_eq(J, I, [F|J], L),
|
|
make_attr(H, K, L, U),
|
|
substitute_eq(J, I, [F], M),
|
|
make_attr(H, V, M, W),
|
|
copy_term_nat(I, N),
|
|
nth1(G, N, [F]),
|
|
chr_delete(N, [F], O),
|
|
set_elems(O, []),
|
|
make_attr(H, P, N, X),
|
|
get_target_module(R),
|
|
B1= ((get_attr(Q, R, S)->S=T, (K/\P=:=P->put_attr(Q, R, U);V is K\/P, put_attr(Q, R, W));put_attr(Q, R, X)), Y),
|
|
Z= (A1:-B1).
|
|
generate_detach_a_constraint(A, [B, D]) :-
|
|
generate_detach_a_constraint_empty_list(A, B),
|
|
get_max_constraint_index(C),
|
|
( C==1
|
|
-> generate_detach_a_constraint_1_1(A, D)
|
|
; generate_detach_a_constraint_t_p(A, D)
|
|
).
|
|
generate_detach_a_constraint_empty_list(A/B, E) :-
|
|
atom_concat_list([detach_, A, /, B], C),
|
|
D=[[], _],
|
|
F=..[C|D],
|
|
E= (F:-true).
|
|
generate_detach_a_constraint_1_1(A/B, L) :-
|
|
atom_concat_list([detach_, A, /, B], C),
|
|
D=[[G|E], F],
|
|
M=..[C|D],
|
|
K=..[C, E, F],
|
|
get_target_module(H),
|
|
N= ((get_attr(G, H, I)->'chr sbag_del_element'(I, F, J), (J==[]->del_attr(G, H);put_attr(G, H, J));true), K),
|
|
L= (M:-N).
|
|
generate_detach_a_constraint_t_p(A/B, Y) :-
|
|
atom_concat_list([detach_, A, /, B], C),
|
|
D=[[N|E], F],
|
|
Z=..[C|D],
|
|
X=..[C, E, F],
|
|
get_constraint_index(A/B, G),
|
|
or_pattern(G, R),
|
|
and_pattern(G, U),
|
|
get_max_constraint_index(H),
|
|
make_attr(H, L, I, Q),
|
|
nth1(G, I, J),
|
|
substitute_eq(J, I, [], K),
|
|
make_attr(H, T, K, V),
|
|
substitute_eq(J, I, S, M),
|
|
make_attr(H, L, M, W),
|
|
get_target_module(O),
|
|
A1= ((get_attr(N, O, P)->P=Q, (L/\R=:=R->'chr sbag_del_element'(J, F, S), (S==[]->T is L/\U, (T==0->del_attr(N, O);put_attr(N, O, V));put_attr(N, O, W));true);true), X),
|
|
Y= (Z:-A1).
|
|
generate_attach_increment([A, C]) :-
|
|
generate_attach_increment_empty(A),
|
|
get_max_constraint_index(B),
|
|
( B==1
|
|
-> generate_attach_increment_one(C)
|
|
; generate_attach_increment_many(B, C)
|
|
).
|
|
generate_attach_increment_empty((attach_increment([], _):-true)).
|
|
generate_attach_increment_one(H) :-
|
|
I=attach_increment([A|G], D),
|
|
get_target_module(B),
|
|
J= ('chr not_locked'(A), (get_attr(A, B, C)->sort(C, E), merge(D, E, F), put_attr(A, B, F);put_attr(A, B, D)), attach_increment(G, D)),
|
|
H= (I:-J).
|
|
generate_attach_increment_many(A, Z) :-
|
|
make_attr(A, V, C, B),
|
|
make_attr(A, W, D, S),
|
|
A1=attach_increment([P|Y], B),
|
|
bagof(G, E^F^H^I^ (member2(C, D, E-F), G= (sort(F, H), 'chr merge_attributes'(E, H, I))), J),
|
|
list2conj(J, T),
|
|
bagof(N, K^L^M^member((K, 'chr merge_attributes'(L, M, N)), J), O),
|
|
make_attr(A, U, O, X),
|
|
get_target_module(Q),
|
|
B1= ('chr not_locked'(P), (get_attr(P, Q, R)->R=S, T, U is V\/W, put_attr(P, Q, X);put_attr(P, Q, B)), attach_increment(Y, B)),
|
|
Z= (A1:-B1).
|
|
generate_attr_unify_hook([B]) :-
|
|
get_max_constraint_index(A),
|
|
( A==1
|
|
-> generate_attr_unify_hook_one(B)
|
|
; generate_attr_unify_hook_many(A, B)
|
|
).
|
|
generate_attr_unify_hook_one(K) :-
|
|
L=A:attr_unify_hook(B, C),
|
|
get_target_module(A),
|
|
make_run_suspensions(G, H),
|
|
make_run_suspensions(B, J),
|
|
M= (sort(B, E), (var(C)-> (get_attr(C, A, D)->true;D=[]), sort(D, F), 'chr merge_attributes'(E, F, G), put_attr(C, A, G), H; (compound(C)->term_variables(C, I), attach_increment(I, E);true), J)),
|
|
K= (L:-M).
|
|
generate_attr_unify_hook_many(A, F1) :-
|
|
make_attr(A, Q, C, R),
|
|
make_attr(A, Z, H, W),
|
|
bagof(D, B^E^ (member(B, C), D=sort(B, E)), F),
|
|
list2conj(F, T),
|
|
bagof(E, B^member(sort(B, E), F), G),
|
|
bagof(K, I^J^L^M^ (member2(G, H, I-J), K= (sort(J, L), 'chr merge_attributes'(I, L, M))), O),
|
|
bagof(M, I^L^N^member((N, 'chr merge_attributes'(I, L, M)), O), P),
|
|
list2conj(O, X),
|
|
make_attr(A, Y, P, A1),
|
|
make_attr(A, Q, G, C1),
|
|
G1=S:attr_unify_hook(R, U),
|
|
get_target_module(S),
|
|
make_run_suspensions_loop(P, B1),
|
|
make_run_suspensions_loop(G, D1),
|
|
H1= (T, (var(U)-> (get_attr(U, S, V)->V=W, X, Y is Q\/Z, put_attr(U, S, A1), B1;put_attr(U, S, C1), D1); (compound(U)->term_variables(U, E1), attach_increment(E1, C1);true), D1)),
|
|
F1= (G1:-H1).
|
|
make_run_suspensions(B, A) :-
|
|
( chr_pp_flag(debugable, on)
|
|
-> A='chr run_suspensions_d'(B)
|
|
; A='chr run_suspensions'(B)
|
|
).
|
|
make_run_suspensions_loop(B, A) :-
|
|
( chr_pp_flag(debugable, on)
|
|
-> A='chr run_suspensions_loop_d'(B)
|
|
; A='chr run_suspensions_loop'(B)
|
|
).
|
|
check_attachments(A) :-
|
|
( chr_pp_flag(check_attachments, on)
|
|
-> check_attachments_(A)
|
|
; true
|
|
).
|
|
check_attachments_([]).
|
|
check_attachments_([A|B]) :-
|
|
check_attachment(A),
|
|
check_attachments_(B).
|
|
check_attachment(A) :-
|
|
A=pragma(B, _, _, _),
|
|
B=rule(C, D, E, F),
|
|
check_attachment_heads1(C, C, D, E),
|
|
check_attachment_heads2(D, C, F).
|
|
check_attachment_heads1([], _, _, _).
|
|
check_attachment_heads1([A|H], B, C, D) :-
|
|
functor(A, F, G),
|
|
( B==[A],
|
|
C==[],
|
|
D==true,
|
|
A=..[_|E],
|
|
no_matching(E, [])
|
|
-> attached(F/G, no)
|
|
; attached(F/G, maybe)
|
|
),
|
|
check_attachment_heads1(H, B, C, D).
|
|
no_matching([], _).
|
|
no_matching([A|C], B) :-
|
|
var(A),
|
|
\+memberchk_eq(A, B),
|
|
no_matching(C, [A|B]).
|
|
check_attachment_heads2([], _, _).
|
|
check_attachment_heads2([A|F], B, C) :-
|
|
functor(A, D, E),
|
|
( B\==[],
|
|
C==true
|
|
-> attached(D/E, maybe)
|
|
; attached(D/E, yes)
|
|
),
|
|
check_attachment_heads2(F, B, C).
|
|
all_attached([]).
|
|
all_attached([A|D]) :-
|
|
functor(A, B, C),
|
|
is_attached(B/C),
|
|
all_attached(D).
|
|
set_constraint_indices([], A) :-
|
|
B is A-1,
|
|
max_constraint_index(B).
|
|
set_constraint_indices([A|C], B) :-
|
|
( is_attached(A)
|
|
-> constraint_index(A, B),
|
|
D is B+1,
|
|
set_constraint_indices(C, D)
|
|
; set_constraint_indices(C, B)
|
|
).
|
|
constraints_code(A, B, D) :-
|
|
post_constraints(A, 1),
|
|
constraints_code1(1, B, C, []),
|
|
clean_clauses(C, D).
|
|
post_constraints([], A) :-
|
|
B is A-1,
|
|
constraint_count(B).
|
|
post_constraints([A/B|D], C) :-
|
|
constraint(A/B, C),
|
|
E is C+1,
|
|
post_constraints(D, E).
|
|
constraints_code1(A, E, D, C) :-
|
|
constraint_count(B),
|
|
( A>B
|
|
-> C=D
|
|
; constraint_code(A, E, D, G),
|
|
F is A+1,
|
|
constraints_code1(F, E, G, C)
|
|
).
|
|
constraint_code(A, E, C, J) :-
|
|
constraint(B, A),
|
|
constraint_prelude(B, D),
|
|
C=[D|G],
|
|
F=[0],
|
|
rules_code(E, 1, A, F, H, G, I),
|
|
gen_cond_attach_clause(B, H, I, J).
|
|
constraint_prelude(B/A, E) :-
|
|
vars_susp(A, C, I, D),
|
|
F=..[B|C],
|
|
build_head(B, A, [0], D, H),
|
|
get_target_module(G),
|
|
( chr_pp_flag(debugable, on)
|
|
-> E= (F:-'chr allocate_constraint'(G:H, I, B, C), ('chr debug_event'(call(I)), H;'chr debug_event'(fail(I)), !, fail), ('chr debug_event'(exit(I));'chr debug_event'(redo(I)), fail))
|
|
; E= (F:-H)
|
|
).
|
|
gen_cond_attach_clause(A/B, C, K, M) :-
|
|
( is_attached(A/B)
|
|
-> ( C==[0]
|
|
-> gen_cond_attach_goal(A/B, G, F, D, E)
|
|
; vars_susp(B, D, E, F),
|
|
gen_uncond_attach_goal(A/B, E, G, _)
|
|
),
|
|
( chr_pp_flag(debugable, on)
|
|
-> H=..[A|D],
|
|
I='chr debug_event'(insert(#(H, E)))
|
|
; I=true
|
|
),
|
|
build_head(A, B, C, F, J),
|
|
L= (J:-I, G),
|
|
K=[L|M]
|
|
; K=M
|
|
).
|
|
gen_cond_attach_goal(E/A, G, D, B, C) :-
|
|
vars_susp(A, B, C, D),
|
|
build_head(E, A, [0], D, J),
|
|
atom_concat_list([attach_, E, /, A], F),
|
|
K=..[F, H, C],
|
|
get_target_module(I),
|
|
G= ((var(C)->'chr insert_constraint_internal'(H, C, I:J, E, B);'chr activate_constraint'(H, C, _)), K).
|
|
gen_uncond_attach_goal(A/B, D, E, G) :-
|
|
atom_concat_list([attach_, A, /, B], C),
|
|
H=..[C, F, D],
|
|
E= ('chr activate_constraint'(F, D, G), H).
|
|
rules_code([], _, _, A, A, B, B).
|
|
rules_code([A|F], B, C, D, I, E, K) :-
|
|
rule_code(A, B, C, D, H, E, J),
|
|
G is B+1,
|
|
rules_code(F, G, C, H, I, J, K).
|
|
rule_code(A, K, F, G, L, H, N) :-
|
|
A=pragma(C, B, _, _),
|
|
B=ids(E, J),
|
|
C=rule(D, I, _, _),
|
|
heads1_code(D, [], E, [], A, F, G, H, M),
|
|
heads2_code(I, [], J, [], A, K, F, G, L, M, N).
|
|
heads1_code([], _, _, _, _, _, _, A, A).
|
|
heads1_code([C|J], F, [H|L], M, A, B, P, Q, S) :-
|
|
A=pragma(G, _, I, _),
|
|
constraint(D/E, B),
|
|
( functor(C, D, E),
|
|
\+check_unnecessary_active(C, F, G),
|
|
\+memberchk_eq(passive(H), I),
|
|
all_attached(J),
|
|
all_attached(F),
|
|
G=rule(_, K, _, _),
|
|
all_attached(K)
|
|
-> append(J, F, N),
|
|
append(L, M, O),
|
|
head1_code(C, N, O, A, D/E, B, P, Q, R)
|
|
; Q=R
|
|
),
|
|
heads1_code(J, [C|F], L, [H|M], A, B, P, R, S).
|
|
head1_code(D, E, F, A, I, _, J, K, L) :-
|
|
A=pragma(B, _, _, _),
|
|
B=rule(_, C, _, _),
|
|
( C==[]
|
|
-> reorder_heads(D, E, F, G, H),
|
|
simplification_code(D, G, H, A, I, J, K, L)
|
|
; simpagation_head1_code(D, E, F, A, I, J, K, L)
|
|
).
|
|
heads2_code([], _, _, _, _, _, _, A, A, B, B).
|
|
heads2_code([C|J], F, [H|L], M, A, P, B, R, W, S, X) :-
|
|
A=pragma(G, _, I, _),
|
|
constraint(D/E, B),
|
|
( functor(C, D, E),
|
|
\+check_unnecessary_active(C, F, G),
|
|
\+memberchk_eq(passive(H), I),
|
|
\+set_semantics_rule(A),
|
|
all_attached(J),
|
|
all_attached(F),
|
|
G=rule(K, _, _, _),
|
|
all_attached(K)
|
|
-> append(J, F, N),
|
|
append(L, M, O),
|
|
length(J, Q),
|
|
head2_code(C, N, O, A, P, Q, D/E, R, S, T),
|
|
inc_id(R, V),
|
|
gen_alloc_inc_clause(D/E, R, T, U)
|
|
; S=U,
|
|
V=R
|
|
),
|
|
heads2_code(J, [C|F], L, [H|M], A, P, B, V, W, U, X).
|
|
head2_code(D, E, M, A, G, H, I, J, K, L) :-
|
|
A=pragma(B, _, _, _),
|
|
B=rule(C, _, _, _),
|
|
( C==[]
|
|
-> reorder_heads(D, E, F),
|
|
propagation_code(D, F, B, G, H, I, J, K, L)
|
|
; simpagation_head2_code(D, E, M, A, I, J, K, L)
|
|
).
|
|
gen_alloc_inc_clause(B/A, C, K, M) :-
|
|
vars_susp(A, F, G, D),
|
|
build_head(B, A, C, D, I),
|
|
inc_id(C, E),
|
|
build_head(B, A, E, D, J),
|
|
( C==[0]
|
|
-> gen_cond_allocation(F, G, B/A, D, H)
|
|
; H=true
|
|
),
|
|
L= (I:-H, J),
|
|
K=[L|M].
|
|
gen_cond_allocation(H, E, A/B, C, D) :-
|
|
build_head(A, B, [0], C, G),
|
|
get_target_module(F),
|
|
D= (var(E)->'chr allocate_constraint'(F:G, E, A, H);true).
|
|
guard_via_reschedule(A, B, C, D) :-
|
|
( chr_pp_flag(guard_via_reschedule, on)
|
|
-> guard_via_reschedule_main(A, B, C, D)
|
|
; append(A, B, E),
|
|
list2conj(E, D)
|
|
).
|
|
guard_via_reschedule_main(B, C, A, G) :-
|
|
initialize_unit_dictionary(A, D),
|
|
build_units(B, C, D, E),
|
|
dependency_reorder(E, F),
|
|
units2goal(F, G).
|
|
units2goal([], true).
|
|
units2goal([unit(_, A, _, _)|B], (A, C)) :-
|
|
units2goal(B, C).
|
|
dependency_reorder(A, B) :-
|
|
dependency_reorder(A, [], B).
|
|
dependency_reorder([], A, B) :-
|
|
reverse(A, B).
|
|
dependency_reorder([A|F], C, G) :-
|
|
A=unit(_, _, B, D),
|
|
( B==fixed
|
|
-> E=[A|C]
|
|
; dependency_insert(C, A, D, E)
|
|
),
|
|
dependency_reorder(F, E, G).
|
|
dependency_insert([], A, _, [A]).
|
|
dependency_insert([A|F], E, C, D) :-
|
|
A=unit(B, _, _, _),
|
|
( memberchk(B, C)
|
|
-> D=[E, A|F]
|
|
; D=[A|G],
|
|
dependency_insert(F, E, C, G)
|
|
).
|
|
build_units(A, D, B, C) :-
|
|
build_retrieval_units(A, 1, E, B, F, C, G),
|
|
build_guard_units(D, E, F, G).
|
|
build_retrieval_units([], A, A, B, B, C, C).
|
|
build_retrieval_units([A|G], C, I, D, K, E, M) :-
|
|
term_variables(A, B),
|
|
update_unit_dictionary(B, C, D, J, [], F),
|
|
E=[unit(C, A, movable, F)|L],
|
|
H is C+1,
|
|
build_retrieval_units2(G, H, I, J, K, L, M).
|
|
build_retrieval_units2([], A, A, B, B, C, C).
|
|
build_retrieval_units2([A|G], C, I, D, K, E, M) :-
|
|
term_variables(A, B),
|
|
update_unit_dictionary(B, C, D, J, [], F),
|
|
E=[unit(C, A, fixed, F)|L],
|
|
H is C+1,
|
|
build_retrieval_units(G, H, I, J, K, L, M).
|
|
initialize_unit_dictionary(A, C) :-
|
|
term_variables(A, B),
|
|
pair_all_with(B, 0, C).
|
|
update_unit_dictionary([], _, A, A, B, B).
|
|
update_unit_dictionary([B|H], D, A, I, E, J) :-
|
|
( lookup_eq(A, B, C)
|
|
-> ( ( C==D
|
|
; memberchk(C, E)
|
|
)
|
|
-> F=E
|
|
; F=[C|E]
|
|
),
|
|
G=A
|
|
; G=[B-D|A],
|
|
F=E
|
|
),
|
|
update_unit_dictionary(H, D, G, I, F, J).
|
|
build_guard_units(A, C, F, B) :-
|
|
( A=[D]
|
|
-> B=[unit(C, D, fixed, [])]
|
|
; A=[D|H]
|
|
-> term_variables(D, E),
|
|
update_unit_dictionary2(E, C, F, J, [], G),
|
|
B=[unit(C, D, movable, G)|K],
|
|
I is C+1,
|
|
build_guard_units(H, I, J, K)
|
|
).
|
|
update_unit_dictionary2([], _, A, A, B, B).
|
|
update_unit_dictionary2([B|H], D, A, I, E, J) :-
|
|
( lookup_eq(A, B, C)
|
|
-> ( ( C==D
|
|
; memberchk(C, E)
|
|
)
|
|
-> F=E
|
|
; F=[C|E]
|
|
),
|
|
G=[B-D|A]
|
|
; G=[B-D|A],
|
|
F=E
|
|
),
|
|
update_unit_dictionary2(H, D, G, I, F, J).
|
|
unique_analyse_optimise(A, B) :-
|
|
( chr_pp_flag(unique_analyse_optimise, on)
|
|
-> unique_analyse_optimise_main(A, 1, [], B)
|
|
; B=A
|
|
).
|
|
unique_analyse_optimise_main([], _, _, []).
|
|
unique_analyse_optimise_main([A|R], B, D, [O|T]) :-
|
|
( discover_unique_pattern(A, B, C)
|
|
-> E=[C|D]
|
|
; E=D
|
|
),
|
|
A=pragma(F, G, N, Q),
|
|
F=rule(H, J, _, _),
|
|
G=ids(I, K),
|
|
apply_unique_patterns_to_constraints(H, I, E, L),
|
|
apply_unique_patterns_to_constraints(J, K, E, M),
|
|
append([L, M, N], P),
|
|
O=pragma(F, G, P, Q),
|
|
S is B+1,
|
|
unique_analyse_optimise_main(R, S, E, T).
|
|
apply_unique_patterns_to_constraints([], _, _, []).
|
|
apply_unique_patterns_to_constraints([B|H], [C|I], A, E) :-
|
|
( member(D, A),
|
|
apply_unique_pattern(B, C, D, F)
|
|
-> E=[F|G]
|
|
; E=G
|
|
),
|
|
apply_unique_patterns_to_constraints(H, I, A, G).
|
|
apply_unique_pattern(B, L, A, K) :-
|
|
A=unique(C, E),
|
|
subsumes(B, C, F),
|
|
( setof(I, D^G^H^ (member(D, E), lookup_eq(F, D, G), term_variables(G, H), member(I, H)), J)
|
|
-> true
|
|
; J=[]
|
|
),
|
|
K=unique(L, J).
|
|
subsumes(A, B, F) :-
|
|
empty_ds(C),
|
|
subsumes_aux(A, B, C, D),
|
|
ds_to_list(D, E),
|
|
build_unifier(E, F).
|
|
subsumes_aux(B, A, E, F) :-
|
|
( compound(A),
|
|
functor(A, C, D)
|
|
-> compound(B),
|
|
functor(B, C, D),
|
|
subsumes_aux(D, B, A, E, F)
|
|
; B==A
|
|
-> F=E
|
|
; var(A),
|
|
get_ds(B, E, G)
|
|
-> G==A,
|
|
F=E
|
|
; var(A),
|
|
put_ds(B, E, A, F)
|
|
).
|
|
subsumes_aux(0, _, _, A, A) :- !.
|
|
subsumes_aux(A, B, C, F, I) :-
|
|
arg(A, B, D),
|
|
arg(A, C, E),
|
|
subsumes_aux(D, E, F, H),
|
|
G is A-1,
|
|
subsumes_aux(G, B, C, H, I).
|
|
build_unifier([], []).
|
|
build_unifier([B-A|C], [A-B|D]) :-
|
|
build_unifier(C, D).
|
|
discover_unique_pattern(A, M, L) :-
|
|
A=pragma(B, _, G, N),
|
|
( B=rule([C], [D], E, F)
|
|
-> true
|
|
; B=rule([C, D], [], E, F)
|
|
),
|
|
check_unique_constraints(C, D, E, F, G, H),
|
|
term_variables(C, I),
|
|
select_pragma_unique_variables(H, I, J),
|
|
K=unique(C, J),
|
|
copy_term_nat(K, L),
|
|
( verbosity_on
|
|
-> format('Found unique pattern ~w in rule ~d~@\n', [L, M, (N=yes(O)->write([58, 32]), write(O);true)])
|
|
; true
|
|
).
|
|
select_pragma_unique_variables([], _, []).
|
|
select_pragma_unique_variables([A-B|F], D, C) :-
|
|
( A==B
|
|
-> C=[A|E]
|
|
; once((
|
|
( \+memberchk_eq(A, D)
|
|
; \+memberchk_eq(B, D)
|
|
)
|
|
)),
|
|
C=E
|
|
),
|
|
select_pragma_unique_variables(F, D, E).
|
|
check_unique_constraints(B, C, E, _, A, D) :-
|
|
\+member(passive(_), A),
|
|
variable_replacement(B-C, C-B, D),
|
|
copy_with_variable_replacement(E, G, D),
|
|
negate(E, F),
|
|
once(entails(F, G)).
|
|
negate(true, fail).
|
|
negate(fail, true).
|
|
negate(B=<A, A<B).
|
|
negate(B>A, A>=B).
|
|
negate(B>=A, A>B).
|
|
negate(B<A, A=<B).
|
|
negate(var(A), nonvar(A)).
|
|
negate(nonvar(A), var(A)).
|
|
entails(B, A) :-
|
|
A==B.
|
|
entails(fail, _).
|
|
entails(B>D, A>=C) :-
|
|
A==B,
|
|
C==D.
|
|
entails(B<D, A=<C) :-
|
|
A==B,
|
|
C==D.
|
|
entails(ground(B), nonvar(A)) :-
|
|
A==B.
|
|
entails(compound(B), nonvar(A)) :-
|
|
A==B.
|
|
entails(atomic(B), nonvar(A)) :-
|
|
A==B.
|
|
entails(number(B), nonvar(A)) :-
|
|
A==B.
|
|
entails(atom(B), nonvar(A)) :-
|
|
A==B.
|
|
check_unnecessary_active(A, B, C) :-
|
|
( chr_pp_flag(check_unnecessary_active, full)
|
|
-> check_unnecessary_active_main(A, B, C)
|
|
; chr_pp_flag(check_unnecessary_active, simplification),
|
|
C=rule(_, [], _, _)
|
|
-> check_unnecessary_active_main(A, B, C)
|
|
; fail
|
|
).
|
|
check_unnecessary_active_main(C, A, D) :-
|
|
member(B, A),
|
|
variable_replacement(B, C, E),
|
|
copy_with_variable_replacement(D, F, E),
|
|
identical_rules(D, F), !.
|
|
set_semantics_rule(A) :-
|
|
( chr_pp_flag(set_semantics_rule, on)
|
|
-> set_semantics_rule_main(A)
|
|
; fail
|
|
).
|
|
set_semantics_rule_main(A) :-
|
|
A=pragma(B, C, E, _),
|
|
B=rule([_], [_], true, _),
|
|
C=ids([D], [F]),
|
|
once(member(unique(D, G), E)),
|
|
once(member(unique(F, H), E)),
|
|
G==H,
|
|
\+memberchk_eq(passive(D), E).
|
|
identical_rules(rule(E, H, A, C), rule(G, J, B, D)) :-
|
|
A==B,
|
|
identical_bodies(C, D),
|
|
permutation(E, F),
|
|
F==G,
|
|
permutation(H, I),
|
|
I==J.
|
|
identical_bodies(A, B) :-
|
|
( A= (C=E),
|
|
B= (D=F)
|
|
-> ( C==D,
|
|
E==F
|
|
; C==F,
|
|
D==E
|
|
), !
|
|
; A==B
|
|
).
|
|
copy_with_variable_replacement(A, C, B) :-
|
|
( var(A)
|
|
-> ( lookup_eq(B, A, C)
|
|
-> true
|
|
; A=C
|
|
)
|
|
; functor(A, D, E),
|
|
functor(C, D, E),
|
|
A=..[_|F],
|
|
C=..[_|G],
|
|
copy_with_variable_replacement_l(F, G, B)
|
|
).
|
|
copy_with_variable_replacement_l([], [], _).
|
|
copy_with_variable_replacement_l([A|D], [B|E], C) :-
|
|
copy_with_variable_replacement(A, B, C),
|
|
copy_with_variable_replacement_l(D, E, C).
|
|
variable_replacement(A, B, C) :-
|
|
variable_replacement(A, B, [], C).
|
|
variable_replacement(A, B, C, E) :-
|
|
( var(A)
|
|
-> var(B),
|
|
( lookup_eq(C, A, D)
|
|
-> D==B,
|
|
E=C
|
|
; E=[A-B|C]
|
|
)
|
|
; A=..[F|G],
|
|
nonvar(B),
|
|
B=..[F|H],
|
|
variable_replacement_l(G, H, C, E)
|
|
).
|
|
variable_replacement_l([], [], A, A).
|
|
variable_replacement_l([A|D], [B|E], C, G) :-
|
|
variable_replacement(A, B, C, F),
|
|
variable_replacement_l(D, E, F, G).
|
|
simplification_code(B, H, J, A, D/C, E, E1, G1) :-
|
|
A=pragma(O, _, K, _),
|
|
head_info(B, C, _, S, F, G),
|
|
build_head(D, C, E, F, Q),
|
|
head_arg_matches(G, [], R, I),
|
|
( H==[]
|
|
-> M=[],
|
|
N=I,
|
|
L=[]
|
|
; rest_heads_retrieval_and_matching(H, J, K, B, L, M, I, N)
|
|
),
|
|
guard_body_copies2(O, N, P, D1),
|
|
guard_via_reschedule(L, P, Q-R, A1),
|
|
gen_uncond_susps_detachments(M, H, B1),
|
|
gen_cond_susp_detachment(S, D/C, C1),
|
|
( chr_pp_flag(debugable, on)
|
|
-> O=rule(_, _, T, U),
|
|
my_term_copy(T-U, N, _, V-W),
|
|
Y='chr debug_event'(try([S|X], [], V, W)),
|
|
Z='chr debug_event'(apply([S|X], [], V, W))
|
|
; Y=true,
|
|
Z=true
|
|
),
|
|
F1= (Q:-R, A1, Y, !, Z, B1, C1, D1),
|
|
E1=[F1|G1].
|
|
head_arg_matches(A, B, E, C) :-
|
|
head_arg_matches_(A, B, D, C),
|
|
list2conj(D, E).
|
|
head_arg_matches_([], A, [], A).
|
|
head_arg_matches_([A-D|H], B, C, P) :-
|
|
( var(A)
|
|
-> ( lookup_eq(B, A, E)
|
|
-> C=[D==E|G],
|
|
F=B
|
|
; F=[A-D|B],
|
|
C=G
|
|
),
|
|
I=H
|
|
; atomic(A)
|
|
-> C=[D==A|G],
|
|
B=F,
|
|
I=H
|
|
; A=..[_|M],
|
|
functor(A, J, K),
|
|
functor(L, J, K),
|
|
L=..[_|N],
|
|
C=[nonvar(D), D=L|G],
|
|
pairup(M, N, O),
|
|
append(O, H, I),
|
|
F=B
|
|
),
|
|
head_arg_matches_(I, F, G, P).
|
|
rest_heads_retrieval_and_matching(A, B, C, D, E, F, G, H) :-
|
|
rest_heads_retrieval_and_matching(A, B, C, D, E, F, G, H, [], [], []).
|
|
rest_heads_retrieval_and_matching(A, B, C, F, G, H, I, J, D, E, K) :-
|
|
( A=[_|_]
|
|
-> rest_heads_retrieval_and_matching_n(A, B, C, D, E, F, G, H, I, J, K)
|
|
; G=[],
|
|
H=[],
|
|
I=J
|
|
).
|
|
rest_heads_retrieval_and_matching_n([], _, _, _, _, _, [], [], A, A, B) :-
|
|
instantiate_pattern_goals(B).
|
|
rest_heads_retrieval_and_matching_n([A|B1], [W|C1], X, C, Q, B, [F, Z|D1], [P|E1], E, G1, D) :-
|
|
passive_head_via(A, [B|C], D, E, F, K, H1),
|
|
functor(A, L, G),
|
|
head_info(A, G, I, _, _, H),
|
|
head_arg_matches(H, E, V, F1),
|
|
S=..[suspension, _, R, _, _, _, _|I],
|
|
get_max_constraint_index(J),
|
|
( J==1
|
|
-> O=K
|
|
; get_constraint_index(L/G, M),
|
|
make_attr(J, _, N, K),
|
|
nth1(M, N, O)
|
|
),
|
|
different_from_other_susps(A, P, C, Q, U),
|
|
create_get_mutable_ref(active, R, T),
|
|
A1= ('chr sbag_member'(P, O), P=S, T, U, V),
|
|
( member(unique(W, Y), X),
|
|
check_unique_keys(Y, E)
|
|
-> Z= (A1->true)
|
|
; Z=A1
|
|
),
|
|
rest_heads_retrieval_and_matching_n(B1, C1, X, [A|C], [P|Q], B, D1, E1, F1, G1, H1).
|
|
instantiate_pattern_goals([]).
|
|
instantiate_pattern_goals([_-attr(C, D, B)|G]) :-
|
|
get_max_constraint_index(A),
|
|
( A==1
|
|
-> B=true
|
|
; make_attr(A, E, _, C),
|
|
or_list(D, F), !,
|
|
B= (E/\F=:=F)
|
|
),
|
|
instantiate_pattern_goals(G).
|
|
check_unique_keys([], _).
|
|
check_unique_keys([B|C], A) :-
|
|
lookup_eq(A, B, _),
|
|
check_unique_keys(C, A).
|
|
different_from_other_susps(C, G, B, E, J) :-
|
|
( bagof(F, A^ (nth1(A, B, D), \+C\=D, nth1(A, E, H), F= (G\==H)), I)
|
|
-> list2conj(I, J)
|
|
; J=true
|
|
).
|
|
passive_head_via(A, D, I, F, O, K, N) :-
|
|
functor(A, B, C),
|
|
get_constraint_index(B/C, G),
|
|
common_variables(A, D, E),
|
|
translate(E, F, H),
|
|
or_pattern(G, L),
|
|
( permutation(H, J),
|
|
lookup_eq(I, J, attr(K, M, _))
|
|
-> member(L, M), !,
|
|
N=I,
|
|
O=true
|
|
; O= (P, Q),
|
|
gen_get_mod_constraints(H, P, K),
|
|
N=[H-attr(K, [L|_], Q)|I]
|
|
).
|
|
common_variables(A, B, E) :-
|
|
term_variables(A, C),
|
|
term_variables(B, D),
|
|
intersect_eq(C, D, E).
|
|
gen_get_mod_constraints(A, B, F) :-
|
|
get_target_module(D),
|
|
( A==[]
|
|
-> B= ('chr default_store'(C), get_attr(C, D, E), E=F)
|
|
; ( A=[G]
|
|
-> H='chr via_1'(G, J)
|
|
; A=[G, I]
|
|
-> H='chr via_2'(G, I, J)
|
|
; H='chr via'(A, J)
|
|
),
|
|
B= (H, get_attr(J, D, E), E=F)
|
|
).
|
|
guard_body_copies(A, B, E, C) :-
|
|
guard_body_copies2(A, B, D, C),
|
|
list2conj(D, E).
|
|
guard_body_copies2(A, D, H, W) :-
|
|
A=rule(_, _, B, U),
|
|
conj2list(B, C),
|
|
split_off_simple_guard(C, D, E, F),
|
|
my_term_copy(E-F, D, V, G-I),
|
|
append(G, [Q], H),
|
|
term_variables(F, L),
|
|
term_variables(I, M),
|
|
( chr_pp_flag(guard_locks, on),
|
|
bagof('chr lock'(J)-'chr unlock'(J), K^ (member(K, L), lookup_eq(D, K, J), memberchk_eq(J, M)), N)
|
|
-> once(pairup(O, P, N))
|
|
; O=[],
|
|
P=[]
|
|
),
|
|
list2conj(O, R),
|
|
list2conj(P, T),
|
|
list2conj(I, S),
|
|
Q= (R, S, T),
|
|
my_term_copy(U, V, W).
|
|
split_off_simple_guard([], _, [], []).
|
|
split_off_simple_guard([A|D], B, C, F) :-
|
|
( simple_guard(A, B)
|
|
-> C=[A|E],
|
|
split_off_simple_guard(D, B, E, F)
|
|
; C=[],
|
|
F=[A|D]
|
|
).
|
|
simple_guard(var(_), _).
|
|
simple_guard(nonvar(_), _).
|
|
simple_guard(ground(_), _).
|
|
simple_guard(number(_), _).
|
|
simple_guard(atom(_), _).
|
|
simple_guard(integer(_), _).
|
|
simple_guard(float(_), _).
|
|
simple_guard(_>_, _).
|
|
simple_guard(_<_, _).
|
|
simple_guard(_=<_, _).
|
|
simple_guard(_>=_, _).
|
|
simple_guard(_=:=_, _).
|
|
simple_guard(_==_, _).
|
|
simple_guard(B is _, A) :-
|
|
\+lookup_eq(A, B, _).
|
|
simple_guard((A, C), B) :-
|
|
simple_guard(A, B),
|
|
simple_guard(C, B).
|
|
simple_guard(\+A, B) :-
|
|
simple_guard(A, B).
|
|
my_term_copy(A, B, C) :-
|
|
my_term_copy(A, B, _, C).
|
|
my_term_copy(A, B, D, C) :-
|
|
( var(A)
|
|
-> ( lookup_eq(B, A, C)
|
|
-> D=B
|
|
; D=[A-C|B]
|
|
)
|
|
; functor(A, E, F),
|
|
functor(C, E, F),
|
|
A=..[_|G],
|
|
C=..[_|H],
|
|
my_term_copy_list(G, B, D, H)
|
|
).
|
|
my_term_copy_list([], A, A, []).
|
|
my_term_copy_list([A|D], B, F, [C|G]) :-
|
|
my_term_copy(A, B, E, C),
|
|
my_term_copy_list(D, E, F, G).
|
|
gen_cond_susp_detachment(B, A, C) :-
|
|
( is_attached(A)
|
|
-> gen_uncond_susp_detachment(B, A, D),
|
|
C= (var(B)->true;D)
|
|
; C=true
|
|
).
|
|
gen_uncond_susp_detachment(D, A/B, F) :-
|
|
( is_attached(A/B)
|
|
-> atom_concat_list([detach_, A, /, B], C),
|
|
H=..[C, G, D],
|
|
( chr_pp_flag(debugable, on)
|
|
-> E='chr debug_event'(remove(D))
|
|
; E=true
|
|
),
|
|
F= (E, 'chr remove_constraint_internal'(D, G), H)
|
|
; F=true
|
|
).
|
|
gen_uncond_susps_detachments([], [], true).
|
|
gen_uncond_susps_detachments([B|F], [A|G], (E, H)) :-
|
|
functor(A, C, D),
|
|
gen_uncond_susp_detachment(B, C/D, E),
|
|
gen_uncond_susps_detachments(F, G, H).
|
|
simpagation_head1_code(C, I, K, A, F/D, G, L1, N1) :-
|
|
A=pragma(B, ids(_, L), Q, _),
|
|
B=rule(_, J, A1, B1),
|
|
head_info(C, D, _, Z, H, E),
|
|
head_arg_matches(E, [], X, R),
|
|
build_head(F, D, G, H, W),
|
|
append(I, J, M),
|
|
append(K, L, N),
|
|
reorder_heads(C, M, N, O, P),
|
|
rest_heads_retrieval_and_matching(O, P, Q, C, U, S, R, T),
|
|
split_by_ids(P, S, K, Y, C1),
|
|
guard_body_copies2(B, T, V, K1),
|
|
guard_via_reschedule(U, V, W-X, H1),
|
|
gen_uncond_susps_detachments(Y, I, I1),
|
|
gen_cond_susp_detachment(Z, F/D, J1),
|
|
( chr_pp_flag(debugable, on)
|
|
-> my_term_copy(A1-B1, T, _, D1-E1),
|
|
F1='chr debug_event'(try([Z|Y], C1, D1, E1)),
|
|
G1='chr debug_event'(apply([Z|Y], C1, D1, E1))
|
|
; F1=true,
|
|
G1=true
|
|
),
|
|
M1= (W:-X, H1, F1, !, G1, I1, J1, K1),
|
|
L1=[M1|N1].
|
|
split_by_ids([], [], _, [], []).
|
|
split_by_ids([A|H], [D|I], B, C, E) :-
|
|
( memberchk_eq(A, B)
|
|
-> C=[D|F],
|
|
E=G
|
|
; C=F,
|
|
E=[D|G]
|
|
),
|
|
split_by_ids(H, I, B, F, G).
|
|
simpagation_head2_code(C, G, P, A, J, K, L, T) :-
|
|
A=pragma(B, ids(E, _), Q, _),
|
|
B=rule(D, _, H, I),
|
|
reorder_heads(C, D, E, [F|N], [M|O]),
|
|
simpagation_head2_prelude(C, F, [G, D, H, I], J, K, L, S),
|
|
extend_id(K, R),
|
|
simpagation_head2_worker(C, F, M, N, O, G, P, B, Q, J, R, S, T).
|
|
simpagation_head2_prelude(A, G, T, C/B, D, B1, D1) :-
|
|
head_info(A, B, Q, R, E, F),
|
|
build_head(C, B, D, E, X),
|
|
head_arg_matches(F, [], Y, H),
|
|
passive_head_via(G, [A], [], H, Z, K, I),
|
|
instantiate_pattern_goals(I),
|
|
get_max_constraint_index(J),
|
|
( J==1
|
|
-> P=K
|
|
; functor(G, L, M),
|
|
get_constraint_index(L/M, N),
|
|
make_attr(J, _, O, K),
|
|
nth1(N, O, P)
|
|
),
|
|
( D==[0]
|
|
-> gen_cond_allocation(Q, R, C/B, E, S)
|
|
; S=true
|
|
),
|
|
extend_id(D, V),
|
|
extra_active_delegate_variables(A, T, H, U),
|
|
append([P|E], U, W),
|
|
build_head(C, B, V, W, A1),
|
|
C1= (X:-Y, Z, !, S, A1),
|
|
B1=[C1|D1].
|
|
extra_active_delegate_variables(A, B, C, E) :-
|
|
A=..[_|D],
|
|
delegate_variables(A, B, C, D, E).
|
|
passive_delegate_variables(B, A, C, D, F) :-
|
|
term_variables(A, E),
|
|
delegate_variables(B, C, D, E, F).
|
|
delegate_variables(A, B, H, F, I) :-
|
|
term_variables(A, C),
|
|
term_variables(B, D),
|
|
intersect_eq(C, D, E),
|
|
list_difference_eq(E, F, G),
|
|
translate(G, H, I).
|
|
simpagation_head2_worker(B, C, K, D, L, E, M, A, N, H, I, J, P) :-
|
|
A=rule(_, _, F, G),
|
|
simpagation_head2_worker_end(B, [C, D, E, F, G], H, I, J, O),
|
|
simpagation_head2_worker_body(B, C, K, D, L, E, M, A, N, H, I, O, P).
|
|
simpagation_head2_worker_body(A, E, C2, F, X, G, Y, D, D1, O/B, P, H2, I2) :-
|
|
gen_var(K),
|
|
gen_var(L),
|
|
head_info(A, B, _, R1, M, C),
|
|
head_arg_matches(C, [], _, J),
|
|
D=rule(_, _, H, I),
|
|
extra_active_delegate_variables(A, [E, F, G, H, I], J, N),
|
|
append([[K|L]|M], N, Q),
|
|
build_head(O, B, P, Q, N1),
|
|
functor(E, _, R),
|
|
head_info(E, R, T, _, _, S),
|
|
head_arg_matches(S, J, P1, E1),
|
|
V=..[suspension, _, U, _, _, _, _|T],
|
|
create_get_mutable_ref(active, U, W),
|
|
O1= (K=V, W),
|
|
( ( F\==[]
|
|
; G\==[]
|
|
)
|
|
-> append(F, G, Z),
|
|
append(X, Y, A1),
|
|
reorder_heads(E-A, Z, A1, B1, C1),
|
|
rest_heads_retrieval_and_matching(B1, C1, D1, [E, A], G1, F1, E1, J1, [E], [K], []),
|
|
split_by_ids(C1, F1, X, H1, I1)
|
|
; G1=[],
|
|
H1=[],
|
|
I1=[],
|
|
J1=E1
|
|
),
|
|
gen_uncond_susps_detachments([K|H1], [E|F], F2),
|
|
append([L|M], N, K1),
|
|
build_head(O, B, P, K1, S1),
|
|
append([[]|M], N, L1),
|
|
build_head(O, B, P, L1, U1),
|
|
guard_body_copies2(D, J1, M1, Q1),
|
|
guard_via_reschedule(G1, M1, v(N1, O1, P1), E2),
|
|
( Q1\==true
|
|
-> gen_uncond_attach_goal(O/B, R1, V1, T1),
|
|
gen_state_cond_call(R1, B, S1, T1, W1),
|
|
gen_state_cond_call(R1, B, U1, T1, X1)
|
|
; V1=true,
|
|
W1=S1,
|
|
X1=U1
|
|
),
|
|
( chr_pp_flag(debugable, on)
|
|
-> my_term_copy(H-I, J1, _, Y1-Z1),
|
|
A2='chr debug_event'(try([K|H1], [R1|I1], Y1, Z1)),
|
|
B2='chr debug_event'(apply([K|H1], [R1|I1], Y1, Z1))
|
|
; A2=true,
|
|
B2=true
|
|
),
|
|
( member(unique(C2, D2), D1),
|
|
check_unique_keys(D2, J)
|
|
-> G2= (N1:-O1, P1-> (E2, A2->B2, F2, V1, Q1, X1;U1);S1)
|
|
; G2= (N1:-O1, P1, E2, A2->B2, F2, V1, Q1, W1;S1)
|
|
),
|
|
H2=[G2|I2].
|
|
gen_state_cond_call(G, A, K, D, F) :-
|
|
length(B, A),
|
|
H=..[suspension, _, C, _, E, _, _|B],
|
|
create_get_mutable_ref(active, C, I),
|
|
create_get_mutable_ref(D, E, J),
|
|
F= (G=H, I, J->'chr update_mutable'(inactive, C), K;true).
|
|
simpagation_head2_worker_end(A, D, H/B, I, N, P) :-
|
|
head_info(A, B, _, _, F, C),
|
|
head_arg_matches(C, [], _, E),
|
|
extra_active_delegate_variables(A, D, E, G),
|
|
append([[]|F], G, J),
|
|
build_head(H, B, I, J, L),
|
|
next_id(I, K),
|
|
build_head(H, B, K, F, M),
|
|
O= (L:-M),
|
|
N=[O|P].
|
|
propagation_code(B, A, C, D, I, E, F, G, H) :-
|
|
( A==[]
|
|
-> propagation_single_headed(B, C, D, E, F, G, H)
|
|
; propagation_multi_headed(B, A, C, D, I, E, F, G, H)
|
|
).
|
|
propagation_single_headed(A, I, Y, C/B, D, D1, F1) :-
|
|
head_info(A, B, K, L, E, H),
|
|
build_head(C, B, D, E, W),
|
|
inc_id(D, F),
|
|
build_head(C, B, F, E, G),
|
|
O=G,
|
|
head_arg_matches(H, [], X, J),
|
|
guard_body_copies(I, J, Z, B1),
|
|
( D==[0]
|
|
-> gen_cond_allocation(K, L, C/B, E, M),
|
|
N=M
|
|
; N=true
|
|
),
|
|
gen_uncond_attach_goal(C/B, L, A1, P),
|
|
gen_state_cond_call(L, B, O, P, C1),
|
|
( chr_pp_flag(debugable, on)
|
|
-> I=rule(_, _, Q, R),
|
|
my_term_copy(Q-R, J, _, S-T),
|
|
U='chr debug_event'(try([], [L], S, T)),
|
|
V='chr debug_event'(apply([], [L], S, T))
|
|
; U=true,
|
|
V=true
|
|
),
|
|
E1= (W:-X, N, 'chr novel_production'(L, Y), Z, U, !, V, 'chr extend_history'(L, Y), A1, B1, C1),
|
|
D1=[E1|F1].
|
|
propagation_multi_headed(B, A, C, I, J, D, E, F, M) :-
|
|
A=[H|G],
|
|
propagation_prelude(B, A, C, D, E, F, L),
|
|
extend_id(E, K),
|
|
propagation_nested_code(G, [H, B], C, I, J, D, K, L, M).
|
|
propagation_prelude(A, [H|I], G, C/B, D, F1, H1) :-
|
|
head_info(A, B, U, V, E, F),
|
|
build_head(C, B, D, E, B1),
|
|
head_arg_matches(F, [], C1, L),
|
|
G=rule(_, _, J, K),
|
|
extra_active_delegate_variables(A, [H, I, J, K], L, X),
|
|
passive_head_via(H, [A], [], L, D1, O, M),
|
|
instantiate_pattern_goals(M),
|
|
get_max_constraint_index(N),
|
|
( N==1
|
|
-> T=O
|
|
; functor(H, P, Q),
|
|
make_attr(N, _, S, O),
|
|
get_constraint_index(P/Q, R),
|
|
nth1(R, S, T)
|
|
),
|
|
( D==[0]
|
|
-> gen_cond_allocation(U, V, C/B, E, W)
|
|
; W=true
|
|
),
|
|
extend_id(D, Y),
|
|
append([T|E], X, Z),
|
|
build_head(C, B, Y, Z, A1),
|
|
E1=A1,
|
|
G1= (B1:-C1, D1, !, W, E1),
|
|
F1=[G1|H1].
|
|
propagation_nested_code([], [A|B], C, G, H, D, E, F, J) :-
|
|
propagation_end([A|B], [], C, D, E, F, I),
|
|
propagation_body(A, B, C, G, H, D, E, I, J).
|
|
propagation_nested_code([B|C], A, D, I, J, E, F, G, M) :-
|
|
propagation_end(A, [B|C], D, E, F, G, H),
|
|
propagation_accumulator([B|C], A, D, E, F, H, L),
|
|
inc_id(F, K),
|
|
propagation_nested_code(C, [B|A], D, I, J, E, K, L, M).
|
|
propagation_body(C, B, A, G1, B1, N/O, P, W1, Y1) :-
|
|
A=rule(_, _, D, E),
|
|
get_prop_inner_loop_vars(B, [C, D, E], M, V, Y, W),
|
|
gen_var(I),
|
|
gen_var(L),
|
|
functor(C, _, F),
|
|
gen_vars(F, G),
|
|
J=..[suspension, _, H, _, _, _, _|G],
|
|
create_get_mutable_ref(active, H, K),
|
|
M1= (I=J, K),
|
|
Q=[[I|L]|M],
|
|
build_head(N, O, P, Q, L1),
|
|
R=[L|M],
|
|
build_head(N, O, P, R, S),
|
|
Z=S,
|
|
C=..[_|T],
|
|
pairup(T, G, U),
|
|
head_arg_matches(U, V, O1, X),
|
|
different_from_other_susps(C, I, B, W, N1),
|
|
guard_body_copies(A, X, S1, U1),
|
|
gen_uncond_attach_goal(N/O, Y, T1, A1),
|
|
gen_state_cond_call(Y, O, Z, A1, V1),
|
|
history_susps(B1, [I|W], Y, [], D1),
|
|
bagof('chr novel_production'(C1, E1), (member(C1, D1), E1=P1), F1),
|
|
list2conj(F1, R1),
|
|
Q1=..[t, G1|D1],
|
|
( chr_pp_flag(debugable, on)
|
|
-> A=rule(_, _, D, E),
|
|
my_term_copy(D-E, X, _, H1-I1),
|
|
J1='chr debug_event'(try([], [Y, I|W], H1, I1)),
|
|
K1='chr debug_event'(apply([], [Y, I|W], H1, I1))
|
|
; J1=true,
|
|
K1=true
|
|
),
|
|
X1= (L1:-M1, N1, O1, P1=Q1, R1, S1, J1->K1, 'chr extend_history'(Y, P1), T1, U1, V1;Z),
|
|
W1=[X1|Y1].
|
|
history_susps(A, B, D, E, F) :-
|
|
( A==0
|
|
-> reverse(B, C),
|
|
append(C, [D|E], F)
|
|
; B=[I|H],
|
|
G is A-1,
|
|
history_susps(G, H, D, [I|E], F)
|
|
).
|
|
get_prop_inner_loop_vars([A], F, I, E, C, []) :- !,
|
|
functor(A, _, B),
|
|
head_info(A, B, _, C, G, D),
|
|
head_arg_matches(D, [], _, E),
|
|
extra_active_delegate_variables(A, F, E, H),
|
|
append(G, H, I).
|
|
get_prop_inner_loop_vars([B|A], C, N, J, D, [G|E]) :-
|
|
get_prop_inner_loop_vars(A, [B|C], M, I, D, E),
|
|
functor(B, _, F),
|
|
gen_var(L),
|
|
head_info(B, F, _, G, _, H),
|
|
head_arg_matches(H, I, _, J),
|
|
passive_delegate_variables(B, A, C, J, K),
|
|
append(K, [G, L|M], N).
|
|
propagation_end([C|B], D, A, H/I, J, S, U) :-
|
|
A=rule(_, _, E, F),
|
|
gen_var_susp_list_for(B, [C, D, E, F], _, G, L, O),
|
|
K=[[]|G],
|
|
build_head(H, I, J, K, Q),
|
|
( J=[0|_]
|
|
-> next_id(J, M),
|
|
N=L
|
|
; dec_id(J, M),
|
|
N=[O|L]
|
|
),
|
|
build_head(H, I, M, N, P),
|
|
R=P,
|
|
T= (Q:-R),
|
|
S=[T|U].
|
|
gen_var_susp_list_for([A], G, F, I, D, C) :- !,
|
|
functor(A, _, B),
|
|
head_info(A, B, _, C, D, E),
|
|
head_arg_matches(E, [], _, F),
|
|
extra_active_delegate_variables(A, G, F, H),
|
|
append(D, H, I).
|
|
gen_var_susp_list_for([B|A], C, I, L, D, E) :-
|
|
gen_var_susp_list_for(A, [B|C], H, D, _, _),
|
|
functor(B, _, F),
|
|
gen_var(E),
|
|
head_info(B, F, _, K, _, G),
|
|
head_arg_matches(G, H, _, I),
|
|
passive_delegate_variables(B, A, C, I, J),
|
|
append(J, [K, E|D], L).
|
|
propagation_accumulator([D|E], [C|B], A, E1/F1, B1, Q1, S1) :-
|
|
A=rule(_, _, F, G),
|
|
pre_vars_and_susps(B, [C, D, E, F, G], D1, K, M),
|
|
gen_var(C1),
|
|
functor(C, _, H),
|
|
gen_vars(H, I),
|
|
head_info(C, H, I, L, _, J),
|
|
head_arg_matches(J, K, R, S),
|
|
O=..[suspension, _, N, _, _, _, _|I],
|
|
different_from_other_susps(C, L, B, M, Q),
|
|
create_get_mutable_ref(active, N, P),
|
|
M1= (L=O, P, Q, R),
|
|
functor(D, W, X),
|
|
passive_head_via(D, [C|B], [], S, N1, V, T),
|
|
instantiate_pattern_goals(T),
|
|
get_max_constraint_index(U),
|
|
( U==1
|
|
-> A1=V
|
|
; get_constraint_index(W/X, Y),
|
|
make_attr(U, _, Z, V),
|
|
nth1(Y, Z, A1)
|
|
),
|
|
inc_id(B1, I1),
|
|
G1=[[L|C1]|D1],
|
|
build_head(E1, F1, B1, G1, L1),
|
|
passive_delegate_variables(C, B, [D, E, F, G], S, H1),
|
|
append([A1|H1], [L, C1|D1], J1),
|
|
build_head(E1, F1, I1, J1, O1),
|
|
K1=[C1|D1],
|
|
build_head(E1, F1, B1, K1, P1),
|
|
R1= (L1:-M1, N1->O1;P1),
|
|
Q1=[R1|S1].
|
|
pre_vars_and_susps([A], E, H, D, []) :- !,
|
|
functor(A, _, B),
|
|
head_info(A, B, _, _, F, C),
|
|
head_arg_matches(C, [], _, D),
|
|
extra_active_delegate_variables(A, E, D, G),
|
|
append(F, G, H).
|
|
pre_vars_and_susps([B|A], C, M, I, [F|D]) :-
|
|
pre_vars_and_susps(A, [B|C], L, H, D),
|
|
functor(B, _, E),
|
|
gen_var(K),
|
|
head_info(B, E, _, F, _, G),
|
|
head_arg_matches(G, H, _, I),
|
|
passive_delegate_variables(B, A, C, I, J),
|
|
append(J, [F, K|L], M).
|
|
reorder_heads(A, B, C, D, E) :-
|
|
( chr_pp_flag(reorder_heads, on)
|
|
-> reorder_heads_main(A, B, C, D, E)
|
|
; D=B,
|
|
E=C
|
|
).
|
|
reorder_heads_main(A, B, C, E, F) :-
|
|
term_variables(A, D),
|
|
reorder_heads1(B, C, D, E, F).
|
|
reorder_heads1(A, D, E, B, C) :-
|
|
( A==[]
|
|
-> B=[],
|
|
C=[]
|
|
; B=[F|K],
|
|
C=[G|L],
|
|
select_best_head(A, D, E, F, G, H, I, J),
|
|
reorder_heads1(H, I, J, K, L)
|
|
).
|
|
select_best_head(C, D, G, J, K, L, M, Q) :-
|
|
( bagof(tuple(H, A, B, E, F), (select2(A, B, C, D, E, F), order_score(A, G, E, H)), I)
|
|
-> true
|
|
; I=[]
|
|
),
|
|
max_go_list(I, tuple(_, J, K, L, M)),
|
|
term_variables(J, O),
|
|
( setof(N, (member(N, O), \+memberchk_eq(N, G)), P)
|
|
-> true
|
|
; P=[]
|
|
),
|
|
append(P, G, Q).
|
|
reorder_heads(A, B, D) :-
|
|
term_variables(A, C),
|
|
reorder_heads1(B, C, D).
|
|
reorder_heads1(A, C, B) :-
|
|
( A==[]
|
|
-> B=[]
|
|
; B=[D|G],
|
|
select_best_head(A, C, D, E, F),
|
|
reorder_heads1(E, F, G)
|
|
).
|
|
select_best_head(B, D, G, H, L) :-
|
|
( bagof(tuple(E, A, C), (select(A, B, C), order_score(A, D, C, E)), F)
|
|
-> true
|
|
; F=[]
|
|
),
|
|
max_go_list(F, tuple(_, G, H)),
|
|
term_variables(G, J),
|
|
( setof(I, (member(I, J), \+memberchk_eq(I, D)), K)
|
|
-> true
|
|
; K=[]
|
|
),
|
|
append(K, D, L).
|
|
order_score(A, D, B, F) :-
|
|
term_variables(A, C),
|
|
term_variables(B, E),
|
|
order_score_vars(C, D, E, 0, F).
|
|
order_score_vars([], _, _, A, B) :-
|
|
( A==0
|
|
-> B=99999
|
|
; B=A
|
|
).
|
|
order_score_vars([A|F], B, D, C, G) :-
|
|
( memberchk_eq(A, B)
|
|
-> E is C+1
|
|
; memberchk_eq(A, D)
|
|
-> E is C+1
|
|
; E=C
|
|
),
|
|
order_score_vars(F, B, D, E, G).
|
|
create_get_mutable_ref(C, B, A) :-
|
|
A= (B=mutable(C)).
|
|
clean_clauses([], []).
|
|
clean_clauses([A|C], [B|D]) :-
|
|
clean_clause(A, B),
|
|
clean_clauses(C, D).
|
|
clean_clause(A, D) :-
|
|
( A= (E:-B)
|
|
-> clean_goal(B, C),
|
|
( C==true
|
|
-> D=E
|
|
; D= (E:-C)
|
|
)
|
|
; D=A
|
|
).
|
|
clean_goal(A, B) :-
|
|
var(A), !,
|
|
B=A.
|
|
clean_goal((A, B), D) :- !,
|
|
clean_goal(A, C),
|
|
clean_goal(B, E),
|
|
( C==true
|
|
-> D=E
|
|
; E==true
|
|
-> D=C
|
|
; D= (C, E)
|
|
).
|
|
clean_goal((A->C;F), D) :- !,
|
|
clean_goal(A, B),
|
|
( B==true
|
|
-> clean_goal(C, E),
|
|
D=E
|
|
; B==fail
|
|
-> clean_goal(F, G),
|
|
D=G
|
|
; clean_goal(C, E),
|
|
clean_goal(F, G),
|
|
D= (B->E;G)
|
|
).
|
|
clean_goal((A;B), D) :- !,
|
|
clean_goal(A, C),
|
|
clean_goal(B, E),
|
|
( C==fail
|
|
-> D=E
|
|
; E==fail
|
|
-> D=C
|
|
; D= (C;E)
|
|
).
|
|
clean_goal(once(A), C) :- !,
|
|
clean_goal(A, B),
|
|
( B==true
|
|
-> C=true
|
|
; B==fail
|
|
-> C=fail
|
|
; C=once(B)
|
|
).
|
|
clean_goal((A->C), D) :- !,
|
|
clean_goal(A, B),
|
|
( B==true
|
|
-> clean_goal(C, D)
|
|
; B==fail
|
|
-> D=fail
|
|
; clean_goal(C, E),
|
|
D= (B->E)
|
|
).
|
|
clean_goal(A, A).
|
|
gen_var(_).
|
|
gen_vars(B, A) :-
|
|
length(A, B).
|
|
head_info(E, A, B, C, D, G) :-
|
|
vars_susp(A, B, C, D),
|
|
E=..[_|F],
|
|
pairup(F, B, G).
|
|
inc_id([C|A], [B|A]) :-
|
|
B is C+1.
|
|
dec_id([C|A], [B|A]) :-
|
|
B is C-1.
|
|
extend_id(A, [0|A]).
|
|
next_id([_, C|A], [B|A]) :-
|
|
B is C+1.
|
|
build_head(A, B, C, F, D) :-
|
|
buildName(A, B, C, E),
|
|
D=..[E|F].
|
|
buildName(A, C, D, F) :-
|
|
atom_concat(A, /, B),
|
|
atomic_concat(B, C, E),
|
|
buildName_(D, E, F).
|
|
buildName_([], A, A).
|
|
buildName_([E|A], B, F) :-
|
|
buildName_(A, B, C),
|
|
atom_concat(C, '__', D),
|
|
atomic_concat(D, E, F).
|
|
vars_susp(B, A, C, D) :-
|
|
length(A, B),
|
|
append(A, [C], D).
|
|
make_attr(B, D, A, C) :-
|
|
length(A, B),
|
|
C=..[v, D|A].
|
|
or_pattern(A, B) :-
|
|
C is A-1,
|
|
B is 1<<C.
|
|
and_pattern(A, C) :-
|
|
B is A-1,
|
|
D is 1<<B,
|
|
C is-1* (D+1).
|
|
conj2list(A, B) :-
|
|
conj2list(A, B, []).
|
|
conj2list(A, C, F) :-
|
|
A= (B, D), !,
|
|
conj2list(B, C, E),
|
|
conj2list(D, E, F).
|
|
conj2list(A, [A|B], B).
|
|
list2conj([], true).
|
|
list2conj([B], A) :- !,
|
|
A=B.
|
|
list2conj([A|B], C) :-
|
|
( A==true
|
|
-> list2conj(B, C)
|
|
; C= (A, D),
|
|
list2conj(B, D)
|
|
).
|
|
atom_concat_list([A], A) :- !.
|
|
atom_concat_list([B|A], D) :-
|
|
atom_concat_list(A, C),
|
|
atomic_concat(B, C, D).
|
|
make_atom(A, B) :-
|
|
( atom(A)
|
|
-> B=A
|
|
; number(A)
|
|
-> number_codes(A, C),
|
|
atom_codes(B, C)
|
|
).
|
|
set_elems([], _).
|
|
set_elems([A|B], A) :-
|
|
set_elems(B, A).
|
|
member2([A|_], [B|_], A-B).
|
|
member2([_|A], [_|B], C) :-
|
|
member2(A, B, C).
|
|
select2(A, B, [A|C], [B|D], C, D).
|
|
select2(C, D, [A|E], [B|F], [A|G], [B|H]) :-
|
|
select2(C, D, E, F, G, H).
|
|
pair_all_with([], _, []).
|
|
pair_all_with([A|C], B, [A-B|D]) :-
|
|
pair_all_with(C, B, D).
|
|
verbosity_on :-
|
|
prolog_flag(verbose, A),
|
|
A==yes.
|
|
'attach_constraint/2'([], _).
|
|
'attach_constraint/2'([A|L], D) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, E, F, G, H, I, J),
|
|
( C/\1=:=1
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, [D|E], F, G, H, I, J))
|
|
; K is C\/1,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, [D], F, G, H, I, J))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(1, [D], [], [], [], [], []))
|
|
),
|
|
'attach_constraint/2'(L, D).
|
|
'detach_constraint/2'([], _).
|
|
'detach_constraint/2'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, H, I, J, K, L),
|
|
( C/\1=:=1
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -2,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, [], H, I, J, K, L))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, F, H, I, J, K, L))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_constraint/2'(M, E).
|
|
'attach_constraint_count/1'([], _).
|
|
'attach_constraint_count/1'([A|L], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, F, G, H, I, J),
|
|
( C/\2=:=2
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, D, [E|F], G, H, I, J))
|
|
; K is C\/2,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, D, [E], G, H, I, J))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(2, [], [E], [], [], [], []))
|
|
),
|
|
'attach_constraint_count/1'(L, E).
|
|
'detach_constraint_count/1'([], _).
|
|
'detach_constraint_count/1'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, H, D, I, J, K, L),
|
|
( C/\2=:=2
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -3,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, H, [], I, J, K, L))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, H, F, I, J, K, L))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_constraint_count/1'(M, E).
|
|
'attach_constraint_index/2'([], _).
|
|
'attach_constraint_index/2'([A|L], F) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, E, G, H, I, J),
|
|
( C/\4=:=4
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, D, E, [F|G], H, I, J))
|
|
; K is C\/4,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, D, E, [F], H, I, J))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(4, [], [], [F], [], [], []))
|
|
),
|
|
'attach_constraint_index/2'(L, F).
|
|
'detach_constraint_index/2'([], _).
|
|
'detach_constraint_index/2'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, H, I, D, J, K, L),
|
|
( C/\4=:=4
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -5,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, H, I, [], J, K, L))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, H, I, F, J, K, L))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_constraint_index/2'(M, E).
|
|
'attach_max_constraint_index/1'([], _).
|
|
'attach_max_constraint_index/1'([A|L], G) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, E, F, H, I, J),
|
|
( C/\8=:=8
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, D, E, F, [G|H], I, J))
|
|
; K is C\/8,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, D, E, F, [G], I, J))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(8, [], [], [], [G], [], []))
|
|
),
|
|
'attach_max_constraint_index/1'(L, G).
|
|
'detach_max_constraint_index/1'([], _).
|
|
'detach_max_constraint_index/1'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, H, I, J, D, K, L),
|
|
( C/\8=:=8
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -9,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, H, I, J, [], K, L))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, H, I, J, F, K, L))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_max_constraint_index/1'(M, E).
|
|
'attach_target_module/1'([], _).
|
|
'attach_target_module/1'([A|L], H) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, E, F, G, I, J),
|
|
( C/\16=:=16
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, D, E, F, G, [H|I], J))
|
|
; K is C\/16,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, D, E, F, G, [H], J))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(16, [], [], [], [], [H], []))
|
|
),
|
|
'attach_target_module/1'(L, H).
|
|
'detach_target_module/1'([], _).
|
|
'detach_target_module/1'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, H, I, J, K, D, L),
|
|
( C/\16=:=16
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -17,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, H, I, J, K, [], L))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, H, I, J, K, F, L))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_target_module/1'(M, E).
|
|
'attach_attached/2'([], _).
|
|
'attach_attached/2'([A|L], I) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, D, E, F, G, H, J),
|
|
( C/\32=:=32
|
|
-> put_attr(A, chr_translate_bootstrap1, v(C, D, E, F, G, H, [I|J]))
|
|
; K is C\/32,
|
|
put_attr(A, chr_translate_bootstrap1, v(K, D, E, F, G, H, [I]))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(32, [], [], [], [], [], [I]))
|
|
),
|
|
'attach_attached/2'(L, I).
|
|
'detach_attached/2'([], _).
|
|
'detach_attached/2'([A|M], E) :-
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(C, H, I, J, K, L, D),
|
|
( C/\32=:=32
|
|
-> 'chr sbag_del_element'(D, E, F),
|
|
( F==[]
|
|
-> G is C/\ -33,
|
|
( G==0
|
|
-> del_attr(A, chr_translate_bootstrap1)
|
|
; put_attr(A, chr_translate_bootstrap1, v(G, H, I, J, K, L, []))
|
|
)
|
|
; put_attr(A, chr_translate_bootstrap1, v(C, H, I, J, K, L, F))
|
|
)
|
|
; true
|
|
)
|
|
; true
|
|
),
|
|
'detach_attached/2'(M, E).
|
|
attach_increment([], _).
|
|
attach_increment([A|D1], v(U, D, G, J, M, P, S)) :-
|
|
'chr not_locked'(A),
|
|
( get_attr(A, chr_translate_bootstrap1, B)
|
|
-> B=v(V, C, F, I, L, O, R),
|
|
sort(C, E),
|
|
'chr merge_attributes'(D, E, X),
|
|
sort(F, H),
|
|
'chr merge_attributes'(G, H, Y),
|
|
sort(I, K),
|
|
'chr merge_attributes'(J, K, Z),
|
|
sort(L, N),
|
|
'chr merge_attributes'(M, N, A1),
|
|
sort(O, Q),
|
|
'chr merge_attributes'(P, Q, B1),
|
|
sort(R, T),
|
|
'chr merge_attributes'(S, T, C1),
|
|
W is U\/V,
|
|
put_attr(A, chr_translate_bootstrap1, v(W, X, Y, Z, A1, B1, C1))
|
|
; put_attr(A, chr_translate_bootstrap1, v(U, D, G, J, M, P, S))
|
|
),
|
|
attach_increment(D1, v(U, D, G, J, M, P, S)).
|
|
chr_translate_bootstrap1:attr_unify_hook(v(A1, A, B, C, D, E, F), G) :-
|
|
sort(A, J),
|
|
sort(B, M),
|
|
sort(C, P),
|
|
sort(D, S),
|
|
sort(E, V),
|
|
sort(F, Y),
|
|
( var(G)
|
|
-> ( get_attr(G, chr_translate_bootstrap1, H)
|
|
-> H=v(B1, I, L, O, R, U, X),
|
|
sort(I, K),
|
|
'chr merge_attributes'(J, K, D1),
|
|
sort(L, N),
|
|
'chr merge_attributes'(M, N, E1),
|
|
sort(O, Q),
|
|
'chr merge_attributes'(P, Q, F1),
|
|
sort(R, T),
|
|
'chr merge_attributes'(S, T, G1),
|
|
sort(U, W),
|
|
'chr merge_attributes'(V, W, H1),
|
|
sort(X, Z),
|
|
'chr merge_attributes'(Y, Z, I1),
|
|
C1 is A1\/B1,
|
|
put_attr(G, chr_translate_bootstrap1, v(C1, D1, E1, F1, G1, H1, I1)),
|
|
'chr run_suspensions_loop'([D1, E1, F1, G1, H1, I1])
|
|
; put_attr(G, chr_translate_bootstrap1, v(A1, J, M, P, S, V, Y)),
|
|
'chr run_suspensions_loop'([J, M, P, S, V, Y])
|
|
)
|
|
; ( compound(G)
|
|
-> term_variables(G, J1),
|
|
attach_increment(J1, v(A1, J, M, P, S, V, Y))
|
|
; true
|
|
),
|
|
'chr run_suspensions_loop'([J, M, P, S, V, Y])
|
|
).
|
|
constraint(A, B) :-
|
|
'constraint/2__0'(A, B, _).
|
|
'constraint/2__0'(A, K, I) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, E, _, _, _, _, _),
|
|
D/\1=:=1,
|
|
( 'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, H, L),
|
|
G=mutable(active),
|
|
H==A
|
|
-> true
|
|
), !,
|
|
( var(I)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(I, J),
|
|
'detach_constraint/2'(J, I)
|
|
),
|
|
K=L.
|
|
'constraint/2__0'(K, A, I) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, E, _, _, _, _, _),
|
|
D/\1=:=1,
|
|
'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, L, H),
|
|
G=mutable(active),
|
|
H==A, !,
|
|
( var(I)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(I, J),
|
|
'detach_constraint/2'(J, I)
|
|
),
|
|
K=L.
|
|
'constraint/2__0'(B, C, A) :-
|
|
( var(A)
|
|
-> 'chr insert_constraint_internal'(D, A, chr_translate_bootstrap1:'constraint/2__0'(B, C, A), constraint, [B, C])
|
|
; 'chr activate_constraint'(D, A, _)
|
|
),
|
|
'attach_constraint/2'(D, A).
|
|
constraint_count(A) :-
|
|
'constraint_count/1__0'(A, _).
|
|
'constraint_count/1__0'(I, G) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, D, _, _, _, _),
|
|
C/\2=:=2,
|
|
'chr sbag_member'(E, D),
|
|
E=suspension(_, F, _, _, _, _, J),
|
|
F=mutable(active), !,
|
|
( var(G)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(G, H),
|
|
'detach_constraint_count/1'(H, G)
|
|
),
|
|
I=J.
|
|
'constraint_count/1__0'(B, A) :-
|
|
( var(A)
|
|
-> 'chr insert_constraint_internal'(C, A, chr_translate_bootstrap1:'constraint_count/1__0'(B, A), constraint_count, [B])
|
|
; 'chr activate_constraint'(C, A, _)
|
|
),
|
|
'attach_constraint_count/1'(C, A).
|
|
constraint_index(A, B) :-
|
|
'constraint_index/2__0'(A, B, _).
|
|
'constraint_index/2__0'(B, C, A) :-
|
|
( var(A)
|
|
-> 'chr insert_constraint_internal'(D, A, chr_translate_bootstrap1:'constraint_index/2__0'(B, C, A), constraint_index, [B, C])
|
|
; 'chr activate_constraint'(D, A, _)
|
|
),
|
|
'attach_constraint_index/2'(D, A).
|
|
get_constraint_index(A, B) :-
|
|
'get_constraint_index/2__0'(A, B, _).
|
|
'get_constraint_index/2__0'(A, I, _) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, _, _, E, _, _, _),
|
|
D/\4=:=4,
|
|
'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, H, J),
|
|
G=mutable(active),
|
|
H==A, !,
|
|
I=J.
|
|
'get_constraint_index/2__0'(_, _, _) :- !,
|
|
fail.
|
|
max_constraint_index(A) :-
|
|
'max_constraint_index/1__0'(A, _).
|
|
'max_constraint_index/1__0'(B, A) :-
|
|
( var(A)
|
|
-> 'chr insert_constraint_internal'(C, A, chr_translate_bootstrap1:'max_constraint_index/1__0'(B, A), max_constraint_index, [B])
|
|
; 'chr activate_constraint'(C, A, _)
|
|
),
|
|
'attach_max_constraint_index/1'(C, A).
|
|
get_max_constraint_index(A) :-
|
|
'get_max_constraint_index/1__0'(A, _).
|
|
'get_max_constraint_index/1__0'(G, _) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, _, D, _, _),
|
|
C/\8=:=8,
|
|
'chr sbag_member'(E, D),
|
|
E=suspension(_, F, _, _, _, _, H),
|
|
F=mutable(active), !,
|
|
G=H.
|
|
'get_max_constraint_index/1__0'(_, _) :- !,
|
|
fail.
|
|
target_module(A) :-
|
|
'target_module/1__0'(A, _).
|
|
'target_module/1__0'(B, A) :-
|
|
( var(A)
|
|
-> 'chr insert_constraint_internal'(C, A, chr_translate_bootstrap1:'target_module/1__0'(B, A), target_module, [B])
|
|
; 'chr activate_constraint'(C, A, _)
|
|
),
|
|
'attach_target_module/1'(C, A).
|
|
get_target_module(A) :-
|
|
'get_target_module/1__0'(A, _).
|
|
'get_target_module/1__0'(G, _) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, _, _, D, _),
|
|
C/\16=:=16,
|
|
'chr sbag_member'(E, D),
|
|
E=suspension(_, F, _, _, _, _, H),
|
|
F=mutable(active), !,
|
|
G=H.
|
|
'get_target_module/1__0'(A, _) :- !,
|
|
A=user.
|
|
attached(A, B) :-
|
|
'attached/2__0'(A, B, _).
|
|
'attached/2__0'(A, _, J) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, _, _, _, _, _, E),
|
|
D/\32=:=32,
|
|
'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, H, I),
|
|
G=mutable(active),
|
|
H==A,
|
|
I==yes, !,
|
|
( var(J)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(J, K),
|
|
'detach_attached/2'(K, J)
|
|
).
|
|
'attached/2__0'(B, A, F) :-
|
|
A==yes,
|
|
'chr via_1'(B, C),
|
|
get_attr(C, chr_translate_bootstrap1, D),
|
|
D=v(E, _, _, _, _, _, G),
|
|
E/\32=:=32, !,
|
|
( var(F)
|
|
-> 'chr allocate_constraint'(chr_translate_bootstrap1:'attached/2__0'(B, A, F), F, attached, [B, A])
|
|
; true
|
|
),
|
|
'attached/2__0__0'(G, B, A, F).
|
|
'attached/2__0__0'([], A, B, C) :-
|
|
'attached/2__1'(A, B, C).
|
|
'attached/2__0__0'([A|F], D, G, H) :-
|
|
( A=suspension(_, B, _, _, _, _, C, _),
|
|
B=mutable(active),
|
|
C==D
|
|
-> 'chr remove_constraint_internal'(A, E),
|
|
'detach_attached/2'(E, A),
|
|
'attached/2__0__0'(F, D, G, H)
|
|
; 'attached/2__0__0'(F, D, G, H)
|
|
).
|
|
'attached/2__0'(B, C, A) :-
|
|
( var(A)
|
|
-> 'chr allocate_constraint'(chr_translate_bootstrap1:'attached/2__0'(B, C, A), A, attached, [B, C])
|
|
; true
|
|
),
|
|
'attached/2__1'(B, C, A).
|
|
'attached/2__1'(A, _, J) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, _, _, _, _, _, E),
|
|
D/\32=:=32,
|
|
'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, H, I),
|
|
G=mutable(active),
|
|
H==A,
|
|
I==no, !,
|
|
( var(J)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(J, K),
|
|
'detach_attached/2'(K, J)
|
|
).
|
|
'attached/2__1'(B, A, G) :-
|
|
A==no,
|
|
'chr via_1'(B, C),
|
|
get_attr(C, chr_translate_bootstrap1, D),
|
|
D=v(E, _, _, _, _, _, F),
|
|
E/\32=:=32, !,
|
|
'attached/2__1__0'(F, B, A, G).
|
|
'attached/2__1__0'([], A, B, C) :-
|
|
'attached/2__2'(A, B, C).
|
|
'attached/2__1__0'([A|F], D, G, H) :-
|
|
( A=suspension(_, B, _, _, _, _, C, _),
|
|
B=mutable(active),
|
|
C==D
|
|
-> 'chr remove_constraint_internal'(A, E),
|
|
'detach_attached/2'(E, A),
|
|
'attached/2__1__0'(F, D, G, H)
|
|
; 'attached/2__1__0'(F, D, G, H)
|
|
).
|
|
'attached/2__1'(A, B, C) :-
|
|
'attached/2__2'(A, B, C).
|
|
'attached/2__2'(B, A, K) :-
|
|
A==maybe,
|
|
'chr via_1'(B, C),
|
|
get_attr(C, chr_translate_bootstrap1, D),
|
|
D=v(E, _, _, _, _, _, F),
|
|
E/\32=:=32,
|
|
( 'chr sbag_member'(G, F),
|
|
G=suspension(_, H, _, _, _, _, I, J),
|
|
H=mutable(active),
|
|
I==B,
|
|
J==maybe
|
|
-> true
|
|
), !,
|
|
( var(K)
|
|
-> true
|
|
; 'chr remove_constraint_internal'(K, L),
|
|
'detach_attached/2'(L, K)
|
|
).
|
|
'attached/2__2'(_, _, A) :-
|
|
'chr activate_constraint'(B, A, _),
|
|
'attach_attached/2'(B, A).
|
|
is_attached(A) :-
|
|
'is_attached/1__0'(A, _).
|
|
'is_attached/1__0'(A, _) :-
|
|
'chr via_1'(A, B),
|
|
get_attr(B, chr_translate_bootstrap1, C),
|
|
C=v(D, _, _, _, _, _, E),
|
|
D/\32=:=32,
|
|
'chr sbag_member'(F, E),
|
|
F=suspension(_, G, _, _, _, _, H, I),
|
|
G=mutable(active),
|
|
H==A, !,
|
|
( I==no
|
|
-> fail
|
|
; true
|
|
).
|
|
'is_attached/1__0'(_, _) :- !.
|
|
chr_clear :-
|
|
'chr_clear/0__0'(_).
|
|
'chr_clear/0__0'(D) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, E, _, _, _, _, _),
|
|
C/\1=:=1, !,
|
|
( var(D)
|
|
-> 'chr allocate_constraint'(chr_translate_bootstrap1:'chr_clear/0__0'(D), D, chr_clear, [])
|
|
; true
|
|
),
|
|
'chr_clear/0__0__0'(E, D).
|
|
'chr_clear/0__0__0'([], A) :-
|
|
'chr_clear/0__1'(A).
|
|
'chr_clear/0__0__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_constraint/2'(C, A),
|
|
'chr_clear/0__0__0'(D, E)
|
|
; 'chr_clear/0__0__0'(D, E)
|
|
).
|
|
'chr_clear/0__0'(A) :-
|
|
( var(A)
|
|
-> 'chr allocate_constraint'(chr_translate_bootstrap1:'chr_clear/0__0'(A), A, chr_clear, [])
|
|
; true
|
|
),
|
|
'chr_clear/0__1'(A).
|
|
'chr_clear/0__1'(E) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, D, _, _, _, _),
|
|
C/\2=:=2, !,
|
|
'chr_clear/0__1__0'(D, E).
|
|
'chr_clear/0__1__0'([], A) :-
|
|
'chr_clear/0__2'(A).
|
|
'chr_clear/0__1__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_constraint_count/1'(C, A),
|
|
'chr_clear/0__1__0'(D, E)
|
|
; 'chr_clear/0__1__0'(D, E)
|
|
).
|
|
'chr_clear/0__1'(A) :-
|
|
'chr_clear/0__2'(A).
|
|
'chr_clear/0__2'(E) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, D, _, _, _),
|
|
C/\4=:=4, !,
|
|
'chr_clear/0__2__0'(D, E).
|
|
'chr_clear/0__2__0'([], A) :-
|
|
'chr_clear/0__3'(A).
|
|
'chr_clear/0__2__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_constraint_index/2'(C, A),
|
|
'chr_clear/0__2__0'(D, E)
|
|
; 'chr_clear/0__2__0'(D, E)
|
|
).
|
|
'chr_clear/0__2'(A) :-
|
|
'chr_clear/0__3'(A).
|
|
'chr_clear/0__3'(E) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, _, D, _, _),
|
|
C/\8=:=8, !,
|
|
'chr_clear/0__3__0'(D, E).
|
|
'chr_clear/0__3__0'([], A) :-
|
|
'chr_clear/0__4'(A).
|
|
'chr_clear/0__3__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_max_constraint_index/1'(C, A),
|
|
'chr_clear/0__3__0'(D, E)
|
|
; 'chr_clear/0__3__0'(D, E)
|
|
).
|
|
'chr_clear/0__3'(A) :-
|
|
'chr_clear/0__4'(A).
|
|
'chr_clear/0__4'(E) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, _, _, D, _),
|
|
C/\16=:=16, !,
|
|
'chr_clear/0__4__0'(D, E).
|
|
'chr_clear/0__4__0'([], A) :-
|
|
'chr_clear/0__5'(A).
|
|
'chr_clear/0__4__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_target_module/1'(C, A),
|
|
'chr_clear/0__4__0'(D, E)
|
|
; 'chr_clear/0__4__0'(D, E)
|
|
).
|
|
'chr_clear/0__4'(A) :-
|
|
'chr_clear/0__5'(A).
|
|
'chr_clear/0__5'(E) :-
|
|
'chr default_store'(A),
|
|
get_attr(A, chr_translate_bootstrap1, B),
|
|
B=v(C, _, _, _, _, _, D),
|
|
C/\32=:=32, !,
|
|
'chr_clear/0__5__0'(D, E).
|
|
'chr_clear/0__5__0'([], A) :-
|
|
'chr_clear/0__6'(A).
|
|
'chr_clear/0__5__0'([A|D], E) :-
|
|
( A=suspension(_, B, _, _, _, _, _, _),
|
|
B=mutable(active)
|
|
-> 'chr remove_constraint_internal'(A, C),
|
|
'detach_attached/2'(C, A),
|
|
'chr_clear/0__5__0'(D, E)
|
|
; 'chr_clear/0__5__0'(D, E)
|
|
).
|
|
'chr_clear/0__5'(A) :-
|
|
'chr_clear/0__6'(A).
|
|
'chr_clear/0__6'(_) :- !.
|