mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-21 12:23:44 +00:00
2725b1a331
Estimated hours taken: 220
Aditi update syntax, type and mode checking.
Change the hlds_goal for constructions in preparation for
structure reuse to avoid making multiple conflicting changes.
compiler/hlds_goal.m:
Merge `higher_order_call' and `class_method_call' into a single
`generic_call' goal type. This also has alternatives for the
various Aditi builtins for which type declarations can't
be written.
Remove the argument types field from higher-order/class method calls.
It wasn't used often, and wasn't updated by optimizations
such as inlining. The types can be obtained from the vartypes
field of the proc_info.
Add a `lambda_eval_method' field to lambda_goals.
Add a field to constructions to identify which RL code fragment should
be used for an top-down Aditi closure.
Add fields to constructions to hold structure reuse information.
This is currently ignored -- the changes to implement structure
reuse will be committed to the alias branch.
This is included here to avoid lots of CVS conflicts caused by
changing the definition of `hlds_goal' twice.
Add a field to `some' goals to specify whether the quantification
can be removed. This is used to make it easier to ensure that
indexes are used for updates.
Add a field to lambda_goals to describe whether the modes were
guessed by the compiler and may need fixing up after typechecking
works out the argument types.
Add predicate `hlds_goal__generic_call_id' to work out a call_id
for a generic call for use in error messages.
compiler/purity.m:
compiler/post_typecheck.m:
Fill in the modes of Aditi builtin calls and closure constructions.
This needs to know which are the `aditi__state' arguments, so
it must be done after typechecking.
compiler/prog_data.m:
Added `:- type sym_name_and_arity ---> sym_name/arity'.
Add a type `lambda_eval_method', which describes how a closure
is to be executed. The alternatives are normal Mercury execution,
bottom-up execution by Aditi and top-down execution by Aditi.
compiler/prog_out.m:
Add predicate `prog_out__write_sym_name_and_arity', which
replaces duplicated inline code in a few places.
compiler/hlds_data.m:
Add a `lambda_eval_method' field to `pred_const' cons_ids and
`pred_closure_tag' cons_tags.
compiler/hlds_pred.m:
Remove type `pred_call_id', replace it with type `simple_call_id',
which combines a `pred_or_func' and a `sym_name_and_arity'.
Add a type `call_id' which describes all the different types of call,
including normal calls, higher-order and class-method calls
and Aditi builtins.
Add `aditi_top_down' to the type `marker'.
Remove `aditi_interface' from type `marker'. Interfacing to
Aditi predicates is now handled by `generic_call' hlds_goals.
Add a type `rl_exprn_id' which identifies a predicate to
be executed top-down by Aditi.
Add a `maybe(rl_exprn_id)' field to type `proc_info'.
Add predicate `adjust_func_arity' to convert between the arity
of a function to its arity as a predicate.
Add predicates `get_state_args' and `get_state_args_det' to
extract the DCG state arguments from an argument list.
Add predicate `pred_info_get_call_id' to get a `simple_call_id'
for a predicate for use in error messages.
compiler/hlds_out.m:
Write the new representation for call_ids.
Add a predicate `hlds_out__write_call_arg_id' which
replaces similar code in mode_errors.m and typecheck.m.
compiler/prog_io_goal.m:
Add support for `aditi_bottom_up' and `aditi_top_down' annotations
on pred expressions.
compiler/prog_io_util.m:
compiler/prog_io_pragma.m:
Add predicates
- `prog_io_util:parse_name_and_arity' to parse `SymName/Arity'
(moved from prog_io_pragma.m).
- `prog_io_util:parse_pred_or_func_name_and_arity to parse
`pred SymName/Arity' or `func SymName/Arity'.
- `prog_io_util:parse_pred_or_func_and_args' to parse terms resembling
a clause head (moved from prog_io_pragma.m).
compiler/type_util.m:
Add support for `aditi_bottom_up' and `aditi_top_down' annotations
on higher-order types.
Add predicates `construct_higher_order_type',
`construct_higher_order_pred_type' and
`construct_higher_order_func_type' to avoid some code duplication.
compiler/mode_util.m:
Add predicate `unused_mode/1', which returns `builtin:unused'.
Add functions `aditi_di_mode/0', `aditi_ui_mode/0' and
`aditi_uo_mode/0' which return `in', `in', and `out', but will
be changed to return `di', `ui' and `uo' when alias tracking
is implemented.
compiler/goal_util.m:
Add predicate `goal_util__generic_call_vars' which returns
any arguments to a generic_call which are not in the argument list,
for example the closure passed to a higher-order call or
the typeclass_info for a class method call.
compiler/llds.m:
compiler/exprn_aux.m:
compiler/dupelim.m:
compiler/llds_out.m:
compiler/opt_debug.m:
Add builtin labels for the Aditi update operations.
compiler/hlds_module.m:
Add predicate predicate_table_search_pf_sym, used for finding
possible matches for a call with the wrong number of arguments.
compiler/intermod.m:
Don't write predicates which build `aditi_top_down' goals,
because there is currently no way to tell importing modules
which RL code fragment to use.
compiler/simplify.m:
Obey the `cannot_remove' field of explicit quantification goals.
compiler/make_hlds.m:
Parse Aditi updates.
Don't typecheck clauses for which syntax errors in Aditi updates
are found - this avoids spurious "undefined predicate `aditi_insert/3'"
errors.
Factor out some common code to handle terms of the form `Head :- Body'.
Factor out common code in the handling of pred and func expressions.
compiler/typecheck.m:
Typecheck Aditi builtins.
Allow the argument types of matching predicates to be adjusted
when typechecking the higher-order arguments of Aditi builtins.
Change `typecheck__resolve_pred_overloading' to take a list of
argument types rather than a `map(var, type)' and a list of
arguments to allow a transformation to be performed on the
argument types before passing them.
compiler/error_util.m:
Move the part of `report_error_num_args' which writes
"wrong number of arguments (<x>; expected <y>)" from
typecheck.m for use by make_hlds.m when reporting errors
for Aditi builtins.
compiler/modes.m:
compiler/unique_modes.m:
compiler/modecheck_call.m:
Modecheck Aditi builtins.
compiler/lambda.m:
Handle the markers for predicates introduced for
`aditi_top_down' and `aditi_bottom_up' lambda expressions.
compiler/polymorphism.m:
Add extra type_infos to `aditi_insert' calls
describing the tuple to insert.
compiler/call_gen.m:
Generate code for Aditi builtins.
compiler/unify_gen.m:
compiler/bytecode_gen.m:
Abort on `aditi_top_down' and `aditi_bottom_up' lambda
expressions - code generation for them is not yet implemented.
compiler/magic.m:
Use the `aditi_call' generic_call rather than create
a new procedure for each Aditi predicate called from C.
compiler/rl_out.pp:
compiler/rl_gen.m:
compiler/rl.m:
Move some utility code used by magic.m and call_gen.m into rl.m.
Remove an XXX comment about reference counting being not yet
implemented - Evan has fixed that.
library/ops.m:
compiler/mercury_to_mercury.m:
doc/transition_guide.texi:
Add unary prefix operators `aditi_bottom_up' and `aditi_top_down',
used as qualifiers on lambda expressions.
Add infix operator `==>' to separate the tuples in an
`aditi_modify' call.
compiler/follow_vars.m:
Thread a `map(prog_var, type)' through, needed because
type information is no longer held in higher-order call goals.
compiler/table_gen.m:
Use the `make_*_construction' predicates in hlds_goal.m
to construct constants.
compiler/*.m:
Trivial changes to add extra fields to hlds_goal structures.
doc/reference_manual.texi:
Document Aditi updates.
Use @samp{pragma base_relation} instead of
@samp{:- pragma base_relation} throughout the Aditi documentation
to be consistent with other parts of the reference manual.
tests/valid/Mmakefile:
tests/valid/aditi_update.m:
tests/valid/aditi.m:
Test case.
tests/valid/Mmakefile:
Remove some hard-coded --intermodule-optimization rules which are
no longer needed because `mmake depend' is now run in this directory.
tests/invalid/*.err_exp:
Fix expected output for changes in reporting of call_ids
in typecheck.m.
tests/invalid/Mmakefile
tests/invalid/aditi_update_errors.{m,err_exp}:
tests/invalid/aditi_update_mode_errors.{m,err_exp}:
Test error messages for Aditi updates.
tests/valid/aditi.m:
tests/invalid/aditi.m:
Cut down version of extras/aditi/aditi.m to provide basic declarations
for Aditi compilation such as `aditi__state' and the modes
`aditi_di', `aditi_uo' and `aditi_ui'. Installing extras/aditi/aditi.m
somewhere would remove the need for these.
395 lines
14 KiB
Mathematica
395 lines
14 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1994-1999 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU General
|
|
% Public License - see the file COPYING in the Mercury distribution.
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Main author: conway.
|
|
% Extensive modifications by zs.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module follow_code.
|
|
|
|
:- interface.
|
|
|
|
:- import_module hlds_module, hlds_pred, hlds_goal.
|
|
:- import_module list.
|
|
|
|
:- pred move_follow_code_in_proc(proc_info, proc_info,
|
|
module_info, module_info).
|
|
% :- mode move_follow_code_in_proc(di, uo, di, uo) is det.
|
|
:- mode move_follow_code_in_proc(in, out, in, out) is det.
|
|
|
|
% Split a list of goals into the prefix of builtins and the rest.
|
|
:- pred move_follow_code_select(list(hlds_goal), list(hlds_goal),
|
|
list(hlds_goal)).
|
|
:- mode move_follow_code_select(in, out, out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module hlds_data, goal_util, mode_util, prog_data.
|
|
:- import_module globals, options, det_analysis, quantification.
|
|
:- import_module bool, map, set, term, std_util, require.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
move_follow_code_in_proc(ProcInfo0, ProcInfo, ModuleInfo0, ModuleInfo) :-
|
|
module_info_globals(ModuleInfo0, Globals),
|
|
globals__lookup_bool_option(Globals, follow_code, FollowCode),
|
|
globals__lookup_bool_option(Globals, prev_code, PrevCode),
|
|
Flags = FollowCode - PrevCode,
|
|
proc_info_goal(ProcInfo0, Goal0),
|
|
proc_info_varset(ProcInfo0, Varset0),
|
|
proc_info_vartypes(ProcInfo0, VarTypes0),
|
|
(
|
|
move_follow_code_in_goal(Goal0, Goal1, Flags, no, Res),
|
|
% did the goal change?
|
|
Res = yes
|
|
->
|
|
% we need to fix up the goal_info by recalculating
|
|
% the nonlocal vars and the non-atomic instmap deltas.
|
|
proc_info_headvars(ProcInfo0, HeadVars),
|
|
implicitly_quantify_clause_body(HeadVars, Goal1,
|
|
Varset0, VarTypes0, Goal2, Varset, VarTypes, _Warnings),
|
|
proc_info_get_initial_instmap(ProcInfo0,
|
|
ModuleInfo0, InstMap0),
|
|
recompute_instmap_delta(no, Goal2, Goal, InstMap0,
|
|
ModuleInfo0, ModuleInfo)
|
|
;
|
|
Goal = Goal0,
|
|
Varset = Varset0,
|
|
VarTypes = VarTypes0,
|
|
ModuleInfo = ModuleInfo0
|
|
),
|
|
proc_info_set_goal(ProcInfo0, Goal, ProcInfo1),
|
|
proc_info_set_varset(ProcInfo1, Varset, ProcInfo2),
|
|
proc_info_set_vartypes(ProcInfo2, VarTypes, ProcInfo).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_goal(hlds_goal, hlds_goal, pair(bool),
|
|
bool, bool).
|
|
:- mode move_follow_code_in_goal(in, out, in, in, out) is det.
|
|
|
|
move_follow_code_in_goal(Goal0 - GoalInfo, Goal - GoalInfo, Flags, R0, R) :-
|
|
move_follow_code_in_goal_2(Goal0, Goal, Flags, R0, R).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_goal_2(hlds_goal_expr, hlds_goal_expr,
|
|
pair(bool), bool, bool).
|
|
:- mode move_follow_code_in_goal_2(in, out, in, in, out) is det.
|
|
|
|
move_follow_code_in_goal_2(conj(Goals0), conj(Goals), Flags, R0, R) :-
|
|
move_follow_code_in_conj(Goals0, Goals, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(par_conj(Goals0, SM), par_conj(Goals, SM),
|
|
Flags, R0, R) :-
|
|
% move_follow_code_in_disj treats its list of goals as
|
|
% independent goals, so we can use it to process the
|
|
% independent parallel conjuncts.
|
|
move_follow_code_in_disj(Goals0, Goals, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(disj(Goals0, SM), disj(Goals, SM), Flags, R0, R) :-
|
|
move_follow_code_in_disj(Goals0, Goals, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(not(Goal0), not(Goal), Flags, R0, R) :-
|
|
move_follow_code_in_goal(Goal0, Goal, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(switch(Var, Det, Cases0, SM),
|
|
switch(Var, Det, Cases, SM), Flags, R0, R) :-
|
|
move_follow_code_in_cases(Cases0, Cases, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(if_then_else(Vars, Cond0, Then0, Else0, SM),
|
|
if_then_else(Vars, Cond, Then, Else, SM), Flags, R0, R) :-
|
|
move_follow_code_in_goal(Cond0, Cond, Flags, R0, R1),
|
|
move_follow_code_in_goal(Then0, Then, Flags, R1, R2),
|
|
move_follow_code_in_goal(Else0, Else, Flags, R2, R).
|
|
|
|
move_follow_code_in_goal_2(some(Vars, CanRemove, Goal0),
|
|
some(Vars, CanRemove, Goal), Flags, R0, R) :-
|
|
move_follow_code_in_goal(Goal0, Goal, Flags, R0, R).
|
|
|
|
move_follow_code_in_goal_2(generic_call(A,B,C,D),
|
|
generic_call(A,B,C,D), _, R, R).
|
|
|
|
move_follow_code_in_goal_2(call(A,B,C,D,E,F), call(A,B,C,D,E,F), _, R, R).
|
|
|
|
move_follow_code_in_goal_2(unify(A,B,C,D,E), unify(A,B,C,D,E), _, R, R).
|
|
|
|
move_follow_code_in_goal_2(pragma_c_code(A,B,C,D,E,F,G),
|
|
pragma_c_code(A,B,C,D,E,F,G), _, R, R).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% move_follow_code_in_disj is used both for disjunction and
|
|
% parallel conjunction.
|
|
|
|
:- pred move_follow_code_in_disj(list(hlds_goal), list(hlds_goal),
|
|
pair(bool), bool, bool).
|
|
:- mode move_follow_code_in_disj(in, out, in, in, out) is det.
|
|
|
|
move_follow_code_in_disj([], [], _, R, R).
|
|
move_follow_code_in_disj([Goal0|Goals0], [Goal|Goals], Flags, R0, R) :-
|
|
move_follow_code_in_goal(Goal0, Goal, Flags, R0, R1),
|
|
move_follow_code_in_disj(Goals0, Goals, Flags, R1, R).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_cases(list(case), list(case), pair(bool),
|
|
bool, bool).
|
|
:- mode move_follow_code_in_cases(in, out, in, in, out) is det.
|
|
|
|
move_follow_code_in_cases([], [], _, R, R).
|
|
move_follow_code_in_cases([case(Cons, Goal0)|Goals0], [case(Cons, Goal)|Goals],
|
|
Flags, R0, R) :-
|
|
move_follow_code_in_goal(Goal0, Goal, Flags, R0, R1),
|
|
move_follow_code_in_cases(Goals0, Goals, Flags, R1, R).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_conj(list(hlds_goal), list(hlds_goal),
|
|
pair(bool), bool, bool).
|
|
:- mode move_follow_code_in_conj(in, out, in, in, out) is det.
|
|
|
|
% Find the first branched structure, and split the
|
|
% conj into those goals before and after it.
|
|
|
|
move_follow_code_in_conj(Goals0, Goals, Flags, R0, R) :-
|
|
move_follow_code_in_conj_2(Goals0, [], RevGoals, Flags, R0, R),
|
|
list__reverse(RevGoals, Goals).
|
|
|
|
:- pred move_follow_code_in_conj_2(list(hlds_goal), list(hlds_goal),
|
|
list(hlds_goal), pair(bool), bool, bool).
|
|
:- mode move_follow_code_in_conj_2(in, in, out, in, in, out) is det.
|
|
|
|
move_follow_code_in_conj_2([], RevPrevGoals, RevPrevGoals, _, R, R).
|
|
move_follow_code_in_conj_2([Goal0 | Goals0], RevPrevGoals0, RevPrevGoals,
|
|
Flags, R0, R) :-
|
|
Flags = PushFollowCode - PushPrevCode,
|
|
(
|
|
PushFollowCode = yes,
|
|
Goal0 = GoalExpr0 - _,
|
|
goal_util__goal_is_branched(GoalExpr0),
|
|
move_follow_code_select(Goals0, FollowGoals, RestGoalsPrime),
|
|
FollowGoals \= [],
|
|
move_follow_code_move_goals(Goal0, FollowGoals, Goal1Prime)
|
|
->
|
|
R1 = yes,
|
|
Goal1 = Goal1Prime,
|
|
RestGoals = RestGoalsPrime
|
|
;
|
|
R1 = R0,
|
|
Goal1 = Goal0,
|
|
RestGoals = Goals0
|
|
),
|
|
(
|
|
PushPrevCode = yes
|
|
->
|
|
move_prev_code_forbidden_vars(RestGoals, ForbiddenVars),
|
|
move_prev_code(Goal1, Goal2, ForbiddenVars,
|
|
RevPrevGoals0, RevPrevGoals1, R1, R2)
|
|
;
|
|
RevPrevGoals1 = RevPrevGoals0,
|
|
Goal2 = Goal1,
|
|
R2 = R1
|
|
),
|
|
move_follow_code_in_goal(Goal2, Goal, Flags, R2, R3),
|
|
RevPrevGoals2 = [Goal | RevPrevGoals1],
|
|
move_follow_code_in_conj_2(RestGoals, RevPrevGoals2, RevPrevGoals,
|
|
Flags, R3, R).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
move_follow_code_select([], [], []).
|
|
move_follow_code_select([Goal|Goals], FollowGoals, RestGoals) :-
|
|
(
|
|
move_follow_code_is_builtin(Goal)
|
|
->
|
|
move_follow_code_select(Goals, FollowGoals0, RestGoals),
|
|
FollowGoals = [Goal|FollowGoals0]
|
|
;
|
|
FollowGoals = [],
|
|
RestGoals = [Goal|Goals]
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals(hlds_goal, list(hlds_goal), hlds_goal).
|
|
:- mode move_follow_code_move_goals(in, in, out) is semidet.
|
|
|
|
move_follow_code_move_goals(Goal0 - GoalInfo, FollowGoals, Goal - GoalInfo) :-
|
|
(
|
|
Goal0 = switch(Var, Det, Cases0, SM),
|
|
move_follow_code_move_goals_cases(Cases0, FollowGoals, Cases),
|
|
Goal = switch(Var, Det, Cases, SM)
|
|
;
|
|
Goal0 = disj(Goals0, SM),
|
|
move_follow_code_move_goals_disj(Goals0, FollowGoals, Goals),
|
|
Goal = disj(Goals, SM)
|
|
;
|
|
Goal0 = if_then_else(Vars, Cond, Then0, Else0, SM),
|
|
follow_code__conjoin_goal_and_goal_list(Then0,
|
|
FollowGoals, Then),
|
|
follow_code__conjoin_goal_and_goal_list(Else0,
|
|
FollowGoals, Else),
|
|
Goal = if_then_else(Vars, Cond, Then, Else, SM)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals_cases(list(case), list(hlds_goal),
|
|
list(case)).
|
|
:- mode move_follow_code_move_goals_cases(in, in, out) is semidet.
|
|
|
|
move_follow_code_move_goals_cases([], _FollowGoals, []).
|
|
move_follow_code_move_goals_cases([Case0|Cases0], FollowGoals, [Case|Cases]) :-
|
|
Case0 = case(Cons, Goal0),
|
|
follow_code__conjoin_goal_and_goal_list(Goal0, FollowGoals, Goal),
|
|
Case = case(Cons, Goal),
|
|
move_follow_code_move_goals_cases(Cases0, FollowGoals, Cases).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals_disj(list(hlds_goal), list(hlds_goal),
|
|
list(hlds_goal)).
|
|
:- mode move_follow_code_move_goals_disj(in, in, out) is semidet.
|
|
|
|
move_follow_code_move_goals_disj([], _FollowGoals, []).
|
|
move_follow_code_move_goals_disj([Goal0|Goals0], FollowGoals, [Goal|Goals]) :-
|
|
follow_code__conjoin_goal_and_goal_list(Goal0, FollowGoals, Goal),
|
|
move_follow_code_move_goals_disj(Goals0, FollowGoals, Goals).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Takes a goal and a list of goals, and conjoins them
|
|
% (with a potentially blank goal_info), checking that the
|
|
% determinism of the goal is not changed.
|
|
|
|
:- pred follow_code__conjoin_goal_and_goal_list(hlds_goal, list(hlds_goal),
|
|
hlds_goal).
|
|
:- mode follow_code__conjoin_goal_and_goal_list(in, in, out) is semidet.
|
|
|
|
follow_code__conjoin_goal_and_goal_list(Goal0, FollowGoals, Goal) :-
|
|
Goal0 = GoalExpr0 - GoalInfo0,
|
|
goal_info_get_determinism(GoalInfo0, Detism0),
|
|
determinism_components(Detism0, _CanFail0, MaxSolns0),
|
|
( MaxSolns0 = at_most_zero ->
|
|
Goal = Goal0
|
|
;
|
|
check_follow_code_detism(FollowGoals, Detism0),
|
|
( GoalExpr0 = conj(GoalList0) ->
|
|
list__append(GoalList0, FollowGoals, GoalList),
|
|
GoalExpr = conj(GoalList)
|
|
;
|
|
GoalExpr = conj([Goal0 | FollowGoals])
|
|
),
|
|
Goal = GoalExpr - GoalInfo0
|
|
).
|
|
|
|
% This check is necessary to make sure that follow_code
|
|
% doesn't change the determinism of the goal.
|
|
|
|
:- pred check_follow_code_detism(list(hlds_goal), determinism).
|
|
:- mode check_follow_code_detism(in, in) is semidet.
|
|
|
|
check_follow_code_detism([], _).
|
|
check_follow_code_detism([_ - GoalInfo | Goals], Detism0) :-
|
|
goal_info_get_determinism(GoalInfo, Detism1),
|
|
det_conjunction_detism(Detism0, Detism1, Detism0),
|
|
check_follow_code_detism(Goals, Detism0).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_is_builtin(hlds_goal).
|
|
:- mode move_follow_code_is_builtin(in) is semidet.
|
|
|
|
move_follow_code_is_builtin(unify(_, _, _, Unification, _) - _GoalInfo) :-
|
|
Unification \= complicated_unify(_, _, _).
|
|
move_follow_code_is_builtin(call(_, _, _, Builtin, _, _) - _GoalInfo) :-
|
|
Builtin = inline_builtin.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_prev_code(hlds_goal, hlds_goal, set(prog_var),
|
|
list(hlds_goal), list(hlds_goal), bool, bool).
|
|
% :- mode move_prev_code(di, uo, in, di, uo, in, out) is det.
|
|
:- mode move_prev_code(in, out, in, in, out, in, out) is det.
|
|
|
|
move_prev_code(Goal, Goal, _, RevPrevGoals, RevPrevGoals, R, R).
|
|
|
|
% move_prev_code(Goal0, Goal, ForbiddenVars0, RevPrevGoals0, RevPrevGoals,
|
|
% R0, R) :-
|
|
% (
|
|
% move_prev_code_breakup_branched(Goal0, Cond0, First0, Rest0)
|
|
% ->
|
|
% move_prev_code_new_forbidden_vars(Cond0, First0,
|
|
% ForbiddenVars0, ForbiddenVars1),
|
|
% (
|
|
% move_prev_code_vars_difference(Cond0, First0, Rest0,
|
|
% ForbiddenVars0, LocalVars),
|
|
% move_prev_code_can_pull_producer(LocalVars, Producers,
|
|
% RevPrevGoals0, RevPrevGoals1)
|
|
% ->
|
|
% move_prev_code(Rest0, Rest, ForbiddenVars1,
|
|
% RevPrevGoals1, RevPrevGoals, R0, R),
|
|
% move_prev_code_replace_first(Goal0,
|
|
% Producers, Rest, Goal)
|
|
% ;
|
|
% move_prev_code(Rest0, Rest, ForbiddenVars1,
|
|
% RevPrevGoals0, RevPrevGoals, R0, R)
|
|
% )
|
|
% ;
|
|
% R = R0,
|
|
% Goal = Goal0,
|
|
% RevPrevGoals = [Goal0 | RevPrevGoals0]
|
|
% ).
|
|
%
|
|
% :- pred move_prev_code_breakup_branched(hlds_goal, hlds_goal, hlds_goal,
|
|
% hlds_goal).
|
|
% :- mode move_prev_code_breakup_branched(in, out, out, out) is semidet.
|
|
|
|
:- pred move_prev_code_forbidden_vars(list(hlds_goal), set(prog_var)).
|
|
:- mode move_prev_code_forbidden_vars(in, out) is det.
|
|
|
|
move_prev_code_forbidden_vars([], Empty) :-
|
|
set__init(Empty).
|
|
move_prev_code_forbidden_vars([_Goal - GoalInfo | Goals], Varset) :-
|
|
move_prev_code_forbidden_vars(Goals, Varset0),
|
|
goal_info_get_nonlocals(GoalInfo, NonLocals),
|
|
set__union(Varset0, NonLocals, Varset).
|
|
|
|
%
|
|
% :- pred move_prev_code_new_forbidden_vars(hlds_goal, hlds_goal,
|
|
% set(prog_var), set(prog_var)).
|
|
% :- mode move_prev_code_new_forbidden_vars(in, in, in, out) is det.
|
|
%
|
|
% :- pred move_prev_code_vars_difference(hlds_goal, hlds_goal, hlds_goal,
|
|
% set(prog_var), set(prog_var)).
|
|
% :- mode move_prev_code_vars_difference(in, in, in, in, out) is det.
|
|
%
|
|
% move_prev_code_vars_difference(Cond, First, Rest, ForbiddenVars, LocalVars) :-
|
|
% Cond = _ - CondInfo,
|
|
% First = _ - FirstInfo,
|
|
% Rest = _ - RestInfo,
|
|
% goal_info_get_nonlocals(CondInfo, CondVars),
|
|
% goal_info_get_nonlocals(FirstInfo, FirstVars),
|
|
% goal_info_get_nonlocals(RestInfo, RestVars),
|
|
% set__union(CondVars, FirstVars, ThisBranchVars),
|
|
% set__difference(ThisBranchVars, RestVars, LocalVars0),
|
|
% set__difference(LocalVars0, ForbiddenVars, LocalVars).
|
|
%
|
|
% :- pred move_prev_code_can_pull_producer(set(prog_var), list(hlds_goal),
|
|
% list(hlds_goal), list(hlds_goal)).
|
|
% :- mode move_prev_code_can_pull_producer(in, in, di, uo) is det.
|
|
%
|
|
% :- pred move_prev_code_replace_first(hlds_goal,
|
|
% list(hlds_goal), list(hlds_goal), hlds_goal).
|
|
% :- mode move_prev_code_replace_first(di, in, in, uo) is det.
|