[m-dev.] diff: update alias branch [1/3]
Simon Taylor
stayl at cs.mu.OZ.AU
Mon Jul 19 11:45:33 AEST 1999
Estimated hours taken: 15
Merge trunk changes into alias branch up to tag trunk_snapshot_19990712123833.
compiler/liveness.m:
Add a call to `recompute_instmap_delta_proc' after the call
to `requantify_proc'. Without this change, compilation
of library/term_io.m with `--intermodule-optimization'
aborts in code generation. This is not the best fix, but it works.
Fergus fixed this problem in the main branch by having
quantification.m call `instmap_delta_restrict', but
`instmap_delta_restrict' does not exist in the alias branch.
--- accumulator.m 1999/07/14 00:26:57 1.1
+++ accumulator.m 1999/07/16 05:24:54
@@ -594,6 +594,8 @@
pred_info_get_class_context(PredInfo, ClassContext),
pred_info_get_aditi_owner(PredInfo, Owner),
+ set__init(Assertions),
+
proc_info_context(NewProcInfo, Context),
term__context_line(Context, Line),
Counter = 0,
@@ -605,7 +607,7 @@
pred_info_create(ModuleName, SymName, TypeVarSet, ExistQVars, Types,
Cond, PredContext, local, Markers, PredOrFunc,
- ClassContext, Owner, NewProcInfo, NewProcId,
+ ClassContext, Owner, Assertions, NewProcInfo, NewProcId,
NewPredInfo).
:- pred calculate_instmap(hlds_goals::in, instmap::in, instmap::out) is det.
@@ -1416,11 +1418,7 @@
accumulator__check_assoc_unify_rhs(var(_)).
accumulator__check_assoc_unify_rhs(functor(_, _)).
-<<<<<<< accumulator.m
-accumulator__check_assoc_unify_rhs(lambda_goal(_, _, _, _, _, _, _)) :-
-=======
-accumulator__check_assoc_unify_rhs(lambda_goal(_, _, _, _, _, _, _, _)) :-
->>>>>>> 1.5
+accumulator__check_assoc_unify_rhs(lambda_goal(_, _, _, _, _, _, _, _, _)) :-
%
% For the moment just fail, as I am not sure how to
% handle this.
--- bytecode_gen.m 1999/07/14 00:26:57 1.2
+++ bytecode_gen.m 1999/07/16 05:22:06
@@ -290,26 +290,18 @@
% Generate bytecode for a higher order call.
:- pred bytecode_gen__higher_order_call(prog_var::in, list(prog_var)::in,
-<<<<<<< bytecode_gen.m
- list(type)::in, argument_modes::in, determinism::in, byte_info::in,
+ argument_modes::in, determinism::in, byte_info::in,
byte_tree::out) is det.
-=======
- list(mode)::in, determinism::in, byte_info::in, byte_tree::out) is det.
->>>>>>> 1.45
bytecode_gen__higher_order_call(PredVar, ArgVars, ArgModes, Detism,
ByteInfo, Code) :-
determinism_to_code_model(Detism, CodeModel),
bytecode_gen__get_module_info(ByteInfo, ModuleInfo),
-<<<<<<< bytecode_gen.m
+ list__map(bytecode_gen__get_var_type(ByteInfo), ArgVars, ArgTypes),
ArgModes = argument_modes(InstTable, Modes),
bytecode_gen__get_instmap(ByteInfo, InstMap),
make_arg_infos(ArgTypes, Modes, CodeModel, InstMap,
InstTable, ModuleInfo, ArgInfo),
-=======
- list__map(bytecode_gen__get_var_type(ByteInfo), ArgVars, ArgTypes),
- make_arg_infos(ArgTypes, ArgModes, CodeModel, ModuleInfo, ArgInfo),
->>>>>>> 1.45
assoc_list__from_corresponding_lists(ArgVars, ArgInfo, ArgVarsInfos),
call_gen__partition_args(ArgVarsInfos, InVars, OutVars),
--- call_gen.m 1999/07/14 00:26:57 1.2
+++ call_gen.m 1999/07/16 05:22:06
@@ -21,25 +21,11 @@
:- import_module prog_data, hlds_pred, hlds_goal, llds, code_info.
:- import_module list, set, assoc_list.
-<<<<<<< call_gen.m
-:- pred call_gen__generate_higher_order_call(code_model, prog_var,
- list(prog_var), list(type), argument_modes, determinism,
- hlds_goal_info, code_tree, code_info, code_info).
-:- mode call_gen__generate_higher_order_call(in, in, in, in, in, in, in, out,
- in, out) is det.
-
-:- pred call_gen__generate_class_method_call(code_model, prog_var, int,
- list(prog_var), list(type), argument_modes, determinism,
- hlds_goal_info, code_tree, code_info, code_info).
-:- mode call_gen__generate_class_method_call(in, in, in, in, in, in, in, in,
- out, in, out) is det.
-=======
:- pred call_gen__generate_generic_call(code_model, generic_call,
- list(prog_var), list(mode), determinism,
+ list(prog_var), argument_modes, determinism,
hlds_goal_info, code_tree, code_info, code_info).
:- mode call_gen__generate_generic_call(in, in, in, in, in, in,
out, in, out) is det.
->>>>>>> 1.133
:- pred call_gen__generate_call(code_model, pred_id, proc_id, list(prog_var),
hlds_goal_info, code_tree, code_info, code_info).
@@ -158,11 +144,8 @@
call_gen__generate_generic_call(_OuterCodeModel, GenericCall, Args,
Modes, Det, GoalInfo, Code) -->
-<<<<<<< call_gen.m
{ Modes = argument_modes(ArgIKT, ArgModes) },
-=======
list__map_foldl(code_info__variable_type, Args, Types),
->>>>>>> 1.133
{ determinism_to_code_model(Det, CodeModel) },
code_info__get_module_info(ModuleInfo),
{ instmap__init_reachable(BogusInstMap) }, % YYY
@@ -198,32 +181,10 @@
{ goal_info_get_instmap_delta(GoalInfo, InstMapDelta) },
{ instmap__apply_instmap_delta(InstMap, InstMapDelta, ReturnInstMap) },
-<<<<<<< call_gen.m
- code_info__produce_variable(PredVar, PredVarCode, PredRVal),
- (
- { PredRVal = lval(reg(r, 1)) }
- ->
- { CopyCode = empty }
- ;
- { CopyCode = node([
- assign(reg(r, 1), PredRVal) - "Copy pred-term"
- ]) }
- ),
-
- { list__length(InVars, NInVars) },
- { list__length(OutVars, NOutVars) },
- { ArgNumCode = node([
- assign(reg(r, 2), const(int_const(NInVars))) -
- "Assign number of immediate input arguments",
- assign(reg(r, 3), const(int_const(NOutVars))) -
- "Assign number of output arguments"
- ]) },
-=======
% Doing this after generating the immediate input arguments,
% results in slightly more efficient code by not moving
% the immediate arguments twice.
call_gen__generic_call_setup(GenericCall, InVars, OutVars, SetupCode),
->>>>>>> 1.133
trace__prepare_for_call(TraceCode),
@@ -257,49 +218,7 @@
tree(CallCode,
FailHandlingCode))))))
}.
-<<<<<<< call_gen.m
-%---------------------------------------------------------------------------%
-
- %
- % For a class method call,
- % we split the arguments into inputs and outputs, put the inputs
- % in the locations expected by mercury__do_call_class_method in
- % runtime/mercury_ho_call.c, generate the call to that code,
- % and pick up the outputs from the locations that we know
- % the runtime system leaves them in.
- %
-
-call_gen__generate_class_method_call(_OuterCodeModel, TCVar, MethodNum, Args,
- Types, ArgModes, Det, GoalInfo, Code) -->
- { determinism_to_code_model(Det, CodeModel) },
- code_info__get_module_info(ModuleInfo),
-=======
->>>>>>> 1.133
-
-<<<<<<< call_gen.m
- { ArgModes = argument_modes(InstTable, Modes) },
- { instmap__init_reachable(BogusInstMap) }, % YYY
- { make_arg_infos(Types, Modes, CodeModel,
- BogusInstMap, InstTable, ModuleInfo, ArgInfo) },
- { assoc_list__from_corresponding_lists(Args, ArgInfo, ArgsAndArgInfo) },
- { call_gen__partition_args(ArgsAndArgInfo, InVars, OutVars) },
- { set__list_to_set(OutVars, OutArgs) },
- call_gen__save_variables(OutArgs, SaveCode),
- call_gen__prepare_for_call(CodeModel, FlushCode, CallModel),
-
- % place the immediate input arguments in registers
- % starting at r5.
- call_gen__generate_immediate_args(InVars, 5, InLocs, ImmediateCode),
- code_info__generate_call_stack_vn_livevals(OutArgs, LiveVals0),
- { set__insert_list(LiveVals0,
- [reg(r, 1), reg(r, 2), reg(r, 3), reg(r, 4) | InLocs],
- LiveVals) },
- (
- { CodeModel = model_semi }
- ->
- { FirstArg = 2 }
-=======
% The registers before the first input argument are all live.
:- pred call_gen__extra_livevals(int, list(lval)).
:- mode call_gen__extra_livevals(in, out) is det.
@@ -315,7 +234,6 @@
ExtraLiveVals = [reg(r, Reg) | ExtraLiveVals1],
NextReg is Reg + 1,
call_gen__extra_livevals(NextReg, FirstInput, ExtraLiveVals1)
->>>>>>> 1.133
;
ExtraLiveVals = []
).
@@ -385,31 +303,6 @@
assign(reg(r, 4), const(int_const(NOutVars))) -
"Assign number of output arguments"
]) },
-<<<<<<< call_gen.m
-
- trace__prepare_for_call(TraceCode),
-
- % We must update the code generator state to reflect
- % the situation after the call before building
- % the return liveness info. No later code in this
- % predicate depends on the old state.
- call_gen__rebuild_registers(OutArguments),
- code_info__generate_return_live_lvalues(OutputArgLocs, ReturnInstMap,
- ReturnLiveLvalues),
-
- code_info__get_next_label(ReturnLabel),
- { CallCode = node([
- livevals(LiveVals)
- - "",
- call(do_call_class_method, label(ReturnLabel),
- ReturnLiveLvalues, CallModel)
- - "Setup and call class method",
- label(ReturnLabel)
- - "Continuation label"
- ]) },
-
- call_gen__handle_failure(CodeModel, FailHandlingCode),
-=======
{ SetupCode = tree(TCVarCode, ArgsCode) }.
call_gen__generic_call_setup(aditi_builtin(Builtin, _),
InVars, OutVars, SetupCode) -->
@@ -477,7 +370,6 @@
:- pred call_gen__setup_base_relation_name(pred_id,
code_tree, code_info, code_info).
:- mode call_gen__setup_base_relation_name(in, out, in, out) is det.
->>>>>>> 1.133
call_gen__setup_base_relation_name(PredId, SetupCode) -->
code_info__get_module_info(ModuleInfo),
--- check_typeclass.m 1999/07/14 00:26:57 1.2
+++ check_typeclass.m 1999/07/16 05:22:07
@@ -578,8 +578,11 @@
pred_info_set_clauses_info(PredInfo1, ClausesInfo, PredInfo),
module_info_get_predicate_table(ModuleInfo0, PredicateTable0),
+ module_info_get_partial_qualifier_info(ModuleInfo0, PQInfo),
+ % XXX why do we need to pass may_be_unqualified here,
+ % rather than passing must_be_qualified or calling the /4 version?
predicate_table_insert(PredicateTable0, PredInfo,
- may_be_unqualified, PredId, PredicateTable),
+ may_be_unqualified, PQInfo, PredId, PredicateTable),
module_info_set_predicate_table(ModuleInfo0, PredicateTable,
ModuleInfo),
--- code_util.m 1999/07/14 00:26:57 1.2
+++ code_util.m 1999/07/16 05:22:09
@@ -828,13 +828,7 @@
PredId, ProcId, Min, Max) :-
code_util__count_recursive_calls(Goal, PredId, ProcId, Min, Max).
code_util__count_recursive_calls_2(unify(_, _, _, _, _), _, _, 0, 0).
-<<<<<<< code_util.m
-code_util__count_recursive_calls_2(higher_order_call(_, _,_, _, _, _), _, _,
- 0, 0).
-code_util__count_recursive_calls_2(class_method_call(_, _,_, _, _, _), _, _,
-=======
code_util__count_recursive_calls_2(generic_call(_, _, _, _), _, _,
->>>>>>> 1.111
0, 0).
code_util__count_recursive_calls_2(pragma_c_code(_,_,_, _, _, _, _), _, _,
0, 0).
--- constraint.m 1999/07/14 00:26:57 1.2
+++ constraint.m 1999/07/16 05:22:09
@@ -185,30 +185,12 @@
[].
constraint__propagate_goal_2(
-<<<<<<< constraint.m
- higher_order_call(A, B, C, D, E, F),
- higher_order_call(A, B, C, D, E, F)) -->
-% mode_checkpoint(enter, "higher-order call"),
-% mode_checkpoint(exit, "higher-order call").
- [].
-=======
generic_call(A, B, C, D),
generic_call(A, B, C, D)) -->
- mode_checkpoint(enter, "generic call"),
- mode_checkpoint(exit, "generic call").
->>>>>>> 1.44
+% mode_checkpoint(enter, "generic call"),
+% mode_checkpoint(exit, "generic call").
constraint__propagate_goal_2(
-<<<<<<< constraint.m
- class_method_call(A, B, C, D, E, F),
- class_method_call(A, B, C, D, E, F)) -->
-% mode_checkpoint(enter, "class method call"),
-% mode_checkpoint(exit, "class method call").
- [].
-
-constraint__propagate_goal_2(
-=======
->>>>>>> 1.44
call(PredId, ProcId, ArgVars, Builtin, Sym, Context),
call(PredId, ProcId, ArgVars, Builtin, Sym, Context)) -->
% mode_checkpoint(enter, "call"),
--- cse_detection.m 1999/07/14 00:26:57 1.2
+++ cse_detection.m 1999/07/16 05:22:10
@@ -221,24 +221,14 @@
detect_cse_in_goal_2(unify(A,B0,C,D,E), _, InstMap0, CseInfo0, CseInfo, Redo,
unify(A,B,C,D,E)) :-
(
-<<<<<<< cse_detection.m
- B0 = lambda_goal(PredOrFunc, NonLocalVars,
- Vars, Modes, Det, IMDelta, Goal0)
-=======
B0 = lambda_goal(PredOrFunc, EvalMethod, FixModes,
- NonLocalVars, Vars, Modes, Det, Goal0)
->>>>>>> 1.57
+ NonLocalVars, Vars, Modes, Det, IMDelta, Goal0)
->
instmap__apply_instmap_delta(InstMap0, IMDelta, InstMap),
detect_cse_in_goal(Goal0, InstMap, CseInfo0, CseInfo, Redo,
Goal),
-<<<<<<< cse_detection.m
- B = lambda_goal(PredOrFunc, NonLocalVars,
- Vars, Modes, Det, IMDelta, Goal)
-=======
B = lambda_goal(PredOrFunc, EvalMethod, FixModes,
- NonLocalVars, Vars, Modes, Det, Goal)
->>>>>>> 1.57
+ NonLocalVars, Vars, Modes, Det, IMDelta, Goal)
;
B = B0,
CseInfo = CseInfo0,
--- dead_proc_elim.m 1999/07/14 00:26:57 1.2
+++ dead_proc_elim.m 1999/07/16 05:22:10
@@ -435,13 +435,7 @@
Needed1, Needed2),
dead_proc_elim__examine_goal(Else, CurrProc, Queue2, Queue,
Needed2, Needed).
-<<<<<<< dead_proc_elim.m
-dead_proc_elim__examine_expr(higher_order_call(_,_,_,_,_,_), _,
- Queue, Queue, Needed, Needed).
-dead_proc_elim__examine_expr(class_method_call(_,_,_,_,_,_), _,
-=======
dead_proc_elim__examine_expr(generic_call(_,_,_,_), _,
->>>>>>> 1.48
Queue, Queue, Needed, Needed).
dead_proc_elim__examine_expr(call(PredId, ProcId, _,_,_,_),
CurrProc, Queue0, Queue, Needed0, Needed) :-
@@ -845,11 +839,7 @@
;
[]
).
-<<<<<<< dead_proc_elim.m
-pre_modecheck_examine_unify_rhs(lambda_goal(_, _, _, _, _, _, Goal)) -->
-=======
-pre_modecheck_examine_unify_rhs(lambda_goal(_, _, _, _, _, _, _, Goal)) -->
->>>>>>> 1.48
+pre_modecheck_examine_unify_rhs(lambda_goal(_, _, _, _, _, _, _, _, Goal)) -->
pre_modecheck_examine_goal(Goal).
:- pred dead_pred_info_add_pred_name(sym_name::in, dead_pred_info::in,
--- det_analysis.m 1999/07/14 00:26:57 1.2
+++ det_analysis.m 1999/07/16 05:22:12
@@ -497,57 +497,20 @@
Detism = Detism0
).
-det_infer_goal_2(higher_order_call(PredVar, ArgVars, Types, Modes, Det0,
- IsPredOrFunc),
- GoalInfo, _InstMap0, SolnContext,
- _MiscInfo, _NonLocalVars, _DeltaInstMap,
- higher_order_call(PredVar, ArgVars, Types, Modes, Det0,
- IsPredOrFunc),
- Det, Msgs) :-
- determinism_components(Det0, CanFail, NumSolns),
- (
- NumSolns = at_most_many_cc,
- SolnContext \= first_soln
- ->
- Msgs = [higher_order_cc_pred_in_wrong_context(GoalInfo, Det0)],
- % Code elsewhere relies on the assumption that
- % SolnContext \= first_soln => NumSolns \= at_most_many_cc,
- % so we need to enforce that here.
- determinism_components(Det, CanFail, at_most_many)
- ;
- Msgs = [],
- Det = Det0
- ).
-
-<<<<<<< det_analysis.m
-det_infer_goal_2(class_method_call(TCVar, Num, ArgVars, Types, Modes, Det0),
-=======
det_infer_goal_2(generic_call(GenericCall, ArgVars, Modes, Det0),
->>>>>>> 1.142
GoalInfo, _InstMap0, SolnContext,
_MiscInfo, _NonLocalVars, _DeltaInstMap,
-<<<<<<< det_analysis.m
- class_method_call(TCVar, Num, ArgVars, Types, Modes, Det0),
-=======
generic_call(GenericCall, ArgVars, Modes, Det0),
->>>>>>> 1.142
Det, Msgs) :-
determinism_components(Det0, CanFail, NumSolns),
(
NumSolns = at_most_many_cc,
SolnContext \= first_soln
->
-<<<<<<< det_analysis.m
- % If called, this would give a slightly misleading
- % error message. class_method_calls are introduced
- % after det_analysis, though, so it doesn't really
- % matter.
-=======
% This error can only occur for higher-order calls.
% class_method calls are only introduced by polymorphism,
% and the aditi_builtins are all det (for the updates)
% or introduced later (for calls).
->>>>>>> 1.142
Msgs = [higher_order_cc_pred_in_wrong_context(GoalInfo, Det0)],
% Code elsewhere relies on the assumption that
% SolnContext \= first_soln => NumSolns \= at_most_many_cc,
@@ -563,13 +526,9 @@
det_infer_goal_2(unify(LT, RT0, M, U, C), GoalInfo, InstMap0, SolnContext,
DetInfo, _, _, unify(LT, RT, M, U, C), UnifyDet, Msgs) :-
(
-<<<<<<< det_analysis.m
- RT0 = lambda_goal(PredOrFunc, NonLocalVars, Vars,
- Modes, LambdaDeclaredDet, InstMapDelta, Goal0)
-=======
RT0 = lambda_goal(PredOrFunc, EvalMethod, FixModes,
- NonLocalVars, Vars, Modes, LambdaDeclaredDet, Goal0)
->>>>>>> 1.142
+ NonLocalVars, Vars, Modes, LambdaDeclaredDet,
+ InstMapDelta, Goal0)
->
(
determinism_components(LambdaDeclaredDet, _,
@@ -585,13 +544,9 @@
det_check_lambda(LambdaDeclaredDet, LambdaInferredDet,
Goal, GoalInfo, DetInfo, Msgs2),
list__append(Msgs1, Msgs2, Msgs3),
-<<<<<<< det_analysis.m
- RT = lambda_goal(PredOrFunc, NonLocalVars, Vars,
- Modes, LambdaDeclaredDet, InstMapDelta, Goal)
-=======
RT = lambda_goal(PredOrFunc, EvalMethod, FixModes,
- NonLocalVars, Vars, Modes, LambdaDeclaredDet, Goal)
->>>>>>> 1.142
+ NonLocalVars, Vars, Modes, LambdaDeclaredDet,
+ InstMapDelta, Goal)
;
RT = RT0,
Msgs3 = []
--- det_util.m 1999/07/14 00:26:57 1.2
+++ det_util.m 1999/07/16 05:22:13
@@ -123,14 +123,8 @@
term__var_list_to_term_list(ArgVars, ArgTerms),
cons_id_and_args_to_term(ConsId, ArgTerms, RhsTerm),
term__unify(term__variable(X), RhsTerm, Subst0, Subst).
-<<<<<<< det_util.m
-interpret_unify(_X, lambda_goal(_POrF, _NonLocals, _Vars, _Modes, _Det,
- _IMDelta, _Goal),
- Subst0, Subst) :-
-=======
-interpret_unify(_X, lambda_goal(_POrF, _Method, _Fix, _NonLocals,
- _Vars, _Modes, _Det, _Goal), Subst0, Subst) :-
->>>>>>> 1.18
+interpret_unify(_X, lambda_goal(_POrF, _Method, _Fix, _NonLocals, _Vars,
+ _Modes, _Det, _IMDelta, _Goal), Subst0, Subst) :-
% For ease of implementation we just ignore unifications with
% lambda terms. This is a safe approximation, it just
% prevents us from optimizing them as well as we would like.
--- follow_vars.m 1999/07/14 00:26:57 1.2
+++ follow_vars.m 1999/07/16 05:22:16
@@ -29,25 +29,15 @@
:- interface.
-<<<<<<< follow_vars.m
-:- import_module hlds_module, hlds_pred, hlds_goal, hlds_data.
-=======
-:- import_module hlds_module, hlds_pred, hlds_goal, prog_data.
+:- import_module hlds_data, hlds_module, hlds_pred, hlds_goal, prog_data.
:- import_module map.
->>>>>>> 1.54
:- pred find_final_follow_vars(proc_info, follow_vars).
:- mode find_final_follow_vars(in, out) is det.
-<<<<<<< follow_vars.m
-:- pred find_follow_vars_in_goal(hlds_goal, inst_table,
+:- pred find_follow_vars_in_goal(hlds_goal, map(prog_var, type), inst_table,
module_info, follow_vars, hlds_goal, follow_vars).
-:- mode find_follow_vars_in_goal(in, in, in, in, out, out) is det.
-=======
-:- pred find_follow_vars_in_goal(hlds_goal, map(prog_var, type), module_info,
- follow_vars, hlds_goal, follow_vars).
-:- mode find_follow_vars_in_goal(in, in, in, in, out, out) is det.
->>>>>>> 1.54
+:- mode find_follow_vars_in_goal(in, in, in, in, in, out, out) is det.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
@@ -61,6 +51,7 @@
:- type follow_vars_info
---> follow_vars_info(
module_info,
+ map(prog_var, type),
inst_table
).
@@ -96,10 +87,9 @@
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
-<<<<<<< follow_vars.m
-find_follow_vars_in_goal(Goal0, InstTable, ModuleInfo, FollowVars0,
+find_follow_vars_in_goal(Goal0, VarTypes, InstTable, ModuleInfo, FollowVars0,
Goal, FollowVars) :-
- FVInfo = follow_vars_info(ModuleInfo, InstTable),
+ FVInfo = follow_vars_info(ModuleInfo, VarTypes, InstTable),
find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0, Goal, FollowVars).
:- pred find_follow_vars_in_goal(hlds_goal, follow_vars_info, follow_vars,
@@ -109,99 +99,49 @@
find_follow_vars_in_goal(Goal0 - GoalInfo, FVInfo, FollowVars0,
Goal - GoalInfo, FollowVars) :-
find_follow_vars_in_goal_expr(Goal0, FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal(Goal0 - GoalInfo, VarTypes, ModuleInfo, FollowVars0,
- Goal - GoalInfo, FollowVars) :-
- find_follow_vars_in_goal_2(Goal0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goal, FollowVars).
%-----------------------------------------------------------------------------%
-<<<<<<< follow_vars.m
:- pred find_follow_vars_in_goal_expr(hlds_goal_expr, follow_vars_info,
follow_vars, hlds_goal_expr, follow_vars).
:- mode find_follow_vars_in_goal_expr(in, in, in, out, out) is det.
-=======
-:- pred find_follow_vars_in_goal_2(hlds_goal_expr, map(prog_var, type),
- module_info, follow_vars, hlds_goal_expr, follow_vars).
-:- mode find_follow_vars_in_goal_2(in, in, in, in, out, out) is det.
->>>>>>> 1.54
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(conj(Goals0), FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(conj(Goals0), VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
conj(Goals), FollowVars) :-
-<<<<<<< follow_vars.m
find_follow_vars_in_conj(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_conj(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
no, Goals, FollowVars).
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(par_conj(Goals0, SM), FVInfo,
-=======
-find_follow_vars_in_goal_2(par_conj(Goals0, SM), VarTypes, ModuleInfo,
->>>>>>> 1.54
FollowVars0, par_conj(Goals, SM), FollowVars) :-
% find_follow_vars_in_disj treats its list of goals as a
% series of independent goals, so we can use it to process
% independent parallel conjunction.
-<<<<<<< follow_vars.m
find_follow_vars_in_disj(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_disj(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goals, FollowVars).
% We record that at the end of each disjunct, live variables should
% be in the locations given by the initial follow_vars, which reflects
% the requirements of the code following the disjunction.
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(disj(Goals0, _), FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(disj(Goals0, _), VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
disj(Goals, FollowVars0), FollowVars) :-
-<<<<<<< follow_vars.m
find_follow_vars_in_disj(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_disj(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goals, FollowVars).
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(not(Goal0), FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(not(Goal0), VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
not(Goal), FollowVars) :-
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goal, FollowVars).
% We record that at the end of each arm of the switch, live variables
% should be in the locations given by the initial follow_vars, which
% reflects the requirements of the code following the switch.
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(switch(Var, Det, Cases0, _), FVInfo,
FollowVars0,
switch(Var, Det, Cases, FollowVars0), FollowVars) :-
find_follow_vars_in_cases(Cases0, FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(switch(Var, Det, Cases0, _), VarTypes, ModuleInfo,
- FollowVars0, switch(Var, Det, Cases, FollowVars0),
- FollowVars) :-
- find_follow_vars_in_cases(Cases0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Cases, FollowVars).
% Set the follow_vars field for the condition, the then-part and the
@@ -221,92 +161,36 @@
% follow_vars, which reflects the requirements of the code
% following the if-then-else.
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(if_then_else(Vars, Cond0, Then0, Else0, _),
FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(if_then_else(Vars, Cond0, Then0, Else0, _),
- VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
if_then_else(Vars, Cond, Then, Else, FollowVars0),
FollowVarsCond) :-
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Then0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_goal(Then0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Then1, FollowVarsThen),
goal_set_follow_vars(Then1, yes(FollowVarsThen), Then),
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Cond0, FVInfo, FollowVarsThen,
-=======
- find_follow_vars_in_goal(Cond0, VarTypes, ModuleInfo, FollowVarsThen,
->>>>>>> 1.54
Cond1, FollowVarsCond),
goal_set_follow_vars(Cond1, yes(FollowVarsCond), Cond),
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Else0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_goal(Else0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Else1, FollowVarsElse),
goal_set_follow_vars(Else1, yes(FollowVarsElse), Else).
-<<<<<<< follow_vars.m
-find_follow_vars_in_goal_expr(some(Vars, Goal0), FVInfo,
- FollowVars0, some(Vars, Goal), FollowVars) :-
- find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0,
-=======
-find_follow_vars_in_goal_2(some(Vars, CanRemove, Goal0), VarTypes, ModuleInfo,
+find_follow_vars_in_goal_expr(some(Vars, CanRemove, Goal0), FVInfo,
FollowVars0, some(Vars, CanRemove, Goal), FollowVars) :-
- find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
+ find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0,
Goal, FollowVars).
% XXX These follow-vars aren't correct since the desired positions for
% XXX the arguments are different from an ordinary call --- they are
-<<<<<<< follow_vars.m
- % XXX as required by do_call_{det,semidet,nondet}_closure
-find_follow_vars_in_goal_expr(
- higher_order_call(PredVar, Args, Types, Modes, Det,
- IsPredOrFunc),
- FVInfo, _FollowVars0,
- higher_order_call(PredVar, Args, Types, Modes, Det,
- IsPredOrFunc),
-=======
% XXX as required by the builtin operation.
-find_follow_vars_in_goal_2(
+find_follow_vars_in_goal_expr(
generic_call(GenericCall, Args, Modes, Det),
- VarTypes, ModuleInfo, _FollowVars0,
+ FVInfo, _FollowVars0,
generic_call(GenericCall, Args, Modes, Det),
->>>>>>> 1.54
FollowVars) :-
- FVInfo = follow_vars_info(ModuleInfo, _),
+ FVInfo = follow_vars_info(ModuleInfo, VarTypes, _),
determinism_to_code_model(Det, CodeModel),
-<<<<<<< follow_vars.m
- Modes = argument_modes(ArgInstTable, ArgModes),
- instmap__init_reachable(BogusInstMap),
- make_arg_infos(Types, ArgModes, CodeModel, BogusInstMap,
- ArgInstTable, ModuleInfo, ArgInfo),
-=======
map__apply_to_list(Args, VarTypes, Types),
- make_arg_infos(Types, Modes, CodeModel, ModuleInfo, ArgInfo),
->>>>>>> 1.54
- find_follow_vars_from_arginfo(ArgInfo, Args, FollowVars).
-
-<<<<<<< follow_vars.m
- % XXX These follow-vars aren't correct since the desired positions for
- % XXX the arguments are different from an ordinary call --- they are
- % XXX as required by do_call_{det,semidet,nondet}_class_method
-find_follow_vars_in_goal_expr(
- class_method_call(TypeClassInfoVar, Num, Args, Types, Modes,
- Det),
- FVInfo, _FollowVars0,
- class_method_call(TypeClassInfoVar, Num, Args, Types, Modes,
- Det),
- FollowVars) :-
- FVInfo = follow_vars_info(ModuleInfo, _),
- determinism_to_code_model(Det, CodeModel),
Modes = argument_modes(ArgInstTable, ArgModes),
instmap__init_reachable(BogusInstMap),
make_arg_infos(Types, ArgModes, CodeModel, BogusInstMap,
@@ -314,11 +198,8 @@
find_follow_vars_from_arginfo(ArgInfo, Args, FollowVars).
find_follow_vars_in_goal_expr(call(A,B,C,D,E,F), FVInfo,
-=======
-find_follow_vars_in_goal_2(call(A,B,C,D,E,F), _, ModuleInfo,
->>>>>>> 1.54
FollowVars0, call(A,B,C,D,E,F), FollowVars) :-
- FVInfo = follow_vars_info(ModuleInfo, _),
+ FVInfo = follow_vars_info(ModuleInfo, _, _),
(
D = inline_builtin
->
@@ -327,11 +208,7 @@
find_follow_vars_in_call(A, B, C, ModuleInfo, FollowVars)
).
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(unify(A,B,C,D,E), _FVInfo,
-=======
-find_follow_vars_in_goal_2(unify(A,B,C,D,E), _, _ModuleInfo,
->>>>>>> 1.54
FollowVars0, unify(A,B,C,D,E), FollowVars) :-
(
D = assign(LVar, RVar),
@@ -342,14 +219,8 @@
FollowVars = FollowVars0
).
-<<<<<<< follow_vars.m
find_follow_vars_in_goal_expr(pragma_c_code(A,B,C,D,E,F,G), _FVInfo,
FollowVars, pragma_c_code(A,B,C,D,E,F,G), FollowVars).
-=======
-find_follow_vars_in_goal_2(pragma_c_code(A,B,C,D,E,F,G),
- _, _ModuleInfo, FollowVars,
- pragma_c_code(A,B,C,D,E,F,G), FollowVars).
->>>>>>> 1.54
%-----------------------------------------------------------------------------%
@@ -422,31 +293,13 @@
follow_vars, list(hlds_goal), follow_vars).
:- mode find_follow_vars_in_disj(in, in, in, out, out) is det.
-<<<<<<< follow_vars.m
find_follow_vars_in_disj([], _FVInfo, FollowVars, [], FollowVars).
find_follow_vars_in_disj([Goal0 | Goals0], FVInfo, FollowVars0,
-=======
-:- pred find_follow_vars_in_disj(list(hlds_goal), map(prog_var, type),
- module_info, follow_vars, list(hlds_goal), follow_vars).
-:- mode find_follow_vars_in_disj(in, in, in, in, out, out) is det.
-
-find_follow_vars_in_disj([], _, _ModuleInfo, FollowVars,
- [], FollowVars).
-find_follow_vars_in_disj([Goal0 | Goals0], VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
[Goal | Goals], FollowVars) :-
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goal1, FollowVars),
goal_set_follow_vars(Goal1, yes(FollowVars), Goal),
-<<<<<<< follow_vars.m
find_follow_vars_in_disj(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_disj(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goals, _FollowVars1).
%-----------------------------------------------------------------------------%
@@ -462,32 +315,17 @@
% its follow_vars) and to let different branches "vote" on
% what should be in registers.
-<<<<<<< follow_vars.m
:- pred find_follow_vars_in_cases(list(case), follow_vars_info,
-=======
-:- pred find_follow_vars_in_cases(list(case), map(prog_var, type), module_info,
->>>>>>> 1.54
follow_vars, list(case), follow_vars).
-:- mode find_follow_vars_in_cases(in, in, in, in, out, out) is det.
+:- mode find_follow_vars_in_cases(in, in, in, out, out) is det.
-<<<<<<< follow_vars.m
find_follow_vars_in_cases([], _FVInfo, FollowVars, [], FollowVars).
find_follow_vars_in_cases([case(Cons, IMDelta, Goal0) | Goals0], FVInfo,
FollowVars0, [case(Cons, IMDelta, Goal) | Goals], FollowVars) :-
find_follow_vars_in_goal(Goal0, FVInfo, FollowVars0,
-=======
-find_follow_vars_in_cases([], _, _ModuleInfo, FollowVars, [], FollowVars).
-find_follow_vars_in_cases([case(Cons, Goal0) | Goals0], VarTypes, ModuleInfo,
- FollowVars0, [case(Cons, Goal) | Goals], FollowVars) :-
- find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goal1, FollowVars),
goal_set_follow_vars(Goal1, yes(FollowVars), Goal),
-<<<<<<< follow_vars.m
find_follow_vars_in_cases(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_cases(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
Goals, _FollowVars1).
%-----------------------------------------------------------------------------%
@@ -495,27 +333,13 @@
% We attach the follow_vars to each goal that follows a goal
% that is not cachable by the code generator.
-<<<<<<< follow_vars.m
:- pred find_follow_vars_in_conj(list(hlds_goal), follow_vars_info,
follow_vars, bool, list(hlds_goal), follow_vars).
:- mode find_follow_vars_in_conj(in, in, in, in, out, out) is det.
-=======
-:- pred find_follow_vars_in_conj(list(hlds_goal), map(prog_var, type),
- module_info, follow_vars, bool, list(hlds_goal), follow_vars).
-:- mode find_follow_vars_in_conj(in, in, in, in, in, out, out) is det.
->>>>>>> 1.54
-<<<<<<< follow_vars.m
find_follow_vars_in_conj([], _FVInfo, FollowVars,
-=======
-find_follow_vars_in_conj([], _, _ModuleInfo, FollowVars,
->>>>>>> 1.54
_AttachToFirst, [], FollowVars).
-<<<<<<< follow_vars.m
find_follow_vars_in_conj([Goal0 | Goals0], FVInfo, FollowVars0,
-=======
-find_follow_vars_in_conj([Goal0 | Goals0], VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
AttachToFirst, [Goal | Goals], FollowVars) :-
(
Goal0 = GoalExpr0 - _,
@@ -531,17 +355,9 @@
;
AttachToNext = yes
),
-<<<<<<< follow_vars.m
find_follow_vars_in_conj(Goals0, FVInfo, FollowVars0,
-=======
- find_follow_vars_in_conj(Goals0, VarTypes, ModuleInfo, FollowVars0,
->>>>>>> 1.54
AttachToNext, Goals, FollowVars1),
-<<<<<<< follow_vars.m
find_follow_vars_in_goal(Goal0, FVInfo, FollowVars1,
-=======
- find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo, FollowVars1,
->>>>>>> 1.54
Goal1, FollowVars),
(
AttachToFirst = yes,
--- goal_util.m 1999/07/14 00:26:57 1.2
+++ goal_util.m 1999/07/16 05:22:17
@@ -385,22 +385,12 @@
functor(Functor, ArgVars)) :-
goal_util__rename_var_list(ArgVars0, Must, Subn, ArgVars).
goal_util__rename_unify_rhs(
-<<<<<<< goal_util.m
- lambda_goal(PredOrFunc, NonLocals0, Vars0, Modes, Det, IMDelta0,
- Goal0),
-=======
lambda_goal(PredOrFunc, EvalMethod, FixModes, NonLocals0,
- Vars0, Modes, Det, Goal0),
->>>>>>> 1.53
+ Vars0, Modes, Det, IMDelta0, Goal0),
Must, Subn,
-<<<<<<< goal_util.m
- lambda_goal(PredOrFunc, NonLocals, Vars, Modes, Det, IMDelta,
- Goal)) :-
- instmap_delta_apply_sub(IMDelta0, Must, Subn, IMDelta),
-=======
lambda_goal(PredOrFunc, EvalMethod, FixModes, NonLocals,
- Vars, Modes, Det, Goal)) :-
->>>>>>> 1.53
+ Vars, Modes, Det, IMDelta, Goal)) :-
+ instmap_delta_apply_sub(IMDelta0, Must, Subn, IMDelta),
goal_util__rename_var_list(NonLocals0, Must, Subn, NonLocals),
goal_util__rename_var_list(Vars0, Must, Subn, Vars),
goal_util__rename_vars_in_goal(Goal0, Must, Subn, Goal).
@@ -605,12 +595,8 @@
goal_util__rhs_goal_vars(functor(_Functor, ArgVars), Set0, Set) :-
set__insert_list(Set0, ArgVars, Set).
goal_util__rhs_goal_vars(
-<<<<<<< goal_util.m
- lambda_goal(_POrF, NonLocals, LambdaVars, _M, _D, _IMDelta,
+ lambda_goal(_, _, _, NonLocals, LambdaVars, _M, _D, _IMDelta,
Goal - _),
-=======
- lambda_goal(_, _, _, NonLocals, LambdaVars, _M, _D, Goal - _),
->>>>>>> 1.53
Set0, Set) :-
set__insert_list(Set0, NonLocals, Set1),
set__insert_list(Set1, LambdaVars, Set2),
--- higher_order.m 1999/07/14 00:26:57 1.2
+++ higher_order.m 1999/07/16 05:22:18
@@ -426,19 +426,6 @@
% check whether this call could be specialized
traverse_goal(Goal0, Goal) -->
- { Goal0 = higher_order_call(Var, Args, _,_,_,_) - GoalInfo },
- maybe_specialize_higher_order_call(Var, no, Args, Goal0, Goals),
- { conj_list_to_goal(Goals, GoalInfo, Goal) }.
-
- % class_method_calls are treated similarly to
- % higher_order_calls.
-traverse_goal(Goal0, Goal) -->
-<<<<<<< higher_order.m
- { Goal0 = class_method_call(Var, Method, Args,_,_,_) - GoalInfo },
- maybe_specialize_higher_order_call(Var, yes(Method), Args,
- Goal0, Goals),
- { conj_list_to_goal(Goals, GoalInfo, Goal) }.
-=======
{ Goal0 = generic_call(GenericCall, Args, _, _) - GoalInfo },
(
{
@@ -455,7 +442,6 @@
;
{ Goal = Goal0 }
).
->>>>>>> 1.53
% check whether this call could be specialized
traverse_goal(Goal0, Goal) -->
--- hlds_data.m 1999/07/14 00:26:57 1.2
+++ hlds_data.m 1999/07/16 05:22:18
@@ -915,8 +915,8 @@
:- pred assertion_table_init(assertion_table::out) is det.
-:- pred assertion_table_add_assertion(pred_id::in,
- assertion_table::in, assertion_table::out) is det.
+:- pred assertion_table_add_assertion(pred_id::in, assertion_table::in,
+ assert_id::out, assertion_table::out) is det.
:- pred assertion_table_lookup(assertion_table::in, assert_id::in,
pred_id::out) is det.
@@ -932,7 +932,7 @@
assertion_table_init(assertion_table(0, AssertionMap)) :-
map__init(AssertionMap).
-assertion_table_add_assertion(Assertion, AssertionTable0, AssertionTable) :-
+assertion_table_add_assertion(Assertion, AssertionTable0, Id, AssertionTable) :-
AssertionTable0 = assertion_table(Id, AssertionMap0),
map__det_insert(AssertionMap0, Id, Assertion, AssertionMap),
AssertionTable = assertion_table(Id + 1, AssertionMap).
--- hlds_goal.m 1999/07/14 00:26:57 1.2
+++ hlds_goal.m 1999/07/16 05:22:18
@@ -58,32 +58,12 @@
; generic_call(
generic_call,
list(prog_var), % the list of argument variables
-<<<<<<< hlds_goal.m
- list(type), % the types of the argument variables
- argument_modes, % the argument modes of the called
- % pred or func (since we can't look
- % these up in the proc_info of the
- % called pred/func)
- determinism, % the determinism of the called pred
- pred_or_func % call/N (pred) or apply/N (func)
- )
-
- ; class_method_call(
- prog_var, % the typeclass_info for the instance
- int, % the number of the method to call
- list(prog_var), % the list of argument variables (other
- % than this instance's typeclass_info)
- list(type), % the types of the argument variables
- argument_modes, % the modes of the argument variables
- determinism % the determinism of the called pred
-=======
- list(mode), % The modes of the argument variables.
+ argument_modes, % The modes of the argument variables.
% For higher_order calls, this field
% is junk until after mode analysis.
% For aditi_builtins, this field
% is junk until after purity checking.
determinism % the determinism of the call
->>>>>>> 1.62
)
% Deterministic disjunctions are converted
@@ -144,10 +124,6 @@
% field of the goal_info, so these get ignored
% (except to recompute the goal_info quantification).
% `all Vs' gets converted to `not some Vs not'.
-<<<<<<< hlds_goal.m
-
- ; { some(list(prog_var), hlds_goal) }
-=======
% The second argument is `can_remove' if the quantification
% is allowed to be removed. A non-removable explicit
% quantification may be introduced to keep related goals
@@ -157,7 +133,6 @@
% they should be kept close to the update call where
% possible to make it easier to use indexes for the update.
; { some(list(prog_var), can_remove, hlds_goal) }
->>>>>>> 1.62
% An if-then-else,
% `if some <Vars> <Condition> then <Then> else <Else>'.
@@ -212,7 +187,6 @@
% conjunction.
.
-<<<<<<< hlds_goal.m
:- type pragma_c_code_arg_info
@@ -221,13 +195,6 @@
list(maybe(pair(string, mode)))
).
-
- % Given the variable info field from a pragma c_code, get all the
- % variable names.
-:- pred get_pragma_c_var_names(pragma_c_code_arg_info, list(string)).
-:- mode get_pragma_c_var_names(in, out) is det.
-
-=======
:- type generic_call
---> higher_order(
prog_var,
@@ -329,7 +296,6 @@
---> can_remove
; cannot_remove.
->>>>>>> 1.62
% There may be two sorts of "builtin" predicates - those that we
% open-code using inline instructions (e.g. arithmetic predicates),
% and those which are still "internal", but for which we generate
@@ -391,15 +357,11 @@
list(prog_var)
)
; lambda_goal(
-<<<<<<< hlds_goal.m
- pred_or_func, % Is this a predicate or a function
-=======
- pred_or_func,
+ pred_or_func, % Is this a predicate or a function
lambda_eval_method,
% should be `normal' except for
% closures executed by Aditi.
fix_aditi_state_modes,
->>>>>>> 1.62
list(prog_var), % non-locals of the goal excluding
% the lambda quantified variables
list(prog_var), % lambda quantified variables
@@ -647,7 +609,7 @@
% Given the variable info field from a pragma c_code, get all the
% variable names.
-:- pred get_pragma_c_var_names(list(maybe(pair(string, mode))), list(string)).
+:- pred get_pragma_c_var_names(pragma_c_code_arg_info, list(string)).
:- mode get_pragma_c_var_names(in, out) is det.
% Get a description of a generic_call goal.
@@ -1497,16 +1459,11 @@
make_const_construction(Var, ConsId, Goal - GoalInfo) :-
RHS = functor(ConsId, []),
Inst = bound(unique, [functor(ConsId, [])]),
-<<<<<<< hlds_goal.m
Mode = (free(unique) - Inst) - (Inst - Inst),
- Unification = construct(Var, ConsId, [], []),
-=======
- Mode = (free -> Inst) - (Inst -> Inst),
VarToReuse = no,
RLExprnId = no,
Unification = construct(Var, ConsId, [], [],
VarToReuse, cell_is_unique, RLExprnId),
->>>>>>> 1.62
Context = unify_context(explicit, []),
Goal = unify(Var, RHS, Mode, Unification, Context),
set__singleton_set(NonLocals, Var),
--- hlds_module.m 1999/07/14 00:26:57 1.2
+++ hlds_module.m 1999/07/16 05:25:14
@@ -21,7 +21,8 @@
:- interface.
-:- import_module hlds_pred, hlds_data, prog_data, unify_proc, special_pred.
+:- import_module prog_data, module_qual.
+:- import_module hlds_pred, hlds_data, unify_proc, special_pred.
:- import_module globals, llds.
:- import_module relation, map, std_util, list, set, multi_map.
@@ -125,8 +126,9 @@
% Create an empty module_info for a given module name (and the
% global options).
-:- pred module_info_init(module_name, globals, module_info).
-:- mode module_info_init(in, in, out) is det.
+:- pred module_info_init(module_name, globals, partial_qualifier_info,
+ module_info).
+:- mode module_info_init(in, in, in, out) is det.
:- pred module_info_get_predicate_table(module_info, predicate_table).
:- mode module_info_get_predicate_table(in, out) is det.
@@ -147,13 +149,13 @@
module_info).
:- mode module_info_set_special_pred_map(in, in, out) is det.
-% This junk field is unused... feel free to replace it.
-
-:- pred module_info_get_junk(module_info, unit).
-:- mode module_info_get_junk(in, out) is det.
-
-:- pred module_info_set_junk(module_info, unit, module_info).
-:- mode module_info_set_junk(in, in, out) is det.
+:- pred module_info_get_partial_qualifier_info(module_info,
+ partial_qualifier_info).
+:- mode module_info_get_partial_qualifier_info(in, out) is det.
+
+:- pred module_info_set_partial_qualifier_info(module_info,
+ partial_qualifier_info, module_info).
+:- mode module_info_set_partial_qualifier_info(in, in, out) is det.
:- pred module_info_types(module_info, type_table).
:- mode module_info_types(in, out) is det.
@@ -554,7 +556,7 @@
predicate_table,
proc_requests,
special_pred_map,
- unit, % junk (unused)
+ partial_qualifier_info,
type_table,
user_inst_table,
mode_table,
@@ -607,14 +609,13 @@
% A predicate which creates an empty module
-module_info_init(Name, Globals, ModuleInfo) :-
+module_info_init(Name, Globals, QualifierInfo, ModuleInfo) :-
predicate_table_init(PredicateTable),
unify_proc__init_requests(Requests),
map__init(UnifyPredMap),
map__init(Types),
user_inst_table_init(UserInsts),
mode_table_init(Modes),
- Junk = unit,
map__init(Ctors),
set__init(StratPreds),
map__init(UnusedArgInfo),
@@ -637,11 +638,7 @@
[], [], StratPreds, UnusedArgInfo, 0, ModuleNames,
no_aditi_compilation, TypeSpecInfo),
ModuleInfo = module(ModuleSubInfo, PredicateTable, Requests,
-<<<<<<< hlds_module.m
- UnifyPredMap, GlobalData, Types, UserInsts, Modes, Ctors,
-=======
- UnifyPredMap, Junk, Types, Insts, Modes, Ctors,
->>>>>>> 1.47
+ UnifyPredMap, QualifierInfo, Types, UserInsts, Modes, Ctors,
ClassTable, SuperClassTable, InstanceTable, AssertionTable, 0).
%-----------------------------------------------------------------------------%
@@ -805,7 +802,7 @@
% B predicate_table,
% C proc_requests,
% D special_pred_map,
-% E unit, % junk (unused)
+% E partial_qualifier_info,
% F type_table,
% G user_inst_table,
% H mode_table,
@@ -836,7 +833,7 @@
module_info_get_special_pred_map(MI0, D) :-
MI0 = module(_, _, _, D, _, _, _, _, _, _, _, _, _, _).
-module_info_get_junk(MI0, E) :-
+module_info_get_partial_qualifier_info(MI0, E) :-
MI0 = module(_, _, _, _, E, _, _, _, _, _, _, _, _, _).
module_info_types(MI0, F) :-
@@ -886,7 +883,7 @@
MI0 = module(A, B, C, _, E, F, G, H, I, J, K, L, M, N),
MI = module(A, B, C, D, E, F, G, H, I, J, K, L, M, N).
-module_info_set_junk(MI0, E, MI) :-
+module_info_set_partial_qualifier_info(MI0, E, MI) :-
MI0 = module(A, B, C, D, _, F, G, H, I, J, K, L, M, N),
MI = module(A, B, C, D, E, F, G, H, I, J, K, L, M, N).
@@ -1507,18 +1504,21 @@
sym_name, list(pred_id)) is semidet.
:- mode predicate_table_search_pf_sym(in, in, in, out) is semidet.
- % predicate_table_insert(PredTable0, PredInfo, NeedQual, PredId,
- % PredTable).
+ % predicate_table_insert(PredTable0, PredInfo,
+ % NeedQual, PartialQualInfo, PredId, PredTable).
%
% Insert PredInfo into PredTable0 and assign it a new pred_id.
% You should check beforehand that the pred doesn't already
% occur in the table.
-:- pred predicate_table_insert(predicate_table, pred_info, need_qualifier,
- pred_id, predicate_table).
-:- mode predicate_table_insert(in, in, in, out, out) is det.
-
- % Equivalent to predicate_table_insert(PredTable0, PredInfo,
- % yes, PredId, PredTable).
+:- pred predicate_table_insert(predicate_table, pred_info, need_qualifier,
+ partial_qualifier_info, pred_id, predicate_table).
+:- mode predicate_table_insert(in, in, in, in, out, out) is det.
+
+ % Equivalent to predicate_table_insert/6, except that only the
+ % fully-qualified version of the predicate will be inserted into
+ % the predicate symbol table. This is useful for creating
+ % compiler-generated predicates which will only ever be accessed
+ % via fully-qualified names.
:- pred predicate_table_insert(predicate_table, pred_info, pred_id,
predicate_table).
:- mode predicate_table_insert(in, in, out, out) is det.
@@ -1950,11 +1950,22 @@
%-----------------------------------------------------------------------------%
predicate_table_insert(PredicateTable0, PredInfo, PredId, PredicateTable) :-
- predicate_table_insert(PredicateTable0, PredInfo, must_be_qualified,
- PredId, PredicateTable).
+ predicate_table_insert_2(PredicateTable0, PredInfo,
+ must_be_qualified, no, PredId, PredicateTable).
-predicate_table_insert(PredicateTable0, PredInfo, NeedQual,
+predicate_table_insert(PredicateTable0, PredInfo, NeedQual, QualInfo,
PredId, PredicateTable) :-
+ predicate_table_insert_2(PredicateTable0, PredInfo,
+ NeedQual, yes(QualInfo),
+ PredId, PredicateTable).
+
+:- pred predicate_table_insert_2(predicate_table, pred_info, need_qualifier,
+ maybe(partial_qualifier_info), pred_id, predicate_table).
+:- mode predicate_table_insert_2(in, in, in, in, out, out) is det.
+
+predicate_table_insert_2(PredicateTable0, PredInfo, NeedQual, MaybeQualInfo,
+ PredId, PredicateTable) :-
+
PredicateTable0 = predicate_table(Preds0, NextPredId0, PredIds0,
Pred_N_Index0, Pred_NA_Index0, Pred_MNA_Index0,
Func_N_Index0, Func_NA_Index0, Func_MNA_Index0),
@@ -1971,8 +1982,9 @@
pred_info_get_is_pred_or_func(PredInfo, PredOrFunc),
(
PredOrFunc = predicate,
- predicate_table_do_insert(Module, Name, Arity, NeedQual,
- PredId, Pred_N_Index0, Pred_N_Index,
+ predicate_table_do_insert(Module, Name, Arity,
+ NeedQual, MaybeQualInfo, PredId,
+ Pred_N_Index0, Pred_N_Index,
Pred_NA_Index0, Pred_NA_Index,
Pred_MNA_Index0, Pred_MNA_Index),
@@ -1984,8 +1996,9 @@
FuncArity is Arity - 1,
- predicate_table_do_insert(Module, Name, FuncArity, NeedQual,
- PredId, Func_N_Index0, Func_N_Index,
+ predicate_table_do_insert(Module, Name, FuncArity,
+ NeedQual, MaybeQualInfo, PredId,
+ Func_N_Index0, Func_N_Index,
Func_NA_Index0, Func_NA_Index,
Func_MNA_Index0, Func_MNA_Index),
@@ -2004,20 +2017,16 @@
Pred_N_Index, Pred_NA_Index, Pred_MNA_Index,
Func_N_Index, Func_NA_Index, Func_MNA_Index).
-:- pred predicate_table_do_insert(module_name, string, arity, need_qualifier,
- pred_id, name_index, name_index, name_arity_index, name_arity_index,
- module_name_arity_index, module_name_arity_index).
-:- mode predicate_table_do_insert(in, in, in, in, in,
+:- pred predicate_table_do_insert(module_name, string, arity,
+ need_qualifier, maybe(partial_qualifier_info),
+ pred_id, name_index, name_index, name_arity_index,
+ name_arity_index, module_name_arity_index, module_name_arity_index).
+:- mode predicate_table_do_insert(in, in, in, in, in, in,
in, out, in, out, in, out) is det.
-predicate_table_do_insert(Module, Name, Arity, NeedQual, PredId,
- N_Index0, N_Index, NA_Index0, NA_Index,
+predicate_table_do_insert(Module, Name, Arity, NeedQual, MaybeQualInfo,
+ PredId, N_Index0, N_Index, NA_Index0, NA_Index,
MNA_Index0, MNA_Index) :-
-
- % XXX the code below doesn't handle mixing of
- % `import_module' and `use_module' for
- % parent & child modules properly.
-
( NeedQual = may_be_unqualified ->
% insert the unqualified name into the name index
multi_map__set(N_Index0, Name, PredId, N_Index),
@@ -2025,21 +2034,25 @@
% insert the unqualified name/arity into the
% name/arity index
NA = Name / Arity,
- multi_map__set(NA_Index0, NA, PredId, NA_Index),
+ multi_map__set(NA_Index0, NA, PredId, NA_Index)
+ ;
+ N_Index = N_Index0,
+ NA_Index = NA_Index0
+ ),
+ ( MaybeQualInfo = yes(QualInfo) ->
% insert partially module-qualified versions
% of the name into the module:name/arity index
- get_partial_qualifiers(Module, PartialQuals),
+ get_partial_qualifiers(Module, QualInfo, PartialQuals),
list__map_foldl(lambda([AncModule::in, AncModule::out,
MNAs0::in, MNAs::out] is det,
insert_into_mna_index(AncModule, Name, Arity, PredId,
MNAs0, MNAs)),
PartialQuals, _, MNA_Index0, MNA_Index1)
;
- N_Index = N_Index0,
- NA_Index = NA_Index0,
MNA_Index1 = MNA_Index0
),
+
% insert the fully-qualified name into the
% module:name/arity index
insert_into_mna_index(Module, Name, Arity, PredId,
--- hlds_out.m 1999/07/14 00:26:57 1.2
+++ hlds_out.m 1999/07/16 05:22:19
@@ -1202,13 +1202,9 @@
io__write_string(")"),
io__write_string(Follow).
-<<<<<<< hlds_out.m
-hlds_out__write_goal_2(some(Vars, Goal), InstMap0, InstTable, ModuleInfo,
- VarSet, AppendVarnums, Indent, Follow, TypeQual) -->
-=======
-hlds_out__write_goal_2(some(Vars, CanRemove, Goal), ModuleInfo,
- VarSet, AppendVarnums, Indent, Follow, TypeQual) -->
->>>>>>> 1.223
+hlds_out__write_goal_2(some(Vars, CanRemove, Goal), InstMap0, InstTable,
+ ModuleInfo, VarSet, AppendVarnums,
+ Indent, Follow, TypeQual) -->
hlds_out__write_indent(Indent),
io__write_string("some ["),
mercury_output_vars(Vars, VarSet, AppendVarnums),
@@ -1336,14 +1332,9 @@
io__write_string(Follow)
).
-<<<<<<< hlds_out.m
-hlds_out__write_goal_2(higher_order_call(PredVar, ArgVars, _, _, _, PredOrFunc),
- _InstMap0, _InstTable, _ModuleInfo, VarSet, AppendVarnums,
- Indent, Follow, _) -->
-=======
hlds_out__write_goal_2(generic_call(GenericCall, ArgVars, _, _),
- ModuleInfo, VarSet, AppendVarnums, Indent, Follow, _) -->
->>>>>>> 1.223
+ _InstMap0, _InstTable, ModuleInfo, VarSet, AppendVarnums,
+ Indent, Follow, _) -->
% XXX we should print more info here
(
{ GenericCall = higher_order(PredVar, PredOrFunc, _) },
@@ -1375,20 +1366,10 @@
hlds_out__write_functor(term__atom("apply"), FuncArgVars,
VarSet, AppendVarnums)
),
-<<<<<<< hlds_out.m
- io__write_string(Follow).
-
-hlds_out__write_goal_2(
- class_method_call(TCInfoVar, MethodNum, ArgVars, _, _, _),
- _InstMap0, _InstTable, _ModuleInfo, VarSet, AppendVarnums,
- Indent, Follow, _) -->
- % XXX we should print more info here too
-=======
io__write_string(Follow)
;
{ GenericCall = class_method(TCInfoVar, MethodNum,
_ClassId, _MethodId) },
->>>>>>> 1.223
globals__io_lookup_string_option(dump_hlds_options, Verbose),
hlds_out__write_indent(Indent),
( { string__contains_char(Verbose, 'l') } ->
@@ -1605,14 +1586,6 @@
io__write_string(", "),
hlds_out__write_string_list([Name2 | Names]).
-<<<<<<< hlds_out.m
-:- pred hlds_out__write_unification(unification, instmap, inst_table,
- module_info, prog_varset, inst_varset, bool, int, io__state, io__state).
-:- mode hlds_out__write_unification(in, in, in, in, in, in, in, in, di, uo)
- is det.
-
-hlds_out__write_unification(assign(X, Y), _, _, _, ProgVarSet, _InstVarSet,
-=======
:- pred hlds_out__write_aditi_builtin(module_info, aditi_builtin,
simple_call_id, list(prog_var), prog_varset, bool, int, string,
io__state, io__state).
@@ -1734,12 +1707,12 @@
).
hlds_out__aditi_builtin_name(aditi_modify(_, _), "aditi_modify").
-:- pred hlds_out__write_unification(unification, module_info, prog_varset,
- inst_varset, bool, int, io__state, io__state).
-:- mode hlds_out__write_unification(in, in, in, in, in, in, di, uo) is det.
+:- pred hlds_out__write_unification(unification, instmap, inst_table,
+ module_info, prog_varset, inst_varset, bool, int, io__state, io__state).
+:- mode hlds_out__write_unification(in, in, in, in, in, in, in, in, di, uo)
+ is det.
-hlds_out__write_unification(assign(X, Y), _, ProgVarSet, _InstVarSet,
->>>>>>> 1.223
+hlds_out__write_unification(assign(X, Y), _, _, _, ProgVarSet, _InstVarSet,
AppendVarnums, Indent) -->
hlds_out__write_indent(Indent),
io__write_string("% "),
@@ -1755,14 +1728,9 @@
io__write_string(" == "),
mercury_output_var(Y, ProgVarSet, AppendVarnums),
io__write_string("\n").
-<<<<<<< hlds_out.m
-hlds_out__write_unification(construct(Var, ConsId, ArgVars, ArgModes), InstMap,
- InstTable, ModuleInfo, ProgVarSet, InstVarSet, AppendVarnums,
- Indent) -->
-=======
hlds_out__write_unification(construct(Var, ConsId, ArgVars, ArgModes, _, _, _),
- ModuleInfo, ProgVarSet, InstVarSet, AppendVarnums, Indent) -->
->>>>>>> 1.223
+ InstMap, InstTable, ModuleInfo, ProgVarSet, InstVarSet,
+ AppendVarnums, Indent) -->
hlds_out__write_indent(Indent),
io__write_string("% "),
mercury_output_var(Var, ProgVarSet, AppendVarnums),
@@ -1849,7 +1817,7 @@
is det.
hlds_out__write_unify_rhs_2(Rhs, InstTable, ModuleInfo, VarSet, InstVarSet,
- AppendVarnums, Indent, Follow, MaybeType, TypeQual) -->
+ AppendVarnums, Indent, Follow, MaybeType, TypeQual) -->
hlds_out__write_unify_rhs_3(Rhs, InstTable, ModuleInfo, VarSet,
InstVarSet, AppendVarnums, Indent, MaybeType, TypeQual),
io__write_string(Follow).
@@ -1874,19 +1842,11 @@
[]
).
hlds_out__write_unify_rhs_3(
-<<<<<<< hlds_out.m
- lambda_goal(PredOrFunc, NonLocals, Vars, Modes, Det,
- _IMDelta, Goal),
+ lambda_goal(PredOrFunc, EvalMethod, _, NonLocals, Vars, Modes,
+ Det, _IMDelta, Goal),
InstTable, ModuleInfo, VarSet, InstVarSet, AppendVarnums,
Indent, MaybeType, TypeQual) -->
{ Modes = argument_modes(ArgInstTable, ArgModes) },
-=======
- lambda_goal(PredOrFunc, EvalMethod, _, NonLocals, Vars, Modes,
- Det, Goal),
- ModuleInfo, VarSet, InstVarSet, AppendVarnums, Indent,
- MaybeType, TypeQual)
- -->
->>>>>>> 1.223
{ Indent1 is Indent + 1 },
{
EvalMethod = normal,
@@ -1900,17 +1860,11 @@
},
(
{ PredOrFunc = predicate },
-<<<<<<< hlds_out.m
- io__write_string("(pred("),
- hlds_out__write_var_modes(Vars, ArgModes, VarSet, InstVarSet,
- AppendVarnums, ArgInstTable),
-=======
io__write_string("("),
io__write_string(EvalStr),
io__write_string("pred("),
- hlds_out__write_var_modes(Vars, Modes, VarSet, InstVarSet,
- AppendVarnums),
->>>>>>> 1.223
+ hlds_out__write_var_modes(Vars, ArgModes, VarSet, InstVarSet,
+ AppendVarnums, ArgInstTable),
io__write_string(") is "),
mercury_output_det(Det),
io__write_string(" :-\n"),
@@ -1921,21 +1875,13 @@
io__write_string(")")
;
{ PredOrFunc = function },
-<<<<<<< hlds_out.m
{ pred_args_to_func_args(ArgModes, ParamModes, RetMode) },
{ pred_args_to_func_args(Vars, ParamVars, RetVar) },
- io__write_string("(func("),
- hlds_out__write_var_modes(ParamVars, ParamModes, VarSet,
- InstVarSet, AppendVarnums, ArgInstTable),
-=======
- { pred_args_to_func_args(Modes, ArgModes, RetMode) },
- { pred_args_to_func_args(Vars, ArgVars, RetVar) },
io__write_string("("),
io__write_string(EvalStr),
io__write_string("func("),
- hlds_out__write_var_modes(ArgVars, ArgModes, VarSet,
- InstVarSet, AppendVarnums),
->>>>>>> 1.223
+ hlds_out__write_var_modes(ParamVars, ParamModes, VarSet,
+ InstVarSet, AppendVarnums, ArgInstTable),
io__write_string(") = ("),
hlds_out__write_var_mode(RetVar, RetMode, VarSet,
InstVarSet, AppendVarnums, ArgInstTable),
@@ -2130,7 +2076,7 @@
;
hlds_out__write_goal_a(Goal1, InstMap0, InstTable,
ModuleInfo, VarSet, AppendVarnums, Indent,
- ",", TypeQual)
+ ",\n", TypeQual)
),
{ Goal1 = _ - GoalInfo },
{ goal_info_get_instmap_delta(GoalInfo, IMD) },
--- hlds_pred.m 1999/07/14 00:26:57 1.2
+++ hlds_pred.m 1999/07/16 05:25:44
@@ -490,10 +490,10 @@
:- pred pred_info_create(module_name, sym_name, tvarset, existq_tvars,
list(type), condition, prog_context, import_status, pred_markers,
- pred_or_func, class_constraints, aditi_owner, proc_info,
- proc_id, pred_info).
+ pred_or_func, class_constraints, aditi_owner, set(assert_id),
+ proc_info, proc_id, pred_info).
:- mode pred_info_create(in, in, in, in, in, in, in, in, in, in, in, in, in,
- out, out) is det.
+ in, out, out) is det.
:- pred pred_info_module(pred_info, module_name).
:- mode pred_info_module(in, out) is det.
@@ -657,6 +657,12 @@
:- pred pred_info_set_indexes(pred_info, list(index_spec), pred_info).
:- mode pred_info_set_indexes(in, in, out) is det.
+:- pred pred_info_get_assertions(pred_info, set(assert_id)).
+:- mode pred_info_get_assertions(in, out) is det.
+
+:- pred pred_info_set_assertions(pred_info, set(assert_id), pred_info).
+:- mode pred_info_set_assertions(in, in, out) is det.
+
:- pred pred_info_get_purity(pred_info, purity).
:- mode pred_info_get_purity(in, out) is det.
@@ -851,10 +857,13 @@
% it is an Aditi predicate. Set to
% the value of --aditi-user if no
% `:- pragma owner' declaration exists.
- list(index_spec)
+ list(index_spec),
% Indexes if this predicate is
% an Aditi base relation, ignored
% otherwise.
+ set(assert_id)
+ % List of assertions which
+ % mention this predicate.
).
pred_info_init(ModuleName, SymName, Arity, TypeVarSet, ExistQVars, Types,
@@ -867,15 +876,16 @@
list__delete_elems(TVars, ExistQVars, HeadTypeParams),
UnprovenBodyConstraints = [],
Indexes = [],
+ set__init(Assertions),
PredInfo = predicate(TypeVarSet, Types, Cond, ClausesInfo, Procs,
Context, PredModuleName, PredName, Arity, Status, TypeVarSet,
GoalType, Markers, PredOrFunc, ClassContext, ClassProofs,
ExistQVars, HeadTypeParams, UnprovenBodyConstraints, User,
- Indexes).
+ Indexes, Assertions).
pred_info_create(ModuleName, SymName, TypeVarSet, ExistQVars, Types, Cond,
Context, Status, Markers, PredOrFunc, ClassContext, User,
- ProcInfo, ProcId, PredInfo) :-
+ Assertions, ProcInfo, ProcId, PredInfo) :-
map__init(Procs0),
proc_info_declared_determinism(ProcInfo, MaybeDetism),
next_mode_id(Procs0, MaybeDetism, ProcId),
@@ -900,11 +910,11 @@
Context, ModuleName, PredName, Arity, Status, TypeVarSet,
clauses, Markers, PredOrFunc, ClassContext, ClassProofs,
ExistQVars, HeadTypeParams, UnprovenBodyConstraints, User,
- Indexes).
+ Indexes, Assertions).
pred_info_procids(PredInfo, ProcIds) :-
PredInfo = predicate(_, _, _, _, Procs, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _),
+ _, _, _, _, _, _, _, _, _, _),
map__keys(Procs, ProcIds).
pred_info_non_imported_procids(PredInfo, ProcIds) :-
@@ -937,57 +947,57 @@
pred_info_clauses_info(PredInfo, Clauses) :-
PredInfo = predicate(_, _, _, Clauses, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _).
pred_info_set_clauses_info(PredInfo0, Clauses, PredInfo) :-
PredInfo0 = predicate(A, B, C, _, E, F, G, H, I, J, K, L, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, Clauses, E, F, G, H, I, J, K,
- L, M, N, O, P, Q, R, S, T, U).
+ L, M, N, O, P, Q, R, S, T, U, V).
pred_info_arg_types(PredInfo, ArgTypes) :-
pred_info_arg_types(PredInfo, _TypeVars, _ExistQVars, ArgTypes).
pred_info_arg_types(PredInfo, TypeVars, ExistQVars, ArgTypes) :-
PredInfo = predicate(TypeVars, ArgTypes, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, ExistQVars, _, _, _, _).
+ _, _, _, _, _, ExistQVars, _, _, _, _, _).
pred_info_set_arg_types(PredInfo0, TypeVarSet, ExistQVars, ArgTypes,
PredInfo) :-
PredInfo0 = predicate(_, _, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
- _, R, S, T, U),
+ _, R, S, T, U, V),
PredInfo = predicate(TypeVarSet, ArgTypes, C, D, E, F, G, H, I, J, K,
- L, M, N, O, P, ExistQVars, R, S, T, U).
+ L, M, N, O, P, ExistQVars, R, S, T, U, V).
pred_info_procedures(PredInfo, Procs) :-
PredInfo = predicate(_, _, _, _, Procs, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _, _, _).
pred_info_set_procedures(PredInfo0, Procedures, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, _, F, G, H, I, J, K, L, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, Procedures, F, G, H, I, J, K, L, M,
- N, O, P, Q, R, S, T, U).
+ N, O, P, Q, R, S, T, U, V).
pred_info_context(PredInfo, Context) :-
PredInfo = predicate(_, _, _, _, _, Context, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _, _, _, _, _).
pred_info_module(PredInfo, Module) :-
PredInfo = predicate(_, _, _, _, _, _, Module, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _, _, _).
pred_info_name(PredInfo, PredName) :-
PredInfo = predicate(_, _, _, _, _, _, _, PredName, _, _, _,
- _, _, _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _, _, _).
pred_info_arity(PredInfo, Arity) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, Arity, _, _,
- _, _, _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _, _, _).
pred_info_import_status(PredInfo, ImportStatus) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, ImportStatus, _, _, _,
- _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _).
pred_info_is_imported(PredInfo) :-
pred_info_import_status(PredInfo, imported).
@@ -1020,35 +1030,35 @@
pred_info_mark_as_external(PredInfo0, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, _, K, L, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, imported, K, L, M,
- N, O, P, Q, R, S, T, U).
+ N, O, P, Q, R, S, T, U, V).
pred_info_set_import_status(PredInfo0, Status, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, _, K, L, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, Status, K,
- L, M, N, O, P, Q, R, S, T, U).
+ L, M, N, O, P, Q, R, S, T, U, V).
pred_info_typevarset(PredInfo, TypeVarSet) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, TypeVarSet, _, _,
- _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _).
pred_info_set_typevarset(PredInfo0, TypeVarSet, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, _, L, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, TypeVarSet, L, M,
- N, O, P, Q, R, S, T, U).
+ N, O, P, Q, R, S, T, U, V).
pred_info_get_goal_type(PredInfo, GoalType) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, GoalType, _,
- _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _).
pred_info_set_goal_type(PredInfo0, GoalType, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, _, M, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, GoalType, M,
- N, O, P, Q, R, S, T, U).
+ N, O, P, Q, R, S, T, U, V).
pred_info_requested_inlining(PredInfo0) :-
pred_info_get_markers(PredInfo0, Markers),
@@ -1082,41 +1092,41 @@
pred_info_get_markers(PredInfo, Markers) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, Markers,
- _, _, _, _, _, _, _, _).
+ _, _, _, _, _, _, _, _, _).
pred_info_set_markers(PredInfo0, Markers, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, _, N, O, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, Markers,
- N, O, P, Q, R, S, T, U).
+ N, O, P, Q, R, S, T, U, V).
pred_info_get_is_pred_or_func(PredInfo, IsPredOrFunc) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _,
- IsPredOrFunc, _, _, _, _, _, _, _).
+ IsPredOrFunc, _, _, _, _, _, _, _, _).
pred_info_set_class_context(PredInfo0, ClassContext, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, _, P,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- ClassContext, P, Q, R, S, T, U).
+ ClassContext, P, Q, R, S, T, U, V).
pred_info_get_class_context(PredInfo, ClassContext) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _,
- ClassContext, _, _, _, _, _, _).
+ ClassContext, _, _, _, _, _, _, _).
pred_info_set_constraint_proofs(PredInfo0, Proofs, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _,
- Q, R, S, T, U),
+ Q, R, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- O, Proofs, Q, R, S, T, U).
+ O, Proofs, Q, R, S, T, U, V).
pred_info_get_constraint_proofs(PredInfo, ConstraintProofs) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- ConstraintProofs, _, _, _, _, _).
+ ConstraintProofs, _, _, _, _, _, _).
pred_info_get_exist_quant_tvars(PredInfo, ExistQVars) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, ExistQVars, _, _, _, _).
+ _, ExistQVars, _, _, _, _, _).
pred_info_get_univ_quant_tvars(PredInfo, UnivQVars) :-
pred_info_arg_types(PredInfo, ArgTypes),
@@ -1127,45 +1137,55 @@
pred_info_get_head_type_params(PredInfo, HeadTypeParams) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, HeadTypeParams, _, _, _).
+ _, _, HeadTypeParams, _, _, _, _).
pred_info_set_head_type_params(PredInfo0, HeadTypeParams, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
- Q, _, S, T, U),
+ Q, _, S, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
- Q, HeadTypeParams, S, T, U).
+ Q, HeadTypeParams, S, T, U, V).
pred_info_get_unproven_body_constraints(PredInfo, UnprovenBodyConstraints) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, UnprovenBodyConstraints, _, _).
+ _, _, UnprovenBodyConstraints, _, _, _).
pred_info_set_unproven_body_constraints(PredInfo0, UnprovenBodyConstraints,
PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
- Q, R, _, T, U),
+ Q, R, _, T, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P,
- Q, R, UnprovenBodyConstraints, T, U).
+ Q, R, UnprovenBodyConstraints, T, U, V).
pred_info_get_aditi_owner(PredInfo, Owner) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, Owner, _).
+ _, _, _, _, Owner, _, _).
pred_info_set_aditi_owner(PredInfo0, Owner, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- O, P, Q, R, S, _, U),
+ O, P, Q, R, S, _, U, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- O, P, Q, R, S, Owner, U).
+ O, P, Q, R, S, Owner, U, V).
pred_info_get_indexes(PredInfo, Indexes) :-
PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, Indexes).
+ _, _, _, _, _, Indexes, _).
pred_info_set_indexes(PredInfo0, Indexes, PredInfo) :-
PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- O, P, Q, R, S, T, _),
+ O, P, Q, R, S, T, _, V),
PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
- O, P, Q, R, S, T, Indexes).
+ O, P, Q, R, S, T, Indexes, V).
+
+pred_info_get_assertions(PredInfo, Assertions) :-
+ PredInfo = predicate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+ _, _, _, _, _, _, Assertions).
+
+pred_info_set_assertions(PredInfo0, Assertions, PredInfo) :-
+ PredInfo0 = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
+ O, P, Q, R, S, T, U, _),
+ PredInfo = predicate(A, B, C, D, E, F, G, H, I, J, K, L, M, N,
+ O, P, Q, R, S, T, U, Assertions).
%-----------------------------------------------------------------------------%
@@ -1322,9 +1342,12 @@
proc_info_set_maybe_termination_info(ProcInfo0, TermInfo, ProcInfo),
map__apply_to_list(ArgVars, VarTypes, ArgTypes),
+
+ set__init(Assertions),
+
pred_info_create(ModuleName, SymName, TVarSet, ExistQVars, ArgTypes,
true, Context, local, Markers, predicate, ClassContext,
- Owner, ProcInfo, ProcId, PredInfo),
+ Owner, Assertions, ProcInfo, ProcId, PredInfo),
module_info_get_predicate_table(ModuleInfo0, PredTable0),
predicate_table_insert(PredTable0, PredInfo, PredId,
@@ -1612,10 +1635,8 @@
% typeinfo liveness for them, so that
% deep_copy and accurate gc have the
% RTTI they need for copying closures.
-<<<<<<< hlds_pred.m
- inst_table
+ inst_table,
% the inst_table for this proc
-=======
maybe(rl_exprn_id)
% For predicates with an
% `aditi_top_down' marker, which are
@@ -1623,7 +1644,6 @@
% of the connection, we generate an RL
% expression, for which this is an
% identifier. See rl_update.m.
->>>>>>> 1.62
).
% Some parts of the procedure aren't known yet. We initialize
@@ -1654,31 +1674,19 @@
MaybeDet, BodyVarSet, BodyTypes, HeadVars, Modes, MaybeArgLives,
ClauseBody, MContext, StackSlots, InferredDet, CanProcess,
ArgInfo, InitialLiveness, TVarsMap, TCVarsMap, eval_normal,
-<<<<<<< hlds_pred.m
- no, no, DeclaredModes, IsAddressTaken, InstTable
-=======
- no, no, DeclaredModes, IsAddressTaken, RLExprn
->>>>>>> 1.62
+ no, no, DeclaredModes, IsAddressTaken, InstTable, RLExprn
).
proc_info_set(DeclaredDetism, BodyVarSet, BodyTypes, HeadVars, HeadModes,
HeadLives, Goal, Context, StackSlots, InferredDetism,
CanProcess, ArgInfo, Liveness, TVarMap, TCVarsMap, ArgSizes,
-<<<<<<< hlds_pred.m
Termination, IsAddressTaken, InstTable, ProcInfo) :-
-=======
- Termination, IsAddressTaken, ProcInfo) :-
RLExprn = no,
->>>>>>> 1.62
ProcInfo = procedure(
DeclaredDetism, BodyVarSet, BodyTypes, HeadVars, HeadModes,
HeadLives, Goal, Context, StackSlots, InferredDetism,
CanProcess, ArgInfo, Liveness, TVarMap, TCVarsMap, eval_normal,
-<<<<<<< hlds_pred.m
- ArgSizes, Termination, no, IsAddressTaken, InstTable).
-=======
- ArgSizes, Termination, no, IsAddressTaken, RLExprn).
->>>>>>> 1.62
+ ArgSizes, Termination, no, IsAddressTaken, InstTable, RLExprn).
proc_info_create(VarSet, VarTypes, HeadVars, HeadModes, Detism, Goal,
Context, TVarMap, TCVarsMap, IsAddressTaken, InstTable,
@@ -1690,18 +1698,14 @@
ProcInfo = procedure(yes(Detism), VarSet, VarTypes, HeadVars, HeadModes,
MaybeHeadLives, Goal, Context, StackSlots, Detism, yes, [],
Liveness, TVarMap, TCVarsMap, eval_normal, no, no, no,
-<<<<<<< hlds_pred.m
- IsAddressTaken, InstTable).
-=======
- IsAddressTaken, RLExprn).
->>>>>>> 1.62
+ IsAddressTaken, InstTable, RLExprn).
proc_info_set_body(ProcInfo0, VarSet, VarTypes, HeadVars, Goal,
TI_VarMap, TCI_VarMap, ProcInfo) :-
ProcInfo0 = procedure(A, _, _, _, E, F, _,
- H, I, J, K, L, M, _, _, P, Q, R, S, T, U),
+ H, I, J, K, L, M, _, _, P, Q, R, S, T, U, V),
ProcInfo = procedure(A, VarSet, VarTypes, HeadVars, E, F, Goal,
- H, I, J, K, L, M, TI_VarMap, TCI_VarMap, P, Q, R, S, T, U).
+ H, I, J, K, L, M, TI_VarMap, TCI_VarMap, P, Q, R, S, T, U, V).
proc_info_interface_determinism(ProcInfo, Determinism) :-
proc_info_declared_determinism(ProcInfo, MaybeDeterminism),
@@ -1760,95 +1764,92 @@
proc_info_declared_determinism(ProcInfo, A) :-
ProcInfo = procedure(A, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_varset(ProcInfo, B) :-
ProcInfo = procedure(_, B, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_vartypes(ProcInfo, C) :-
ProcInfo = procedure(_, _, C, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_headvars(ProcInfo, D) :-
ProcInfo = procedure(_, _, _, D, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_argmodes(ProcInfo, E) :-
ProcInfo = procedure(_, _, _, _, E, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_maybe_arglives(ProcInfo, F) :-
ProcInfo = procedure(_, _, _, _, _, F, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_goal(ProcInfo, G) :-
ProcInfo = procedure(_, _, _, _, _, _, G, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_context(ProcInfo, H) :-
ProcInfo = procedure(_, _, _, _, _, _, _, H, _, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_stack_slots(ProcInfo, I) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, I, _, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_inferred_determinism(ProcInfo, J) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, J, _, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_can_process(ProcInfo, K) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, K, _, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_arg_info(ProcInfo, L) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, L, _, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_liveness_info(ProcInfo, M) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, M, _, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_typeinfo_varmap(ProcInfo, N) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, N, _, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_typeclass_info_varmap(ProcInfo, O) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, O, _,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_eval_method(ProcInfo, P) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, P,
- _, _, _, _, _).
+ _, _, _, _, _, _).
proc_info_get_maybe_arg_size_info(ProcInfo, Q) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- Q, _, _, _, _).
+ Q, _, _, _, _, _).
proc_info_get_maybe_termination_info(ProcInfo, R) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, R, _, _, _).
+ _, R, _, _, _, _).
proc_info_maybe_declared_argmodes(ProcInfo, S) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, S, _, _).
+ _, _, S, _, _, _).
proc_info_is_address_taken(ProcInfo, T) :-
ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, T, _).
+ _, _, _, T, _, _).
--------------------------------------------------------------------------
mercury-developers mailing list
Post messages to: mercury-developers at cs.mu.oz.au
Administrative Queries: owner-mercury-developers at cs.mu.oz.au
Subscriptions: mercury-developers-request at cs.mu.oz.au
--------------------------------------------------------------------------
More information about the developers
mailing list