mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-13 12:53:53 +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.
396 lines
13 KiB
Mathematica
396 lines
13 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1996-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.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% File: prog_io_goal.m.
|
|
% Main author: fjh.
|
|
%
|
|
% This module defines the predicates that parse goals.
|
|
|
|
:- module prog_io_goal.
|
|
|
|
:- interface.
|
|
|
|
:- import_module prog_data.
|
|
:- import_module list, term.
|
|
|
|
% Convert a single term into a goal.
|
|
%
|
|
:- pred parse_goal(term, prog_varset, goal, prog_varset).
|
|
:- mode parse_goal(in, in, out, out) is det.
|
|
|
|
% Convert a term, possibly starting with `some [Vars]', into
|
|
% a list of variables and a goal. (If the term doesn't start
|
|
% with `some [Vars]', we return an empty list of variables.)
|
|
%
|
|
:- pred parse_some_vars_goal(term, prog_varset, list(prog_var),
|
|
goal, prog_varset).
|
|
:- mode parse_some_vars_goal(in, in, out, out, out) is det.
|
|
|
|
% parse_lambda_expression/3 converts the first argument to a lambda/2
|
|
% expression into a list of arguments, a list of their corresponding
|
|
% modes, and a determinism.
|
|
% The syntax of a lambda expression is
|
|
% `lambda([Var1::Mode1, ..., VarN::ModeN] is Det, Goal)'
|
|
% but this predicate just parses the first argument, i.e. the
|
|
% `[Var1::Mode1, ..., VarN::ModeN] is Det'
|
|
% part.
|
|
%
|
|
:- pred parse_lambda_expression(term, list(prog_term),
|
|
list(mode), determinism).
|
|
:- mode parse_lambda_expression(in, out, out, out) is semidet.
|
|
|
|
% parse_pred_expression/3 converts the first argument to a :-/2
|
|
% higher-order pred expression into a list of variables, a list
|
|
% of their corresponding modes, and a determinism. This is just
|
|
% a variant on parse_lambda_expression with a different syntax:
|
|
% `(pred(Var1::Mode1, ..., VarN::ModeN) is Det :- Goal)'.
|
|
%
|
|
:- pred parse_pred_expression(term, lambda_eval_method, list(prog_term),
|
|
list(mode), determinism).
|
|
:- mode parse_pred_expression(in, out, out, out, out) is semidet.
|
|
|
|
% parse_dcg_pred_expression/3 converts the first argument to a -->/2
|
|
% higher-order dcg pred expression into a list of arguments, a list
|
|
% of their corresponding modes and the two dcg argument modes, and a
|
|
% determinism.
|
|
% This is a variant of the higher-order pred syntax:
|
|
% `(pred(Var1::Mode1, ..., VarN::ModeN, DCG0Mode, DCGMode)
|
|
% is Det --> Goal)'.
|
|
%
|
|
:- pred parse_dcg_pred_expression(term, lambda_eval_method, list(prog_term),
|
|
list(mode), determinism).
|
|
:- mode parse_dcg_pred_expression(in, out, out, out, out) is semidet.
|
|
|
|
% parse_func_expression/3 converts the first argument to a :-/2
|
|
% higher-order func expression into a list of arguments, a list
|
|
% of their corresponding modes, and a determinism. The syntax
|
|
% of a higher-order func expression is
|
|
% `(func(Var1::Mode1, ..., VarN::ModeN) = (VarN1::ModeN1) is Det
|
|
% :- Goal)'.
|
|
%
|
|
:- pred parse_func_expression(term, lambda_eval_method, list(prog_term),
|
|
list(mode), determinism).
|
|
:- mode parse_func_expression(in, out, out, out, out) is semidet.
|
|
|
|
% parse_lambda_eval_method/3 extracts the `aditi' or `aditi_top_down'
|
|
% annotation (if any) from a pred expression and returns the rest
|
|
% of the term.
|
|
:- pred parse_lambda_eval_method(term(T), lambda_eval_method, term(T)).
|
|
:- mode parse_lambda_eval_method(in, out, out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module mode_util, purity, prog_io, prog_io_util, term_util.
|
|
:- import_module term.
|
|
:- import_module int, map, string, std_util.
|
|
|
|
% Parse a goal.
|
|
%
|
|
% We could do some error-checking here, but all errors are picked up
|
|
% in either the type-checker or parser anyway.
|
|
|
|
parse_goal(Term, VarSet0, Goal, VarSet) :-
|
|
% first, get the goal context
|
|
(
|
|
Term = term__functor(_, _, Context)
|
|
;
|
|
Term = term__variable(_),
|
|
term__context_init(Context)
|
|
),
|
|
% We just check if it matches the appropriate pattern
|
|
% for one of the builtins. If it doesn't match any of the
|
|
% builtins, then it's just a predicate call.
|
|
(
|
|
% check for builtins...
|
|
Term = term__functor(term__atom(Name), Args, Context),
|
|
parse_goal_2(Name, Args, VarSet0, GoalExpr, VarSet1)
|
|
->
|
|
Goal = GoalExpr - Context,
|
|
VarSet = VarSet1
|
|
;
|
|
% it's not a builtin
|
|
term__coerce(Term, ArgsTerm),
|
|
(
|
|
% check for predicate calls
|
|
sym_name_and_args(ArgsTerm, SymName, Args)
|
|
->
|
|
VarSet = VarSet0,
|
|
Goal = call(SymName, Args, pure) - Context
|
|
;
|
|
% A call to a free variable, or to a number or string.
|
|
% Just translate it into a call to call/1 - the typechecker
|
|
% will catch calls to numbers and strings.
|
|
Goal = call(unqualified("call"), [ArgsTerm], pure)
|
|
- Context,
|
|
VarSet = VarSet0
|
|
)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred parse_goal_2(string, list(term), prog_varset, goal_expr, prog_varset).
|
|
:- mode parse_goal_2(in, in, in, out, out) is semidet.
|
|
parse_goal_2("true", [], V, true, V).
|
|
parse_goal_2("fail", [], V, fail, V).
|
|
parse_goal_2("=", [A0, B0], V, unify(A, B), V) :-
|
|
term__coerce(A0, A),
|
|
term__coerce(B0, B).
|
|
/******
|
|
Since (A -> B) has different semantics in standard Prolog
|
|
(A -> B ; fail) than it does in NU-Prolog or Mercury (A -> B ; true),
|
|
for the moment we'll just disallow it.
|
|
parse_goal_2("->", [A0, B0], V0, if_then(Vars, A, B), V) :-
|
|
parse_some_vars_goal(A0, V0, Vars, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
******/
|
|
parse_goal_2(",", [A0, B0], V0, (A, B), V) :-
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
parse_goal_2("&", [A0, B0], V0, (A & B), V) :-
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
parse_goal_2(";", [A0, B0], V0, R, V) :-
|
|
(
|
|
A0 = term__functor(term__atom("->"), [X0, Y0], _Context)
|
|
->
|
|
parse_some_vars_goal(X0, V0, Vars, X, V1),
|
|
parse_goal(Y0, V1, Y, V2),
|
|
parse_goal(B0, V2, B, V),
|
|
R = if_then_else(Vars, X, Y, B)
|
|
;
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V),
|
|
R = (A;B)
|
|
).
|
|
/****
|
|
For consistency we also disallow if-then
|
|
parse_goal_2("if",
|
|
[term__functor(term__atom("then"), [A0, B0], _)], V0,
|
|
if_then(Vars, A, B), V) :-
|
|
parse_some_vars_goal(A0, V0, Vars, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
****/
|
|
parse_goal_2("else", [
|
|
term__functor(term__atom("if"), [
|
|
term__functor(term__atom("then"), [A0, B0], _)
|
|
], _),
|
|
C0
|
|
], V0,
|
|
if_then_else(Vars, A, B, C), V) :-
|
|
parse_some_vars_goal(A0, V0, Vars, A, V1),
|
|
parse_goal(B0, V1, B, V2),
|
|
parse_goal(C0, V2, C, V).
|
|
parse_goal_2("not", [A0], V0, not(A), V) :-
|
|
parse_goal(A0, V0, A, V).
|
|
parse_goal_2("\\+", [A0], V0, not(A), V) :-
|
|
parse_goal(A0, V0, A, V).
|
|
parse_goal_2("all", [Vars0, A0], V0, all(Vars, A), V):-
|
|
term__coerce(Vars0, Vars1),
|
|
term__vars(Vars1, Vars),
|
|
parse_goal(A0, V0, A, V).
|
|
|
|
% handle implication
|
|
parse_goal_2("<=", [A0, B0], V0, implies(B, A), V):-
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
|
|
parse_goal_2("=>", [A0, B0], V0, implies(A, B), V):-
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
|
|
% handle equivalence
|
|
parse_goal_2("<=>", [A0, B0], V0, equivalent(A, B), V):-
|
|
parse_goal(A0, V0, A, V1),
|
|
parse_goal(B0, V1, B, V).
|
|
|
|
parse_goal_2("some", [Vars0, A0], V0, some(Vars, A), V):-
|
|
parse_list_of_vars(Vars0, Vars1),
|
|
list__map(term__coerce_var, Vars1, Vars),
|
|
parse_goal(A0, V0, A, V).
|
|
|
|
% The following is a temporary hack to handle `is' in
|
|
% the parser - we ought to handle it in the code generation -
|
|
% but then `is/2' itself is a bit of a hack
|
|
%
|
|
parse_goal_2("is", [A0, B0], V, unify(A, B), V) :-
|
|
term__coerce(A0, A),
|
|
term__coerce(B0, B).
|
|
parse_goal_2("impure", [A0], V0, A, V) :-
|
|
parse_goal_with_purity(A0, V0, (impure), A, V).
|
|
parse_goal_2("semipure", [A0], V0, A, V) :-
|
|
parse_goal_with_purity(A0, V0, (semipure), A, V).
|
|
|
|
|
|
:- pred parse_goal_with_purity(term, prog_varset, purity, goal_expr,
|
|
prog_varset).
|
|
:- mode parse_goal_with_purity(in, in, in, out, out) is det.
|
|
|
|
parse_goal_with_purity(A0, V0, Purity, A, V) :-
|
|
parse_goal(A0, V0, A1, V),
|
|
( A1 = call(Pred, Args, pure) - _ ->
|
|
A = call(Pred, Args, Purity)
|
|
;
|
|
% Inappropriate placement of an impurity marker, so we treat
|
|
% it like a predicate call. typecheck.m prints out something
|
|
% descriptive for these errors.
|
|
purity_name(Purity, PurityString),
|
|
term__coerce(A0, A2),
|
|
A = call(unqualified(PurityString), [A2], pure)
|
|
).
|
|
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
parse_some_vars_goal(A0, VarSet0, Vars, A, VarSet) :-
|
|
(
|
|
A0 = term__functor(term__atom("some"), [Vars0, A1], _Context),
|
|
parse_list_of_vars(Vars0, Vars1)
|
|
->
|
|
list__map(term__coerce_var, Vars1, Vars),
|
|
parse_goal(A1, VarSet0, A, VarSet)
|
|
;
|
|
Vars = [],
|
|
parse_goal(A0, VarSet0, A, VarSet)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
parse_lambda_expression(LambdaExpressionTerm, Args, Modes, Det) :-
|
|
LambdaExpressionTerm = term__functor(term__atom("is"),
|
|
[LambdaArgsTerm, DetTerm], _),
|
|
DetTerm = term__functor(term__atom(DetString), [], _),
|
|
standard_det(DetString, Det),
|
|
parse_lambda_args(LambdaArgsTerm, Args, Modes).
|
|
|
|
:- pred parse_lambda_args(term, list(prog_term), list(mode)).
|
|
:- mode parse_lambda_args(in, out, out) is semidet.
|
|
|
|
parse_lambda_args(Term, Args, Modes) :-
|
|
( Term = term__functor(term__atom("."), [Head, Tail], _Context) ->
|
|
parse_lambda_arg(Head, Arg, Mode),
|
|
Args = [Arg | Args1],
|
|
Modes = [Mode | Modes1],
|
|
parse_lambda_args(Tail, Args1, Modes1)
|
|
; Term = term__functor(term__atom("[]"), [], _) ->
|
|
Args = [],
|
|
Modes = []
|
|
;
|
|
Args = [Arg],
|
|
Modes = [Mode],
|
|
parse_lambda_arg(Term, Arg, Mode)
|
|
).
|
|
|
|
:- pred parse_lambda_arg(term, prog_term, mode).
|
|
:- mode parse_lambda_arg(in, out, out) is semidet.
|
|
|
|
parse_lambda_arg(Term, ArgTerm, Mode) :-
|
|
Term = term__functor(term__atom("::"), [ArgTerm0, ModeTerm], _),
|
|
term__coerce(ArgTerm0, ArgTerm),
|
|
convert_mode(ModeTerm, Mode).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
parse_pred_expression(PredTerm, EvalMethod, Args, Modes, Det) :-
|
|
PredTerm = term__functor(term__atom("is"),
|
|
[PredEvalArgsTerm, DetTerm], _),
|
|
DetTerm = term__functor(term__atom(DetString), [], _),
|
|
standard_det(DetString, Det),
|
|
parse_lambda_eval_method(PredEvalArgsTerm, EvalMethod, PredArgsTerm),
|
|
PredArgsTerm = term__functor(term__atom("pred"), PredArgsList, _),
|
|
parse_pred_expr_args(PredArgsList, Args, Modes).
|
|
|
|
parse_dcg_pred_expression(PredTerm, EvalMethod, Args, Modes, Det) :-
|
|
PredTerm = term__functor(term__atom("is"),
|
|
[PredEvalArgsTerm, DetTerm], _),
|
|
DetTerm = term__functor(term__atom(DetString), [], _),
|
|
standard_det(DetString, Det),
|
|
parse_lambda_eval_method(PredEvalArgsTerm, EvalMethod, PredArgsTerm),
|
|
PredArgsTerm = term__functor(term__atom("pred"), PredArgsList, _),
|
|
parse_dcg_pred_expr_args(PredArgsList, Args, Modes).
|
|
|
|
parse_func_expression(FuncTerm, EvalMethod, Args, Modes, Det) :-
|
|
%
|
|
% parse a func expression with specified modes and determinism
|
|
%
|
|
FuncTerm = term__functor(term__atom("is"), [EqTerm, DetTerm], _),
|
|
EqTerm = term__functor(term__atom("="),
|
|
[FuncEvalArgsTerm, RetTerm], _),
|
|
DetTerm = term__functor(term__atom(DetString), [], _),
|
|
standard_det(DetString, Det),
|
|
parse_lambda_eval_method(FuncEvalArgsTerm, EvalMethod, FuncArgsTerm),
|
|
FuncArgsTerm = term__functor(term__atom("func"), FuncArgsList, _),
|
|
parse_pred_expr_args(FuncArgsList, Args0, Modes0),
|
|
parse_lambda_arg(RetTerm, RetArg, RetMode),
|
|
list__append(Args0, [RetArg], Args),
|
|
list__append(Modes0, [RetMode], Modes).
|
|
parse_func_expression(FuncTerm, EvalMethod, Args, Modes, Det) :-
|
|
%
|
|
% parse a func expression with unspecified modes and determinism
|
|
%
|
|
FuncTerm = term__functor(term__atom("="),
|
|
[FuncEvalArgsTerm, RetArg], _),
|
|
parse_lambda_eval_method(FuncEvalArgsTerm, EvalMethod, FuncArgsTerm),
|
|
FuncArgsTerm = term__functor(term__atom("func"), Args0, _),
|
|
%
|
|
% the argument modes default to `in',
|
|
% the return mode defaults to `out',
|
|
% and the determinism defaults to `det'.
|
|
%
|
|
in_mode(InMode),
|
|
out_mode(OutMode),
|
|
list__length(Args0, NumArgs),
|
|
list__duplicate(NumArgs, InMode, Modes0),
|
|
RetMode = OutMode,
|
|
Det = det,
|
|
list__append(Modes0, [RetMode], Modes),
|
|
list__append(Args0, [RetArg], Args1),
|
|
list__map(term__coerce, Args1, Args).
|
|
|
|
parse_lambda_eval_method(Term0, EvalMethod, Term) :-
|
|
( Term0 = term__functor(term__atom(MethodStr), [Term1], _) ->
|
|
( MethodStr = "aditi_bottom_up" ->
|
|
EvalMethod = (aditi_bottom_up),
|
|
Term = Term1
|
|
; MethodStr = "aditi_top_down" ->
|
|
EvalMethod = (aditi_top_down),
|
|
Term = Term1
|
|
;
|
|
EvalMethod = normal,
|
|
Term = Term0
|
|
)
|
|
;
|
|
EvalMethod = normal,
|
|
Term = Term0
|
|
).
|
|
|
|
:- pred parse_pred_expr_args(list(term), list(prog_term), list(mode)).
|
|
:- mode parse_pred_expr_args(in, out, out) is semidet.
|
|
|
|
parse_pred_expr_args([], [], []).
|
|
parse_pred_expr_args([Term|Terms], [Arg|Args], [Mode|Modes]) :-
|
|
parse_lambda_arg(Term, Arg, Mode),
|
|
parse_pred_expr_args(Terms, Args, Modes).
|
|
|
|
% parse_dcg_pred_expr_args is like parse_pred_expr_args except
|
|
% that the last two elements of the list are the modes of the
|
|
% two dcg arguments.
|
|
:- pred parse_dcg_pred_expr_args(list(term), list(prog_term),
|
|
list(mode)).
|
|
:- mode parse_dcg_pred_expr_args(in, out, out) is semidet.
|
|
|
|
parse_dcg_pred_expr_args([DCGModeTerm0, DCGModeTerm1], [],
|
|
[DCGMode0, DCGMode1]) :-
|
|
convert_mode(DCGModeTerm0, DCGMode0),
|
|
convert_mode(DCGModeTerm1, DCGMode1).
|
|
parse_dcg_pred_expr_args([Term|Terms], [Arg|Args], [Mode|Modes]) :-
|
|
Terms = [_, _|_],
|
|
parse_lambda_arg(Term, Arg, Mode),
|
|
parse_dcg_pred_expr_args(Terms, Args, Modes).
|
|
|
|
%-----------------------------------------------------------------------------%
|