mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-17 06:47:17 +00:00
9551640f556c20d54558fd93ffb2d00d10025a93
116 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Zoltan Somogyi
|
9551640f55 |
Import only one compiler module per line. Sort the blocks of imports.
Estimated hours taken: 2 Branches: main compiler/*.m: Import only one compiler module per line. Sort the blocks of imports. This makes it easier to merge in changes. In a couple of places, remove unnecessary imports. |
||
|
Simon Taylor
|
482105e074 |
Allow user-defined comparison functions using the syntax
Estimated hours taken: 10
Branches: main
Allow user-defined comparison functions using the syntax
:- type t ---> t where equality is t_equal, comparison is t_compare.
.
Allow user-defined equality and comparison for foreign types using the syntax
:- pragma foreign_type(c, t, "c_t") where
equality is t_equal, comparison is t_compare.
compiler/prog_data.m:
compiler/mercury_to_mercury.m:
compiler/hlds_out.m:
compiler/*.m:
Allow comparison predicates in `type' and `pragma foreign_type'
declarations
compiler/hlds_data.m:
compiler/*.m:
Allow equality and comparison predicates to be attached
to foreign types.
compiler/prog_io.m:
compiler/prog_io_pragma.m:
Parse the new syntax.
compiler/make_hlds.m:
Don't add the types to the HLDS or do typechecking if
there are errors in the type declarations.
Test case: tests/invalid/foreign_type_visibility.m.
compiler/foreign.m:
compiler/special_pred.m:
compiler/type_util.m:
Check whether foreign types have user-defined equality.
compiler/unify_proc.m:
Generate clauses for user-defined comparison,
and clauses for unification for foreign types.
compiler/intermod.m:
Resolve overloading before writing the `.opt' files.
library/builtin.m:
Add `uo' modes for promise_only_solution, for use in
user-defined comparison predicates.
Add types and insts to allow declaration of user-defined
comparison predicates using `with_type` and `with_inst`.
We already have types and insts `builtin__comparison_pred',
but they have a different argument ordering to `compare/3'.
NEWS:
doc/reference_manual.texi:
Document the change.
tests/hard_coded/Mmakefile:
tests/hard_coded/user_compare.{m,exp}:
Test case.
tests/invalid/Mmakefile:
tests/invalid/typeclass_test_{9,10}.{m,err_exp}:
tests/invalid/purity/purity_nonsense{,2}.{m,err_exp}:
The change to error-checking in make_hlds.m meant that
the compilation stopped before some errors in
typeclass_test_9.m were detected. The code which
tests for those errors is now in typeclass_test_10.m.
|
||
|
Fergus Henderson
|
ef7ed9c2f5 |
Support impurity declarations for higher-order code.
Estimated hours taken: 24 Branches: main Support impurity declarations for higher-order code. In particular, allow `impure' and `semipure' annotations on higher-order types, higher-order calls, and lambda expresions. NEWS: doc/reference_manual.texi: Document the new language feature. compiler/hlds_goal.m: compiler/hlds_pred.m: Add `purity' field to - the `higher_order' alternative of the hlds_goal.generic_call type - the `higher_order' alternative of the hlds_pred.generic_call_id type - the `lambda_goal' alternative of the hlds_goal.unify_rhs type compiler/type_util.m: Add a new `purity' argument to the procedures dealing with higher-order types. Add code for parsing impure/semipure higher-order types. compiler/lambda.m: compiler/make_hlds.m: compiler/typecheck.m: compiler/post_typecheck.m: compiler/purity.m: compiler/polymorphism.m: Various minor changes to support impure/semipure higher-order lambda expressions. compiler/polymorphism.m: compiler/pseudo_type_info.m: XXX ought to change these to include purity in the RTTI for higher-order function types. compiler/simplify.m: Don't try to optimize semipure/impure higher-order calls. compiler/assertion.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/det_analysis.m: compiler/det_util.m: compiler/equiv_type.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/magic.m: compiler/magic_util.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/pd_util.m: compiler/prog_rep.m: compiler/pseudo_type_info.m: compiler/quantification.m: compiler/recompilation.usage.m: compiler/rl_gen.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_traversal.m: compiler/term_util.m: compiler/unify_gen.m: compiler/unique_modes.m: Trivial changes to handle the new purity fields and/or arguments. tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/impure_func_t5_fixed2.m: tests/hard_coded/purity/impure_func_t5_fixed2.exp: tests/hard_coded/purity/impure_func_t5_fixed2.exp2: tests/hard_coded/purity/impure_pred_t1_fixed3.m: tests/hard_coded/purity/impure_pred_t1_fixed3.exp: tests/invalid/purity/Mmakefile: tests/invalid/purity/impure_func_t5_fixed.m: tests/invalid/purity/impure_func_t5_fixed.err_exp: tests/invalid/purity/impure_pred_t1_fixed.m: tests/invalid/purity/impure_pred_t1_fixed.err_exp: Add new test cases to test the new feature. tests/invalid/purity/impure_func_t5.err_exp: tests/invalid/purity/impure_pred_t1.err_exp: tests/invalid/purity/impure_pred_t2.err_exp: tests/invalid/purity/purity.err_exp: tests/invalid/purity/purity_nonsense.err_exp: Update the expected error messages for existing test cases. tests/invalid/purity/.cvsignore: New file, copied from tests/invalid/.cvsignore. |
||
|
Fergus Henderson
|
17f53149a4 |
Implement `:- pragma reserve_tag(<TypeName>/<Arity>).'.
Estimated hours taken: 6 Branches: main Implement `:- pragma reserve_tag(<TypeName>/<Arity>).'. This has the same effect as the `--reserve-tag' option, except that it only applies to specified type, rather than to all types. doc/reference_manual.texi: Document the new feature. (However, the documentation is currently commented out.) compiler/prog_data.m: Add `reserve_tag(sym_name, arity)' to the `pragma_type' type. compiler/hlds_data.m: Add a new boolean field to the representation of discriminated union type bodies to record whether or not the type has a reserved tag. compiler/prog_io_pragma.m: Add code to parse the new pragma. compiler/make_hlds.m: Add code to process the new pragma: - check all the appropriate semantic restrictions: - the pragma must have the same visibility as the type - the type must be defined - the type must be a discriminated union type - warn if there are multiple such pragmas for the same type - call make_tags.m to recompute the tags used for the constructor. - record the presence of the reserve_tag pragma in the HLDS type definition body compiler/make_tags.m: compiler/type_util.m: Add an extra argument to assign_constructor_tags (in make_tags.m) and type_constructors_should_be_no_tag (in type_util.m) to specify whether or not there was a `reserve_tag' pragma. Reserve a tag if either this argument or the global `reserve_tag' option is set. compiler/intermod.m: Output a `:- reserve_tag' pragma whenever outputting a type to which such a pragma applies. compiler/ml_type_gen.m: compiler/ml_unify_gen.m: Ignore the reserved_tag field. XXX This means that the `reserve_tag' pragma (or the compiler option) won't have much effect if --high-level-data is set. compiler/code_util.m: compiler/det_report.m: compiler/hlds_out.m: compiler/magic_util.m: compiler/mercury_to_mercury.m: compiler/mode_util.m: compiler/module_qual.m: compiler/modules.m: compiler/post_typecheck.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/special_pred.m: compiler/stack_opt.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_util.m: compiler/type_ctor_info.m: compiler/unify_gen.m: compiler/unify_proc.m: Trivial changes to handle the new reserved_tag field of hlds_type_defn_body. tests/valid/Mmakefile: tests/valid/reserve_tag.m: tests/invalid/Mmakefile: tests/invalid/reserve_tag.m: tests/invalid/reserve_tag.err_exp: Some tests of the new feature. |
||
|
Ralph Becket
|
3607da6191 |
Added infix `.' as a module separator. This is paving the way to phasing
Estimated hours taken: 3 Branches: main Added infix `.' as a module separator. This is paving the way to phasing out `:' as a module separator in order to use it as a synonym for `with_type` instead. NEWS: Report the change. compiler/prog_io.m: compiler/type_util.m: Changed so that `.'/2 is recognised as a module separator. library/ops.m: Change associativity of `.'/2 from xfy to yfx. |
||
|
Ralph Becket
|
1cdfefc8ae | Backed out last change due to wrong log message | ||
|
Ralph Becket
|
bfd2905743 |
NEWS for Mercury release 0.12:
------------------------------ HIGHLIGHTS ========== Changes to the Mercury language: * Infix `.' is now accepted as a module name separator. Changes to the Mercury compiler: * Nothing yet. Portability improvements: * Nothing yet. Changes to the Mercury debugger: * Nothing yet. Changes to the compiler back-ends: * Nothing yet. Numerous minor improvements to the Mercury standard library. DETAILED LISTING ================ Changes to the Mercury language: * Infix `.' is now accepted as a module name separator. Hence it is now possible to write io.write_string and list.member to mean the same thing as io__write_string and list__member, for instance. This has required changing the associativity of `.' from xfy to yfx and from precedence 600 to 10. Changes to the Mercury standard library: * We've added the three predicates, `is_nan/1', `is_inf/1' and `is_nan_or_inf/1' to float.m. These predicates are for use only on systems which support IEEE floating point arithmetic. * The determinisms of the following predicates in the `std_util' module have been changed from cc_nondet to cc_multi: arg_cc/3 and limited_deconstruct_cc/3 (formerly limited_deconstruct_cc/5). The success or failure of these predicates is now encoded in a maybe type. * The incorrect cc_nondet modes of the following predicates in the `deconstruct' module have been removed: arg/4, limited_deconstruct/6. cc_multi version of the predicates have been introduced where the success or failure of the predicate has been encoded into a maybe type. Changes to the extras distribution: * Nothing yet. Changes to the Mercury compiler: * Nothing yet. Portability improvements: * Nothing yet. Changes to the Mercury debugger: * Nothing yet. Changes to the compiler back-ends: * Nothing yet. NEWS for Mercury 0.11 --------------------- HIGHLIGHTS ========== Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution. A new regex module for string matching and search-and-replace in the extras distribution. DETAILED LISTING ================ Changes to the Mercury language: * We have added support for constrained polymorphic modes. See the section on Constrained Polymorphic Modes in the Modes chapter of the Mercury Language Reference Manual. * A more general alternative to DCG syntax has been added to the language to simplify the manipulation of threaded state. See the section on State Variables in the Syntax chapter in the Mercury Language Reference Manual. * If a higher-order function term has inst 'ground' it is now assumed to have the standard higher-order function inst 'func(in, .., in) = out is det'. This makes higher-order functional programming much easier, particularly when passing functions to polymorphic predicates. This change is not completely backwards compatible since, for safety, we must now disallow calls that would cause a variable that has a nonstandard function inst to become 'ground'. * Predicate and function type and mode declarations can now be expressed in terms of higher-order predicate and function types and insts, rather than explicitly listing the argument types and modes. This is useful where several predicates or functions must have the the same type and mode signature. For example: :- type foldl_pred(T, U) == pred(T, U, U). :- inst foldl_pred == (pred(in, in, out) is det). :- pred p `with_type` foldl_pred(T, U) `with_inst` foldl_pred. For more information see the "Predicate and function type declarations" section of the "Types" chapter and the "Predicate and function mode declarations" section of the "Modes chapter" of the Mercury Language Reference Manual. * The constructor for lists is now called '[|]' rather than '.'. `./2' will eventually become the module qualification operator. This change only affects programs which use `./2' explicitly. Programs which only use the `[H | T]' syntax will be unaffected. * We've added a new kind of expression to the language. A unification expression, written `X @ Y', unifies X and Y and returns the result. Unification expressions are most useful when writing switches: p(X, X) :- X = f(_, _). can now be written as p(X @ f(_, _), X). See the "Data-terms" section of the "Syntax" chapter of the Mercury Language Reference Manual for more details. * We've extended the language to allow you to specify different clauses for different modes of a predicate or function. This is done by putting mode annotations in the head of each clause. For example, you can write :- mode p(in). :- mode p(out). p(X::in) :- ... /* clause for the `in' mode */ p(X::out) :- ... /* clause for the `out' mode */ For predicates or functions which have different clauses for different modes, you need to either (1) add a `pragma promise_pure' declaration for the predicate or function, and ensure that the declarative semantics remains the same in each mode, or (2) declare the predicate as impure. * We now allow `:- pragma promise_semipure' declarations. For more information, see the "Impurity" chapter of the Mercury Language Reference Manual. * We've added `:- pragma c_import_module' declarations, which are used to make the C declarations for predicates and functions with `:- pragma export' declarations in the imported module visible to any C code in the importing module. `mmake' uses `:- pragma c_import_module' declarations to make sure that the header file for the imported module is built before it is needed, which it can't do if the header file is explicitly #included. * The foreign language interface has been generalized to support interfacing with languages other than C. In particular, the Mercury compiler's .NET back-end now supports interfacing with C#, IL, and "Managed C++" (C++ with Microsoft's extensions for the .NET CLR). Mercury procedures can be defined using inline code fragments written in any of these languages. For details, see the new "Foreign language interface" chapter of the Mercury Language Reference Manual. * We've removed the undocumented operators `export_adt', `export_cons', `export_module', `export_op', `export_pred', `export_sym', `export_type', `import_adt', `import_cons', `import_op', `import_pred', `import_sym', `import_type' `use_adt', `use_cons', `use_op', `use_pred', `use_sym' and `use_type'. These operators were reserved for module system extensions which are unlikely to be implemented. Changes to the Mercury standard library: * The Prolog-style term comparison operators @<, @=<, @>, @>= are now builtin. * A new builtin function ordering/2 has been added. * We've added a function to io.m to construct io__error codes from error messages: `io__make_io_error'. * The assumptions that we make about user supplied comparison predicates and functions have been relaxed to allow more general orderings. The new assumptions are documented in builtin.m. * The builtin predicates !/0 and !/2 from Mercury's Prolog heritage have been removed (`!' is now a prefix operator used in the state variable syntax). * We have added the type class `pprint__doc/1' and a new concatenation operator, `++/2', which should make it easier to construct doc values. * Performance bugs in `pprint__to_doc' have now been fixed. Even very large terms can now be converted to docs and pretty printed without causing a machine to thrash or run out of memory. * `io__read_file' and `io__read_file_as_string' now have better error handling. The result types have changed, so code using these predicates will need minor modifications. * We've added predicates `io__input_stream_foldl', `io__input_stream_foldl_io' and `io__input_stream_foldl2_io', which apply a predicate to each character of an input stream in turn. * We've added predicates `io__binary_input_stream_foldl', `io__binary_input_stream_foldl_io' and `io__binary_input_stream_foldl2_io', which apply a predicate to each byte of a binary input stream in turn. * We've added versions of `io__print', `io__write' and `io__write_univ' that allow the caller to specify how they should treat values of noncanonical types, e.g. types in which a single semantic value may have more than one syntactic expression. * We've added four new predicates to allow programs to retrieve current streams: `io__current_input_stream', `io__current_output_stream', `io__current_binary_input_stream', and `io__current_binary_output_stream'. * We've added a predicate to io.m to return the last modification time of a file: `io__file_modification_time'. * We've added cc_multi modes to io__write_list/5 and io__write_list/6. * You can now close stdin, stdout and stderr. * We've added four functions to list.m for mapping functions over corresponding members of lists: list__map_corresponding/3, list__map_corresponding3/4, list__filter_map_corresponding/3 and list__filter_map_corresponding3/4. * We've added some other new functions to list.m, namely list__last_det/2, list__split_last/3 and list__split_last_det/3. * We've added cc_multi modes to list__foldl/4 and list__foldr/4. * We've added a predicate list__map_foldl2. * As mentioned above, the constructor for lists has changed from './2' to `[|]/2'. This change affects the behaviour of the term manipulation predicates in the standard library when dealing with values of type `term__term/1' representing lists. The affected predicates are parser__read_term, parser__read_term_from_string, term__type_to_term, term__term_to_type, term_io__read_term and term_io__write_term. Also beware that std_util__functor and std_util__deconstruct now return `[|]' rather than `.' for lists, and calls to std_util__construct which construct lists may need to be updated. * We've added the predicate list__is_empty/1 and list__is_not_empty/1. * We've added the predicate list__remove_adjacent_dups/3. * We've added a function version of error/1, called func_error/1, to require.m. * ops.m now defines a typeclass which can be used to define operator precedence tables for use by parser.m and term_io.m. See samples/calculator2.m for an example program. The `ops__table' type has been renamed `ops__mercury_op_table'. `ops__init_op_table' has been renamed `ops__init_mercury_op_table'. `ops__max_priority' is now a function taking an operator table argument. * The predicates and functions in int.m, float.m, math.m and array.m now generate exceptions rather than program aborts on domain errors and out-of-bounds array accesses. There are new functions `float__unchecked_quotient/2', `int__unchecked_quotient/2' and `int__unchecked_rem/2' for which no checking is performed and the behaviour if the right operand is zero is undefined. * We've removed the reverse modes of the arithmetic functions in float.m and extras/complex_numbers. (Because of rounding errors, the functions aren't actually reversible.) * float__pow now works for negative exponents, and runs much faster for large exponents. * We've removed the destructive update modes of string__set_char, string__set_char_det and string__unsafe_set_char. The compiler currently always stores constant strings in static data, even if they are passed to procedures with mode `di', so any attempt to update a constant string will cause a crash. Fixing this properly will be a lot of work, so for now we have just removed the modes. * We've added string__suffix, string__words/1, string__foldr, string__foldl_substring and string__foldr_substring. * The exception module has a new predicate `try_store', which is like `try_io', but which works with stores rather than io__states. * We've fixed a bug in time.m. Type `tm' didn't store the day of the month, which meant that the functions which required that field (e.g. time__asctime, time__mktime) did not work. The order of the fields of type `time__tm' has been changed so that comparison of values of type `tm' whose `tm_dst' fields are identical is equivalent to comparison of the times those values represent. * std_util.m now contains predicates and functions `map_maybe', `fold_maybe', `map_fold_maybe' and `map_fold2_maybe', which are analogues of `list__map', `list__foldl', `list__map_foldl' and `list__map_foldl2' operating on values of type `maybe' instead of `list'. * We've added a predicate to io.m to return the last modification time of a file (io__file_modification_time). * There is a variant of io__call_system, io__call_system_return_signal which on interrupt returns the number of the signal which interrupted the command rather than just an error message. * We've added added several new predicates for deconstructing terms to std_util.m. `named_argument' and `det_named_argument' are analogous to `argument' and `det_argument' respectively, but specify the desired argument by its name, not its position. We have also added committed choice version of all the predicates that deconstruct terms. These differ from the existing versions in that they do not abort when called upon to deconstruct non-canonical terms, such as values of types with user-defined equality. * We've added a new predicate `intersect_list' in each of the modules implementing sets in the Mercury standard library. * We've added a predicate version of `set__fold'. * We've added function versions of `builtin__unsafe_promise_unique', `ops__init_op_table' and `ops__max_priority'. * We've added a version of `getopt__process_options' which returns the option arguments. * `getopt__process_options' has been modified to allow negation of accumulating options. Negating an accumulating option empties the accumulated list of strings. * We've added some functions to the term_io module to return printable representations of term components as strings. * We've made the outputs of the string concatenation primitives unique. * New convenience/readability predicates `int__even/1' and `int__odd/1'. * New predicate benchmark_det_io for benchmarking code that performs I/O. * We've removed the long obsolete `int__builtin_*' and `float__builtin_float_*' predicates, which were synonyms for the arithmetic functions dating from when Mercury didn't have functions. * We've added int:'/'/2 as a synonym for int:'//'/2 and false/0 as a built-in synonym for fail/0 (both left-overs from Mercury's Prolog heritage.) * dir:'/'/2 is now a synonym for `dir__make_path_name'. * We've removed the long obsolete predicates `io__read_anything', `io__write_anything', and `io__print_anything', which were long ago renamed as `io__read', `io__write', and `io__print' respectively. * We've added random__random/5, which produces a random integer in a given range, and random__randcount/3, which returns the number of distinct random numbers that can be generated. Changes to the extras distribution: * The lex subdirectory now contains a new module, regex, which provides for more traditional string-based ways of defining regular expressions and provides string matching and search-and-replace functionality. * There's a new testing tool called "quickcheck", which is similar to Haskell's "QuickCheck". See quickcheck/tutes/index.html. * The interface to Moose has been changed in a non-backwards compatible way to support user-defined modes for the parser state and integrate better with lex. Changes to the Mercury compiler: * There is a new `--make' option which performs most of the functions of Mmake. The advantages of `mmc --make' are that no `mmake depend' step is necessary and the dependencies are more accurate. Parallel builds are not yet supported. See the "Using Mmake" chapter of the "Mercury User's Guide" for details. * The Mercury compiler can now perform smart recompilation, enabled by the `--smart-recompilation' option. With smart recompilation, when the interface of a module changes, only modules which use the changed declarations are recompiled. Smart recompilation does not yet work with `--intermodule-optimization'. * The Mercury compiler can now handle arbitrary mappings from source files to module names. If the program contains modules for which the source file name does not match the module name, before generating the dependencies the command `mmc -f SOURCES' must be run, where `SOURCES' is a list of the names of all of the source files. If the names of the source files all match the contained module names, `mmc -f' need not be run. * There is a new `--use-grade-subdirs' option which is similar to `--use-subdirs', but allows multiple grades to be built in a directory at the same time. `--use-grade-subdirs' does not work with Mmake (it does work with `mmc --make'). * The compiler and scripts accept a `--mercury-stdlib-dir' option, which overrides the configured location of the Mercury standard library. There is also an environment variable MERCURY_STDLIB_DIR which has the same effect. The environment variables which were previously used to override the location of the standard library (MERCURY_ALL_C_INCL_DIRS, MERCURY_ALL_MC_C_INCL_DIRS, MERCURY_INT_DIR, MERCURY_C_LIB_DIR, MERCURY_MOD_LIB_MODS, MERCURY_TRACE_LIB_MODS) are now deprecated, and will be removed in a future release. MERCURY_C_INCL_DIR has already been removed. * We've added a new compiler option `--warn-non-tail-recursion', which causes the compiler to issue a warning about any directly recursive call that is not a tail call. * The automatically generated header files for modules containing `pragma export' declarations are now named `<module>.mh', not `<module>.h'. This avoids conflicts with system header files. * We've fixed a long-standing bug in the handling of module imports. Previously, if `module1' imported `module2' which imported `module3' in its interface section, then any types, insts, modes and typeclasses defined in the interface of `module3' could be used in `module1' even if `module1' did not import `module3' directly. This change will break some existing programs, but that is easily fixed by adding any necessary `:- import_module' or `:- use_module' declarations. * Options for the Mercury runtime can now be set at compile time using the new `--runtime-flags' option of ml and c2init. * We've added a new optimization pass -- constraint propagation. Constraint propagation attempts to transform the code so that goals which can fail are executed as early as possible. It is enabled with the `--constraint-propagation' option (or `--local-constraint-propagation' for a more restricted version of the transformation). * The Mercury compiler can now perform inter-module optimization using information from transitively imported modules. This is especially useful for back-ends which do not support abstract equivalence types properly (for example the .NET backend). To disable this behaviour and only optimize using information from directly imported modules, use the option `--no-read-opt-files-transitively'. * For each `--Xflags' option there is now a `--Xflag' option which allows a single quoted argument to be passed to the invoked program. This is useful where the argument is a directory name containing spaces. * The `--convert-to-goedel' option has been removed. It never really worked anyway. Portability improvements: * Mac OS X is now supported "out-of-the-box". See README.MacOSX for details. * On Windows we now support generating non-Cygwin executables. The Mercury compiler source distribution can be configured using `configure --with-cc="gcc -mno-cygwin"'. This option ensures that the Mercury libraries are only linked with the standard Windows libraries, not the Cygwin Unix emulation library, so Mercury programs don't need Cygwin, and use DOS/Windows-style path names rather than Cygwin's Unix-style path names. Note that you still need Cygwin to install and use Mercury. The change is that the programs which you build using Mercury don't need Cygwin anymore. * Better conformance to ANSI/ISO C. We now pass all the tests in the Mercury test suite when the compiler is built with the "lcc" C compiler, which is more strict about ANSI/ISO C conformance than GNU C. This should also make it easier to port to other C compilers. Changes to the Mercury debugger: * The debugger can now print goals just as Prolog debuggers do. At an exit port of e.g. append, the command "print goal" will print the current goal in a form such as "append([1], [2], [1, 2])". * You can now navigate terms in the debugger by argument name as well as by argument number. * The debugger can now print higher order values. * The debugger can now print type_info structures. However, since such structures are normally of interest to implementors only, the debugger will print such values only if the user gives the command "print_optionals on". * The debugger can now perform command line completion when compiled with GNU Readline support enabled. * We've added a 'view' command to `mdb', which opens a `vim' window and in it displays the current source location, updated at each event. This requires X11 and a version of `vim' with the `clientserver' feature enabled. * The `--window' mdb option now creates a window for mdb, not the program. The main advantage of the new behaviour is that redirection of the program's input and output works. The old behaviour is still available with `mdb --program-in-window'. * The debugger now includes support for declarative debugging. The `dd' command starts diagnosis at any exit, fail or exception port in mdb. See the Mercury User's Guide for more details. * When a program is compiled in a debugging grade, the debugger can be asked, via the command `table_io start', to make I/O primitives (such as io__open_file, io__write_string etc) idempotent. This means that a given call to e.g. io__open_file will open the specified file only once, even if retry commands cause the call to be executed more than once. A new profiler, which we call the Mercury deep profiler or mdprof: * The old Mercury profiler is based on the technology of the standard Unix profiler gprof. This technology makes the assumption that all calls to a given C function (in Mercury, a given function or predicate in a given mode) have the same cost, whether the cost being measured is CPU time, memory cells allocated, memory words allocated etc. In C programs, this assumption is usually close enough to correct for the output of gprof to be useful. In Mercury, due to the presence of parametric polymorphism and the significantly higher frequency of higher order code, different call sites are far more likely to have distinct performance characteristics than in C, so the output of a gprof-style profiler is usually not accurate enough to be useful. The new profiler records, for each of its measurements, not just the current predicate/function and its caller, but the entire chain of ancestors. This "deep context" is what gives the profiler its name. Actually, to keep overheads down, we don't walk the stack at every measurement; we just associate the current context with each measurement, and update the current context when it changes. Given this fact, it costs very little extra to record measurements on every aspect of performance (counts of calls, exits, fails and redos, counts of memory cells and memory words allocated, and time spent). We thus have only one deep profiling grade component, .profdeep, as opposed to the old profiler which has several grade components for different subsets of these measurements. * The deep context recorded by the deep profiler records the identities of the call sites as well as the identities of predicates and functions in the list of ancestors. If a predicate p contains two calls to predicate q, this allows the deep profiler to report that one call to q costs next to nothing while the other one is a major performance problem. * The deep profiler gathers so much data that giving it to the user all at once would swamp the user with too much information. We therefore implemented the deep profiler as a CGI program. Users can use thus use a web browser to explore the information contained in profiling data files. * The deep profiler currently does not handle programs that catch exceptions. * Further information about the deep profiler is available in the paper "Deep profiling: engineering a profiler for a declarative programming language" by Thomas C. Conway and Zoltan Somogyi, available from our web site at <http://www.cs.mu.oz.au/mercury/information/papers.html#mu_01_24>. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". The native code back-end, which was first released in Mercury 0.10, compiles directly to assembler, rather than than going via C. This back-end is enabled using the `--target asm' option. It is implemented by linking the Mercury compiler with the (relatively) language independent GNU Compiler Collection back-end. In other words, it is a Mercury front-end for GCC. This release is the first to be based on an officially released version of GCC (it is based on GCC 3.2). In this release, the native code back-end now passes all of the applicable tests in the Mercury test suite, including bootstraping the Mercury compiler. Currently it is only supported on i*86-pc-linux-gnu (Intel x86-based PCs running Linux). For details see <http://www.cs.mu.oz.au/mercury/download/gcc-backend.html>. * .NET CLR back-end much improved. The .NET CLR back-end, which generates MSIL code for Microsoft's new .NET Common Language Runtime, has been substantially improved. Mercury data structures are mapped to .NET CLR data types in a more natural and more efficient manner. A lot more of the standard library is now supported. Text files on Windows are now output with proper Windows CR-LF line endings. Many bugs have been fixed. This back-end supports the whole of the Mercury language, but the Mercury standard library implementation for the .NET CLR is still not yet complete. The .NET CLR back-end now passes about half of the tests in the Mercury test suite. This back-end is selected when you use the `--grade il' option. See <http://www.cs.mu.oz.au/mercury/dotnet.html> and/or <http://www.cs.mu.oz.au/mercury/information/dotnet/mercury_and_dotnet.html>. For news about earlier versions, see the HISTORY file. |
||
|
Ralph Becket
|
54255f93e7 |
Make the Prolog term comparison operators (@<, @=<, @>, @>=)
Estimated hours taken: 32 Branches: main Make the Prolog term comparison operators (@<, @=<, @>, @>=) builtin since they're often useful and calling compare/3 can look a little awkward. Simplification now applies the following transformations on the new builtin operators: X @< Y ---> some [R] (compare(R, X, Y), R = (<)) X @=< Y ---> some [R] (compare(R, X, Y), R \= (>)) X @> Y ---> some [R] (compare(R, X, Y), R = (>)) X @>= Y ---> some [R] (compare(R, X, Y), R \= (<)) compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/table_gen.m: Added `only_mode' argument to calls to goal_util__generate_simple_call which now has an extra parameter. compiler/goal_util.m: Added a new parameter, ModeNo, to goal_util__generate_simple_call. ModeNo is either - `only_mode' in which case the predicate in question is expected to have exactly one mode or - `mode_no(N)' in which case mode number N (counting from 0) is used. The inequality transformation uses this to handle calls to compare/3 with unique arguments (even though the builtin inequality modes don't yet handle ui arguments...) compiler/simplify.m: simplify__goal_2 for calls now makes a decision as to whether to call simplify__call_goal or simplify__inequality_goal. The bulk of simplify__goal_2 is now in simplify__call_goal. The inequality transformation is handled in simplify__inequality_goal. compiler/type_util.m: Added comparison_result_type constant. compiler/NEWS: Mention these changes. library/builtin.m: Added the inequalities as built-ins. Added the function ordering/2. library/prolog.m: Removed the definitions for @< etc. |
||
|
Simon Taylor
|
0387a6e9c2 |
Improvements for `:- pragma foreign_type'.
Estimated hours taken: 10
Branches: main
Improvements for `:- pragma foreign_type'.
- Allow default Mercury definitions. The Mercury definition must define
a discriminated union type. The constructors of the Mercury type are
only visible in predicates which have implementations for all the
foreign languages the type has implementations for. In all other
predicates the type is treated as an abstract type (the check for
this isn't quite right).
- Allow polymorphic foreign types.
- Don't require the `:- pragma foreign_type' for exported foreign types
to be in the interface. We now only require that all definitions
have the same visibility.
compiler/prog_data.m:
compiler/prog_io_pragma.m:
Allow polymorphic foreign types.
compiler/prog_io.m:
Export code to parse the type name in a type definition for
use by prog_io_pragma.m.
compiler/make_hlds.m:
Handle Mercury definitions for foreign types.
Separate out the code to add constructors and special predicates
to the HLDS into a separate pass. For foreign types, we don't know
what to add until all type definitions have been seen.
Use the C definition for foreign types with `--target asm'.
compiler/modules.m:
Distinguish properly between `exported' and `exported_to_submodules'.
Previously, if a module had sub-modules, all declarations,
including those in the interface, had import_status
`exported_to_submodules'. Now, the declarations in the
interface have status `exported' or `abstract_exported'.
This is needed to check that the visibility of all the
definitions of a type is the same.
compiler/hlds_pred.m:
Add a predicate status_is_exported_to_non_submodules, which
fails if an item is local to the module and its sub-modules.
compiler/hlds_data.m:
compiler/*.m:
Record whether a du type has foreign definitions as well.
Also record whether uses of the type or its constructors
need to be qualified (this is needed now that adding
the constructors to the HLDS is a separate pass).
compiler/typecheck.m:
Check that a predicate or function has foreign clauses before
allowing the use of a constructor of a type which also has
foreign definitions.
compiler/hlds_pred.m:
compiler/make_hlds.m:
Simplify the code to work out the goal_type for a predicate.
compiler/hlds_out.m:
Don't abort on foreign types.
Print the goal type for each predicate.
compiler/error_util.m:
Handle the case where the message being written is a
continuation of an existing message, so the first line
should be indented.
compiler/module_qual.m:
Remove unnecessary processing of foreign types.
doc/reference_manual.tex:
Document the change.
Update the documentation for mixing Mercury and foreign clauses.
The Mercury clauses no longer need to be mode-specific.
tests/hard_coded/Mmakefile:
tests/hard_coded/foreign_type2.{m,exp}:
tests/hard_coded/foreign_type.m:
tests/hard_coded/intermod_foreign_type.{m,exp}:
tests/hard_coded/intermod_foreign_type2.m:
tests/invalid/Mmakefile:
tests/invalid/foreign_type_2.{m,err_exp}:
tests/invalid/foreign_type_visibility.{m,err_exp}:
Test cases.
tests/invalid/record_syntax.err_exp:
Update expected output.
|
||
|
Fergus Henderson
|
7597790760 |
Use sub-modules to structure the modules in the Mercury compiler directory.
The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c. |
||
|
Zoltan Somogyi
|
41a27af862 |
Change type_id to the more descriptive type_ctor everywhere.
Estimated hours taken: 6 Branches: main compiler/*.m: Change type_id to the more descriptive type_ctor everywhere. |
||
|
Fergus Henderson
|
ceae383ec2 |
Fix some bugs with the hlc.agc grade where the compiler was generating
Estimated hours taken: 2 Branches: main Fix some bugs with the hlc.agc grade where the compiler was generating references to type_info variables that were not in scope. compiler/hlds_pred.m: Document the invariant that type_info arguments must precede non-type_info arguments, since MLDS->C accurate GC relies on this. compiler/type_util.m: Add new function put_typeinfo_vars_first, for use by lamdbda.m and ml_code_gen.m. compiler/lambda.m: Call put_typeinfo_vars_first on the arguments of the introduced procedures, to ensure that invariant documented in hlds_pred.m holds. compiler/ml_code_gen.m: Call put_typeinfo_vars_first on the list of local variables that we generate for each subgoal, to avoid referring to type_info variables that are not in scope in the GC tracing code. |
||
|
Fergus Henderson
|
7622e889e0 |
Define the `heap_pointer' type in private_builtin.m as a new builtin
Estimated hours taken: 2 Branches: main Define the `heap_pointer' type in private_builtin.m as a new builtin type with representation MR_TYPECTOR_REP_HP, rather than as equivalent to `c_pointer'. This is needed so that the accurate garbage collector can tell saved heap pointer values apart from other c_pointer values, which it needs to do in order to handle saved heap pointer values. library/private_builtin.m: runtime/mercury.h: runtime/mercury.c: Define the type_ctor_info etc. for the heap_pointer type. compiler/type_util.m: Add a new function `heap_pointer_type'. compiler/add_heap_ops.m: Use `heap_pointer_type' from type_util.m. |
||
|
Fergus Henderson
|
3e8cc77012 |
Various bug fixes for accurate GC with the MLDS->C back-end.
Estimated hours taken: 16 Branches: main Various bug fixes for accurate GC with the MLDS->C back-end. runtime/mercury.c: Fix a typo in the definition of the `stack_chain' global. compiler/ml_code_util.m: compiler/ml_call_gen.m: Fix several bugs: - generate appropriate GC tracing code for tracing type_infos and typeclass_infos. These need to be handled specially because of the parameters of private_builtin:type_info/1 etc. don't affect the representation of the type, and need to be ignored (to avoid infinite recursion). - don't generate GC tracing code for no_type_info_builtin procedures, because the generated GC tracing code would refer to type_info arguments that don't get passed. - in ml_call_gen.m, we were generating incorrect GC tracing code for the `conv_*' variables introduced to hold output arguments of polymorphically typed procedures. compiler/type_util.m: library/private_builtin.m: Add types `sample_type_info' and `sample_typeclass_info', so that ml_code_util.m can use them when tracing type_infos and typeclass_infos (respectively). library/private_builtin.m: Fix some software rot in gc_trace/1: add `MR_eng_' prefixes. library/io.m: runtime/mercury_library_types.h: runtime/mercury_file.c: Implement stream ids for NATIVE_GC. |
||
|
Fergus Henderson
|
a4f23438f0 |
Fix a typo in a comment that Simon Taylor pointed out in his
Estimated hours taken: 0.1 Branches: main compiler/type_util.m: Fix a typo in a comment that Simon Taylor pointed out in his code review. |
||
|
Fergus Henderson
|
116cea5c24 |
Fix a bug in the --high-level-data version of the .NET back-end,
Branches: main Estimated hours taken: 16 Fix a bug in the --high-level-data version of the .NET back-end, where when constructing data types with polymorphically typed fields, we were calling the constructor with incorrect (unboxed) argument types. It was documented in mlds.m that handling this boxing/unboxing was the responsibility of the MLDS->target code generator, but the MLDS didn't contain enough information (in particular it was missing the unsubstituted constructor argument types for new_object statements). So I ended up fixing it by doing this boxing in the HLDS->MLDS code generator. This makes it more consistent with how we handle other cases where boxing/unboxing is needed. compiler/mlds.m: Update the documentation about who is responsible for handling boxing/unboxing for `new_object' statements (and improve the documentation about the same issue for `field' rvals). compiler/ml_unify_gen.m: When generating new_object statements, look up the original (unsubstituted) types for the constructor arguments, and where necessary box the actual arguments to match. compiler/mlds_to_il.m: Don't box arguments of new_object statements, since this is now done in ml_unify_gen.m. compiler/type_util.m: Export type_util__get_cons_defn, for use by ml_unify_gen.m. Add some comments. compiler/ml_code_util.m: compiler/mlds_to_c.m: Improve the comments. compiler/mlds_to_c.m: Avoid generating some unnecessary casts. |
||
|
David Overton
|
40bda1e4a0 |
Fix a bug in inst_merge when merging a ground inst with a bound inst
Estimated hours taken: 8
Branches: main
Fix a bug in inst_merge when merging a ground inst with a bound inst
containing 'any' insts. Previously,
inst_merge(ground, bound(f(..., any, ...)))
would return a result of 'any' which is not as accurate as we would
like (e.g. this problem occurs often in Mercury code generated by the
HAL compiler). To improve this, we pass the type of the variable
being merged to inst_merge and when this situation arises we expand
'ground' to 'bound(<functors of type>)' and use this inst in the
merge.
An alternative to passing the types through inst_merge would be to
reinstate the use of 'typed_inst' and 'typed_ground' which are created
by (currently commented out) code in 'propagate_types_into_insts'.
However, this has previously been found to cause performance problems
since it greatly expands the size of all insts and instmaps in the
program. The approach used here is the same as that adopted for
inst_matches_{initial,final} some time ago, where it does not appear
to have a noticeable performance impact on typical programs.
compiler/inst_util.m:
Pass types through inst_merge and implement the changes to
inst_merge(ground, bound(...)) described above.
compiler/inst_match.m:
compiler/instmap.m:
compiler/mode_util.m:
compiler/simplify.m:
Pass types to calls to inst_merge.
compiler/inst_match.m:
compiler/type_util.m:
Move 'maybe_get_cons_id_arg_types' and
'maybe_get_higher_order_arg_types' from inst_match.m to
type_util.m and export them.
compiler/mode_util.m:
Export 'constructors_to_bound_insts'.
tests/valid/Mmakefile:
tests/valid/merge_ground_any.m :
Add a regression test.
tests/invalid/Mmakefile:
tests/invalid/merge_ground_any.err_exp:
tests/invalid/merge_ground_any.m:
Add a test to make sure the ground inst is expanded out to the
full set of functors for the type.
|
||
|
Simon Taylor
|
ad0aa5b60e |
Allow user-defined types with a single constructor `{}/1'
Estimated hours taken: 1
Branches: main
compiler/type_util.m:
Allow user-defined types with a single constructor `{}/1'
to be treated as no-tag types. Unary tuples aren't treated
as no-tag types because it would significantly complicate
the implementation.
Use more descriptive variable names.
Simplify some code using std_util__map_maybe.
|
||
|
David Overton
|
f21676c3a6 |
When testing for type_info types, check that the type is in
Estimated hours taken: 0.5 Branches: main compiler/type_util.m: When testing for type_info types, check that the type is in the 'private_builtin' module. This allows user-defined types to use the names 'type_info', 'type_ctor_info', etc. This change is required to allow the new module rtti_implementation.m to compile in reserved_tag grades. The compiler was assuming that the types in this module were the builtin type_info types and was not using the reserved_tag representation for them. |
||
|
Simon Taylor
|
9dd11b2fc6 |
Smart recompilation. Record version numbers for each item
Estimated hours taken: 400
Smart recompilation. Record version numbers for each item
in interface files. Record which items are used in each compilation.
Only recompile a module if the output file does not exist or
nothing has changed.
There is still some work to do on this:
- it doesn't work with inter-module optimization.
- it doesn't work when the module name doesn't match the file name.
(this problem will go away when mmake functionality is moved into
the compiler.
I'll hold off documenting this change in the NEWS file and
on the web page for a month or so, until I've had a bit more
experience using it.
compiler/options.m:
compiler/handle_options.m:
doc/user_guide.texi:
Add an option `--smart-recompilation', currently off by default.
Add an internal option `--generate-version-numbers' to control
whether version numbers are written to the interface files. If
`--smart-recompilation' is disabled because the module
is being compiled with `--intermodule-optimization' (e.g. in the
standard library), we still want to write the version numbers
to the interface files.
Add an option `--verbose-recompilation' (default off)
to write messages describing why recompilation is needed.
Add an option `--warn-smart-recompilation' (default on)
to control warnings relating to the smart recompilation
system. Warn if smart recompilation will not work with
the output and inter-module optimization options given.
compiler/recompilation.m:
Type declarations for smart recompilation.
Predicates to record program items used by compilation.
compiler/recompilation_version.m:
Compute version numbers for program items in interface files.
compiler/recompilation_usage.m:
Find all items used by a compilation.
compiler/recompilation_check.m:
Check whether recompilation is necessary.
compiler/timestamp.m:
Timestamp ADT for smart recompilation.
compiler/mercury_compile.m:
Invoke the smart recompilation passes.
compiler/modules.m:
compiler/prog_io.m:
Return timestamps for modules read.
When reading a module make sure the current input stream
is reset to its old value, not stdin.
Handle version number items in interface files.
compiler/module_qual.m:
compiler/unify_proc.m:
compiler/make_hlds.m:
Record all items used by local items.
compiler/make_hlds.m:
Process `:- pragma type_spec' declarations in
add_item_list_clauses. The qual_info is needed
when processing `:- pragma type_spec' declarations
so that any equivalence types used by the declaration
can be recorded as used by the predicate or function to
which the `:- pragma type_spec' applies.
compiler/equiv_type.m:
For each imported item, record which equivalence types
are used by that item.
compiler/hlds_module.m:
Add a field to the module_info to store information about
items used during compilation of a module.
compiler/check_typeclass.m:
Make sure any items used in clauses for typeclass method
implementations are recorded in the `.used' file.
compiler/prog_data.m:
compiler/*.m:
Factor out some duplicated code by combining the
pred and func, and pred_mode and func_mode items.
Make it easier to extract the name of a type, inst or mode
from its declaration.
Add an item type to hold the version numbers for an interface file.
Allow warnings to be reported for `nothing' items (used for
reporting when version numbers are written using an
obsolete format).
compiler/prog_io.m:
compiler/prog_io_util.m:
compiler/typecheck.m:
compiler/type_util.m:
compiler/*.m:
Strip contexts from all types, not just those in class constraints.
This makes it possible to use ordinary unification to check
whether items have changed (with the exception of clauses).
Remove code to create types with contexts in typechecking.
Remove code scattered through the compiler to remove contexts
from types in class constraints.
compiler/hlds_pred.m:
compiler/prog_util.m:
Move hlds_pred__adjust_func_arity to prog_util, so that it
can be used by the pre-hlds passes.
compiler/typecheck.m:
compiler/hlds_module.m:
Move typecheck__visible_modules to hlds_module.m, so it can
be used by recompilation_usage.m.
compiler/typecheck.m:
Add a comment telling where updates may be required if the
code to typecheck a var-functor unification changes.
compiler/error_util.m:
Allow writing messages without contexts (used for the verbose
recompilation messages).
Add functions to format sym_name and sym_name_and_arity,
and to add punctuation to the end of an error message
without unwanted line breaks before the punctuation.
scripts/Mmake.rules:
compiler/modules.m:
Don't remove the output file before running the compiler. We need
to leave the old output file intact if smart recompilation detects
that recompilation is not needed.
compiler/notes/compiler_design.html:
Document the new modules.
library/io.m:
NEWS:
Add predicates to find the modification time of files
and input_streams.
library/set.m:
NEWS:
Add a predicate version of set__fold
Don't sort the output of set__filter, it's already sorted.
library/std_util.m:
NEWS:
Add a predicate `std_util__map_maybe/3' and a function
`std_util__map_maybe/2' to apply a predicate or a function to
a value stored in a term of type `std_util__maybe'.
configure.in:
runtime/mercury_conf.h.in:
runtime/RESERVED_MACRO_NAMES:
When checking whether the compiler is recent enough, check for
the --warn-smart-recompilation option.
Check for stat().
library/Mmakefile:
Disable warnings about smart recompilation not working with
`--intermodule-optimization'.
browser/Mmakefile:
Disable warnings about smart recompilation not working when
the module name doesn't match the file name.
runtime/mercury_string.h:
Add a macro MR_make_string_const() which automates computation
of the length of string argument to MR_string_const().
tests/recompilation/Mmakefile:
tests/recompilation/runtests:
tests/recompilation/test_functions:
tests/recompilation/TESTS:
tests/recompilation/README:
A framework for testing smart recompilation.
The option currently only works for the recompilation directory.
tests/recompilation/TEST.m.{1,2}:
tests/recompilation/TEST_2.m.{1,2}:
tests/recompilation/TEST.exp.{1,2}:
tests/recompilation/TEST.err_exp.2:
Test cases, where TEST is one of add_constructor_r, add_instance_r,
add_instance_2_r, add_type_nr, change_class_r, change_instance_r,
change_mode_r, field_r, func_overloading_nr, func_overloading_r,
lambda_mode_r, nested_module_r, no_version_numbers_r,
pragma_type_spec_r, pred_ctor_ambiguity_r, pred_overloading_r,
add_type_re, remove_type_re, type_qual_re.
tests/handle_options:
Add an option `-e' to generate any missing expected output files.
|
||
|
Zoltan Somogyi
|
04e614485d |
Implement deep profiling; merge the changes on the deep2 branch back
Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet. |
||
|
Tyson Dowd
|
19f6ca24e0 |
Add arity when outputting types. This lets us distinguish types that
Estimated hours taken: 0.5 Branches: main, dotnet-foreign Add arity when outputting types. This lets us distinguish types that have the same name but different arity, which is a bit of a problem in high-level data grades. Also add a minor fix for mapping Mercury arrays into System.Array. compiler/mlds_to_il.m: Append _arity to the type name. Translate arrays into System.Array. Re-use a little duplicated code. compiler/type_util.m: Add type_id_is_array for detecting arrays. |
||
|
David Jeffery
|
19ceeaf30f |
Merge the changes from the HAL branch onto the main branch.
Estimated hours taken: 40
(to do this merge... 100s of hours on the HAL branch
itself by myself and Warwick Harvey though).
Merge the changes from the HAL branch onto the main branch. With the recent
changes made to the HAL implementation, this means adding just one grade,
`.rt' or --reserve-tag, which reserves one tag (zero) in each type for
use by HAL's Herbrand constraint solver. This disables no-tag types and
enumerations.
This grade will now bootstrap, and passes all tests, except for a few failing
cases in the debugger and tabling directories.
compiler/options.m:
compiler/handle_options.m:
Add the `.rt' or --reserve-tag grade option.
runtime/mercury_conf_param.h:
Document the macro MR_RESERVE_TAG
doc/user_guide.texi:
Document the `.rt' grade.
compiler/make_hlds.m:
Don't record any types as no-tag types if we are in a .rt grade.
compiler/make_tags.m:
compiler/type_ctor_info.m:
Allocate tags starting from `1' in .rt grades.
compiler/rtti_out.m:
In .rt grades, output a dummy ptag definition for tag `0'.
compiler/type_util.m:
Add predicates `type_util__constructors_are_dummy_argument_type' and
`type_constructors_are_type_info' for use when allocating tags to
ensure that type infos and dummy types (io__state/0 and store__store/1)
are still treated as no-tag types in .rt grades.
library/sparse_bitset.m:
When allocating a sparse bitset element, use tag `1' if we are in a
.rt grade.
runtime/mercury_tags.h:
Define a macro `MR_UNIV_TAG' which is `1' is we in a .rt grade and
`0' otherwise. (Now that univ is a user defined type, it is a also
assigned a `var' tag).
Also make the definitions of MR_RAW_TAG_NIL and MR_RAW_TAG_CONS take the
.rt grade into account.
runtime/mercury_type_info.h:
Define `MR_unravel_univ' and
`MR_initialise_univ' for taking apart and putting together univs.
Add a new secondary tag alternative: MR_SECTAG_VARIABLE, used to
represent Herbrand variables.
library/std_util.m:
Use MR_UNIV_TAG, MR_unravel_univ and MR_initialise_univ when
manipulating univs.
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
runtime/mercury_deep_copy_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
library/std_util.m:
Add a constant for MR_SECTAG_VARIABLE in the MC++ back end.
scripts/canonical_grade.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/mgnuc.in:
scripts/parse_grade_options.sh-subr:
Process the new grade.
scripts/mmake.in:
Add an option `--include-makefile', which includes a Makefile given
as a command line argument into the Makefile generated by mmake.
This is used to implement `halmake', a make program for HAL which
just passes a bunch of extra rules and variable definitions onto
mmake.
tests/debugger/existential_type_classes.m:
tests/hard_coded/existential_types_test.m:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
trace/mercury_trace_internal.c:
Use MR_UNIV_TAG.
TODO:
- The declarative debugger falls over in .rt grades. This is possibly
because compiler/static_term.m assumes that the generated code uses
the same data representation as the compiler itself. This should be
fixed, although it is not critical; the declarative debugger won't
work with trailing as is, and the .rt grade is only ever used in
conjunction with trailing (.tr) at this stage.
|
||
|
Zoltan Somogyi
|
50f1674dd5 |
In mdb's print and browse commands, allow the field to be printed to be
Estimated hours taken: 8
In mdb's print and browse commands, allow the field to be printed to be
specified by name as well as by number. This required extending the RTTI
for notag types to record field names.
trace/mercury_trace_vars.m:
Allow the field to be printed to be specified by name as well as by
number.
library/std_util.m:
Add code to find out whether a term has a field with a given name,
and if yes, which field that is. At the moment, this functionality
is accessible only from C. (There is no point to adding to the
user-visible interface before a redesign of that interface.)
Fix an old bug: ML_arg() was not compensating for the extra type_info
and/or typeclass_info arguments inserted at the start of a cell for
functors with existentially typed arguments. Document the ML_expand
data structure better to make that bug less likely in the future.
runtime/mercury_type_info.h:
Add an extra field to the type for notag type functors, recording
the field name of the argument, if it has one.
compiler/rtti.m:
Add a maybe-argument-name field to the record for notag types.
compiler/type_ctor_info.m:
Record the name of the single argument of the single functor of a
notag type, if it has one.
compiler/type_util.m:
Make that argument name available.
compiler/rtti_out.m:
Print out that argument name.
compiler/make_tags.m:
compiler/make_hlds.m:
compiler/rtti_to_mlds.m:
Ignore that argument name.
tests/debugger/field_names.{m,inp,exp}:
A new test case to test the printing of subterms specified by field
numbers and/or names.
tests/debugger/Mmakefile:
Enable the new test case.
|
||
|
Simon Taylor
|
b251a990aa |
Improve the efficiency of type_util__type_is_no_tag_type.
Estimated hours taken: 1 Improve the efficiency of type_util__type_is_no_tag_type. This change reduces the time taken by `mmc -C make_hlds' by about 2%. compiler/hlds_data.m: compiler/hlds_module.m: compiler/make_hlds.m: Add a field to the module_info to hold information about no-tag types to avoid searching the entire type table. compiler/type_util.m: Look up the no-tag type table rather than the type table in type_is_no_tag_type. Minor efficiency improvements for type_to_type_id. Avoid unnecessary calls to type_to_type_id. |
||
|
David Overton
|
82378c381b |
Allow polymorphic ground insts. This change assumes that all inst
Estimated hours taken: 80 Allow polymorphic ground insts. This change assumes that all inst parameters in the mode declaration for a predicate or function are constrained to be ground-shared. This is a temporary measure until we work out a nice syntax to allow the programmer to tell the compiler that certain inst parameters may be treated as ground insts. Since we don't currently support unconstrained inst parameters anyway, this shouldn't cause a problem. TODO: - Add syntax, something like `:- mode p(in(I)) <= ground(I).', to specify that an inst parameter represents a ground inst. - Allow abstract ground insts that are treated in a similar way to what we've done here with ground inst parameters. - Make mode checking more efficient (i.e. rewrite the mode system). compiler/inst.m: Add a new alternative for ground insts: `constrained_inst_var(inst_var)'. Define the type `inst_var_sub'. compiler/inst_match.m: Change inst_matches_initial so that it: - handles constrained_inst_vars correctly; - returns the inst_var substitutions necessary for the call; - handles inst_matches_initial(ground(...), bound(...), ...) properly (this requires knowing the type of the variable). The last change has also been made for inst_matches_final and inst_matches_binding. However, the check is disabled for now because, without alias tracking, the mode checker becomes too conservative. compiler/hlds_pred.m: compiler/mode_info.m: compiler/simplify.m: compiler/det_util.m: Include the inst_varset in the proc_info, mode_info and simplify_info. Add a vartypes field to the det_info. Remove the vartypes field from the simplify_info since it is now in the det_info. Use record syntax for these data structures and their access predicates to make future changes easier. compiler/prog_io.m: When processing pred and func mode declarations, convert all inst_var(V) insts to ground(shared, constrained_inst_var(V)). compiler/prog_data.m: compiler/hlds_data.m: compiler/make_hlds.m: compiler/mode_util.m: Use inst_vars instead of inst_params. compiler/modes.m: compiler/modecheck_call.m: compiler/unique_modes.m: compiler/mode_util.m: When checking or recomputing initial insts of a call, build up an inst_var substitution (using the modified inst_matches_initial) and apply this to the final insts of the called procedure before checking/recomputing them. compiler/mode_util.m: Make sure that recompute_instmap_delta recomputes the instmap_deltas for lambda_goals even when RecomputeAtomic = no. compiler/type_util.m: Add a new predicate, type_util__cons_id_arg_types which nondeterministically returns the cons_ids and argument types for a given type. Add a new predicate type_util__get_consid_non_existential_arg_types which is the same as type_util__get_existential_arg_types except that it fails rather than aborting for existenially typed arguments. compiler/accumulator.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/common.m: compiler/continuation_info.m: compiler/deforest.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/dnf.m: compiler/follow_code.m: compiler/goal_store.m: compiler/goal_util.m: compiler/higher_order.m: compiler/inst_util.m: compiler/instmap.m: compiler/lambda.m: compiler/magic.m: compiler/magic_util.m: compiler/mercury_to_mercury.m: compiler/modecheck_unify.m: compiler/module_qual.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_io_util.m: compiler/prog_rep.m: compiler/saved_vars.m: compiler/stack_layout.m: compiler/table_gen.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Pass inst_varsets and types where needed. Changes to reflect change in definition of the inst data type. compiler/inlining.m: Recompute the instmap deltas for a procedure after inlining. This bug showed up compiling tests/hard_coded/lp.m with inlining and deforestation turned on: deforestation was getting incorrect instmap deltas from inlining, causing the transformation to break mode-correctness. It has only just shown up because of the added call to `inst_matches_initial' from within `recompute_instmap_delta'. tests/invalid/Mmakefile: tests/invalid/unbound_inst_var.m: tests/invalid/unbound_inst_var.err_exp: tests/valid/Mmakefile: tests/valid/unbound_inst_var.m: Move the `unbound_inst_var' test case from `invalid' to `valid' and extend its coverage a bit. |
||
|
Simon Taylor
|
3cf329a739 |
Fix bugs in explicit type qualification.
Estimated hours taken: 4
Fix bugs in explicit type qualification.
compiler/make_hlds.m:
Make the code to handle type qualification expressions match
the documentation. Variables occurring in type qualifications
but not in the predicate's argument types are local to the
clause in which they occur.
Don't export clauses_info_init -- it's not used anywhere else.
Add field labels to the qual_info type.
compiler/hlds_pred.m:
compiler/*.m:
Add a field to the clauses_info to contain the mapping from
type variable names to type variables for the head types.
This needs to be maintained because type variables added
while processing type qualifications in a clause should
not be added to the map used for other clauses.
compiler/typecheck.m:
Apply substitutions to the explicit vartypes at the end
of each pass of typechecking to keep them in sync with
the type variables in the argument types.
compiler/type_util.m:
Add a predicate type_util__apply_variable_renaming_to_type_map
for use by typecheck.m.
doc/reference_manual.texi:
Add some more comments about the handling of explicit type
qualifications to the documentation about valid type assignments.
Change references to existential type _qualifiers_ to consistently
refer to existential type _quantifiers_.
tests/hard_coded/type_qual.{m,exp}:
Add some more tests.
tests/hard_coded/Mmakefile:
Pass `--infer-all' to mmc when compiling type_qual.m.
|
||
|
Simon Taylor
|
46a8da81cb |
Implement builtin tuple types, similar to those in Haskell.
Estimated hours taken: 30
Implement builtin tuple types, similar to those in Haskell.
Tuples are constructed and deconstructed using
the syntax X = {Arg1, Arg2, ...}.
Tuples have type `{Arg1, Arg2, ...}'.
Unary tuples (X = {Arg}) do work, unlike in Haskell. The rationale
for this is that it is useful to be able to construct unary tuples
to be passed to a polymorphic predicate which uses std_util__deconstruct
to deal with a tuple of any arity. Since this is probably the only
use for unary tuples, it's not really worth the effort of treating
them as no_tag types, so we don't.
The type-infos for tuples have the same structure as for higher-order
types. There is a single type_ctor_info for tuples, and the arity
is placed before the argument type_infos.
library/parser.m:
Change the way '{}/N' terms are parsed, so that the parsed
representation is consistent with the way other functors
are represented (previously the arguments were left as
unparsed ','/2 terms). This avoids special case code
in prog_io__parse_qualified_term, term__term_to_type
and term__type_to_term.
compiler/prog_io_dcg.m:
compiler/prog_io_util.m:
Handle the new structure of '{}/N' terms when parsing DCG escapes
by converting the argument list back into a single ','/2 term.
compiler/module_qual.m:
Treat tuples as a builtin type.
compiler/typecheck.m:
Typecheck tuple constructors.
compiler/mode_util.m:
Propagate types into tuple bound insts.
compiler/type_util.m:
Add type_is_tuple/2 and type_id_is_tuple/1 to identify tuple types.
Add tuples to the list of types which are not atomic types.
Handle tuple types in `type_constructors' and
`get_cons_id_arg_types' and `switch_type_num_functors'.
compiler/tabling.m:
Handle tabling of tuples.
compiler/term_util.m:
Handle tuples in the code to compute functor norms.
compiler/magic_util.m:
compiler/rl.m:
compiler/rl_key.m:
Handle tuple types in the Aditi back end.
compiler/mercury_to_mercury.m:
library/io.m:
library/term_io.m:
Handle output of '{}/N' terms.
compiler/higher_order.m:
compiler/simplify.m:
Don't specialize complicated unifications of tuple
types into calls to a specific unification procedure --
even if the procedure were implemented, it probably
wouldn't be that much more efficient.
compiler/unify_proc.m:
Generate unification procedures for complicated unifications
of tuples (other than in-in unifications). These are generated
lazily as required.
compiler/make_hlds.m:
Export add_special_pred for use by unify_proc.m.
compiler/polymorphism.m:
Export polymorphism__process_pred for use by unify_proc.m.
compiler/bytecode_gen.m:
compiler/code_util.m:
compiler/ml_code_util.m:
Handle unify procedure names and tags for tuple types.
compiler/mlds_to_c.m:
Output tuple types as MR_Tuple.
compiler/ml_unify_gen.m:
Compute the field types for tuples.
compiler/polymorphism.m:
compiler/pseudo_type_info.m:
Treat tuple type_infos in a similar way to higher-order type_infos.
compiler/hlds_data.m:
Document how cons_ids for tuple types are represented.
compiler/switch_gen.m:
compiler/table_gen.m:
Add tuple types to switches on type_util__builtin_type.
compiler/llds_out.m:
util/mdemangle.c:
profiler/demangle.m:
Transform items named "{}" to "f_tuple" when mangling symbols.
library/builtin.m:
Define the type_ctor_info used for tuples.
library/private_builtin.m:
Add `builtin_unify_tuple/2' and `builtin_compare_tuple/3',
both of which abort. All comparisons and in-in unifications
of tuples are performed by the generic unification functions
in runtime/mercury_ho_call.c and runtime/mercury.c.
library/std_util.m:
Implement the various RTTI functions for tuples.
Encode tuple `TypeCtorDesc's in a similar way to that
used for higher-order types. This has the consequence that the limit
on the arity of higher-order types is now MAX_VIRTUAL_REG,
rather than 2*MAX_VIRTUAL_REG.
Avoid calling MR_GC_free for the type-info vector returned
from ML_expand() for tuples because unlike the vectors
for du types, it is not copied.
runtime/mercury_type_info.h:
Add macros for extracting fields from tuple type-infos.
These just call the macros for extracting fields from higher-order
type-infos.
Add a macro MR_type_ctor_rep_is_variable_arity(), which
returns TRUE for tuples and higher-order types.
The distinction between higher-order and first-order types
is now misnamed -- the distinction is really between fixed arity
types and builtin variable arity types. I'm not sure whether
it's worth renaming everything.
runtime/mercury.h:
runtime/mercury.c:
Define unification and comparison of tuples in
high-level code grades.
runtime/mercury_deep_copy_body.h:
runtime/mercury_make_type_info_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle tuple types in code which traverses data using RTTI.
tests/hard_coded/construct.{m,exp}:
tests/hard_coded/expand.{m,exp}:
Test RTTI functions from std_util.m applied to tuples.
tests/hard_coded/tuple_test.{m,exp}:
Test unification, comparison, term_to_type etc. applied to tuples.
tests/hard_coded/deep_copy.{m,exp}:
Test deep copy of tuples.
tests/hard_coded/typeclasses/tuple_instance.{m,exp}:
Test instance declarations for tuples.
tests/tabling/expand_tuple.{m,exp}:
Test tabling of tuples.
tests/hard_coded/write.m:
Add some module qualifications for code which uses
`{}/1' constructors which are not tuples.
tests/invalid/errors2.{m,err_exp,err_exp2}:
Test handling of tuples in type errors messages.
NEWS:
doc/reference_manual.texi:
w3/news/newsdb.inc:
Document tuples.
doc/transition_guide.texi:
Document the change to the parsing of '{}/N' terms.
|
||
|
Simon Taylor
|
2490aac4dd |
Generate declarations and clauses for the compiler-generated
Estimated hours taken: 10 Generate declarations and clauses for the compiler-generated unification and comparison procedures only when they are needed. The vast majority of these procedures are never used. This change speeds up `mmc -C make_hlds' by about 5%. compiler/make_hlds.m: Export add_special_pred_for_real and add_special_pred_decl_for_real for use by unify_proc.m. Don't generate declarations or clauses for unification or comparison predicates for imported types immediately unless the predicate needs to be typechecked. Don't generate clauses for comparison predicates for imported types -- they will never be used because the predicate has import_status `imported'. compiler/special_pred.m: compiler/typecheck.m: Add predicate special_pred_for_type_needs_typecheck, which succeeds for types with user-defined equality and types with existentially typed constructors. compiler/unify_proc.m: Make sure the declarations and clauses for the unification predicate for a type have been generated before processing a unify_request for that type. Add predicates for use by higher_order.m to force generation of a special predicate when required for specialization of a call to unify/2 or compare/3. Simplify the code for unification predicates for enumeration types. The code that was being generated cast the arguments to int, then called unify/2 on the ints. The simpler version just creates a unify goal. Enumerations are atomic types, so modecheck_unify.m will treat the unification as a simple_test. compiler/polymorphism.m: Add a predicate polymorphism__process_generated_pred to be used by unify_proc.m to process the bodies of the generated unification predicates. compiler/post_typecheck.m: Add versions of post_typecheck__finish_pred and post_typecheck__finish_imported_pred which don't require an io__state, for use by unify_proc.m. Errors should never be reported in post_typecheck.m for unification or comparison predicates. compiler/simplify.m: Don't generate calls to the type-specific predicate for an in-in complicated unification if the predicate is generated lazily. higher_order.m will handle the specialization in that case. compiler/higher_order.m: Call unify_proc.m to generate the declarations for a special pred when there is a call to that special pred which could be specialized. Add field labels to the higher_order_info type. compiler/type_util.m: Add predicates type_id_is_atomic and classify_type_id, which are similar to type_is_atomic and classify_type, for use by special_pred.m. |
||
|
Simon Taylor
|
19bcf11e7a |
Fix a bug in the handling of instances with unconstrained type
Estimated hours taken: 1 Fix a bug in the handling of instances with unconstrained type variables where a type variable occurs multiple times in the instance declaration. The compiler was adding multiple copies of the type_info for such variables to the typeclass_info. compiler/type_util.m: Remove duplicates in the list of variables returned by `get_unconstrained_tvars/3'. tests/hard_coded/Mmakefile: tests/hard_coded/instance_unconstrained_tvar_dup.m: tests/hard_coded/instance_unconstrained_tvar_dup.exp: Test case. |
||
|
Tyson Dowd
|
791ec10d1e |
Add options for
Estimated hours taken: 1 Add options for unboxed_enums - turns on unboxed enums (default is yes) unboxed_no_tag_types - turns on unboxed no-tag-types (default is yes) Currently every grade uses these representations. We will set these to `no' on the IL backend (and probably the Java backend) if using a simple implementation of the the Array of Object representation for Mercury data structures. compiler/make_tags.m: Check for these options when creating representations. compiler/options.m: Add the new options. compiler/type_util.m: Make sure type_is_no_tag_type checks the appropriate option. Add a new predicate type_constructors_are_no_tag_type which just does a check of the structure of the constructors (you have to do the option checking yourself). compiler/higher_order.m: compiler/mode_util.m: Use the new type_is_no_tag_type (this actually simplifies the code). compiler/type_ctor_info.m: Use type_constructors_are_no_tag_type and check the globals. |
||
|
Zoltan Somogyi
|
9dcab9bee2 |
Add a new optimization, enabled by the option --unneeded-code.
Estimated hours taken: 40 Add a new optimization, enabled by the option --unneeded-code. This optimization removes goals whose outputs are not used at all, and moves goals whose outputs are only used on some computation branches to the starts of those branches, so they do not need to be executed on other branches. Such deletions/movements are done only when the semantic switches and the properties of the relevant goal together permit it. compiler/unneeded_code.m: A new module to perform the goal rearrangement. compiler/hlds_goal.m: The new optimization needs to know how many functors the switched-on variable can be bound to, so it can check whether a given number of switch arms covers all alternatives or not. To make access to this information convenient, we add a field to the goal_path_step alternative for switch arm entry that records this number. compiler/goal_path.m: Fill in this number. To make this possible, we thread the necessary information through the predicates in this module. compiler/type_util.m: Add a utility predicate type_util__switch_type_num_functors, for use by the new code in goal_path.m. compiler/switch_detection.m: Avoid duplicated code by using type_util__switch_type_num_functors where relevant. compiler/code_aux.m: Add three new auxiliary predicate, code_aux__goal_cannot_loop_or_throw, code_aux__goal_can_loop_or_throw and code_aux__goal_can_loop, to the existing code_aux__goal_cannot_loop. code_aux__goal_cannot_loop now checks only what its name says. compiler/trace.m: Ignore the new field when generating goal paths strings. compiler/mercury_compile.m: Invoke unneeded_code.m if required. compiler/hlds_pred.m: Add some utility predicates for use by unneeded_code.m. compiler/unused_args.m: Use the new utility predicates instead of reimplementing them. compiler/options.m: Define the --unneeded-code option, and its auxiliary, --unneeded-code-copy-limit. doc/user_guide.texi: Document the new options. |
||
|
Fergus Henderson
|
3ed3421f49 |
Fix a bug reported by Peter Ross <peter.ross@miscrit.be>:
Estimated hours taken: 3 Fix a bug reported by Peter Ross <peter.ross@miscrit.be>: check that type, mode, and determinism of main/2 conform to what the Mercury language reference manual requires. compiler/post_typecheck.m: Check that the arguments of main/2 have type `io__state'. compiler/type_util.m: Add predicate `type_is_io_state', for use by post_typecheck.m. compiler/modes.m: Check the the arguments of main/2 have mode `di, uo'. Also split some of the code in proc_check_eval_methods out into separate procedures. compiler/det_report.m: Check that main/2 has determinism `det' or `cc_multi', rather than just checking that it doesn't fail. (We don't want to allow main/2 to have determinism `multi', since that doesn't work in MLDS grades, for which `multi' procedures have a different calling convention than `det' or `cc_multi' procedures. Similarly we don't want to allow main/2 to have determinism `erroneous', since a future back-end might use a different calling convention for that.) tests/general/partition.m: Change the declared determinism of main/2 from `multi' to `det', to make this test case conform to the language reference manual. This is needed now that the compiler checks the determinism of main/2 properly. tests/invalid/Mmakefile: tests/invalid/invalid_main.m: tests/invalid/invalid_main.err_exp: A regression test. |
||
|
Fergus Henderson
|
8c62fcec99 |
For --high-level-data, use field names rather than offsets
Estimated hours taken: 12 For --high-level-data, use field names rather than offsets when accessing fields. compiler/hlds_data.m: Include the field names in the hlds_cons_defn, for use by ml_unify_gen.m. compiler/make_hlds.m: compiler/typecheck.m: compiler/post_typecheck.m: compiler/type_util.m: Minor changes to handle the change to hlds_cons_defn. compiler/ml_type_gen.m: For fields of certain types, such as `float', etc., generate the field type as a boxed type (mlds__generic_type). Don't generate a field for the secondary tag if it isn't needed. If none of the ctors need a secondary tag, then skip it entirely. If some but not all ctors need a secondary tag, then put the secondary tag field in a separate class derived fom the base class for this type, and have the classes for the ctors that need it derived from that class rather than from the base class. compiler/ml_unify_gen.m: For --high-level-data, use field names rather than offsets when accessing data fields and secondary tags. (XXX the code for closures still uses offsets.) compiler/ml_code_util.m: Add two new routines for dealing with fields, `ml_gen_field_name' and `ml_must_box_field_type', for use by ml_type_gen.m and ml_unify_gen.m. compiler/mlds.m: Change the documentation for the ClassType field in `field' lvals: rename it as `PtrType', and make it clear that this is the type of the pointer, not the type of the class pointed to. Also add a new CtorType field to the `named_field' field_id. compiler/ml_elim_nested.m: Minor changes to handle the modifications to mlds.m. compiler/mlds_to_c.m: Ensure that we name-mangle struct names and field names. For named_field field accesses, cast the pointer to the type specified by the new CtorType field before dereferencing it. |
||
|
Simon Taylor
|
957c54c0b2 |
My previous bug fix for overloading resolution of field access functions
Estimated hours taken: 1 My previous bug fix for overloading resolution of field access functions and constructors didn't work for existentially typed constructors. compiler/post_typecheck.m: When checking whether a constructor matches a cons_id and argument types, make sure the actual argument types don't bind any of the existentially quantified type variables of the constructor. compiler/typecheck.m: compiler/type_util.m: Factor out the code to check whether the argument types of a call subsume the actual argument types into a new predicate, `type_util__arg_type_list_subsumes'. tests/valid/Mmakefile: tests/valid/record_syntax_bug_2.m: Test case. |
||
|
David Jeffery
|
281796aa9a |
Make an addition to the type class info structure; add type infos for
Estimated hours taken: 10
Make an addition to the type class info structure; add type infos for
any type variables from the head of the instance declaration which are
unconstrained, and make the class method call mechanism insert these as
arguments to method calls. The implementations of methods expect to be passed
a type info for each unconstrained type variable and a type class info for
each constraint. Previously we were not passing the appropriate type infos.
Also move the documentation about the type class transformation from
polymorphism.m to a new file, compiler/notes/type_class_transformation.html.
compiler/base_typeclass_info.m:
Generate the appropriate part of the new structure in the
base_typeclass_info.
compiler/polymorphism.m:
Add the appropriate type infos to the typeclass_info.
compiler/type_util.m:
Add a new predicate `get_unconstrained_tvars'.
runtime/mercury_deep_copy_body.h:
Update copy_typeclass_info to reflect the new structure.
runtime/mercury_ho_call.c:
Copy the extra type infos to the beginning of the arguments when
doing a class method call.
runtime/mercury_type_info.h:
Update the macros used to access the type class info.
compiler/notes/type_class_transformation.html:
The documentation about the type class transformation has been
moved from polymorphism.m to here. This change corrects that
documentation in several places and updates that documentation to
reflect the changes to the typeclass_info structure from this diff.
tests/hard_coded/typeclasses/instance_unconstrained_tvar.exp:
tests/hard_coded/typeclasses/instance_unconstrained_tvar.m:
A test case for this change.
tests/hard_coded/typeclasses/Mmakefile:
Turn this test case on. For the moment, type specialisation is
turned off for this test case as the specialiser does not insert the
extra type infos that are needed.
|
||
|
David Jeffery
|
d0e7584c8e |
Add a new predicate, type_util__real_vars, which is the same
Estimated hours taken: 8
(including a few misguided tries...)
compiler/type_util.m:
Add a new predicate, type_util__real_vars, which is the same
as type_util__vars except it doesn't count type-info variables.
compiler/{continuation_info.m, hlds_pred.m, trace.m}:
Use type_util__real_vars rather than type_util__vars since the
latter was causing problems when calculating the live type-infos,
and causing the failure of the test case
tests/hard_coded/existential_rtti.m in debug grade.
|
||
|
Zoltan Somogyi
|
736424a5e6 |
Remove type_id_is_hand_defined, because it makes bootstrapping hard.
Estimated hours taken: 1 Remove type_id_is_hand_defined, because it makes bootstrapping hard. Instead, consider that a type is hand defined if it is abstract even in the module that defines it, or if it appears on a short list of types which have hand-defined RTTI even though they have (incorrect) Mercury definitions as well. The list contains private_builtin's type_info, type_ctor_info, typeclass_info and base_typeclass_info. compiler/base_type_info.m: compiler/base_type_layout.m: compiler/make_hlds.m: compiler/unify_proc.m: Remove references to type_id_is_hand_defined. compiler/type_util.m: Replace replace type_id_is_hand_defined with type_id_has_hand_defined_rtti. |
||
|
Fergus Henderson
|
89d56f909e |
Update some obsolete comments.
Estimated hours taken: 0.5 compiler/type_util.m: Update some obsolete comments. (The typevarset syncronization problem that the comment was referring to has been fixed long ago. Also there should be no need to rename apart when substituting equivalence types.) |
||
|
Zoltan Somogyi
|
cc8ecc43f1 |
Prepare for the breakup of std_util.m.
Estimated hours taken: 0.1 Prepare for the breakup of std_util.m. |
||
|
Simon Taylor
|
5940825cdb |
Implement syntax for getting and setting fields of constructors.
Estimated hours taken: 70 Implement syntax for getting and setting fields of constructors. compiler/make_hlds.m: Add information about field definitions to the module_info. Check that user-defined field access functions for exported fields are also exported, otherwise predicates in other modules could use a different method to access a field than predicates in module defining the field. Add a `predicate preds_add_implicit_report_error' to allow that check to be performed for functions which are added to the module_info by some means other than a `:- func' declaration. Parse field access goals and expressions. Add predicates `insert_arg_unifications_with_supplied_contexts', and `append_arg_unification', which allow more control over the contexts given to the added unifications. These are useful because the field value for an update is really an argument of the inner-most update function call, while the input term is an argument of the outer-most function call. compiler/prog_io_dcg.m: Allow DCG goals of the form `:=(DCGArg)', which unifies `DCGArg' with the output DCG argument, ignoring the input DCG argument. The rationale for this change is that if we have convenient syntax for updating parts of a DCG argument, we should also have convenient syntax for updating the whole DCG argument. compiler/typecheck.m: Add a default clause for field access functions for which the user has supplied type and mode declarations but no clauses. Typecheck field access function calls. Use `io__write_list' to remove some duplication of code to write out comma separated lists of error descriptions. compiler/post_typecheck.m: Expand field accessor goals into the equivalent unifications. They are expanded inline rather than generating new get and set predicates for field name to avoid having to work out how to mode the generated predicates. Remove an unnecessary goal traversal to qualify function calls and constructors. That code is now called from purity.m. compiler/prog_data.m: compiler/prog_io.m: compiler/mercury_to_goedel.m: compiler/mercury_to_mercury.m: Store field names as `sym_name's rather than strings. Use a `maybe' type rather than an empty string to designate an unlabelled field. compiler/hlds_data.m: Define data structures to hold information about the field names visible in a module. compiler/hlds_module.m: Add a field to type module_info to hold information about the fields visible in a module. compiler/hlds_pred.m: Add predicates to identify field access function names, and to handle the arguments of field access functions. compiler/make_hlds.m: compiler/hlds_goal.m: compiler/modecheck_call.m: compiler/higher_order.m: compiler/purity.m: compiler/polymorphism.m: compiler/dnf.m: compiler/cse_detection.m: compiler/lambda.m: Move `create_atomic_unification' from make_hlds.m to hlds_goal.m because it is used by several other modules. compiler/hlds_goal.m: Add a version of goal_info_init which takes the context of the goal, for use by make_hlds.m. compiler/type_util.m: Add a predicate `type_util__get_type_and_cons_defn' to get the hlds_type_defn and hlds_cons_defn for a user-defined constructor. compiler/prog_util.m: Add predicates to add and remove prefixes or suffixes from the unqualified part of a sym_name. compiler/prog_out.m: Add a predicate to convert a `sym_name/arity' to a string. compiler/hlds_out.m: Add `hlds_out__simple_call_id_to_string' to convert a `pred_or_func - sym_name/arity' to a string for use in error messages. compiler/purity.m: Thread through the pred_info so that the expansion of field accessor goals can add new variables. compiler/mercury_to_mercury.m: library/ops.m: Reduce precedence of `^/2' for use as a field name separator. Add operator `^'/1 to designate which side of the `:=' is the field name in a DCG field access goal. Add operator `:=/2' for field update expressions. doc/reference_manual.texi: Document the new syntax. doc/transition_guide.texi: Document the new operators. tests/hard_coded/Mmakefile: tests/hard_coded/record_syntax.m: tests/hard_coded/record_syntax.exp: tests/invalid/Mmakefile: tests/invalid/record_syntax_errors.m: tests/invalid/record_syntax_errors.err_exp: Test cases. |
||
|
Simon Taylor
|
8a074ac664 |
Remove unnecessary explicit quantification goals before working
Estimated hours taken: 2
compiler/simplify.m:
Remove unnecessary explicit quantification goals before working
out whether a goal can cause a stack flush.
Don't increase the non-locals set of an explicit quantification
goal through common structure elimination because that could change
the determinism.
Don't optimize a singleton switch into a test followed
by the case goal if the constructor being tested against
is existentially quantified. This is necessary because
the code to produce the test uses type_util__get_cons_id_arg_types,
which does not correctly handle the existentially quantified
type variables or the type-infos for those type variables.
compiler/type_util.m:
Add type_util__is_existq_cons, which succeeds if a constructor
is existentially typed.
type_util__get_cons_id_arg_types now aborts if the cons_id
is existentially typed rather than silently giving wrong answers.
compiler/goal_util.m:
Add a comment that goal_util__switch_to_disjunction and
goal_util__case_to_disjunct abort on existentially typed constructors.
compiler/magic.m:
Add an XXX comment that we should check for existentially
typed constructors before calling goal_util__switch_to_disjunction.
tests/hard_coded/Mmakefile:
tests/hard_coded/existential_type_switch_opt.{m,exp}:
Test case.
|
||
|
Fergus Henderson
|
34d52a4091 |
Fix a bug with switches on existential types.
Estimated hours taken: 12 Fix a bug with switches on existential types. This bug meant that existential types with two or more functors did not work at all, due to internal compiler errors when compiling the unification and comparison predicates for those types. compiler/type_util.m: Add new function cons_id_adjusted_arity, which computes the arity _including_ the extra typeinfo and typeclassinfo arguments inserted for existential data types. compiler/type_util.m: compiler/polymorphism.m: Move the predicates constraint_list_get_tvars and constraint_get_tvars from polymorphism.m into type_util.m, for use in cons_id_adjusted_arity. compiler/modes.m: compiler/unique_modes.m: When modechecking the functor test in switch statements, use cons_id_adjusted_arity to compute the arity of the inst, compiler/instmap.m: In instmap__bind_var_to_functor (and the instmap_delta version), use cons_id_adjusted_arity to compute the arity of the inst. compiler/goal_util.m: compiler/pd_info.m: compiler/pd_util.m: compiler/saved_vars.m: compiler/mode_util.m: compiler/deforest.m: compiler/follow_code.m: compiler/higher_order.m: compiler/simplify.m: Pass the type(s) down to recompute_instmap_delta and instmap__bind_var_to_functor, since cons_id_adjusted_arity needs to know the type. compiler/hlds_pred.m: compiler/hlds_out.m: Add a `vartypes' typedef, defined by `:- type vartypes == map(prog_var, type)', and make use of it. Rename the `vartypes' type in hlds_out as `maybe_vartypes'. tests/hard_coded/Mmakefile: tests/hard_coded/existential_type_switch.m: tests/hard_coded/existential_type_switch.exp: Add a regression test. tests/hard_coded/Mmakefile: Enable the existential_types_test.m test case, which should have been enabled previously. (The reason that it wasn't seems to be that I made a mistake when merging in the changes from the existential types branch.) |
||
|
Simon Taylor
|
00df2750bd |
Remove the limitation of user-guided type specialization that
Estimated hours taken: 50 Remove the limitation of user-guided type specialization that the replacement types must be ground. compiler/higher_order.m: Only add extra type-infos, not typeclass-infos when --typeinfo-liveness is set, extracting type-infos from typeclass-infos where necessary. The arguments of the specialized version are now independent of the class context of the requesting procedure, which maximises the chance of multiple specialized calls to the same procedure being able to use the same code. The code to specialize calls is now slightly simpler because it does not have to work out how to order extra typeclass-info arguments. Specialize special preds for no-tag types where the wrapped type is an atomic type and the no-tag type does not have a user-defined equality pred. This will be useful for specializations involving type `term__var/1'. Make sure the proc_infos for specialized procedures are valid before reanalyzing the goals requesting the specializations. Rework the handling of branched goals to ensure that pred_infos and proc_infos are single threaded through branched goals - when higher_order.m was first written they were constant. Always go over all procedures for every predicate to make sure unifications are specialized in all procedures. compiler/make_hlds.m: Check for type variables substituted multiple times or occurring on both sides of the substitution. Adjust the arity for specializations of functions. compiler/polymorphism.m: Make sure the vartypes field for imported procedures is valid by copying it from the clauses_info to the proc_info. compiler/polymorphism.m: compiler/simplify.m: compiler/table_gen.m: compiler/magic.m: Remove an unused argument from polymorphism__make_type_info_vars. compiler/type_util.m: compiler/det_analysis.m: Add a predicate `type_util__type_has_user_defined_equality_pred' replacing similar code in det_analysis.m. compiler/post_typecheck: Don't overwrite the vartypes field in the pred_info for automatically generated unification procedures for imported types. library/varset.m: Add predicates `varset__merge_without_names' and `varset__merge_subst_without_names'. compiler/equiv_type.m: Use the new predicates in varset.m to avoid adding the variable names from the declarations of equivalence types into the tvarsets of declarations which use those types. This is needed so that `varset__create_name_var_map' (used by make_hlds.m for `:- pragma type_spec' declarations and explicit type qualifications) is not confused by multiple occurrences of a variable name. doc/reference_manual.texi: Remove documentation of the limitation that the substituted types must be ground. tests/hard_coded/type_spec.m: tests/hard_coded/type_spec.err_exp: Tests for non-ground substitutions and specialization of unification of no-tag types. tests/invalid/type_spec.err_exp: Remove the error for a non-ground substitution. Add tests for recursive type substitutions and type variables with multiple replacement types. |
||
|
Fergus Henderson
|
396fb9edcf |
Strip away io__state' (and store__store') arguments
Estimated hours taken: 1 Strip away `io__state' (and `store__store') arguments in the MLDS code generator. compiler/export.m: compiler/type_util.m: compiler/make_hlds.m: Move export__exclude_argument_type to type_util.m and rename it as type_util__is_dummy_argument_type. compiler/ml_code_gen.m: Omit arguments for which type_util__is_dummy_argument_type is true. compiler/mlds_to_c.m: Output `Bar foo(void)' rather than `Bar foo()' for functions with no parameters. |
||
|
Tyson Dowd
|
b845fcb08f |
Fix a bug that was causing the compiler to fail the debugger
Estimated hours taken: 4 Fix a bug that was causing the compiler to fail the debugger tests with an unknown layout error. std_util:type_info/0 needs to be defined by hand so we can tell the RTTI system that it is a type_info. This change breaks bootstrapping with earlier compilers. Use the CVS tag bootstrap_19990719_handdefine_typeinfo to bootstrap this change. compiler/type_util.m: Add std_util:type_info/0 to the hand defined types. This is different to private_builtin:type_info/1 which was already there. It was type_info/0 that the debugger was failing on. library/builtin.m: Move the type_ctor_info for c_pointer back into this module. It should have finished bootstrapping by now. library/std_util.m: Define type_ctor_info as (abstractly) equivalent to a type_info instead of equivalent to a c_pointer. This will allow this type to be handled by the garbage collector or debugger. runtime/mercury_bootstrap.c: Move the RTTI info for c_pointer out of this module. Add the type_ctor_info for type_info/0 as it is now a hand defined type. tests/hard_coded/higher_order_type_manip.exp: Fix expected test results not that type_ctor_info is equivalent to type_info/0. Estimated hours taken: _____ <overview or general description of changes> <directory>/<file>: <detailed description of changes> |
||
|
Simon Taylor
|
2725b1a331 |
Aditi update syntax, type and mode checking.
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.
|
||
|
Fergus Henderson
|
8c97633e71 |
Allow construction unifications for existentially typed functors,
Estimated hours taken: 6 Allow construction unifications for existentially typed functors, using the syntax "X = 'new foo'(Y)" rather than the usual "X = foo(Y)". We need to use a special syntax for exisentially typed constructions because type analysis and polymorphism need to know which occurrences of existentially typed functors are constructors and which are deconstructors. Note that we still don't yet support RTTI for existentially typed data types. compiler/typecheck.m: For existentially typed functors, allow the functor to have a "new " prefix, and if so, make the quantifiers and constraints universal rather than existential. compiler/polymorphism.m: For unifications with existentially typed functors, check for a "new " prefix on the functor. If the functor has such a prefix, strip off the prefix, and treat the unification as a construction rather than treating it as a deconstruction. compiler/type_util.m: Define a new predicate `remove_new_prefix', for use by typecheck.m and polymorphism.m. compiler/modecheck_unify.m: For construction unifications, check that all the type_info and typeclass_info arguments introduced by polymorphism.m are ground. tests/hard_coded/typeclasses/existential_data_types.m: Change the test case to use this new feature, rather than hacking it using the C interface. doc/reference_manual.texi: Document the new features. |
||
|
Fergus Henderson
|
ec86c88404 |
Merge in the changes from the existential_types_2 branch.
Estimated hours taken: 4 Merge in the changes from the existential_types_2 branch. This change adds support for mode re-ordering of code involving existential types. The change required modifying the order of the compiler passes so that polymorphism comes before mode analysis, so that mode analysis can check the modes of the `type_info' or `typeclass_info' variables that polymorphism introduces, so that it can thus re-order the code accordingly. This change also includes some more steps towards making existential data types work. In particular, you should be able to declare existentially typed data types, the compiler will generate appropriate unification and compare/3 routines for them, and deconstruction unifications for them should work OK. However, currently there's no way to construct them except via `pragam c_code', and we don't generate correct RTTI for them, so you can't use `io__write' etc. on them. library/private_builtin.m: compiler/accumulator.m: compiler/bytecode_gen.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/code_util.m: compiler/common.m: compiler/dead_proc_elim.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/hlds_pred.m: compiler/intermod.m: compiler/lambda.m: compiler/live_vars.m: compiler/magic.m: compiler/make_hlds.m: compiler/mercury_compile.m: compiler/mercury_to_c.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/pd_cost.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/purity.m: compiler/quantification.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/simplify.m: compiler/table_gen.m: compiler/term_traversal.m: compiler/type_util.m: compiler/typecheck.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unused_args.m: compiler/notes/compiler_design.html: doc/reference_manual.texi: tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/existential_data_types.m: tests/hard_coded/typeclasses/existential_data_types.exp: tests/warnings/simple_code.exp: tests/hard_coded/Mmakefile: tests/term/arit_exp.trans_opt_exp: tests/term/associative.trans_opt_exp: tests/term/pl5_2_2.trans_opt_exp: tests/term/vangelder.trans_opt_exp: tests/term/arit_exp.trans_opt_exp: tests/term/associative.trans_opt_exp: tests/term/pl5_2_2.trans_opt_exp: tests/term/vangelder.trans_opt_exp: tests/invalid/errors2.err_exp2: tests/invalid/prog_io_erroneous.err_exp2: tests/invalid/type_inf_loop.err_exp2: tests/invalid/types.err_exp2: tests/invalid/polymorphic_unification.err_exp: tests/invalid/Mmakefile: tests/warnings/simple_code.exp: tests/debugger/queens.exp: tests/hard_coded/Mmakefile: tests/hard_coded/existential_reordering.m: tests/hard_coded/existential_reordering.exp: Merge in the changes from the existential_types_2 branch. |
||
|
Tyson Dowd
|
2eb7e77257 |
c_pointer needs to be a hand defined type -- up until now everything but
Estimated hours taken: 0.5 c_pointer needs to be a hand defined type -- up until now everything but the type_ctor_info is hand defined. We need to be able to change the contents of the type_ctor_info, however. compiler/type_util.m: library/builtin.m: runtime/mercury_bootstrap.c: Make builtin:c_pointer a hand-defined type, doing the usual bootstrapping trick. |