84 Commits

Author	SHA1	Message	Date
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.	2003-02-12 22:58:20 +00:00
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.	2003-01-27 09:21:03 +00:00
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.	2003-01-14 16:42:44 +00:00
Ralph Becket	b746233ac4	Implemented state variable transformation. ... Estimated hours taken: 600 Branches: main Implemented state variable transformation. NEWS: Record new syntax and withdrawl of !/0 as Prolog cut. compiler/hlds_goal.m: compiler/hlds_out.m: Added implicit/1 constructor to unify_main_context for cases where variables are introduced by compiler transformations. compiler/make_hlds.m: Integrated the state variable transformation with the conversion to HLDS. Changed references to foreign_type and du_type constructors to match recent changes to the foreign type interface. compiler/mercury_compile.m: Removed two unnecessary Prolog cuts left over from the Dark Ages. compiler/mercury_to_mercury.m: Added code to output the new goal_expr constructors for state variable quantifiers (some_state_vars and all_state_vars.) Adapted to handle changes to if_then and if_then_else goal_expr constructors which now include lists of state variables that scope over the condition- and then-goals. compiler/module_qual.m: compiler/prog_util.m: Changes to handle some_state_vars, all_state_vars, and changes to if_then and if_then_else goal_expr constructors. compiler/prog_data.m: Added some_state_vars, all_state_vars constructors and changed if_then and if_then_else constructors in type goal_expr. compiler/prog_io_dcg.m: Changes to handle quantified state variables. compiler/prog_io_goal.m: parse_some_vars_goal now also separates out quantified state variables. compiler/prog_io_util.m: Added pred parse_quantifier_vars/3 which also detects state variables. compiler/typecheck.m: Added case to report_error_undef_cons to handle any uncaught uses of !/1. doc/reference_manual.texi: Documented the transformation. library/builtin.m: library/prolog.m: Deleted code for `!' as fake Prolog cut. library/lexer.m: Made `!' a graphic token rather char than a special token. library/ops.m: Added `!', `!.' and `!:' as prefix ops. library/term.m: Added func var_id/1 which returns an int associated with its var argument which is unique in the context of the given var and the varset it belongs to. library/varset.m: Added pred new_uniquely_named_var/4 which creates a named variable with a unique (w.r.t. the varset) number suffix. tests/general/Mmakefile: tests/general/state_vars_tests.exp: tests/general/state_vars_tests.m: tests/general/state_vars_typeclasses.exp: tests/general/state_vars_typeclasses.m: tests/invalid/Mmakefile: tests/invalid/state_vars_test1.err_exp: tests/invalid/state_vars_test1.m: tests/invalid/state_vars_test2.err_exp: tests/invalid/state_vars_test2.m: tests/invalid/state_vars_test3.err_exp: tests/invalid/state_vars_test3.m: tests/invalid/state_vars_test4.err_exp: tests/invalid/state_vars_test4.m: tests/invalid/state_vars_test5.err_exp: tests/invalid/state_vars_test5.m: Added.	2002-07-09 01:31:12 +00:00
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.	2002-06-30 17:07:20 +00:00
David Jeffery	4bb979c152	Use unification expressions in all the appropriate arms of a large ... Estimated hours taken: 0.5 compiler/module_qual.m: Use unification expressions in all the appropriate arms of a large switch.	2002-05-08 11:45:38 +00:00
David Jeffery	5353dd1d94	Fix a typo that was causing all 'promise_semipure' declarations to ... Estimated hours taken: 0.1 compiler/module_qual.m: Fix a typo that was causing all 'promise_semipure' declarations to be turned into 'promise_pure' declarations during module qualification. This has probably stopped all uses of 'promise_semipure' from working...	2002-05-02 16:24:01 +00:00
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.	2002-03-20 12:37:56 +00:00
Simon Taylor	d96f7a9bd5	Allow declarations of the form ... Estimated hours taken: 40 Branches: main Allow declarations of the form :- pred p `with_type` higher_order_type `with_inst` higher_order_inst. XXX We should allow `with_inst` annotations on higher-order terms. compiler/prog_data.m: Add fields to `pred_or_func' and `pred_or_func_mode' items to hold the `with_type` and `with_inst` annotations. compiler/prog_io.m: compiler/prog_io_typeclass.m: Parse the annotations. compiler/module_qual.m: Module qualify the annotations. compiler/equiv_type.m: Expand away `with_type` and `with_inst`. Report errors. Strip items containing errors from the item list. Record smart recompilation dependencies on the types and modes expanded. Also record a dependency on the arity of predicate and function declarations before expansion. Use error_util for error messages. compiler/mercury_to_mercury.m: Write `with_type` and `with_inst` annotations to interface files. compiler/make_hlds.m: Ignore `with_type` and `with_inst` fields in predicate and function declarations. compiler/recompilation.m: Changes to allow equiv_type.m to record dependencies on arbitrary items, not just types. compiler/recompilation_usage.m: compiler/recompilation_check.m: Allow searches in the sets of used predicates and functions using name, not name and arity, as the key. This is needed because the actual arity of a predicate defined using `with_type` is not known when writing the interface files. compiler/recompilation_version.m: Handle `with_inst` and `with_type`. Pragmas now need to be recorded in the version_numbers even if there is no matching `:- pred' or `:- func' declaration -- the pragma may apply to a predicate or function declared using `with_type`. compiler/mode_util.m: Export inst_subsitute_arg_list for use by equiv_type.m. compiler/error_util.m: Add predicate `pred_or_func_to_string'. library/std_util.m: Add std_util__map_foldl_maybe and std_util__map_foldl2_maybe, which are like list__map_foldl and list__map_foldl2, but apply to the item stored in a value of type std_util__maybe. NEWS: doc/reference_manual.texi: Document the new syntax and library predicates. tests/invalid/Mmakefile: tests/invalid/with_type.m: tests/invalid/with_type.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/recompilation/TESTS: tests/recompilation/unchanged_with_type_nr*: tests/recompilation/with_type_re*: Test cases. tests/invalid/errors1.err_exp: tests/invalid/type_loop.err_exp: tests/invalid/vars_in_wrong_places.err_exp: Update expected output.	2002-03-15 07:32:27 +00:00
David Overton	da2ed598e0	Extend constrained polymorphic modes to allow inst parameters to be ... Estimated hours taken: 80 Branches: main Extend constrained polymorphic modes to allow inst parameters to be constrained to insts other than `ground'. The main motivation for this is that for HAL we want inst parameters constrained to `any', however this change is more general and allows inst parameters to be constrained to any valid inst. Introduce the syntax `InstParam =< Inst' to constrain an inst parameter `InstParam' to an inst `Inst' in a predicate or function mode declaration. compiler/inst.m: Add a new alternative `constrained_inst_var(inst_var, inst)' to the `inst' type. Remove `constrained_inst_var(inst_var)' alternative from the `ground_inst_info' type. compiler/inst_match.m: compiler/inst_util.m: compiler/modecheck_unify.m: Make changes required to the core mode checking algorithms to handle the change. compiler/prog_io.m: compiler/prog_io_util.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: compiler/prog_io_typeclass.m: compiler/make_hlds.m: Add support for `=<'/2 insts, but only when parsing predicate and function mode declarations, lambda argument modes, and pragmas. Also add support for specifying inst constraints in the constraints list for a declaration. Make sure any unconstrained inst parameters in these declarations are constrained to be `ground'. Check that all constraints for a declaration are consistent, i.e. the same constraint for every occurrence of an inst parameter. compiler/hlds_out.m: compiler/mercury_to_mercury.m: Support printing of `=<'/2 insts. compiler/mode_util.m: compiler/module_qual.m: compiler/pd_util.m: compiler/recompilation_usage.m: Handle the changes to the definition of the `inst' type. doc/reference_manual.texi: Document the change. tests/valid/Mmakefile: tests/valid/constrained_poly_insts.m: tests/invalid/Mmakefile: tests/invalid/constrained_poly_insts.m: Add some test cases.	2002-03-14 01:10:44 +00:00
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.	2002-03-07 08:30:28 +00:00
Zoltan Somogyi	7fbb09dc04	Delete the code "handling" undiscrimited unions. ... Estimated hours taken: 1 Branches: main compiler/*.m: Delete the code "handling" undiscrimited unions. Their presence slows things down, the error messages they lead to can confuse users, and we are unlikely to ever implement them in the form now assumed by the code. tests/invalid/bigtest.err_exp: tests/invalid/uu_type.err_exp: Update these expected error messages.	2002-02-26 02:46:05 +00:00
Lars Yencken	cca3d674e1	Added parsing and pretty printing of new promise ex declarations, and ... Estimated hours taken: 50 Branches: main Added parsing and pretty printing of new promise ex declarations, and appropriate documentation. library/ops.m: Added the new operators to op_table. compiler/prog_io.m: Added clauses to enter promise ex declarations into the parse tree. compiler/prog_out.m: Added predicates useful in outputting promise declarations. compiler/prog_data.m: Changed assertion constructor in type item to a more gereral promise constructor to be used for assertions and promise ex declarations. Added the type promise_type to differentiate between different promise declarations. compiler/mercury_to_mercury.m: Added clauses to output promise items, including assertions and promise ex declarations. compiler/make_hlds.m: compiler/module_qual.m: compiler/modules.m: compiler/recompilation_check.m: compiler/recompilation_version.m: Updated to reflect change in item type. compiler/notes/glossary.html: Added new terminology, updated use of `promise'. compiler/notes/todo.html: Added todo list for promise ex declarations. compiler/notes/promise_ex.html: A new file documenting development of promise ex declarations.	2002-02-08 02:27:15 +00:00
Tyson Dowd	70eb377888	Fix and enable the new foreign_type syntax. ... Estimated hours taken: 10 Branches: main Fix and enable the new foreign_type syntax. We now accept declarations such as: :- pragma foreign_type(il, xmldoc, "class [System.Xml]System.Xml.XmlDocument"). compiler/prog_data.m: Remove the foreign type location from the foreign_type pragma, it is better to make this part of the foreign_language_type. Rename backend as foreign_language_type as it specifies a type in a particular language. compiler/prog_io_pragma.m: Uncomment the foreign_type parsing code, change the syntax. Write some simple code to parse CIL type names. compiler/make_hlds.m: Check that there is a :- type declaration, and that it has the same visibility as the pragma foreign_type. compiler/mercury_to_mercury.m: compiler/module_qual.m: compiler/modules.m: compiler/recompilation_version.m: Handle changes to backend_type and the foreign_type pragma. doc/reference_manual.texi: Document the new syntax.	2001-12-12 00:30:22 +00:00
Simon Taylor	5de7305cfe	Implement `:- pragma foreign_import_module(Lang, Module)', which tells ... Estimated hours taken: 10 Implement `:- pragma foreign_import_module(Lang, Module)', which tells the compiler that the foreign code in the module containing the declaration uses `:- pragma export'ed procedures from module `Module'. This information is needed for mmake to build things in the right order. Currently programmers can hand code the required mmake rules, but `mmc --make' will have no mechanism for doing this. `:- pragma c_import_module(Module)' is a synonym for `:- pragma foreign_import_module("C", Module)'. compiler/prog_io_pragma.m: Parse the new pragmas. compiler/prog_data.m: compiler/foreign.m: compiler/hlds_module.m: compiler/mlds.m: compiler/modules.m: Add the `:- pragma foreign_import_module' to the compiler's datastructures. compiler/make_hlds.m: Insert `:- pragma foreign_import_module' declarations into the HLDS. compiler/modules.m: Add the extra dependency information from `:- pragma foreign_import_module' declarations to the `.d' files. compiler/llds.m: compiler/foreign.m: Move some non-backend-specific types describing the foreign language interface from llds.m to foreign.m. compiler/intermod.m: Write `:- pragma foreign_import_module' declarations to `.opt' files. XXX mmake doesn't support this properly yet. compiler/mercury_compile.m: compiler/foreign.m: compiler/ml_code_gen.m: compiler/ml_code_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_csharp.m: compiler/mlds_to_gcc.m: compiler/mlds_to_mcpp.m: Convert `:- pragma foreign_import_module' to `#include' statements where appropriate depending on the target language. compiler/*.m: Handle `:- pragma foreign_import_module'. Import foreign.m rather than llds.m for the foreign interface types. doc/reference_manual.texi: NEWS: Document the new pragmas. Minor fixes for the foreign code documentation. tests/hard_coded/Mmakefile: tests/hard_coded/foreign_import_module.m: tests/hard_coded/foreign_import_module_2.m: tests/hard_coded/foreign_import_module.exp: Test case.	2001-11-06 15:21:27 +00:00
Peter Ross	77a1261d3b	Merge the foreign_type pragma changes from the dotnet branch to the main ... Estimated hours taken: 10 Branches: main Merge the foreign_type pragma changes from the dotnet branch to the main branch, plus do some more development work to generalise the change. compiler/prog_data.m: Add a type to hold the data from parsing a pragma foreign_type decl. compiler/prog_io_pragma.m: Parse the pragma foreign_type. This code is currently commented out, while we decide on the syntax. compiler/hlds_data.m: Add a new alternative to hlds_type_body where the body of the type is a foreign type. compiler/make_hlds.m: Place the foreign_type pragmas into the HLDS. compiler/foreign.m: Implement to_type_string which replaces export__type_to_type_string, unlike export__type_to_type_string foreign__to_type_string takes an argument specifying which language the representation is meant to be in. to_type_string also needs to take a module_info to handle foreign_types correctly. To avoid the need for the module_info to be passed around the MLDS backend we provide a new type exported_type which provides enough information for an alternate version of to_type_string to be called. compiler/export.m: Delete export__type_to_type_string. compiler/llds.m: Since foreign__to_type_string needs a module_info, we add a new field to pragma_c_arg_decl which is the result of calling foreign__to_type_string. This avoids threading the module_info around various llds passes. compiler/mlds.m: Record with in the mercury_type the exported_type, this avoids passing the module_info around the MLDS backend. Also add the foreign_type alternative to mlds__type. Update mercury_type_to_mlds_type so that it handles types which are foreign types. compiler/mlds_to_il.m: Convert a mlds__foreign_type into an ilds__type. compiler/ilds.m: The CLR spec requires that System.Object and System.String be treated specially in the IL assembly so add them as simple types. compiler/ilasm.m: Before outputting a class name into the IL assembly check whether it it can be simplified to a builtin type, and if so output that name instead as required by the ECMA spec. Changes for the addition of string and object as simple types. doc/reference_manual.texi: Document the new pragma, this is currently commented out because it refers to syntax that has not yet been finalised. compiler/fact_table.m: compiler/llds_out.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_simplify_switch.m: compiler/ml_switch_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_csharp.m: compiler/mlds_to_gcc.m: compiler/mlds_to_java.m: compiler/mlds_to_mcpp.m: compiler/pragma_c_gen.m: compiler/rtti_to_mlds.m: Changes to handle using foreign__to_type_string. compiler/hlds_out.m: compiler/intermod.m: compiler/magic_util.m: compiler/ml_type_gen.m: compiler/recompilation_usage.m: compiler/recompilation_version.m: compiler/term_util.m: compiler/type_ctor_info.m: compiler/unify_proc.m: Changes to handle the new hlds_type_body. compiler/mercury_to_mercury.m: Output the pragma foreign_type declaration. compiler/module_qual.m: Qualify the pragma foreign_type declarations. compiler/modules.m: Pragma foreign_type is allowed in the interface.	2001-10-24 13:34:41 +00:00
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.	2001-06-27 05:05:21 +00:00
Fergus Henderson	b973fb0b9d	Add support for using different clauses for different modes of a ... Estimated hours taken: 8 Branches: main Add support for using different clauses for different modes of a predicate or function, using mode annotations on the clauses. compiler/make_hlds.m: Add support for mode annotations on clauses. compiler/module_qual.m: Add new routine qualify_clause_mode_list, for use by make_hlds.m. compiler/mode_errors.m: Export output_mode_decl, for use by make_hlds.m compiler/purity.m: Treat procedures with different clauses for different modes as impure, unless promised pure. compiler/notes/compiler_design.html: Specify when module qualification of modes in clause mode annotations is done (in make_hlds.m). NEWS: doc/reference_manual.texi: Document the new feature.	2001-05-16 04:51:04 +00:00
Simon Taylor	d74eb22905	Fix a bug in the module import mechanism -- use_module should ... Estimated hours taken: 8 Fix a bug in the module import mechanism -- use_module should not be transitive. This change is needed for smart recompilation to avoid needing to check whether the removal of a transitive import could cause compilation errors -- it never should. Also fix some bugs in the handling of type class declarations. compiler/prog_data.m: Add a `transitively_imported' pseudo-declaration, which is placed before the items from `.int2' files and `.opt' files. Fix the representation of type class bodies. `:- typeclass foo where [].' declares a typeclass with no methods. `:- typeclass foo.' declares an abstract typeclass. The old representation made no distinction between these cases. compiler/hlds_data.m: compiler/prog_data.m: compiler/module_qual.m: Move the declaration of type type_id from hlds_data.m to prog_data.m. This avoids a duplicate declaration in module_qual.m. compiler/modules.m: Add a `transitively_imported' pseudo-declaration before the items from `.int2' files. Remove the bodies of typeclass declarations placed in `.int2' files -- the methods should not be available unless the module is explicitly imported. compiler/module_qual.m: Items after the `transitively_imported' pseudo-declaration should not be considered when module qualifying locally declared items. compiler/equiv_type.m: compiler/mercury_to_mercury.m: compiler/prog_io_typeclass.m: Handle the change to the representation of typeclass bodies. compiler/prog_io_typeclass.m: Check that the arguments of a typeclass declaration are distinct variables. compiler/make_hlds.m: Handle abstract typeclass declarations. compiler/check_typeclass.m: Check that all typeclasses have a definition somewhere. compiler/intermod.m: Write abstract_exported typeclasses to the `.opt' file. compiler/add_trail_ops.m: compiler/context.m: compiler/llds.m: compiler/vn_type.m: Add missing imports. compiler/magic_util.m: compiler/ml_type_gen.m: Remove unnecessary imports. NEWS: Note that this change may break existing programs. compiler/notes/todo.html: Remove the item relating to this change. tests/invalid/transitive_import.{m,err_exp}: Add some tests for uses of transitively imported items. tests/invalid/transitive_import_class.m: tests/invalid/transitive_import_class2.m: tests/invalid/transitive_import_class3.m: tests/invalid/transitive_import_class.err_exp: Add a test for use of transitively imported class methods. tests/invalid/invalid_typeclass.{m,err_exp}: Add some tests for invalid typeclass declarations. tests/invalid/Mmakefile: Add the new tests.	2001-05-02 17:34:50 +00:00
Tyson Dowd	711da78188	Rename foreign_code as foreign_proc where appropriate in the compiler. ... Estimated hours taken: 4.0 Branches: main Rename foreign_code as foreign_proc where appropriate in the compiler. The rationale for this change is that it makes maintaining the code much simpler because it is clear whether `foreign' refers to a slab of code (foreign_code) or a procedure (foreign_proc). :- type pragma_foreign_code_attributes :- type pragma_foreign_proc_attributes The functors for pragma_type foreign(Lang, BodyCode) foreign(Attributes, Name, PredOrFunc, Vars, Varset, Impl) become foreign_code(Lang, BodyCode) foreign_proc(Attributes, Name, PredOrFunc, Vars, Varset, Impl) And the HLDS goal `pragma_foreign_code' becomes `foreign_proc'. compiler/*.m: Update the compiler to use the new names.	2001-04-03 03:20:33 +00:00
Simon Taylor	a3819d359c	Fix the handling of purity in the optimization and tabling passes. ... Estimated hours taken: 15 Branches: main Fix the handling of purity in the optimization and tabling passes. Without this change tests/tabling/unused_args.m fails with inter-module optimization. compiler/purity.m: compiler/post_typecheck.m: Allow purity checking to be rerun on a single procedure without requiring an io__state. If the purity is worse (due to inlining a predicate with a `:- pragma promise_pure' declaration), add `promised_pure' or `promised_semipure' to the pred_info. compiler/hlds_out.m: compiler/hlds_pred.m: compiler/intermod.m: compiler/make_hlds.m: compiler/mercury_to_mercury.m: compiler/module_qual.m: compiler/modules.m: compiler/prog_data.m: compiler/prog_io_pragma.m: compiler/purity.m: doc/reference_manual.texi: NEWS: Implement `:- pragma promise_semipure'. This is needed if an predicate marked `promised_pure' which calls impure predicates is inlined into a semipure predicate. compiler/inlining.m: Make sure the purity markers on the goal_infos are correct after inlining predicates which are promised pure. Export a predicate inlining__can_inline_proc which is used by deforestation to determine whether inlining a procedure will change the semantics or will break code generator invariants. compiler/deforest.m: Use the same method as inlining.m to work out whether a procedure can be inlined. Don't inline predicates which are promised pure because the extra impurity which will be propagated through the goal will stop deforestation working on the goal. compiler/simplify.m: Make sure the goal_info resulting from converting a singleton switch into a conjunction has the correct purity. compiler/table_gen.m: Make sure the purity markers on the generated goal_infos are correct. Make sure that call_table_gen goal features cannot be removed by optimization passes. Don't put unnecessary `impure' markers on calls to error/1. tests/debugger/loopcheck.exp: tests/debugger/retry.exp: Adjust the expected output. The change to ensure that `call_table_gen' goal features can't be removed alters the goal paths slightly. tests/invalid/impure_method_impl.m: Adjust the expected output now that predicates can be promised semipure.	2001-03-27 05:23:23 +00:00
David Jeffery	7c0fda18e1	When reporting an error about an undefined entity with an explicit ... Estimated hours taken: 2 compiler/module_qual.m: When reporting an error about an undefined entity with an explicit module qualifier, check that the module in question isn't the current module before reporting that it hasn't been imported. tests/invalid/Mmakefile: tests/invalid/undef_type_mod_qual.err_exp: tests/invalid/undef_type_mod_qual.m: A test case for this.	2001-01-10 02:05:16 +00:00
Tyson Dowd	477ecb18f6	Implement pragma foreign_code for Managed C++. ... Estimated hours taken: 60 Implement pragma foreign_code for Managed C++. Currently you can only write MC++ code if your backend is capable of generating use MC++ as its "native" foreign language. The IL backend is the only backend that does this at the moment (the other backends have C as their "native" foreign language). Most of the machinery is in place to call from C to (normal) C++ but there is little work done on actually spitting out the C++ code into a separate file. The IL backend does this step already with managed C++. The intention is to turn foreign_code for C++ into a pragma import (which imports the C++ function from a separate file) and foreign_code for C (which calls the imported function). The C++ code will be inserted into a separate file that is compiled using C linkage. The important improvement this change gives is that you can write a module with a C and a MC++ implementations side-by-side. The target backend will select the most appropriate foreign language to use. You can override its choice using --use-foreign-language. Later on we will probably want more flexibility than just a single language selection option). This change also implements :- pragma foreign_decl, which allows header file style declarations to be written in languages other than C. compiler/code_gen.m: Reject code that is not C when generating LLDS. compiler/export.m: Start renaming C as foreign. Reject code that is not C when generating exports. compiler/foreign.m: A new module to handle foreign language interfacing. The bulk of the code for pragma import has been moved here from make_hlds. compiler/globals.m: Convert foreign language names to foreign_language. This code has been moved closer to the similar conversion we do for target language names. Add globals__io_lookup_foreign_language_option to make it easier to deterministically lookup the options relating to foreign languages. compiler/hlds_module.m: Move module_add_foreign_decl and module_add_foreign_body_code from make_hlds.m (where they were called module_add_c_header and module_add_c_code). compiler/hlds_out.m: Write the foreign language out in HLDS dumps. compiler/llds.m: Change foreign_header_info to foreign_decl_info. Change definitions of foreign_decl_code and foreign_body_code to include the language. compiler/llds_out.m: Reject code that is not C when writing out LLDS. compiler/make_hlds.m: Add foreign language information to the bodys and decls when creating them. Update error messages to refer to foreign code instead of C code. Use foreign.m to generate interfaces from the backend language to the foreign language. Hardcode C as the language for fact tables. compiler/mercury_compile.m: Collect the appropriate foreign language code together for output to the backend. compiler/intermod.m: compiler/mercury_to_mercury.m: Output the foreign language string. Change a few names to foreign_code instead of c_code. compiler/ml_code_gen.m: Filter the foreign language bodys and decls so that we only get the ones we are in (given by the use-foreign-language option). compiler/mlds_to_c.m: Abort if we are given non C foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/mlds_to_ilasm.m: Abort if we are given non MC++ foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/options.m: compiler/handle_options.m: Add --use-foreign-language as a user option to control the preferred foreign language to use as the implementation of this module. Add backend_foreign_language as an internal option which stores the foreign language that the compiler will use as a default (e.g. the natural foreign language for the backend to use). Set the preferred backend foreign language depending on the target. compiler/prog_data.m: Add managedcplusplus as a new alternative for the foreign_language type. Make c_header_code into foreign_decl. Give the foreign language for foreign_code as an attribute of the code. Write code to turn attributes into a list of strings (suitable for writing out by mercury_to_mercury). This fixes what appears to be a bug in tabled_for_io -- the tabled_for_io attribute was not being written out. Structure the code so this bug is difficult to repeat in future. compiler/prog_io_pragma.m: Parse foreign_decl. Turn c_header_code into a special case of foreign_decl. compiler/*.m: Remove the language field from pragma_foreign_code, it is now an attribute of the code. Various type and variable renamings. tests/invalid/pragma_c_code_and_clauses1.err_exp: tests/invalid/pragma_c_code_dup_var.err_exp: tests/warnings/singleton_test.exp: Update the tests to reflect the new error messages talking about :- pragma foreign_code rather than :- pragma c_code.	2000-11-17 17:48:52 +00:00
Fergus Henderson	e6769ef622	Record the module that each instance declaration came from. ... Estimated hours taken: 8 Record the module that each instance declaration came from. This is needed for the IL back-end, which includes that module name in the symbol name that it generates for each instance declaration. compiler/prog_data.m: Add a module_name field to the `instance' item. compiler/prog_io_typeclass.m: When parsing `instance' declarations, store the module name that they came from in the module_name field of the `instance' item. compiler/hlds_data.m: Add a module_name field to the `hlds_instance_defn' structure. compiler/make_hlds.m: Copy the module_name field from the `instance' item to the `hlds_instance_defn' structure. compiler/polymorphism.m: Fix an old XXX: when constructing `base_typeclass_info_const's, use the module name from the `hlds_instance_defn', rather than hard-coding the invalid value "some bogus module name". compiler/rtti.m: Add a module_name field to the `base_typeclass_info' rtti_name and rtti_data. compiler/base_typeclass_info.m: Copy the module_name field in the `hlds_instance_defn' to the module_name field in the `base_typeclass_info' rtti_data and rtti_name. compiler/rtti_to_mlds.m: When constructing mlds `data_addr's, use the module_name from the `base_typeclass_info' rtti_name, rather than assuming that such references always refer to instance declarations in the current module. (That assumption would be a safe one currently, but doing it this way is probably a bit more robust against future changes.) compiler/*.m: Trivial changes to reflect the above data structure changes.	2000-11-01 05:12:14 +00:00
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.	2000-10-13 13:56:17 +00:00
Fergus Henderson	9387ffe8b9	(a) Move the tabling builtins, which are currently in private_builtin.m, ... Estimated hours taken: 4 (a) Move the tabling builtins, which are currently in private_builtin.m, into a different module which is only imported if the source contains a tabling pragma. (b) Improve the infrastructure for automatically importing modules to make it easy to automatically import a module only if a certain option is set. The idea is to eventually use this to put the simplified HLDS representation used for declarative debugging in a module which is only imported if the appropriate declarative debugging option is enabled. compiler/modules.m: Change add_implicit_imports so that it takes the list of items, for (a) above, and an io__state pair, for (b) above. Change its callers to pass the new parameters. Add a new predicate get_implicit_dependencies (implemented using add_implicit_imports). compiler/hlds_module.m: compiler/module_qual.m: Call get_implicit_dependencies rather than duplicating the code. compiler/make_hlds.m: compiler/hlds_module.m: Pass the item_list to module_info_init, since it's needed by get_implicit_dependencies. compiler/prog_out.m: Add new predicates mercury_table_builtin_module/1 (which returns the name of the "table_builtin" module) and any_mercury_builtin_module (which checks whether any of mercury_{table,public,private}_builtin_module hold). compiler/termination.m: Call any_mercury_builtin_module rather than checking for mercury_{public,private}_builtin_module. compiler/table_gen.m: Change the module for tabling builtins from private_builtin to table_builtin. compiler/hlds_pred.m: Add table_builtin to the builtin_mod enumeration, and change the module for tabling builtins from private_builtin to table_builtin. compiler/dead_proc_elim.m: Add a comment about the treatment of builtin modules. compiler/mode_util.m: When stripping out builtin module qualifiers, only strip qualifiers from "builtin:", not from "private_builtin:". library/table_builtin.m: library/private_builtin.m: Move the tabling builtins from private_builtin.m into a new module table_builtin.m. library/library.m: Add table_builtin.m to the list of imported modules. (Likewise for builtin.m and private_builtin.m; it's not strictly necessary for those, since they're implicitly imported anyway, but importing them explicitly is clearer.) library/io.m: Change private_builtin to table_builtin in the call to private_builtin__report_tabling_stats. doc/Mmakefile: Don't include the documentation for table_builtin.m in the library reference manual.	2000-09-20 12:12:37 +00:00
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.	2000-09-18 11:53:19 +00:00
Tyson Dowd	c192d50143	Add preliminary support for a new pragma: ... Estimated hours taken: 15 Add preliminary support for a new pragma: :- pragma foreign_code(LanguageString, .... <same args as c_code>). This is intended to be the eventual replacement of pragma c_code. Presently the only valid language is "C". The existing pragma c_code is simply turned into pragma foreign_code. pragma foreign_code is not a supported pragma at the moment. There are several other changes that are intended (for example, foreign_code will be impure by default). This change also changes the HLDS goal pragma_c_code/7 to pragma_foreign_code/8 where the extra argument is the foreign language. Any code currently generating output for pragma C code simply checks that the foreign language is set to "c". Since this is the only alternative of the type foreign_language, it will always succeed. However when new alternatives are added it should be fairly easy to find where the changes need to be made. Some type names and predicate names have also been updated, however there are many more that haven't yet been touched. compiler/prog_io_pragma.m: Accept the new syntax. Turn the old syntax into the new item. compiler/hlds_goal.m: Change pragma_c_code/7 to pragma_foreign_code/8. Define the foreign_language type. compiler/llds.m: Change user_c_code/2 to user_foreign_code/3. compiler/*.m: Update the rest of the compiler to handle these types. Make a few small changes to update variable names, predicate names and type names.	2000-08-09 07:48:04 +00:00
Simon Taylor	a033b2e748	Fix a bug which caused intermod.m to abort when a type class ... Estimated hours taken: 2 Fix a bug which caused intermod.m to abort when a type class contained a predicate or function with more than one mode. compiler/check_typeclass.m: Reorder the method declarations in each instance so that they match the order of the list of pred_proc_ids for the instance implementation. compiler/intermod.m: Remove duplicate pred_ids from the list of methods in an instance declaration when module qualifying the original instance declaration before writing it to the `.opt' file. Make sure that predicates referred to by an instance declaration in a `.opt' file are made exported. compiler/prog_data.m: Simplify the code by replacing the `pred_instance' and `func_instance' constructors of the `instance_method/0' type with a single constructor with a `pred_or_func' argument. compiler/mercury_to_mercury.m: compiler/check_typeclass.m: compiler/prog_io_typeclass.m: compiler/intermod.m: Handle the change to the `instance_method/0' type. tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/intermod_typeclass_bug.m: tests/hard_coded/typeclasses/intermod_typeclass_bug2.m: tests/hard_coded/typeclasses/intermod_typeclass_bug.exp: Test case.	2000-07-06 06:25:25 +00:00
Tyson Dowd	79d75acdb0	Add impure functions to Mercury, clean up the purity module somewhat, ... Estimated hours taken: 30 Add impure functions to Mercury, clean up the purity module somewhat, fix some bugs in purity, update and expand the purity documentation, and re-organize the purity checks. Impure functions can be declared just like impure preds. However, they can only be called in an explicit unification preceeded by a purity level: impure X = some_impure_func(Y, Z) The bug fixed was the fact that closures of impure predicates were only being detected when using lambda syntax. Purity information was discarded and impure closures could be created like this: Pred = some_impure_pred You could then use this predicate anywhere you like without any purity declarations. compiler/hlds_module.m: Add get_pred_id pred which will return the pred_id of a predicate matching a given type. This is like get_pred_and_proc_id, but only gets the information we are interested in, and is semidet. We need a semidet version to handle cases where type inference cannot infer a type before the limit is reached, but we try to purity check this code. (The bug mentioned above was stopping us from purity checking the test case for this before). compiler/make_hlds.m: Check for "impure" unifications with expressions that are not function calls and issue appropriate error messages. When unravelling impure function call unifications, put the input parameter unifications (if any) before the actual call. Only mark the goal_info for the function call as impure. compiler/mercury_to_goedel.m: compiler/mercury_to_mercury.m: compiler/module_qual.m: compiler/prog_data.m: compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_util.m: Add purity information to unify goals. Don't assume unify goals are pure. compiler/purity.m: Allow impure functions. Check unification goals for purity (not just lambda unification). Check unifications that are transformed into calls to make sure the call is purity correct. Put purity checking logic into separate predicates. Use an enum to return different errors and warnings. (The last two changes make it much easier to see the similarities between checking goals and checking predicates for purity correctness). Give different error messages for impure functions (highlight that you need to use them in an explicit unification). Handle unknown predicate lookups (can occur when unifying with a higher order term whose type could not be inferred). Add a few comments delineating where changes might need to be made to make foreign code impure by default in future. compiler/notes/authors.html: Add Peter Schachte to the authors list. doc/reference_manual.texi: Document impure functions. Expand more on what impure predicates/functions can do. Explain the concept of worst purity, and use it to explain the "inferred purity"/"declared purity" concepts. Make it more explicit that only impure goals obey strict-sequential like semantics. tests/invalid/type_inf_loop.err_exp2: Fix this test case to reflect the new error message new that we check the purity of this code correctly (or rather, we correctly fail to be able to purity check this code). tests/hard_coded/Mmakefile: tests/hard_coded/purity.exp: tests/hard_coded/purity.m: tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/impure_func_t1.m: tests/hard_coded/purity/purity.m: tests/hard_coded/purity/runtests: Remove purity tests from the hard_coded directory, give it a sub-directory of its own. tests/invalid/Mmakefile: tests/invalid/purity.err_exp: tests/invalid/purity.m: tests/invalid/purity_nonsense.err_exp: tests/invalid/purity_nonsense.m: tests/invalid/purity/Mmakefile: tests/invalid/purity/impure_func_t2.err_exp: tests/invalid/purity/impure_func_t2.m: tests/invalid/purity/impure_func_t3.err_exp: tests/invalid/purity/impure_func_t3.m: tests/invalid/purity/impure_func_t4.err_exp: tests/invalid/purity/impure_func_t4.m: tests/invalid/purity/impure_func_t5.err_exp: tests/invalid/purity/impure_func_t5.m: tests/invalid/purity/impure_pred_t1.err_exp: tests/invalid/purity/impure_pred_t1.m: tests/invalid/purity/impure_pred_t2.err_exp: tests/invalid/purity/impure_pred_t2.m: tests/invalid/purity/purity.err_exp: tests/invalid/purity/purity.m: tests/invalid/purity/purity_nonsense.err_exp: tests/invalid/purity/purity_nonsense.m: tests/invalid/purity/runtests: Remove purity tests from the invalid directory, give it a sub-directory of its own.	2000-04-22 07:12:53 +00:00
David Jeffery	0dab66d926	Allow class methods to be impure or semipure. ... Estimated hours taken: 6 Allow class methods to be impure or semipure. Previously any purity annotation on a class method was ignored, and the method assumed to be pure. (We have for some time caught the case of providing an impure implementation for a (pure) class method, though). compiler/prog_data.m: Add purity to the information we store about each method. compiler/prog_io_typeclass.m: Record the declared purity of each method. compiler/make_hlds.m: For the predicate we generate corresponding to a method, add any purity annotations that the method has. compiler/check_typeclass.m: Add the appropriate impurity marker to the predicate we generate for each instance method. compiler/purity.m: Be careful not to spit out spurious purity warnings: - Never warn about excessive impurity for a class methods. (The body of the method is just class_method_call, which never looks impure as far as it is concerned). - Never warn about excessive impurity for class instance method. The fact that a method is impure doesn't mean that its instances need to be impure, and it would be excessive to warn about it, seeing that there is no way for the user to avoid it (other than actually making their implementation impure...). compiler/mercury_to_mercury.m: Print out method purity in interface files. compiler/module_qual.m: compiler/equiv_type.m: Handle the fact that we now store purity info for class methods. tests/hard_coded/typeclasses/impure_methods.{m,exp}: A test case for this change. tests/hard_coded/typeclasses/Mmakefile: Turn this change on. tests/invalid/impure_methods.{m,err_exp}: A test case for invalid use of impurity and class methods tests/invalid/Mmakefile: Turn this change on.	2000-03-27 05:08:07 +00:00
Peter Ross	98e235be2c	The option, --warn-interface-imports, wasn't respecting the ... Estimated hours taken: 0.5 The option, --warn-interface-imports, wasn't respecting the --halt-at-warn option. compiler/module_qual.m: If --halt-at-warn turned on, make sure the compiler exits with a non-zero exit status. browser/collect_lib.m: Remove unused interface imports.	2000-01-13 04:29:40 +00:00
Peter Ross	1ffa21f5bf	Assertion declarations in the interface must not contain any symbols from ... Estimated hours taken: 26 Assertion declarations in the interface must not contain any symbols from modules imported only in the implementation. This constraint requires that each imported symbol be annotated with whether it is imported from the interface or implementation. compiler/prog_data.m: Update the pseudo declaration `:- imported' to include which section (either implementation or interface) the items following it were imported from. compiler/modules.m: Add a new version of get_dependencies, which divides the modules up into those imported in the interface and implementation. Use the new version of get_dependencies to place the new form of `:- imported' declarations at the start of items from different sections. compiler/hlds_pred.m: Add a new field to the imported data constructor in the type import_status, which records in which section the symbol was imported in. compiler/make_hlds.m: Modify module_defn_update_import_status so that it now records from which section a symbol is imported. compiler/module_qual.m: Any unqualified symbol in an assertion might come from *any* of the imported modules, so turn off the warning about modules which are imported in the interface but not used, if an unqualified symbol appears in the assertion. compiler/assertion.m: Use where a symbol is imported from when deciding whether an assertion in the interface is valid. Call module_info_incr_errors whenever an error message is written. compiler/post_typecheck.m: Add the extra module_info arg to assertion__in_interface_check, so that module_info_incr_errors can be called. compiler/dead_proc_elim.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/unused_args.m: Updates to use the new form of the data constructor imported.	1999-11-11 23:12:15 +00:00
Simon Taylor	e998ecbeb6	Don't report that builtin.m or private_builtin.m have not ... Estimated hours taken: 0.25 compiler/module_qual.m: Don't report that builtin.m or private_builtin.m have not been imported in error messages for undefined symbols. tests/invalid/Mmakefile: tests/invalid/builtin_int.m: tests/invalid/builtin_int.err_exp: Test case.	1999-10-04 04:04:51 +00:00
Fergus Henderson	e2ba68459d	When reporting undefined types, if the type is module-qualified ... Estimated hours taken: 1 compiler/module_qual.m: When reporting undefined types, if the type is module-qualified and the specified module has not been imported, then print a message explaining the problem. This required adding a field which keeps track of which modules have been imported. I also renamed the `interface_imports' field as `unused_interface_imports' to more closely reflect its usage. tests/invalid/undef_type.m: tests/invalid/undef_type.err_exp: Add a test case for this change.	1999-09-10 09:42:58 +00:00
Fergus Henderson	d8cfbaf07a	Fix the remaining bugs with the handling of partial qualifiers ... Estimated hours taken: 10 Fix the remaining bugs with the handling of partial qualifiers for nested modules. compiler/module_qual.m: Define a new abstract type partial_qualifier_info, and a predicate mq_info_get_partial_qualifier_info to get this type from the mq_info. Define a new predicate get_partial_qualifiers/3 in module_qual.m which is like the old get_partial_qualifiers/2 predicate from modules.m except that it takes a partial_qualifier_info and uses the information in this to return only the partial qualifiers for modules which are visible, rather than returning all partial qualifier regardless of whether the modules that they refer to are in scope or not. compiler/prog_util.m: Export the `insert_module_qualifier' predicate, for use in the definition of get_partial_qualifiers/3. compiler/hlds_module.m: compiler/make_hlds.m: Change the code for make_hlds__ctors_add and hlds_module__pred_table_insert/5 so that they handles partial qualifiers properly, computing the partial qualifiers by calling get_partial_qualifiers/3 rather than by checking the NeedQual variable and calling get_partial_qualifiers/2. compiler/modules.m: Delete the old get_partial_qualifiers/2 predicate. compiler/hlds_module.m: Add a new field to the HLDS containing the partial_qualifier_info. Add a partial_qualifier_info parameter to pred_table_insert/5. compiler/check_typeclass.m: compiler/make_hlds.m: When calling pred_table_insert/5, get the partial_qualifier_info from the HLDS and pass it as an extra argument. tests/hard_coded/sub-modules/nested.m: tests/hard_coded/sub-modules/nested3.m: tests/hard_coded/sub-modules/parent.m: tests/hard_coded/sub-modules/nested.exp: tests/hard_coded/sub-modules/nested3.exp: tests/hard_coded/sub-modules/parent.exp: Uncomment parts of these test cases which were previously commented out because they were not yet supported. doc/reference_manual.texi: Delete the description of this bug.	1999-07-14 14:57:13 +00:00
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.	1999-07-13 08:55:28 +00:00
Fergus Henderson	0705c72cf0	Fix some of the bugs with the handling of partial qualifiers ... Estimated hours taken: 4 Fix some of the bugs with the handling of partial qualifiers for nested modules. With this change, we now handle partial qualifiers correctly for types, insts, modes, and type classes, which are handled by module_qual.m. We still don't get it quite right for constructors, functions, and predicates, for which module qualification is handled by other modules (make_hlds.m, hlds_module.m, typecheck.m, post_typecheck.m, and modecheck_unify.m). compiler/module_qual.m: Keep track of which modules are visible. When looking up a qualified symbol, check that the specified module is visible. tests/hard_coded/sub-modules/nested.m: tests/hard_coded/sub-modules/nested3.m: tests/hard_coded/sub-modules/parent.m: Uncomment parts of these test cases which were previously commented out because they were not yet supported.	1999-07-12 15:14:31 +00:00
Fergus Henderson	64b3c37f45	More changes to reduce the complexity of the intermodule dependencies. ... Estimated hours taken: 2 More changes to reduce the complexity of the intermodule dependencies. compiler/module_qual.m: Some minor changes to avoid the need to import hlds*.m. This module acts on the parse tree, not the HLDS, so we shouldn't import hlds*.m here. compiler/modules.m: compiler/prog_io.m: compiler/det_analysis.m: Delete some unnecessary imports. compiler/equiv_type.m: compiler/dependency_graph.m: Add some XXX comments about unwanted intermodule dependencies.	1999-07-12 14:09:12 +00:00
Peter Ross	a5f5c63a3a	Add the infrastructure for assertions into the compiler. ... Estimated hours taken: 50 Add the infrastructure for assertions into the compiler. compiler/error_util.m: Output the correct pred name for assertions. compiler/hlds_data.m: Add the assertion_table structure. compiler/hlds_module.m: Get/set the assertion_table from the module_info. compiler/hlds_out.m: Modify hlds_out__write_pred_id to identify assertions. compiler/hlds_pred.m: Add the goal_type assertion. compiler/make_hlds.m: Transform the assertion to a HLDS data structure that can be typechecked. compiler/mercury_to_goedel.m: compiler/module_qual.m: Handle the assertion structure. compiler/mercury_to_mercury.m: Output assertions. compiler/post_typecheck.m: Add a predicate which must be called after typechecking of assertions has been finished. Also document some possible problems with typechecking assertions. compiler/prog_data.m: Add assertion to the type item. compiler/prog_io.m: Add the ability to parse assertions. compiler/purity.m: After finished typechecking assertions call post_typecheck__finish_assertion. compiler/typecheck.m: Don't output inference messages for assertions. compiler/notes/compiler_design.html: Update documentation about exactly where quantification is done. compiler/notes/glossary.html: Define what an assertion is.	1999-07-09 01:15:40 +00:00
Simon Taylor	79dcbbef15	User-guided type specialization. ... Estimated hours taken: 60 User-guided type specialization. compiler/prog_data.m: compiler/prog_io_pragma.m: compiler/modules.m: compiler/module_qual.m: compiler/mercury_to_mercury.m: Handle `:- pragma type_spec'. compiler/prog_io_pragma.m: Factor out some common code to parse predicate names with arguments. compiler/hlds_module.m: Added a field to the module_sub_info to hold information about user-requested type specializations, filled in by make_hlds.m and not used by anything after higher_order.m. compiler/make_hlds.m: For each `:- pragma type_spec' declaration, introduce a new predicate which just calls the predicate to be specialized with the specified argument types. This forces higher_order.m to produce the specialized versions. compiler/higher_order.m: Process the user-requested type specializations first to ensure that they get the correct names. Allow partial matches against user-specified versions, e.g. map__lookup(map(int, list(int)), int, list(int)) matches map__lookup(map(int, V), int, V). Perform specialization where a typeclass constraint matches a known instance, but the construction of the typeclass_info is done in the calling module. Give slightly more informative progress messages. compiler/dead_proc_elim.m: Remove specializations for dead procedures. compiler/prog_io_util.m: Change the definition of the `maybe1' and `maybe_functor' types to avoid the need for copying to convert between `maybe1' and `maybe1(generic)'. Changed the interface of `make_pred_name_with_context' to allow creation of predicate names for type specializations which describe the type substitution. compiler/make_hlds.m: compiler/prog_io_pragma.m: Make the specification of pragma declarations in error messages consistent. (There are probably some more to be fixed elsewhere for termination and tabling). compiler/intermod.m: Write type specialization pragmas for predicates declared in `.opt' files. compiler/mercury_to_mercury.m: Export `mercury_output_item' for use by intermod.m. compiler/options.m: Add an option `--user-guided-type-specialization' enabled with `-O2' or higher. compiler/handle_options.m: `--type-specialization' implies `--user-guided-type-specialization'. compiler/hlds_goal.m: Add predicates to construct constants. These are duplicated in several other places, I'll fix that as a separate change. compiler/type_util.m: Added functions `int_type/0', `string_type/0', `float_type/0' and `char_type/0' which return the builtin types. These are duplicated in several other places, I'll fix that as a separate change. library/private_builtin.m: Added `instance_constraint_from_typeclass_info/3' to extract the typeclass_infos for a constraint on an instance declaration. This is useful for specializing class method calls. Added `thread_safe' to various `:- pragma c_code's. Added `:- pragma inline' declarations for `builtin_compare_*', which are important for user-guided type specialization. (`builtin_unify_*' are simple enough to go in the `.opt' files automatically). compiler/polymorphism.m: `instance_constraint_from_typeclass_info/3' does not need type_infos. Add `instance_constraint_from_typeclass_info/3' to the list of `typeclass_info_manipulator's which higher_order.m can interpret. NEWS: doc/reference_manual.texi: doc/user_guide.texi Document the new pragma and option. tests/invalid/Mmakefile: tests/invalid/type_spec.m: tests/invalid/type_spec.err_exp: Test error reporting for invalid type specializations. tests/hard_coded/Mmakefile: tests/invalid/type_spec.m: tests/invalid/type_spec.exp: Test type specialization.	1999-04-23 01:03:51 +00:00
Fergus Henderson	39e15e87d7	Implement abstract instance declarations. ... Estimated hours taken: 0.25 Implement abstract instance declarations. (I forgot to commit changes to these two files as part of my last commit.) compiler/mercury_to_mercury.m: compiler/module_qual.m: Change the code to reflect the new name and representation of `instance_interface'.	1999-02-14 13:02:37 +00:00
Simon Taylor	18430aaef1	Aditi compilation. ... Estimated hours taken: 1200 Aditi compilation. compiler/options.m: The documentation for these is commented out because the Aditi system is not currently useful to the general public. --aditi: enable Aditi compilation. --dump-rl: write the intermediate RL to `<module>.rl_dump'. --dump-rl-bytecode: write a text version of the bytecodes to `<module>.rla' --aditi-only: don't produce a `.c' file. --filenames-from-stdin: accept a list of filenames to compile from stdin. This is used by the query shell. --optimize-rl, --optimize-rl-cse, --optimize-rl-invariants, --optimize-rl-index, --detect-rl-streams: Options to control RL optimization passes. --aditi-user: Default owner of any Aditi procedures, defaults to $USER or "guest". --generate-schemas: write schemas for base relations to `<module>'.base_schema and schemas for derived relations to `<module>'.derived_schema. This is used by the query shell. compiler/handle_options.m: Handle the default for --aditi-user. compiler/hlds_pred.m: compiler/prog_data.m: compiler/prog_io_pragma.m: compiler/make_hlds.m: Add some Aditi pragma declarations - `aditi', `supp_magic', `context', `naive', `psn' (predicate semi-naive), `aditi_memo', `aditi_no_memo', `base_relation', `owner' and `index'. Separate out code to parse a predicate name and arity. compiler/hlds_pred.m: Add predicates to identify Aditi procedures. Added markers `generate_inline' and `aditi_interface', which are used internally for Aditi code generation. Add an `owner' field to pred_infos, which is used for database security checks. Add a field to pred_infos to hold the list of indexes for a base relation. compiler/make_hlds.m: Some pragmas must be exported if the corresponding predicates are exported, check this. Make sure stratification of Aditi procedures is checked. Predicates with a mode declaration but no type declaration are no longer assumed to be local. Set the `do_aditi_compilation' field of the module_info if there are any local Aditi procedures or base relations. Check that `--aditi' is set if Aditi compilation is required. compiler/post_typecheck.m: Check that every Aditi predicate has an `aditi__state' argument, which is used to ensure sequencing of updates and that Aditi procedures are only called within transactions. compiler/dnf.m: Changed the definition of disjunctive normal form slightly so that a call followed by some atomic goals not including any database calls is considered atomic. magic.m can handle this kind of goal, and it results in more efficient RL code. compiler/hlds_module.m: compiler/dependency_graph.m: Added dependency_graph__get_scc_entry_points which finds the procedures in an SCC which could be called from outside. Added a new field to the dependency_info, the aditi_dependency_ordering. This contains all Aditi SCCs of the original program, with multiple SCCs merged where possible to improve the effectiveness of differential evaluation and the low level RL optimizations. compiler/hlds_module.m: Add a field to record whether there are any local Aditi procedures in the current module. Added versions of module_info_pred_proc_info and module_info_set_pred_proc_info which take a pred_proc_id, not a separate pred_id and proc_id. compiler/polymorphism.m: compiler/lambda.m: Make sure that predicates created for closures in Aditi procedures have the correct markers. compiler/goal_util.m: Added goal_util__switch_to_disjunction, goal_util__case_to_disjunct (factored out from simplify.m) and goal_util__if_then_else_to_disjunction. These are require because supplementary magic sets can't handle if-then-elses or switches. compiler/type_util.m: Added type_is_aditi_state/1. compiler/mode_util.m: Added partition_args/5 which partitions a list of arguments into inputs and others. compiler/inlining.m: Don't inline memoed procedures. Don't inline Aditi procedures into non-Aditi procedures. compiler/intermod.m: Handle Aditi markers. Clean up handling of markers which should not appear in `.opt' files. compiler/simplify.m: Export a slightly different interface for use by magic.m. Remove explicit quantifications where possible. Merge multiple nested quantifications. Don't report infinite recursion warnings for Aditi procedures. compiler/prog_out.m: Generalised the code to output a module list to write any list. compiler/code_gen.m: compiler/arg_info.m: Don't process Aditi procedures. compiler/mercury_compile.m: Call magic.m and rl_gen.m. Don't perform the low-level annotation passes on Aditi procedures. Remove calls to constraint.m - sometime soon a rewritten version will be called directly from deforestation. compiler/passes_aux.m: Add predicates to process only non-Aditi procedures. compiler/llds.m: compiler/llds_out.m: Added new `code_addr' enum members, do_{det,semidet,nondet}_aditi_call, which are defined in extras/aditi/aditi.m. compiler/call_gen.m: Handle generation of do_*_aditi_call. compiler/llds_out.m: Write the RL code for the module as a constant char array in the `.c' file. compiler/term_errors.m: compiler/error_util.m: Move code to describe predicates into error_util.m Allow the caller to explicitly add line breaks. Added error_util:list_to_pieces to format a list of strings. Reordered some arguments for currying. compiler/hlds_out.m: Don't try to print clauses if there are none. runtime/mercury_init.h: util/mkinit.c: scripts/c2init.in: Added a function `mercury__load_aditi_rl_code()' to the generated `<module>_init.c' file which throws all the RL code for the program at the database. This should be called at connection time by `aditi__connect'. Added an option `--aditi' which controls the output `mercury__load_aditi_rl_code()'. compiler/notes/compiler_design.html: Document the new files. Mmakefile: bindist/Mmakefile: Don't distribute extras/aditi yet. New files: compiler/magic.m: compiler/magic_util.m: Supplementary magic sets transformation. Report errors for constructs that Aditi can't handle. compiler/context.m: Supplementary context transformation. compiler/rl_gen.m: compiler/rl_relops.m: Aditi code generation. compiler/rl_info.m: Code generator state. compiler/rl.m: Intermediate RL representation. compiler/rl_util: Predicates to collect information about RL instructions. compiler/rl_dump.m: Print out the representation in rl.m. compiler/rl_opt.m: Control low-level RL optimizations. compiler/rl_block.m: Break a procedure into basic blocks. compiler/rl_analyse.m: Generic dataflow analysis for RL procedures. compiler/rl_liveness.m: Make sure all relations are initialised before used, clear references to relations that are no longer required. compiler/rl_loop.m: Loop invariant removal. compiler/rl_block_opt.m: CSE and instruction merging on basic blocks. compiler/rl_key.m: Detect upper/lower bounds for which a goal could succeed. compiler/rl_sort.m: Use indexing for joins and projections. Optimize away unnecessary sorting and indexing. compiler/rl_stream.m: Detect relations which don't need to be materialised. compiler/rl_code.m: RL bytecode definitions. Automatically generated from the Aditi header files. compiler/rl_out.m: compiler/rl_file.m: Output the RL bytecodes in binary to <module>.rlo (for use by Aditi) and in text to <module>.rla (for use by the RL interpreter). Also output the schema information if --generate-schemas is set. compiler/rl_exprn.m: Generate bytecodes for join conditions. extras/aditi/Mmakefile: extras/aditi/aditi.m: Definitions of some Aditi library predicates and the interfacing and transaction processing code.	1998-12-06 23:49:14 +00:00
Thomas Conway	5c955626f2	These changes make var' and term' polymorphic. ... Estimated hours taken: 20 These changes make `var' and `term' polymorphic. This allows us to make variables and terms representing types of a different type to those representing program terms and those representing insts. These changes do not *fix* any existing problems (for instance there was a messy conflation of program variables and inst variables, and where necessary I've just called varset__init(InstVarSet) with an XXX comment). NEWS: Mention the changes to the standard library. library/term.m: Make term, var and var_supply polymorphic. Add new predicates: term__generic_term/1 term__coerce/2 term__coerce_var/2 term__coerce_var_supply/2 library/varset.m: Make varset polymorphic. Add the new predicate: varset__coerce/2 compiler/prog_data.m: Introduce type equivalences for the different kinds of vars, terms, and varsets that we use (tvar and tvarset were already there but have been changed to use the polymorphic var and term). Also change the various kinds of items to use the appropriate kinds of var/varset. compiler/*.m: Thousands of boring changes to make the compiler type correct with the different types for type, program and inst vars and varsets.	1998-11-20 04:10:36 +00:00
Fergus Henderson	ecb6edb717	Fix a bug with intermodule optimization of nested modules. ... Estimated hours taken: 20 Fix a bug with intermodule optimization of nested modules. Previously, the compiler used to just label any predicates defined in a module containing sub-modules as `exported', since they may be needed by the separately-compiled sub-modules. However, this is a little bit of a lie, and it turns out that it doesn't work. The fix is to use a new status `exported_to_submodules' for this case. compiler/prog_data.m: Add a new pseudo-declaration ":- private_interface", used to mark items in an ":- implementation" section that will be exported to submodules. compiler/modules.m: Put declarations from modules containing sub-modules into `private_interface' sections rather than into `interface' sections. compiler/hlds_pred.m: Add a new alternative `exported_to_submodules' to the `import_status' data type. Add several new procedures for testing particular aspects of this type. compiler/module_qual.m: Set the import_status of items in a `private_interface' section to `exported_to_submodules'. compiler/intermod.m: Handle procedures with status `exported_to_submodules' specially. Also reorganize the code here a bit to make it more maintainable. compiler/base_type_info.m: compiler/base_type_info.m: compiler/base_typeclass_info.m: compiler/code_util.m: compiler/dead_proc_elim.m: compiler/hlds_out.m: compiler/make_hlds.m: compiler/termination.m: compiler/unused_args.m: Minor changes to reflect the above changes to data-structures; in particular, use the new procedures defined in hlds_pred.m instead of hard-coded tests. In termination.m, the changes included deleting some error-checking code that didn't make much sense anymore when using the new procedures rather than using hard-coded tests. tests/hard_coded/Mmakefile: tests/hard_coded/nested_intermod.m: tests/hard_coded/nested_intermod_main.m: tests/hard_coded/nested_intermod_main.exp: Add a regression test for the bug mentioned above.	1998-11-02 09:49:17 +00:00
Thomas Conway	7d0e4822d1	Fix several bugs in the runtime engine to do with thread-safe execution. ... Estimated hours taken: 15 Fix several bugs in the runtime engine to do with thread-safe execution. Add a new flag to pragma c_code/import to allow programmers to specify whether or not the C code is thread-safe or not, and modify code generation to put a lock around C code that isn't thread_safe. runtime/mercury_thread.{c,h}: Add a global lock. Change the handling of thread creation. create_thread now takes a "closure" (a C struct with a fn pointer and an argument to pass the function) which it calls in the new thread. (The same mechanism is used in the Boehm collector), or NULL which causes the thread to wait for work to appear in the Mercury runqueue. runtime/mercury_context.c: initialize the global lock. runtime/mercury_engine.{c,h}: Add a new field to the MercuryEngine structre which is used to store a list of saved thread ids. These were being saved in a local variable in call_engine_inner which was a bug because call_engine_inner's (C) stack frame gets scribbled on by Mercury execution. For more detail see the comments in mercury_engine.h runtime/mercury_wrapper.c: Use the new interface to create_thread. compiler/prog_io_pragma.m: Parse either a single attribute or a list of attributes instead of just 'may_call_mercury' in pragma c code and pragma import. These are stored in an abstract type 'pragma_c_code_attributes' that uses a bit array (aka int) to store the attributes. compiler/pragma_c_gen.m: Get the code generator to emit c code to obtain and release the global lock for pragma c code that isn't thread_safe. compiler/<various>.m: Change may_call_mercury to pragma_c_code_attributes. doc/reference_manual.m: Document the change to pragma c code. scripts/mgnuc.in: Pass some extra C flags for thread-safe compilation for Linux.	1998-08-07 00:50:34 +00:00
David Jeffery	4556cccae8	Remember the term__context of where we read an instance method from so that ... Estimated hours taken: 2 Remember the term__context of where we read an instance method from so that we can give more accurate error messages. Also (slightly) improve the text of the error message for instance methods. check_typeclass.m: Use the term__context of the instance method declaration as the term__context for the introduced pred. hlds_out.m: If the pred is one introduced as an instance method, give a (slightly) better error message. mercury_to_mercury.m: Ignore the term context. module_qual.m: Pass along the term context. prog_data.m: Add a term__context to the instance_method prog_io_typeclass.m: Store the term__context in the instance_method	1998-08-04 06:44:27 +00:00
Fergus Henderson	6455e041cb	Merge in the changes from the existential types branch, ... Estimated hours taken: 6 (plus another 80 or so already recorded for my commits on the existential_types branch) Merge in the changes from the existential types branch, and make some modifications to address dgj's code review comments. These changes add support for existentially quantified type variables and type class constraints on functions and predicates. (Existential data types, however, are not supported -- see below.) Existentially quantified type variables are introduced with an explicit `some [T]', e.g. `:- some [T] pred foo(T)'. Existentially quantified type class constraints are introduced with `&' instead of `<=', e.g. `:- some [T] (pred foo(T) & ord(T))'. There's still several limitations: 0. XXX It's not yet documented in the language reference manual. 1. XXX It doesn't do any mode checking or mode reordering. If you write code that uses existentially typed procedures in the wrong order, then you'll get an internal error in polymorphism.m or in the code generator. (Cases where a type_info has no producer at all are caught by the check for unbound type variables in post_typecheck.m.) To support this, we need to change things so that polymorphism.m gets invoked before mode checking. 2. Using `in' modes on arguments of existential type won't work. If you try, you will get a compile error. It would be nice to extend things to allow this kind of "implied mode" for type_infos, where an existential type becomes a universal type if some value of that type is input. Supporting this would require first fixing limitation 1 (described above) and then 3. There's no support for `pragma c_code' for procedures with existential type class constraints. (In fact, there's not really any support for `pragma c_code' for procedures with universal type class constraints either -- the C code has no way of getting access to the type class info.) 4. XXX Taking the address of something which is existentially typed should be illegal, but we don't check this. In addition, these changes in this batch make a start towards allowing existentially typed data types. The compiler now accepts existential quantifiers and type class constraints on type definitions, and type checks them accordingly (assuming all functor occurrences are deconstructors, not constructors -- see limitation 2 above). But there's no special handling for them in polymorphism.m, so if you try to use them, it will abort with an internal error. The changes also includes fixes for a couple of bugs in typechecking and polymorphism that I discovered while making the above changes, and an improvement to the error reporting from typecheck.m in one case. Those changes are listed separately below. compiler/prog_data.m: Add a new type `class_constraints', which holds two different lists of constraints, namely the existentially quantified constraints and the universally quantified ones. Add a new field to the parse tree representation of pred and func declarations to hold a list of the existentially quantified type variables, and change the `list(class_constraint)' into `class_constraints' so that we can store existential constraints too. Add new fields to the `constructor' data type (formerly just a pair) to hold the existentially quantified type variables and type class constraints. compiler/hlds_pred.m: Add several new fields to the pred_info: - a list of the existentially quantified type variables; - a list of the "HeadTypeParams": type variables which cannot be bound by this predicate (i.e. those whose type_infos come from this pred's caller or are returned from other preds called by this one); - and a list of unsatisfied type class constraints. Add a predicate pred_info_get_univ_quant_tvars to compute the universally quantified type variables. Change the pred constraints field from `list(class_constraint)' to `class_constraints' so that it can hold existential constraints too. compiler/hlds_data.m: Add new fields to hlds_cons_defn to hold the existentially quantified type variables and type class constraints. compiler/*.m: Minor changes to reflect the above-mentioned data structure changes in prog_data.m, hlds_pred.m, and hlds_data.m. compiler/prog_io.m: Add code to parse the new constructs. Also rewrite the code for parsing purity specifiers, type quantifiers and type class constraints, using basically the method suggested by Peter Schachte: treat these as "declaration attributes", and have parse_decl strip off all the declaration attributes into a seperate list and then pass that list to process_decl, which for each different kind of declaration processes the attributes which are appropriate for that declaration and then calls check_no_attributes to ensure that there were no inappropriate attributes. The purpose of this rewrite was to allow it to handle the new constructs properly, and to avoid unnecessary code duplication. compiler/mercury_to_mercury.m: Add code to pretty-print the new constructs. compiler/make_hlds.m: Copy the new fields in the parse tree into the corresponding new fields in the pred_info. Add code to check for various misuses of quantifiers. compiler/hlds_out.m: Print out the new fields in the pred_info (except the unsatisfied type class constraints -- if these are non-empty, post_typecheck.m will print them out in the error message). When printing out types, pass the AppendVarNums parameter down, so that HLDS dumps will distinguish between different type variables that have the same name. Delete hlds_out__write_constructor, since it was doing exactly the same thing as mercury__output_ctor. compiler/typecheck.m: Lots of changes to handle existential types and existential type class constraints. compiler/post_typecheck.m: When checking for unbound type variables, use the value of HeadTypeParams from the pred_info. compiler/type_util.m: Delete `type_and_constraint_list_matches_exactly', since it was not used. Add various `apply_variable_renaming_to_*' predicates for renaming constraints. compiler/polymorphism.m: Lots of changes to handle existential types and existential type class constraints. Also some changes to make the code more maintainable: compiler/prog_data.m: compiler/hlds_goal.m: compiler/mercury_to_mercury.m: Put curly braces around the definitions of 'some'/2 and '&'/2 functors in `:- type' definitions, to avoid them being misinterpreted as existential type constraints. compiler/goal_util.m: compiler/polymorphism.m: compiler/hlds_pred.m: compiler/lambda.m: Include type_infos for existentially quantified type variables and type_class_infos for existential constraints in the set of extra variables computed by goal_util__extra_type_info_vars. compiler/inlining.m: Change inlining__do_goal to handle inlining of calls to existentially typed predicates -- for them, instead of not binding any type variables at all in the caller, it allows the call to bind any type variables in the caller except for those that are universally quantified. compiler/inlining.m: compiler/deforest.m: Call pred_info_get_univ_quant_tvars and pass the result to inlining__do_inline_goal. tests/hard_coded/Mmakefile: tests/hard_coded/existential_types_test.{m,exp}: tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/existential_type_classes.{m,exp}: Test cases for the use of existential types and existential type class constraints. ---------- Improve an error message. compiler/typecheck.m: Improve error reporting by checking type class constraints for satisfiability as we go and thus reporting unsatisfiable constraints as soon as possible, rather than only at the end of the clause. Previously we already did that for the case of ground constraints, but they are not the only unsatsfiable constraints: constraints on head type params (type variables which cannot be bound) are also unsatisfiable if they can't be eliminated straight away by context reduction. tests/invalid/Mmakefile: tests/invalid/typeclass_test_7.{m,err_exp}: Regression test for the above change. ---------- Avoid problems where type inference was reporting some spurious errors for predicates using type classes, because the check for unsatisfied type class constraints was being done before the final pass of type inference had finished. compiler/hlds_pred.m: Add new field to the pred_info containing the unproven type class constraints. compiler/typecheck.m: When inferring type class constraints, make sure that before we save the results back in the pred_info, we restrict the constraints to the head type variables. Constraints on other type variables should be treated as unsatisfied constraints. Don't check for unsatisfied type class constraints at the end of each pass; instead, just save the unproven type class constraints in the pred_info. compiler/post_typecheck.m: Check for unsatisfied type class constraints, using the new field in the pred_info. tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/inference_test_2.{m,exp}: tests/invalid/Mmakefile: tests/invalid/typeclass_test_8.{m,err_exp}: Add regression tests for this change. ---------- Fix a bug with the computation of the non-locals for predicates with more than one constraint on the same type variable -- it was only including one of the type-class-infos, rather than all of them. compiler/goal_util.m: Change `goal_util__extra_nonlocal_typeinfos' so that it gets passed the TypeClassInfoVarMap and uses this to include all the appropriate typeclass infos in the extra nonlocals. compiler/hlds_pred.m: compiler/lambda.m: compiler/polymorphism.m: Pass the TypeClassInfoVarMap to `goal_util__extra_nonlocal_typeinfos'. tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/lambda_multi_constraint_same_tvar.{m,exp}: Regression test for the above-mentioned bug.	1998-07-08 20:59:50 +00:00
Oliver Hutchison	bcf7dbf9f8	Add support for tabling. ... Estimated hours taken: 250 Add support for tabling. This change allows for model_det, model_semidet and model_non memoing, minimal model and loop detection tabling. compiler/base_type_layout.m: Update comments to reflect new runtime naming standard. compiler/det_analysis.m: Allow tabling to change the result of det analysis. This is necessary in the case of minimal model tabling which can turn a det procedure into a semidet one. compiler/det_report.m: compiler/hlds_data.m: Add code to report error messages for various non compatible tabling methods and determinism. compiler/hlds_out.m: compiler/modules.m: Remove reference to the old memo marker. compiler/hlds_pred.m: Create new type (eval_method) to define which of the available evaluation methods should be used each procedure. Add new field to the proc_info structure. Add several new predicates relating to the new eval_method type. compiler/inlining.m: compiler/intermod.m: Make sure only procedures with normal evaluation are inlined. compiler/make_hlds.m: Add code to process new tabling pragmas. compiler/mercury_compile.m: Call the tabling transformation code. compiler/modes.m: Make sure that all procedures with non normal evaluation have no unique/partially instantiated modes. Produce error messages if they do. Support for partially instantiated modes is currently missing as it represents a large amount of work for a case that is currently not used. compiler/module_qual.m: compile/prog_data.m: compiler/prog_io_pragma.m: Add three new pragma types: `memo' `loop_check' `minimal_model' and code to support them. compiler/simplify.m: Don't report infinite recursion warning if a procedure has minimal model evaluation. compiler/stratify.m: Change the stratification analyser so that it reports cases of definite non-stratification. Rather than reporting warnings for any code that is not definitely stratified. Remove reference to the old memo marker. compiler/switch_detection.m: Fix a small bug where goal were being placed in reverse order. Call list__reverse on the list of goals. compiler/table_gen.m: New module to do the actual tabling transformation. compiler/notes/compiler_design.html: Document addition of new tabling pass to the compiler. doc/reference_manual.texi: Fix mistake in example. library/mercury_builtin.m: Add many new predicates for support of tabling. library/std_util.m: library/store.m: Move the functions : ML_compare_type_info ML_collapse_equivalences ML_create_type_info to the runtime. runtime/mercury_deep_copy.c: runtime/mercury_type_info.h: runtime/mercury_type_info.c: Move the make_type_info function into the mercury_type_info module and make it public. runtime/Mmakefile: runtime/mercury_imp.h: Add references to new files added for tabling support. runtime/mercury_string.h: Change hash macro so it does not cause a name clash with any variable called "hash". runtime/mercury_type_info.c: runtime/mercury_type_info.h: Add three new functions taken from the library : MR_compare_type_info MR_collapse_equivalences MR_create_type_info. runtime/mercury_table_any.c: runtime/mercury_table_any.h: runtime/mercury_table_enum.c: runtime/mercury_table_enum.h: runtime/mercury_table_int_float_string.c: runtime/mercury_table_int_float_string.h: runtime/mercury_table_type_info.c: runtime/mercury_table_type_info.h: runtime/mercury_tabling.h: New modules for the support of tabling.	1998-05-15 07:09:29 +00:00
Fergus Henderson	f884cee0c4	Finish off the centralization of the file name handling code, and ... Estimated hours taken: 11 Finish off the centralization of the file name handling code, and add support for generating intermediate files in subdirectories. scripts/mmake.in: Add a new boolean option `--use-subdirs'; if enabled, it just sets the environment variable MMAKE_USE_SUBDIRS to `yes' before invoking Make. Also add negative versions of the various options (`--no-use-subdirs', `--no-verbose', `--no-save-makefile'). scripts/Mmake.rules: Add code to handle generating intermediate file names in subdirectories. If MMAKE_USE_SUBDIRS=yes, we add `--use-subdirs' to MCFLAGS, and most of the pattern rules are changed to use subdirectories. Note that getting this to work required a bit of a hack: due to what seem to be bugs in GNU Make, `mmake depend' needs to do `mmc --make-short-interface *.m' to get things started. But once the int3s are there, the dependencies seem to work OK. compiler/options.m: Add a new boolean option `--use-subdirs'. compiler/modules.m: Add new predicate `fact_table_file_name'. Add an extra argument to `module_name_to_file_name', specifying whether or not to create any directories needed for the file name. Change all the file-name-creating predicates here to go through a single new predicate `choose_file_name', and add code in that predicate to handle the `--use-subdirs' option. Also if the `--use-subdirs' option is set, don't use the compact dependencies format, since it can't work in that case. compiler/fact_table.m: Call `fact_table_file_name' rather than using `string__append'. compiler/mercury_compile.m: Change `link_module_list' and `join_module_list' so that they create file names by calling `module_name_to_file_name'. compiler/export.m: compiler/intermod.m: compiler/llds_out.m: compiler/mercury_compile.m: compiler/module_qual.m: compiler/modules.m: compiler/termination.m: compiler/trans_opt.m: compiler/unused_args.m: Change all calls to `module_name_to_file_name' to pass the extra argument specifying whether or not to make any directories needed for the file name. library/Mmakefile: Change the rule for `mmake install_ints' so that it creates a `Mercury' subdirectory with symbolic links `ints', `int2s', `int3s', `opts', and `trans_opts' which just point to `..'. This is needed for the `--use-subdirs' option to work, because Mmake currently does not support mixing libraries compiled with and without `--use-subdirs'. doc/user_guide.texi: Document the above changes.	1998-03-18 08:09:50 +00:00