mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-23 13:23:47 +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.
237 lines
11 KiB
Mathematica
237 lines
11 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1995-1999 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU Library General
|
|
% Public License - see the file COPYING.LIB in the Mercury distribution.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% file: ops.m.
|
|
% main author: fjh.
|
|
% stability: low.
|
|
%
|
|
% Here's where we maintain the table of current operators.
|
|
%
|
|
% XXX In the current implementation the table is fixed and cannot be
|
|
% modified at run-time.
|
|
%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module ops.
|
|
:- interface.
|
|
|
|
:- type ops__specifier
|
|
---> fx ; fy ; xf ; yf ; xfx ; yfx ; xfy ; fxx ; fxy ; fyx.
|
|
|
|
:- type ops__assoc
|
|
---> x ; y.
|
|
|
|
:- type ops__class
|
|
---> infix(ops__assoc, ops__assoc)
|
|
; prefix(ops__assoc)
|
|
; binary_prefix(ops__assoc, ops__assoc)
|
|
; postfix(ops__assoc).
|
|
|
|
:- type ops__table.
|
|
|
|
:- type ops__priority == int.
|
|
|
|
% create an ops_table with the standard Mercury operators.
|
|
:- pred ops__init_op_table(ops__table).
|
|
:- mode ops__init_op_table(uo) is det.
|
|
|
|
% check whether a string is the name of an infix operator,
|
|
% and if it is, return its precedence and associativity.
|
|
:- pred ops__lookup_infix_op(ops__table, string, int, ops__assoc, ops__assoc).
|
|
:- mode ops__lookup_infix_op(in, in, out, out, out) is semidet.
|
|
|
|
% check whether a string is the name of a prefix operator,
|
|
% and if it is, return its precedence and associativity.
|
|
:- pred ops__lookup_prefix_op(ops__table, string, int, ops__assoc).
|
|
:- mode ops__lookup_prefix_op(in, in, out, out) is semidet.
|
|
|
|
% check whether a string is the name of a binary prefix operator,
|
|
% and if it is, return its precedence and associativity.
|
|
:- pred ops__lookup_binary_prefix_op(ops__table, string,
|
|
int, ops__assoc, ops__assoc).
|
|
:- mode ops__lookup_binary_prefix_op(in, in, out, out, out) is semidet.
|
|
|
|
% check whether a string is the name of a postfix operator,
|
|
% and if it is, return its precedence and associativity.
|
|
:- pred ops__lookup_postfix_op(ops__table, string, int, ops__assoc).
|
|
:- mode ops__lookup_postfix_op(in, in, out, out) is semidet.
|
|
|
|
% check whether a string is the name of an operator
|
|
:- pred ops__lookup_op(ops__table, string).
|
|
:- mode ops__lookup_op(in, in) is semidet.
|
|
|
|
% convert an ops__specifer (e.g. `xfy') to an ops__class
|
|
% (e.g. `infix(x, y)').
|
|
:- pred ops__op_specifier_to_class(ops__specifier, ops__class).
|
|
:- mode ops__op_specifier_to_class(in, out) is det.
|
|
% :- mode ops__op_specifier_to_class(out, in) is semidet.
|
|
|
|
% Returns the highest priority number (the lowest is zero).
|
|
% Note that due to Prolog tradition, the priority numbers
|
|
% are backwards: higher numbers mean lower priority
|
|
% and lower numbers mean higher priority. Sorry...
|
|
:- pred ops__max_priority(ops__priority).
|
|
:- mode ops__max_priority(out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- type ops__table ---> ops__table. % XXX
|
|
|
|
:- type ops__category ---> before ; after.
|
|
|
|
ops__op_specifier_to_class(fx, prefix(x)).
|
|
ops__op_specifier_to_class(fy, prefix(y)).
|
|
ops__op_specifier_to_class(xf, postfix(x)).
|
|
ops__op_specifier_to_class(yf, postfix(y)).
|
|
ops__op_specifier_to_class(xfx, infix(x,x)).
|
|
ops__op_specifier_to_class(yfx, infix(y,x)).
|
|
ops__op_specifier_to_class(xfy, infix(x,y)).
|
|
ops__op_specifier_to_class(fxx, binary_prefix(x,x)).
|
|
ops__op_specifier_to_class(fyx, binary_prefix(y,x)).
|
|
ops__op_specifier_to_class(fxy, binary_prefix(x,y)).
|
|
|
|
ops__lookup_infix_op(_OpTable, Name, Priority, LeftAssoc, RightAssoc) :-
|
|
ops__op_table(Name, after, Specifier, Priority), !,
|
|
ops__op_specifier_to_class(Specifier,
|
|
infix(LeftAssoc, RightAssoc)).
|
|
|
|
ops__lookup_prefix_op(_OpTable, Name, Priority, LeftAssoc) :-
|
|
ops__op_table(Name, before, Specifier, Priority), !,
|
|
ops__op_specifier_to_class(Specifier, prefix(LeftAssoc)).
|
|
|
|
ops__lookup_binary_prefix_op(_OpTable, Name, Priority, LeftAssoc, RightAssoc) :-
|
|
ops__op_table(Name, before, Specifier, Priority), !,
|
|
ops__op_specifier_to_class(Specifier,
|
|
binary_prefix(LeftAssoc, RightAssoc)).
|
|
|
|
ops__lookup_postfix_op(_OpTable, Name, Priority, LeftAssoc) :-
|
|
ops__op_table(Name, after, Specifier, Priority), !,
|
|
ops__op_specifier_to_class(Specifier, postfix(LeftAssoc)).
|
|
|
|
ops__lookup_op(_OpTable, Name) :-
|
|
ops__op_table(Name, _, _, _).
|
|
|
|
% Changes here may require changes to compiler/mercury_to_mercury.m
|
|
% and doc/transition_guide.texi.
|
|
:- pred ops__op_table(string, ops__category, ops__specifier, ops__priority).
|
|
:- mode ops__op_table(in, in, out, out) is semidet.
|
|
:- mode ops__op_table(in, out, out, out) is nondet.
|
|
|
|
ops__op_table("*", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("**", after, xfy, 200). % standard ISO Prolog
|
|
ops__op_table("+", after, yfx, 500). % standard ISO Prolog
|
|
ops__op_table("+", before, fx, 500). % traditional Prolog (not ISO)
|
|
ops__op_table(",", after, xfy, 1000). % standard ISO Prolog
|
|
ops__op_table("&", after, xfy, 1025). % Mercury extension
|
|
ops__op_table("-", after, yfx, 500). % standard ISO Prolog
|
|
ops__op_table("-", before, fx, 200). % standard ISO Prolog
|
|
ops__op_table("--->", after, xfy, 1179). % Mercury extension
|
|
ops__op_table("-->", after, xfx, 1200). % standard ISO Prolog
|
|
ops__op_table("->", after, xfy, 1050). % standard ISO Prolog
|
|
ops__op_table(".", after, xfy, 600). % traditional Prolog (not ISO)
|
|
ops__op_table("/", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("//", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("/\\", after, yfx, 500). % standard ISO Prolog
|
|
ops__op_table(":", after, yfx, 600). % `xfy' in ISO Prolog
|
|
ops__op_table(":-", after, xfx, 1200). % standard ISO Prolog
|
|
ops__op_table(":-", before, fx, 1200). % standard ISO Prolog
|
|
ops__op_table("::", after, xfx, 1175). % Mercury extension
|
|
ops__op_table(";", after, xfy, 1100). % standard ISO Prolog
|
|
ops__op_table("<", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("<<", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("<=", after, xfy, 920). % Mercury/NU-Prolog extension
|
|
ops__op_table("<=>", after, xfy, 920). % Mercury/NU-Prolog extension
|
|
ops__op_table("=", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("=..", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("=:=", after, xfx, 700). % standard ISO Prolog (*)
|
|
ops__op_table("=<", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("==", after, xfx, 700). % standard ISO Prolog (*)
|
|
ops__op_table("==>", after, xfx, 1175). % Mercury extension
|
|
ops__op_table("=>", after, xfy, 920). % Mercury/NU-Prolog extension
|
|
ops__op_table("=\\=", after, xfx, 700). % standard ISO Prolog (*)
|
|
ops__op_table(">", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table(">=", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table(">>", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("?-", before, fx, 1200). % standard ISO Prolog (*)
|
|
ops__op_table("@<", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("@=<", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("@>", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("@>=", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("\\", before, fx, 200). % standard ISO Prolog
|
|
ops__op_table("\\+", before, fy, 900). % standard ISO Prolog
|
|
ops__op_table("\\/", after, yfx, 500). % standard ISO Prolog
|
|
ops__op_table("\\=", after, xfx, 700). % standard ISO Prolog
|
|
ops__op_table("\\==", after, xfx, 700). % standard ISO Prolog (*)
|
|
ops__op_table("^", after, xfy, 200). % standard ISO Prolog
|
|
ops__op_table("aditi_bottom_up", before, fx, 500). % Mercury extension
|
|
ops__op_table("aditi_top_down", before, fx, 500). % Mercury extension
|
|
ops__op_table("all", before, fxy, 950). % Mercury/NU-Prolog extension
|
|
ops__op_table("and", after, xfy, 720). % NU-Prolog extension
|
|
ops__op_table("assertion", before, fx, 1199). % Mercury extension
|
|
ops__op_table("div", after, yfx, 400). % standard ISO Prolog
|
|
ops__op_table("else", after, xfy, 1170). % Mercury/NU-Prolog extension
|
|
ops__op_table("end_module", before, fx, 1199). % Mercury extension
|
|
ops__op_table("export_adt", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_cons", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_module", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_op", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_pred", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_sym", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("export_type", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("func", before, fx, 800). % Mercury extension
|
|
ops__op_table("if", before, fx, 1160). % Mercury/NU-Prolog extension
|
|
ops__op_table("import_adt", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("import_cons", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("import_module", before, fx, 1199). % Mercury extension
|
|
ops__op_table("include_module", before, fx, 1199). % Mercury extension
|
|
ops__op_table("import_op", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("import_pred", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("import_sym", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("import_type", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("impure", before, fy, 800). % Mercury extension
|
|
ops__op_table("inst", before, fx, 1199). % Mercury extension
|
|
ops__op_table("instance", before, fx, 1199). % Mercury extension
|
|
ops__op_table("is", after, xfx, 701). % ISO Prolog says prec 700
|
|
ops__op_table("lambda", before, fxy, 950). % Mercury extension
|
|
ops__op_table("mod", after, xfx, 400). % Standard ISO Prolog
|
|
ops__op_table("mode", before, fx, 1199). % Mercury extension
|
|
ops__op_table("module", before, fx, 1199). % Mercury extension
|
|
ops__op_table("not", before, fy, 900). % Mercury/NU-Prolog extension
|
|
ops__op_table("or", after, xfy, 740). % NU-Prolog extension
|
|
ops__op_table("pragma", before, fx, 1199). % Mercury extension
|
|
ops__op_table("pred", before, fx, 800). % Mercury/NU-Prolog extension
|
|
ops__op_table("rem", after, xfx, 400). % Standard ISO Prolog
|
|
ops__op_table("rule", before, fx, 1199). % NU-Prolog extension
|
|
ops__op_table("semipure", before, fy, 800). % Mercury extension
|
|
ops__op_table("some", before, fxy, 950). % Mercury/NU-Prolog extension
|
|
ops__op_table("then", after, xfx, 1150). % Mercury/NU-Prolog extension
|
|
ops__op_table("type", before, fx, 1180). % Mercury extension
|
|
ops__op_table("typeclass", before, fx, 1199). % Mercury extension
|
|
ops__op_table("use_adt", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_cons", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_module", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_op", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_pred", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_sym", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("use_type", before, fx, 1199). % Mercury extension (NYI)
|
|
ops__op_table("when", after, xfx, 900). % NU-Prolog extension (*)
|
|
ops__op_table("where", after, xfx, 1175). % NU-Prolog extension (*)
|
|
ops__op_table("~", before, fy, 900). % Goedel (*)
|
|
ops__op_table("~=", after, xfx, 700). % NU-Prolog (*)
|
|
|
|
% (*) means that the operator is not useful in Mercury
|
|
% and is provided only for compatibility.
|
|
% (NYI) means that the operator is reserved for some Not Yet Implemented
|
|
% future purpose
|
|
|
|
ops__init_op_table(ops__table).
|
|
|
|
ops__max_priority(1200).
|
|
|
|
%-----------------------------------------------------------------------------%
|