74 Commits

Author	SHA1	Message	Date
Simon Taylor	d701d8ba06	Use pred_const cons_ids in the unify_rhs field for constructions ... Estimated hours taken: 4 Use pred_const cons_ids in the unify_rhs field for constructions of higher-order terms. Previously there would be a `cons(sym_name, arity)' cons_id in the `unify_rhs', and a pred_const in the `unification'. This avoids multiple calls to get_pred_id_and_proc_id, and is more consistent with how other cons_ids are handled. compiler/post_typecheck.m: Find the pred_const cons_id for constructions of higher-order terms. Make sure the sym_name field of a call goal is fully module qualified. compiler/higher_order.m: compiler/lambda.m: Use `pred_const' rather than `cons(sym_name, arity)' in the `unify_rhs' of constructions of higher-order terms. compiler/polymorphism.m: compiler/modecheck_unify.m: Change the interface of polymorphism__convert_pred_to_lambda_goal to reflect the fact that the pred_proc_id of the higher-order term has already been computed by post_typecheck.m. compiler/purity.m: Don't attempt to resolve overloading if there were type errors. If the type inference iteration limit was exceeded the code to resolve overloading of higher-order terms in post_typecheck.m can abort. This occurred with tests/invalid/type_inf_loop.m. compiler/hlds_goal.m: Remove documentation about the restrictions on cons_ids in a unify_rhs, since they no longer apply. compiler/intermod.m: Remove code duplicated from post_typecheck.m. compiler/hlds_data.m: Add a comment that code_addr_const cons_ids are no longer used (they are left over from an old method of constructing type_ctor_infos). compiler/hlds_out.m: Don't abort on code_addr_consts in hlds_out__write_functor_cons_id. This will avoid problems if anyone decides to start using code_addr_consts again. tests/invalid/Mmakefile: tests/invalid/aditi_update_errors.m: tests/invalid/aditi_update_derived_relation.{m,err_exp}: Separate out parts of aditi_update_errors.m which were no longer being tested because post_typecheck is no longer run when there are type errors. tests/invalid/aditi_update_errors.err_exp: tests/invalid/aditi_update_mode_errors.err_exp: Update the expected output.	2001-07-10 10:45:36 +00:00
Adrian Pellas-Rice	1c65d003f7	Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. ... Estimated hours taken: 4.5 Branches: main Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. compiler/hlds_goal.m Create a new type, the `shorthand_goal_expr', for goals kinds that are implemented by a (ordinary_hlds + shorthand) -> (ordinary_hlds) transformation. At present, bi_implication is the only kind of of goal that is implemented in this way. Moved bi_implication functor from the type goal_expr to the new shorthand_goal_expr type. Added the functor shorthand to the goal_expr type. compiler/*.m Change switches on hlds_goal_expr that call error when they recognise `bi_implication' from calling error when they recognise `bi_implication' to calling error when they recognise `shorthand'. For all predicates K that a) switch on hlds_goal_expr and b) perform non-trivial processing when they recognise `bi_implication' change K such that it now calls K_shorthand upon recognising the functor `shorthand'. Define K_shorthand to switch on shorthand_goal_expr, where the code for the `bi_implication' case formerly contained in K is now contained in K_shorthand.	2001-04-07 14:05:03 +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
Fergus Henderson	9588e2a5ab	Fix a bug that was causing the GCC back-end to abort with an internal ... Estimated hours taken: 5 Fix a bug that was causing the GCC back-end to abort with an internal compiler error (map__det_insert failed) in mlds_to_gcc.m for tests/hard_coded/curry2 and tests/higher_order_syntax2.m. The C back-end also had a bug for these test cases: it generated incorrect code, which `gcc -Wshadow' even warned about, but that by coincidence didn't cause the test to fail. The root cause was that lambda.m was generating incorrect HLDS: it was not recomputing the non-locals properly. compiler/lambda.m: Recompute the non-locals of the introduced procedure, if needed, to handle the case where extra non-locals need to be added for a lambda expression that is itself nested inside another lambda expression. (Also wrap some long lines.)	2001-02-01 06:43:40 +00:00
Fergus Henderson	4be69fa961	Eliminated a lot of the dependencies on the the `code_model' type, ... Estimated hours taken: 6 Eliminated a lot of the dependencies on the the `code_model' type, and move that type from llds.m into a new module `code_model'. The aim of this change is to improve the modularity of the compiler by reducing the number of places in the compiler front-end that depend on back-end concepts and the number of places in the MLDS back-end which depend on the LLDS. compiler/code_model.m: New module. Contains the code_model type and associated procedures. compiler/llds.m: Move the code_model type into code_model.m. compiler/hlds_goal.m: Move the goal_info_get_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/hlds_out.m: Delete `hlds_out__write_code_model', since it wasn't being used. compiler/hlds_pred.m: Move the proc_info_interface_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/goal_path.m: When computing the `maybe_cut' field for `some' goals, compute it by comparing the determinism rather than by comparing the goal_infos. compiler/unique_modes.m: Use determinism and test for soln_count = at_most_many rather than using code_model and testing for model_non. compiler/inlining.m: Test for determinism nondet/multi rather than testing for code_model model_non. compiler/hlds_pred.m: compiler/det_report.m: Change valid_code_model_for_eval_method, which succeeded unless the eval_method was minimal_model and the code_model was model_det, to valid_determinism_for_eval_method, which succeeds unless the eval_method is minimal_model and the determinism cannot fail. As well as avoiding a dependency on code_model in the HLDS modules, this also fixes a bug where det_report could give misleading error messages, saying that `multi' was a valid determinism for `minimal_model' predicates, when in fact the compiler will always report a determinism error if you declare a `minimal_model' predicate with determinism `multi'. (Actually the code in which this bug occurs is in fact unreachable, but this is no doubt also a bug... I'll address that one in a separate change.) compiler/lookup_switch.m: Simplify the code a bit by using globals__lookup_*_option rather than globals__get_option and then getopt__lookup_option. compiler/*.m: Add `import_module' declarations for `code_model', and in some cases remove `import_module' declarations for `llds'.	2000-11-23 04:32:51 +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	4fd150c78f	Change the MLDS calling convention so that for model_det Mercury functions ... Estimated hours taken: 6 Change the MLDS calling convention so that for model_det Mercury functions with output mode results, the function results get mapped to MLDS function return values rather than to by-ref parameters. The rationale for this is to make interoperability simpler (especially for the IL & Java back-ends). compiler/lambda.m: Change the rules for compatibility of closures so that for MLDS grades function closures are not treated as compatible with predicate closures. compiler/ml_code_util.m: Change ml_gen_params so that it takes a pred_or_func parameter, and for model_det functions it maps the output-moded function results to MLDS return values. compiler/ml_code_gen.m: For model_det functions with output mode results, return the function result by value. Rename the `output_vars' field of the ml_gen_info as `byref_output_vars'. compiler/ml_call_gen.m: Pass down the pred_or_func parameter to ml_gen_params. For calls to model_det functions with output mode results, return the function result by value. compiler/hlds_goal.m: Add new predicate generic_call_pred_or_func, for use by ml_call_gen.m. compiler/ml_unify_gen.m: Modify the code for generating wrapper functions for closures so that it reflects the new calling convention for Mercury functions. compiler/mlds.m: compiler/mlds_to_c.m: compiler/ml_code_gen.m: Don't handle model_det functions with output mode results specially in `pragma export' anymore, since the internal MLDS form now has the same prototype as the exported one.	2000-10-30 07:09:04 +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
Zoltan Somogyi	10a433374b	Restore the clipping of instmap deltas to the nonlocals set, undoing most of ... Estimated hours taken: 16 Restore the clipping of instmap deltas to the nonlocals set, undoing most of a recent change of mine. (The general cleanup parts of that change, e.g. added field names, stay.) The reason is that the previous diff changed the clipping algorithm only where the instmap deltas were being originally computed, whereas for completeness you also need to do this in places where they are recomputed after optimizations such as deforestation, and doing so would have required changes in several more parts of the compiler, which would have been tedious to maintain. Instead, I now use a different technique to solve the original problem. This technique is to change liveness.m so that it considers the first occurrence of any type(class)info variable to be a value giving occurrence even if the variable is not referred to by the instmap delta of the goal. This assumption is true in the current polymorphism design and in any extension of it that I can foresee. Type(class)info variables will therefore be born in the first goal that refers to them, even if they are not in the nonlocal set of that goal. If there are any later references to variables whose type is described in whole or in part by that typeinfo, the typeinfo will die at the last such reference, otherwise it will die in the goal in which it is born. From now on, the only module of the compile which needs to worry about the extension of the life of type(class)info variables beyond the goals referring to them is liveness.m. compiler/quantification.m: compiler/mode_info.m: compiler/mode_util.m: Reset the interfaces of quantification and mode checking to the old ones, which do not require knowing typeinfo_liveness and typeinfo varmaps. compiler/modes.m: compiler/unique_modes.m: Clip instmap deltas to the nonlocals, not the completed nonlocals. compiler/hlds_goal.m: Add a utility pred which gets the nonlocals from a goal, not a goal_info. compiler/liveness.m: Add special handling for type(class)info vars as described above. compiler/accumulator.m: compiler/cse_detection.m: compiler/deforest.m: compiler/follow_code.m: compiler/higher_order.m: compiler/lambda.m: compiler/magic.m: compiler/make_hlds.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/saved_vars.m: compiler/simplify.m: compiler/unify_proc.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Use the reset interfaces of quantification and mode checking, and eliminate redundant local copies of goal_get_nonlocals.	2000-09-16 00:08:31 +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
Zoltan Somogyi	891b89e650	Make sure that all parts of the compiler use a consistent idea of which ... Estimated hours taken: 4 Make sure that all parts of the compiler use a consistent idea of which predicates should have typeinfo liveness applied to their bodies when the relevant option is set. This set is all predicates except the few in the builtin modules which do not have the required arguments. compiler/hlds_pred.m: Expand the interface of the should_use_typeinfo_liveness family of predicates to include an id of the predicate in question, to enable them to test whether the pred is a no_type_info_builtin. compiler/hlds_pred.m: compiler/polymorphism.m: Move the list of no_type_info_builtins from polymorphism to hlds_pred, since body_should_use_typeinfo_liveness also needs it now. compiler/*.m: Minor changes to pass the right arguments to predicates of the should_use_typeinfo_liveness family, directly or indirectly.	2000-08-08 04:44:54 +00:00
Zoltan Somogyi	a0a6daa06f	If we are using typeinfo liveness, then clip the instmap delta fields in ... Estimated hours taken: 16 If we are using typeinfo liveness, then clip the instmap delta fields in goal_infos not to the nonlocals, but to the nonlocals plus the type info or typeclass info variables needed to describe the types of the nonlocals (this set is now called the "typeinfo completed nonlocals"). This is necessary for the proper handling of code such as resume_typeinfos.m in tests/debugger. This involves a call to a procedure with an existentially typed argument, where the returned argument is processed only in ways that do not need the typeinfo describing it. The compiler therefore considered the typeinfo to be local to the call binding it. Its binding was therefore not recorded in the instmap delta, which in turn meant that in the absence of a value-giving occurrence, liveness.m considered it not to be born anywhere. On the other hand, with typeinfo liveness, occurrences of the argument are also considered value-using occurrences of the typeinfo, so the typeinfo was considered to die at the last such occurrence. Therefore the typeinfo died without being born. The current code generator is sloppy enough not to mind this, but the upcoming eager code generator isn't. compiler/hlds_goal.m: Document the new semantics of instmap_deltas. compiler/quantification.m: compiler/mode_util.m: compiler/modes.m: compiler/unique_modes.m: If typeinfo liveness is set, include the relevant typeinfo variables in the set of variables the instmap is limited to. compiler/modes.m: Delete some unused predicates. compiler/hlds_pred.m: Centralize the code for (maybe) completing a set of vars with the set of typeinfo vars describing their types here. compiler/call_gen.m: compiler/live_vars.m: Use the central code in hlds_pred.m. compiler/accumulator.m: compiler/cse_detection.m: compiler/follow_code.m: compiler/higher_order.m: compiler/lambda.m: compiler/liveness.m: compiler/magic.m: compiler/make_hlds.m: compiler/mode_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/simplify.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Call quantification and/or mode_util with the right arguments. In some cases, introduce field names, predmode declarations and/or shorter type names to make this change easier.	2000-08-03 08:46:44 +00:00
Fergus Henderson	082b084ac7	Implement static allocation of grounds terms for the ... Estimated hours taken: 20 Implement static allocation of grounds terms for the MLDS back-end. compiler/hlds_goal.m: Change the `maybe(cell_to_reuse)' field of `construct' unifications from a `maybe(cell_to_reuse)' into a `how_to_construct' type with three alternatives, `reuse_cell(cell_to_reuse)', `construct_dynamically', and the new alternative `construct_statically(static_cons)'. `static_cons' is a new type that provides information on how to construct a static ground term. compiler/goal_util.m: compiler/lambda.m: compiler/magic.m: compiler/magic_util.m: compiler/modecheck_unify.m: compiler/polymorphism.m: compiler/quantification.m: Trivial changes to handle the change to the `maybe(cell_to_reuse)' field of `construct' unifications. compiler/mark_static_terms.m: New module. This traverses the HLDS and marks terms which can be construction unifications which can be allocated statically with the `construct_statically' flag. compiler/mercury_compile.m: For the MLDS back-end, if the static_ground_terms option is set, invoke the mark_static_terms pass. compiler/ml_unify_gen.m: When generating code for construction unifications, pass down the `how_to_reuse' field. If this is `construct_statically', then generate a local initialized static constant, rather than using `new_object' to allocate the memory dynamically. (This required some fairly substantial reorganization. I changed ml_gen_construct so that no_tag types and compound terms, including closures, are handled separately from constants. I moved some of the code from ml_gen_construct_rep into ml_gen_construct, and the remainder, which deals with constants, was simplified and renamed ml_get_constant. The code for constructing closures was moved into a separate predicate ml_gen_closure, and was simplified by elimination of some code duplication. I also added a bunch of new procedures for generating static constants.) compiler/mlds.m: Add a new alternative `mlds__array_type' to the mlds__type type. This is needed by ml_unify_gen.m for static constants. compiler/mlds_to_c.m: Handle `mlds__array_type'. This required splitting mlds_output_type into mlds_output_type_prefix and mlds_output_type_suffix. compiler/ml_code_util.m: Reorder the code slightly, to improve readability.	2000-05-22 18:00:52 +00:00
Fergus Henderson	c48050a71a	Fix a bug: it wasn't calculating the non-locals correctly. ... Estimated hours taken: 0.75 compiler/lambda.m: Fix a bug: it wasn't calculating the non-locals correctly. This bug caused the MLDS back-end to generate incorrect code (which gcc -Wshadow warned about) for compiler/call_gen.m.	2000-05-11 06:04:01 +00:00
Fergus Henderson	245976353d	Fix some bugs in lambda.m. ... Estimated hours taken: 4 Fix some bugs in lambda.m. compiler/lambda.m: Fix a bug: in some cases (the cases when it avoided introducing a new predicate), lambda.m was not setting the `address_taken' field correctly. A fix for the MLDS back-end: the optimization of assuming that the calling convention for `model_det' is compatible with the calling convention for `model_non' is not valid if the `--high-level-code' option is set. Update an obsolete comment. compiler/hlds_pred.m: Add a new predicate `proc_info_set_address_taken', for use by lambda.m. tests/hard_coded/deep_copy_bug.m: tests/hard_coded/deep_copy_bug.exp: Add some more regression tests to test the above-mentioned bugs.	2000-02-08 15:08:12 +00:00
Simon Taylor	5940825cdb	Implement syntax for getting and setting fields of constructors. ... Estimated hours taken: 70 Implement syntax for getting and setting fields of constructors. compiler/make_hlds.m: Add information about field definitions to the module_info. Check that user-defined field access functions for exported fields are also exported, otherwise predicates in other modules could use a different method to access a field than predicates in module defining the field. Add a `predicate preds_add_implicit_report_error' to allow that check to be performed for functions which are added to the module_info by some means other than a `:- func' declaration. Parse field access goals and expressions. Add predicates `insert_arg_unifications_with_supplied_contexts', and `append_arg_unification', which allow more control over the contexts given to the added unifications. These are useful because the field value for an update is really an argument of the inner-most update function call, while the input term is an argument of the outer-most function call. compiler/prog_io_dcg.m: Allow DCG goals of the form `:=(DCGArg)', which unifies `DCGArg' with the output DCG argument, ignoring the input DCG argument. The rationale for this change is that if we have convenient syntax for updating parts of a DCG argument, we should also have convenient syntax for updating the whole DCG argument. compiler/typecheck.m: Add a default clause for field access functions for which the user has supplied type and mode declarations but no clauses. Typecheck field access function calls. Use `io__write_list' to remove some duplication of code to write out comma separated lists of error descriptions. compiler/post_typecheck.m: Expand field accessor goals into the equivalent unifications. They are expanded inline rather than generating new get and set predicates for field name to avoid having to work out how to mode the generated predicates. Remove an unnecessary goal traversal to qualify function calls and constructors. That code is now called from purity.m. compiler/prog_data.m: compiler/prog_io.m: compiler/mercury_to_goedel.m: compiler/mercury_to_mercury.m: Store field names as `sym_name's rather than strings. Use a `maybe' type rather than an empty string to designate an unlabelled field. compiler/hlds_data.m: Define data structures to hold information about the field names visible in a module. compiler/hlds_module.m: Add a field to type module_info to hold information about the fields visible in a module. compiler/hlds_pred.m: Add predicates to identify field access function names, and to handle the arguments of field access functions. compiler/make_hlds.m: compiler/hlds_goal.m: compiler/modecheck_call.m: compiler/higher_order.m: compiler/purity.m: compiler/polymorphism.m: compiler/dnf.m: compiler/cse_detection.m: compiler/lambda.m: Move `create_atomic_unification' from make_hlds.m to hlds_goal.m because it is used by several other modules. compiler/hlds_goal.m: Add a version of goal_info_init which takes the context of the goal, for use by make_hlds.m. compiler/type_util.m: Add a predicate `type_util__get_type_and_cons_defn' to get the hlds_type_defn and hlds_cons_defn for a user-defined constructor. compiler/prog_util.m: Add predicates to add and remove prefixes or suffixes from the unqualified part of a sym_name. compiler/prog_out.m: Add a predicate to convert a `sym_name/arity' to a string. compiler/hlds_out.m: Add `hlds_out__simple_call_id_to_string' to convert a `pred_or_func - sym_name/arity' to a string for use in error messages. compiler/purity.m: Thread through the pred_info so that the expansion of field accessor goals can add new variables. compiler/mercury_to_mercury.m: library/ops.m: Reduce precedence of `^/2' for use as a field name separator. Add operator `^'/1 to designate which side of the `:=' is the field name in a DCG field access goal. Add operator `:=/2' for field update expressions. doc/reference_manual.texi: Document the new syntax. doc/transition_guide.texi: Document the new operators. tests/hard_coded/Mmakefile: tests/hard_coded/record_syntax.m: tests/hard_coded/record_syntax.exp: tests/invalid/Mmakefile: tests/invalid/record_syntax_errors.m: tests/invalid/record_syntax_errors.err_exp: Test cases.	2000-01-13 06:19:43 +00:00
Fergus Henderson	d551dd1dc9	Handle quantification analysis of bi-implication (`<=>') goals correctly. ... Estimated hours taken: 10 Handle quantification analysis of bi-implication (`<=>') goals correctly. Previously we used to expand bi-implications before doing quantification analysis, which stuffed up the results of quantification analysis for those goals. We need to do quantification analysis first, and only then can we expand bi-implications. In addition, elimination of double negation needs to come after expansion of bi-implication, so I moved that from make_hlds.m to purity.m. compiler/hlds_goal.m: Add a new alternative to the HLDS goal type for bi-implications. Also add a new predicate negate_goal, for use by purity.m. compiler/make_hlds.m: Don't expand bi-implication here, instead just use the new bi_implication/2 HLDS goal type. Don't eliminated double negation here. compiler/quantification.m: Handle quantification for bi-implications. Expand bi-implications. compiler/purity.m: Eliminate double negation. compiler/hlds_out.m: Add code to print out bi-implication goals. compiler/*.m: Trivial changes to handle the new bi_implication/2 alternative in the HLDS goal type. compiler/notes/compiler_design.html: Document the above changes. tests/hard_coded/Mmakefile: tests/hard_coded/quantifier2.m: tests/hard_coded/quantifier2.exp: A regression test for the above change.	1999-10-25 03:53:14 +00:00
Fergus Henderson	01911fbc00	Clean up the code a bit: lambda__transform_lambda does not ... Estimated hours taken: 0.5 compiler/lambda.m: Clean up the code a bit: lambda__transform_lambda does not need to be exported, since it isn't used elsewhere, and the code is in fact clearer if it is manually inlined into its caller (lambda__process_lambda).	1999-09-15 19:25:00 +00:00
Fergus Henderson	9136d4fc6d	Fix a bug: when adding extra type_infos need for lambda procs, ... Estimated hours taken: 4 compiler/lambda.m: Fix a bug: when adding extra type_infos need for lambda procs, we need to add extra type_infos for the lambda parameters too, not just for the the lambda goal's non-locals. This bug caused an internal compiler error when compiling extras/trailed_update/tests/var_test.m.	1999-09-15 19:23:35 +00:00
Zoltan Somogyi	3c2a19adfd	Make closures always include layout information, not just in grades in which ... Estimated hours taken: 51 Make closures always include layout information, not just in grades in which typeinfo liveness is turned on. This requires separating two notions, which were previously combined: - Body typeinfo liveness means that when a variable X is live, any typeinfo variables describing type variables that occur in the type of X must also be live. - Interface typeinfo liveness means that when the input arguments of a procedure include a polymorphically typed variable (e.g. X), typeinfo variables describing type variables that occur in the type of X must also be among the arguments. This change turns on interface typeinfo liveness for procedures that either have their address taken in the current module, or are exported and thus may have their address taken in some other module. compiler/hlds_pred.m: Centralize decisions wrt whether procedure interfaces and bodies use typeinfo liveness here. compiler/options.m: Rename the typeinfo_liveness option as body_typeinfo_liveness, since this reflects its new function. compiler/call_gen.m: compiler/higher_order.m: compiler/live_vars.m: compiler/liveness.m: compiler/unused_args.m: Use hlds_pred.m to make decisions about liveness. compiler/lambda.m: Always include the relevant typeinfos in the interfaces of procedures created for lambdas. compiler/continuation_info.m: compiler/stack_layout.m: compiler/unify_gen.m: Modify the predicates that record and use layout information about closures to always do so, since the necessary information is now always available about the interfaces of procedures which can be put into closures. Previously, they only did so if typeinfo_liveness was set. Also, generate information about the types of the variables in a closure from the pred_info's arg types field, not from the proc_info's var types field, because unlike the latter, it is valid even for imported predicates. compiler/hlds_out.m: Print the non-clause-related information in the clauses_info part of a pred_info (e.g. the type parameters) even if the predicate has no actual clauses. Simplify the code a bit by getting rid of a duplicate test. compiler/middle_rec.m: Require that the code generated for the base case not refer to any stack slots if this way of generating code is to be used. This is necessary because the base case is executed when the current procedure has no stack frame, and thus any references to stack slots would refer to and possibly overwrite the data in another procedure's frame. In the absence of requiring body typeinfo liveness for exported procedures, such references were not generated; in its presence, they were. However, we now require only interface liveness for exported procedures, so we can still use middle recursion for them. compiler/handle_options.m: Do not turn off middle_rec if (body) typeinfo liveness is turned on, now that the bug has been fixed. For polymorphic predicates, the base case will still contain references to stack slots, and thus the middle-rec optimization will not applied for them, but the optimization may apply to monomorphic predicates. compiler/passes_aux.m: Add the ability to call compiler passes with the procedure id as well as the predicate id of the procedure they are passed. tests/hard_coded/typeclasses/Mmakefile: Refer to --body-typeinfo-liveness instead of --typeinfo-liveness.	1999-08-13 01:43:50 +00:00
Simon Taylor	e95a4f59a6	Don't require an `aditi_bottom_up' annotation for ... Estimated hours taken: 0.25 compiler/lambda.m: Don't require an `aditi_bottom_up' annotation for aggregate input closures -- the interface in extras/aditi/aditi.m has not yet been changed.	1999-07-30 05:17:34 +00:00
Peter Ross	88c3e52881	Record in which predicate an assertion is used. ... Estimated hours taken: 8 Record in which predicate an assertion is used. compiler/accumulator.m: compiler/lambda.m: compiler/magic.m: Initialise the assertions field in the new pred_info. compiler/assertion.m: An abstract interface to the assertion table (hopefully). compiler/hlds_data.m: Modify assertion_table_add_assertion to return the assert_id of the inserted assertion. compiler/hlds_pred.m: Record in the pred_info the set of assertions that mention the pred. compiler/post_typecheck.m: Now record which predicates are used in assertions. compiler/notes/compiler_design.html: Document assertion.m	1999-07-14 04:17: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	6af76f74ea	Move some declarations around and make some other minor changes in order ... Estimated hours taken: 4 Move some declarations around and make some other minor changes in order to reduce the number and complexity of the intermodule dependencies. In particular, ensure that prog_data.m does not need to import hlds*.m, purity.m, rl.m, or term_util.m. Since we expect to have only one input language, but potentially many different target languages, the general design principle that we have adopted in order to minimize the number of dependencies, particularly cyclic ones, is that modules which belong to an earlier stage of compilation should not depend on modules which belong to a later stage of compilation. However, that design principle has not been adhered to in many cases. This change reduces the number of such cases. compiler/prog_data.m: compiler/hlds_pred.m: Move definition of the types `eval_method' and `pred_or_func' from hlds_pred.m to prog_data.m. Add new type `mode_num' to prog_data.m, defined by `type mode_num == int', and change the proc_id argument of the `unused_args' pragma to instead use this type instead of proc_id. Delete the import of module hlds_pred from prog_data.m. compiler/prog_data.m: compiler/hlds_data.m: Move the definition of the type `determinism' from hlds_data.m to prog_data.m. Delete the import of module hlds_data from prog_data.m. compiler/prog_data.m: compiler/purity.m: Move the definition of the type `purity' from purity.m to prog_data.m. Add import of module prog_data to purity.m. Delete the import of module purity from prog_data.m. This is needed because purity.m imports hlds*.m and so by importing purity.m, prog_data.m was indirectly importing hlds*.m. (An possible alternative here would be to split purity.m into two parts, called say purity.m and check_purity.m; of these, only the second would import hlds*.m. But that would be a significantly more complicated change.) compiler/prog_data.m: compiler/rl.m: Move the definition of the `index_spec' and `index_type' types from rl.m to prog_data.m. Delete the import of module rl from prog_data.m. compiler/prog_data.m: Add new types `pragma_arg_size_info' and `pragma_termination_info' to prog_data.m. These are similar to the existing types `arg_size_info' and `termination_info' defined in term_util.m, except that they correspond more directly to what is actually used in `pragma termination_info' declarations. compiler/term_util.m: Add new predicates `add_context_to_arg_size_info' and `add_context_to_pragma_termination_info' for converting the prog_data types to their corresponding term_util types. compiler/make_hlds.m: compiler/mercury_to_mercury.m: compiler/prog_io_pragma.m: compiler/unused_args.m: Minor modifications to handle the change in the type of the mode number argument in `unused_args' pragmas, and in the types of the arg_size_info and termination_info arguments in `termination_info' pragmas. compiler/mercury_to_mercury.m: compiler/prog_io_pragma.m: compiler/inst.m: compiler/make_hlds.m: compiler/call_gen.m: compiler/common.m: compiler/continuation_info.m: compiler/det_report.m: compiler/hlds_pred.m: compiler/lambda.m: compiler/magic_util.m: compiler/modecheck_call.m: compiler/prog_io_goal.m: compiler/prog_io_util.m: compiler/prog_util.m: compiler/termination.m: Delete imports of modules purity, rl, and hlds_pred, or move them from the interface section to the implementation section. compiler/inst.m: compiler/prog_io_util.m: Add an XXX comment explaining why we need to import hlds_data.m.	1999-07-08 05:08:58 +00:00
Fergus Henderson	ec86c88404	Merge in the changes from the existential_types_2 branch. ... Estimated hours taken: 4 Merge in the changes from the existential_types_2 branch. This change adds support for mode re-ordering of code involving existential types. The change required modifying the order of the compiler passes so that polymorphism comes before mode analysis, so that mode analysis can check the modes of the `type_info' or `typeclass_info' variables that polymorphism introduces, so that it can thus re-order the code accordingly. This change also includes some more steps towards making existential data types work. In particular, you should be able to declare existentially typed data types, the compiler will generate appropriate unification and compare/3 routines for them, and deconstruction unifications for them should work OK. However, currently there's no way to construct them except via `pragam c_code', and we don't generate correct RTTI for them, so you can't use `io__write' etc. on them. library/private_builtin.m: compiler/accumulator.m: compiler/bytecode_gen.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/code_util.m: compiler/common.m: compiler/dead_proc_elim.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/hlds_pred.m: compiler/intermod.m: compiler/lambda.m: compiler/live_vars.m: compiler/magic.m: compiler/make_hlds.m: compiler/mercury_compile.m: compiler/mercury_to_c.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/pd_cost.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/purity.m: compiler/quantification.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/simplify.m: compiler/table_gen.m: compiler/term_traversal.m: compiler/type_util.m: compiler/typecheck.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unused_args.m: compiler/notes/compiler_design.html: doc/reference_manual.texi: tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/existential_data_types.m: tests/hard_coded/typeclasses/existential_data_types.exp: tests/warnings/simple_code.exp: tests/hard_coded/Mmakefile: tests/term/arit_exp.trans_opt_exp: tests/term/associative.trans_opt_exp: tests/term/pl5_2_2.trans_opt_exp: tests/term/vangelder.trans_opt_exp: tests/term/arit_exp.trans_opt_exp: tests/term/associative.trans_opt_exp: tests/term/pl5_2_2.trans_opt_exp: tests/term/vangelder.trans_opt_exp: tests/invalid/errors2.err_exp2: tests/invalid/prog_io_erroneous.err_exp2: tests/invalid/type_inf_loop.err_exp2: tests/invalid/types.err_exp2: tests/invalid/polymorphic_unification.err_exp: tests/invalid/Mmakefile: tests/warnings/simple_code.exp: tests/debugger/queens.exp: tests/hard_coded/Mmakefile: tests/hard_coded/existential_reordering.m: tests/hard_coded/existential_reordering.exp: Merge in the changes from the existential_types_2 branch.	1999-06-30 17:13:53 +00:00
Zoltan Somogyi	c6812299c2	Remove support for --args simple. We don't use it, we won't use it even for ... Estimated hours taken: 4.5 Remove support for --args simple. We don't use it, we won't use it even for experiments, and it is unnecessary complication. If anybody were using --args simple, this would need bootstrapping, but since nobody does, there is no need, and this can be committed as an ordinary change. compiler/options.m: doc/user_guide.texi: scripts/*.in: scripts/*.sh-subr: Remove the --args option. compiler/globals.m: Remove the args_method global and its access predicates. compiler/handle_options.m: Don't set the args_method global from the option. compiler/arg_info.m: Remove support for --args simple. This allows us to remove a now redundant argument from an exported predicate. compiler/mercury_compile.m: Remove the code for passing -DCOMPACT_ARGS to the C compiler. compiler/bytecode_gen.m: compiler/fact_table.m: compiler/follow_vars.m: compiler/live_vars.m: compiler/call_gen.m: Don't pass the unnecessary argument to arg_info. compiler/call_gen.m: compiler/unify_gen.m: Remove now unnecessary assertions. compiler/hlds_pred.m: Don't include an args_method in proc_infos; instead, include a slot that says whether the procedure's address is taken or not. (In most cases, this determined whether the args_method was simple or compact.) We will need this bool in the near future (when we generate layout structures for procedures whose address is taken). Modify the signatures of exported predicates to accommodate this change to the data structure. compiler/hlds_out.m: Print the new slot, not the args_method. compiler/lambda.m: When creating procedures from lambdas, set the address-taken slot to address_is_taken instead of setting up its args_method. compiler/make_hlds.m: Minor changes to conform to the changes in the signatures of the predicates exported from hlds_pred.m. compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/dnf.m: compiler/magic.m: compiler/magic_util.m: compiler/modecheck_call.m: compiler/pd_info.m: compiler/post_typecheck.m: compiler/unify_gen.m: Minor changes to conform to the changes in the signatures of the predicates exported from hlds_pred.m and make_hlds.m. runtime/mercury_type_info.h: Remove the conditional definition of the macros that provided an argument-method-independent way of referring to the registers holding the inputs and outputs of e.g. unification procedures. We don't need the independence anymore, and using registers instead of macros in the code ensures that maintainers are aware of register reuse issues (e.g. they copy an input from r1 before overwriting it with an output). runtime/mercury_conf_param.h: runtime/mercury_grade.h: Remove support for the args method component of the grade. runtime/mercury_ho_call.c: runtime/mercury_tabling.c: library/*.m: Conform to the changes in runtime/mercury_type_info.h by effectively applying the #defines appropriate to compact args by hand. Remove code and data structures only needed for simple args. Remove comments needed only in the presence of uncertainty about the args method.	1999-06-01 09:46:20 +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
Simon Taylor	3e244090d7	Rework the handling of types in higher_order.m. ... Estimated hours taken: 50 Rework the handling of types in higher_order.m. - Fix bugs in higher_order.m that stopped it working with --typeinfo-liveness. - Perform type and typeclass specialisation. compiler/polymorphism.m: Previously the type of typeclass_infos variables did not contain any information about the constraint about which the variable contains information. Now the type of a typeclass_info is `private_builtin:typeclass_info( private_builtin:constraint([ClassName, ConstrainedTypes]))'. This allows predicates such as type_list_subsumes to check that the class constraints match. Note that `private_builtin:constraint' has no declaration, so a lookup in the type definition map will fail. That's OK, because type_to_type_id will fail on it, so it will be treated as a type variable by any code which doesn't manipulate types directly. Added polymorphism__typeclass_info_class_constraint to get the class_constraint from a typeclass_info's type. This isn't used yet. Also, fix a bug in extract_type_info: an entry in the typeinfo_var_map was being overwritten using an entry from a dummy typevarset. Actually the optimization to overwrite the location of the type_info after extracting it from a typeclass_info was wrong because the type_info won't be in that location in other branches. compiler/higher_order.m: Rework the handling of type substitutions. Now the types of the called procedure are `inlined' into the calling procedure, rather than building up the types of the specialised version using the higher-order arguments. The advantage of this is that the code is a bit simpler and handles extra type_infos properly. The disadvantage is that the argument types for specialised versions may be more specific than they need to be, so in some cases more specialised versions will be created than before. Also, don't actually rebuild the higher-order terms in the specialised versions - just pass the terms through in case they are needed. Handle the extra typeinfos required for --typeinfo-liveness. Specialize calls to unify/2, index/2 and compare/3. Specialize class_method_calls. Specialize calls to the predicates in private_builtin.m which manipulate typeclass_infos. compiler/type_util.m: type_to_type_id now fails on the dummy `constraint' type. Remove typeinfos for non-variable types from the typeinfo_varmap after inlining and higher-order specialisation. compiler/inlining.m: Factor out some common code to handle type substitutions for use by higher_order.m. compiler/hlds_pred.m: Return the list of extra type_info variables added to the argument list. compiler/goal_util.m: Take a set of non-locals as an argument to goal_util__extra_nonlocal_typeinfos rather than extracting them from a goal. compiler/special_pred.m: Handle unmangled unify/compare/index in special_pred_get_type. compiler/base_type_layout.m: Don't generate references to the typeinfo for `private_builtin:constraint' - it doesn't exist. compiler/unused_args.m: Don't barf on specialised unification predicate names. compiler/options.m: Added options: `--type-specialization' (default off). `--higher-order-size-limit' - restrict the size of specialized versions produced by higher_order.m. `--disable-opt-for-trace' (default on) - where possible don't change the options to make the trace match the source code. compiler/handle_options.m: Don't disable higher_order.m when --typeinfo-liveness is set. Handle `--disable-opt-for-trace'. compiler/hlds_data.m: compiler/*.m: Add the instance number to `base_typeclass_info_const' cons_ids, so that higher_order.m can easily index into the list of instances for a class to find the methods. compiler/hlds_out.m: Use the correct varset when printing out the constraint proofs. Write the typeclass_info_varmap for each procedure. compiler/mercury_to_mercury.m: Print type variables with variable numbers. library/private_builtin.m: Add the argument to the typeclass_info type to hold the representation of the constraint. runtime/mercury_ho_call.c: Semidet and nondet class_method_calls where (0 < num_arg_typeclass_infos < 4) were aborting at runtime because arguments were being placed starting at r1 rather than at r(1 + num_arg_typeclass_infos). doc/user_guide.texi Document the new options. compiler/notes/compiler_design.html: Update the role of higher_order.m. tests/hard_coded/typeclasses/extra_typeinfo.m: Test case for the mercury_ho_call.c bug and the polymorphism.m extract_typeinfo bug and for updating the typeclass_info_varmap for specialised versions.	1998-09-10 06:56:14 +00:00
Simon Taylor	ddfcaa0818	Fix a bug in the computation of the modes of introduced ... Estimated hours taken: 0.5 compiler/lambda.m: Fix a bug in the computation of the modes of introduced predicates. tests/valid/lambda_output.m: Test case.	1998-09-10 06:30:21 +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
Thomas Conway	a70b59e83c	Add a test to find the number of words needed to represent a ... configure.in: Add a test to find the number of words needed to represent a synchronization term. boehm_gc/gc.h: fix a declaration by replacing the args () with (void). boehm_gc/solaris_pthreads.c: add a missing include check the return values of pthread calls. compiler/*.m: Add handling for the new HLDS goal type par_conj. Add handling for the four new LLDS instructions: init_sync_term fork join_and_terminate join_and_continue compiler/code_info.m: add a new alternative for slot_contents - sync_term. compiler/handle_options.m: add .par as part of the grade compiler/hlds_goal.m: add the new goal type par_conj. compiler/instmap.m: add instmap__unify which takes a list of instmaps and abstractly unifies them. add unify_instmap_delta which tajes two instmap deltas and abstractly unifies them. compiler/llds.m: add the new llds instructions. compiler/mode_info.m: add par_conj as a lock reason. library/Makefile: work around a bug in the solaris version pthread.h library/benchmarking.m: reference the stack zones from the engine structure rather than from global variables. library/{nc,sp}_builtin.nl: add an op declaration for &. library/std_util.m: change references to global variables to references inside the engine structure. runtime/Mmakefile: add mercury_thread.{c,h} add THREADLIBS to the libraries runtime/*.{c,h} Remove some old junk from the previous processes/shrd-mem changes that found their way into the repository. Add MR_ prefixes to lots of names. runtime/mercury_context.c: Add init_thread_stuff for creating and initializing a context structure for the current thread. runtime/mercury_context.h: add a field to the mercury context which stores the thread id of the thread where this context originated. add various macros for implementing the new llds instructions. runtime/mercury_engine.c: initialize the engine structure, rather than a bunch of globals. runtime/mercury_engine.h: declare the mercury_engine structure. runtime/mercury_regorder.h: if MR_THREAD_SAFE, and there is at least one global register then use mr0 as a pointer to the mercury engine structure. scripts/init_grade_options.sh-subr add thread_safe scripts/mgnuc.in add THREAD_OPTS scripts/ml.in: add THREAD_LIBS	1998-06-09 02:16:31 +00:00
Simon Taylor	75354e38bb	Deforestation. ... Estimated hours taken: 400 Deforestation. This increases the code size of the compiler by ~80k when compiling with --intermodule-optimization --deforestation. The improvement from deforestation is not measurable for mmc -C make_hlds.m. Compile time for make_hlds.m increased from 50.7 seconds to 52.2 seconds when running deforestation. compiler/simplify.m compiler/common.m Provide a nicer interface for simplifying a goal, not an entire procedure. Rework the interface to avoid manipulating lots of booleans. Return an estimate of the improvement in cost from simplification. Remove failing cases and disjuncts. Add an option to optimize common structures even across calls. Remove code to merge branched goals, since that is now done by deforestation. Fix a bug: the code to collect instmap_deltas for cases was not including the switched-on variable in the instmap_delta, which caused an abort in merge_instmap_delta if the switched on variable was further instantiated in the switch. This came up while compiling the compiler with --deforestation. compiler/det_report. Output duplicate call warnings even if --warn-simple-code is not set. XXX fix the same problem with `:- pragma obsolete'. compiler/code_aux.m Update code_aux__cannot_loop to use termination information. compiler/hlds_pred.m compiler/dnf.m Pass the type_info_varmap and typeclass_info_varmap into hlds_pred__define_new_pred. Restrict the variables of the new procedure onto the variables of the goal. Make sure all relevant type_infos are passed into the new procedure if --typeinfo-liveness is set. compiler/modes.m compiler/unique_modes.m compiler/mode_info.m compiler/modecheck_unify.m Put `how_to_check_goal' into the mode_info, rather than passing it around. Add a field to the `check_unique_modes' case which controls whether unique modes is allowed to choose a different procedure. For deforestation, this is not allowed, since it could result in choosing a less efficient procedure after generalisation. compiler/options.m New options: --deforestation --deforestation-depth-limit Safety net for termination of the algorithm. --deforestation-cost-factor Fudge factor for working out whether deforestation was worthwhile. --deforestation-vars-threshold Like --inline-vars-threshold. Enable deforestation at -O3. Removed an unnecessary mode for option_defaults_2, since it resulted in a warning about disjuncts which cannot succeed. compiler/handle_options.m --no-reorder-conj implies --no-deforestation. compiler/inlining.m Separate code to rename goals into inlining__do_inline_call. compiler/hlds_goal.m Added predicates goal_list_nonlocals, goal_list_instmap_delta and goal_list_determinism to approximate information about conjunctions. compiler/hlds_module.m Added module_info_set_pred_proc_info to put an updated pred_info and proc_info back into the module_info. compiler/hlds_out.m Exported hlds_out__write_instmap for debugging of deforestation. Bracket module names on constructors where necessary. compiler/mercury_compile.m Call deforestation. Use the new interface to simplify.m. compiler/intermod.m Put recursive predicates with a top-level branched goal into `.opt' files. goal_util.m Added goal_calls_pred_id to work out if a predicate is recursive before mode analysis. Export goal_util__goals_goal_vars for use by deforestation. Give a better message for a missing variable in a substitution. compiler/instmap.m Give a better message for inst_merge failing. compiler/notes/compiler_design.m Document the new modules. library/varset.m Add varset__select to project a varset's names and values onto a set of variables. doc/user_guide.texi Document deforestation. Remove a reference to a non-existent option, --no-specialize. util/mdemangle.c profiler/demangle.m tests/misc_tests/mdemangle_test.{exp,inp} Handle the `DeforestationIn__' predicate names introduced by deforestation, similar to the `IntroducedFrom__' for lambda goals. New files: deforest.m Deforestation. pd_cost.m Cost estimation. pd_debug.m Debugging output. pd_info.m State type and version control. pd_term.m Termination checking. pd_util.m Utility predicates	1998-04-27 04:05:12 +00:00
Zoltan Somogyi	67d8308260	Same as previous message.	1998-04-08 11:36:13 +00:00
Fergus Henderson	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
Simon Taylor	d0085d8119	Assorted changes to make the HLDS type and mode correct ... Estimated hours taken: 45 Assorted changes to make the HLDS type and mode correct after lambda expansion. The HLDS is still not unique mode correct after common structure elimination. compiler/det_analysis.m Make sure the inferred_determinism field of the proc_info is filled in correctly for imported procedures and class methods. compiler/mode_util.m Fix a bug in recompute_instmap_delta_call to do with unreachable instmaps. This caused an abort a couple of months ago when compiling with --deforestation (not yet committed), but can't currently be reproduced. compiler/hlds_pred.m compiler/lambda.m Add a field to the proc_info to record which args_method should be used for this procedure. Procedures directly called by do_call_*_closure must be compiled with the `compact' argument convention to avoid the need to permute the arguments so inputs come before outputs. compiler/lambda.m compiler/higher_order.m Remove permutation of argument variables of lambda expressions so the HLDS is type and mode correct and mode analysis can be rerun. Otherwise, rerunning mode analysis will fail on tests/hard_coded/ho_order.m. compiler/arg_info.m Added arg_info__ho_call_args_method which returns an args_method which can always be directly called by do_call_*_closure (`compact'). Added arg_info__args_method_is_ho_callable to check that a given args_method can be directly called. compiler/unify_gen.m Abort if a closure is created for a procedure compiled with the simple argument convention. compiler/hlds_goal.m compiler/lambda.m Mode analysis was not storing the non-locals list on which the uni_modes field of the construction of a lambda goal was computed. If the nonlocals were renamed, the sort order could change, and the non-locals could be incorrectly matched with the arguments of the introduced lambda expression, causing a mode error. The argument list is now stored. This caused rerunning mode-checking on tests/valid/lazy_list.m after polymorphism to fail. compiler/*.m Fill in the args_method field of proc_infos with the value from the globals. Handle the extra argument to the lambda_goal unify_rhs. compiler/follow_vars.m Remove code to handle complicated unifications, since they should be removed by polymorphism.m. compiler/special_pred.m library/mercury_builtin.m Make the uniqueness of the comparison_result argument of builtin_compare_* and the automatically generated comparison procedures match that of compare/3. Unique mode errors will still be introduced if polymorphism.m specializes calls to any of the unique modes of compare/3 and then mode analysis is rerun, since the compiler-generated comparison procedures only implement the (uo, in, in) mode. (This is not yet a problem because currently we don't rerun mode analysis.) runtime/mercury_ho_call.c Remove code in do_call_*_closure to deal with the `simple' args_method. Since the output arguments no longer need to be moved, the closure call is now a tailcall. Remove some magic numbers. compiler/modecheck_unify.m Avoid some aborts and mode errors when rerunning mode analysis, especially those resulting from not_reached insts being treated as bound. Avoid aborting on higher-order predicate constants with multiple modes if lambda expansion has already been run. tests/valid/higher_order.m Add a test case for an abort in mode analysis when compiling with --deforestation (not yet committed), due to a predicate constant for a procedure with multiple modes. tests/valid/unreachable_code.m Add a test case for bogus higher-order unification mode errors in unreachable code.	1998-02-12 01:17:56 +00:00
Fergus Henderson	31a9c3a10a	Fix a bug that caused bootcheck to fail at `-O4 --intermodule-optimization'. ... Estimated hours taken: 8 Fix a bug that caused bootcheck to fail at `-O4 --intermodule-optimization'. compiler/higher_order.m: When doing type substitutions to specialize the types during specialization of higher-order calls, make sure that we permute the argument types of the caller based on the modes, with all input arguments preceding all output arguments, because lambda.m has already done this for the argument types of the callee. compiler/lambda.m: Change the type of lambda__permute_argvars to be polymorphic, so that it can be used to permute types as well as permuting variables.	1998-01-29 13:28:24 +00:00
Zoltan Somogyi	5013dd9c76	Implement nondet pragma C codes. ... Estimated hours taken: 40 Implement nondet pragma C codes. runtime/mercury_stacks.h: Define a new macro, mkpragmaframe, for use in the implementation of nondet pragma C codes. This new macro includes space for a struct with a given sruct tag in the nondet stack frame being created. compiler/{prog_data.m,hlds_goal.m}: Revise the representation of pragma C codes, both as the item and in the HLDS. compiler/prog_io_pragma.m: Parse nondet pragma C declarations. Fix the indentation in some places. compiler/llds.m: Include an extra argument in mkframe instructions. This extra argument gives the details of the C structure (if any) to be included in the nondet stack frame to be created. Generalize the LLDS representation of pragma C codes. Instead of a fixed sequence of <assign from inputs, user c code, assign to outputs>, let the sequence contain these elements, as well as arbitrary compiler-generated C code, in any order and possibly with repetitions. This flexibility is needed for nondet pragma C codes. Add a field to pragma C codes to say whether they can call Mercury. Some optimizations can do a better job if they know that a pragma C code cannot call Mercury. Add another field to pragma C codes to give the name of the label they refer to (if any). This is needed to prevent labelopt from incorrectly optimizing away the label definition. Add a new alternative to the type pragma_c_decl, to describe the declaration of the local variable that points to the save struct. compiler/llds_out.m: Output mkframe instructions that specify a struct as invoking the new mkpragmaframe macro, and make sure that the struct is declared just before the procedure that uses it. Other minor changes to keep up with the changes to the representation of pragma C code in the LLDS, and to make the output look a bit nicer. compiler/pragma_c_gen.m: Add code to generate code for nondet pragma C codes. Revise the utility predicates and their data structures a bit to make this possible. compiler/code_gen.m: Add code for the necessary special handling of prologs and epilogs of procedures defined by nondet pragma C codes. The prologs need to be modified to include a programmer-defined C structure in the nondet stack frame and to communicate the location of this structure to the pragma C code, whereas the functionality of the epilog is taken care of by the pragma C code itself. compiler/make_hlds.m: When creating a proc_info for a procedure defined by a pragma C code, we used to insert unifications between the headvars and the vars of the pragma C code into the body goal. We now perform substitutions instead. This removes a factor that would complicate the generation of code for nondet pragma C codes. Pass a moduleinfo down the procedures that warn about singletons (and other basic scope errors). When checking whether to warn about an argument of a pragma C code not being mentioned in the C code fragment, we need to know whether the argument is input or output, since input variables should appear in some code fragments in a nondet pragma C code and must not appear in others. The mode_is_{in,out}put checks need the moduleinfo. (We do not need to check for any variables being mentioned where they shouldn't be. The C compiler will fail in the presence of any errors of that type, and since those variables could be referred to via macros whose definitions we do not see, we couldn't implement a reliable test anyway.) compiler/opt_util.m: Recognize that some sorts of pragma_c codes cannot affect the data structures that control backtracking. This allows peepholing to do a better job on code sequences produced for nondet pragma C codes. Recognize that the C code strings inside some pragma_c codes refer to other labels in the procedure. This prevents labelopt from incorrectly optimizing away these labels. compiler/dupelim.m: If a label is referred to from within a C code string, then do not attempt to optimize it away. compiler/det_analysis.m: Remove a now incorrect part of an error message. compiler/*.m: Minor changes to conform to changes to the HLDS and LLDS data structures.	1998-01-13 10:14:23 +00:00
Zoltan Somogyi	bb4442ddc1	Update copyright dates for 1998. ... Estimated hours taken: 0.5 compiler/*.m: Update copyright dates for 1998.	1998-01-13 10:06:08 +00:00
Zoltan Somogyi	b4813457c9	A rewrite of termination analysis to make it significantly easier to modify, ... Estimated hours taken: 60 A rewrite of termination analysis to make it significantly easier to modify, and to extend its capabilities. compiler/error_util.m: A new file containing code that makes it easier to generate nicely formatted error messages. compiler/termination.m: Updates to reflect the changes to the representation of termination information. Instead of doing pass 1 on all SCCs and then pass 2 on all SCCs, we now do both pass 1 and 2 on an SCC before moving on to the next. Do not insist that either all procedures in an SCC are compiler-generated or all are user-written, since this need not be true in the presence of user-defined equality predicates. Clarify the structure of the code that handles builtins and compiler generated predicates. Concentrate all the code for updating module_infos in this module. Previously it was scattered in several places in several files. Put all the code for writing out termination information at the end of the module in a logical order. compiler/term_traversal.m: A new file containing code used by both pass 1 and pass 2 to traverse procedure bodies. compiler/term_pass1.m: Use the new traversal module. Clarify the fixpoint computation on the set of output supplier arguments. Remove duplicates from the list of equations given to the solver. This avoids a det stack overflow in lp.m when doing termination analysis on options.m. If an output argument of a predicate makes sense only in the absence of errors, then return it only in the absence of errors. compiler/term_pass2.m: Use the new traversal module. Unlike the previous code, this allows us to ignore recursive calls with input arguments bigger than the head if those calls occur after goals that cannot succeed (since those calls will never be reached). Implement a better way of doing single argument analysis, which (unlike the previous version) works in the presence of mutual recursion and other calls between the recursive call and the start of the clause. Implement a more precise way of checking for recursions that don't cause termination problems. We now allow calls from p to q in which the recursive input supplier arguments can grow, provided that on any path on which q can call p, directly or indirectly, the recursive input supplier arguments shrink by a greater amount. If an output argument of a predicate makes sense only in the absence of errors, then return it only in the absence of errors. compiler/term_util.m: Updates to reflect the changes to the representation of termination information. Reorder to put related code together. Change the interface of several predicates to better reflect the way they are used. Add some more utility predicates. compiler/term_errors.m: Small changes to the set of possible errors, and major changes in the way the messages are printed out (we now use error_util). compiler/options.m: Change --term-single-arg from being a bool to an int option, whose value indicates the maximum size of an SCC in which we try single argument analysis. (Large SCCs can cause single-arg analysis to require a lot of iterations.) Add an (int) option that controls the max number of paths that we are willing to analyze (analyzing too many paths can cause det stack overflow). Add an (int) option that controls the max number of causes of nontermination that we print out. compiler/hlds_pred.m: Use two separate slots in the proc_info to hold argument size data and termination info, instead of the single slot used until now. The two kinds of information are produced and used separately. Make the layout of the get and set procedures for proc_infos more regular, to facilitate later updates. The procedures proc_info_{,set_}variables did the same work as proc_info_{,set_}varset. To eliminate potential confusion, I removed the first set. compiler/*.m: Change proc_info_{,set_}variables to proc_info_{,set_}varset. compiler/hlds_out.m: compiler/make_hlds.m: compiler/mercury_to_mercury.m: Change the code to handle the arg size data and the termination info separately. compiler/prog_data.m: Change the internal representation of termination_info pragmas to hold the arg size data and the termination info separately. compiler/prog_io_pragma.m: Change the external representation of termination_info pragmas to group the arg size data together with the output supplier data, to which it is logically connected. compiler/module_qual.m: compiler/modules.m: Change the code to accommodate the change to the internal representation of termination_info pragmas. compiler/notes/compiler_design.html: Fix some documentation rot, and clarify some points. Document termination analysis. doc/user_guide.texi: Document --term-single-arg and the new options. Remove spaces from the ends of lines. library/bag.m: Add a new predicate, bag__least_upper_bound. Fix code that would do the wrong thing if executed by Prolog. Remove spaces from the ends of lines. library/list.m: Add a new predicate, list__take_upto. library/set{,_ordlist}.m: Add a new predicate, set{,_ordlist}__count. tests/term/*: A bunch of new test cases to test the behaviour of termination analysis. They are the small benchmark suite from our paper. tests/Mmakefile: Enable the new test case directory.	1997-12-22 10:01:33 +00:00
David Jeffery	7406335105	This change implements typeclasses. Included are the necessary changes to ... Estimated hours taken: 500 or so This change implements typeclasses. Included are the necessary changes to the compiler, runtime and library. compiler/typecheck.m: Typecheck the constraints on a pred by adding constraints for each call to a pred/func with constraints, and eliminating constraints by applying context reduction. While reducing the constraints, keep track of the proofs so that polymorphism can produce the tyepclass_infos for eliminated constraints. compiler/polymorphism.m: Perform the source-to-source transformation which turns code with typeclass constraints into code without constraints, but with extra "typeclass_info", or "dictionary" parameters. Also, rather than always having a type_info directly for each type variable, sometimes the type_info is hidden inside a typeclass_info. compiler/bytecode*.m: Insert some code to abort if bytecode generation is used when typeclasses are used. compiler/call_gen.m: Generate code for a class_method_call, which forms the body of a class method (by selecting the appropriate proc from the typeclass_info). compiler/dead_proc_elim.m: Don't eliminate class methods if they are potentially used outside the module compiler/hlds_data.m: Define data types to store: - the typeclass definitions - the instances of a class - "constraint_proof". ie. the proofs of redundancy of a constraint. This info is used by polymorphism to construct the typeclass_infos for a constraint. - the "base_tyepclass_info_constant", which is analagous the the base_type_info_constant compiler/hlds_data.m: Define the class_method_call goal. This goal is inserted into the body of class method procs, and is responsible for selecting the appropriate part of the typeclass_info to call. compiler/hlds_data.m: Add the class table and instance table to the module_info. compiler/hlds_out.m: Output info about base_typeclass_infos and class_method_calls compiler/hlds_pred.m: Change the representation of the locations of type_infos from "var" to type_info_locn, which is either a var, or part of a typeclass_info, since now the typeclass_infos contain the type_infos for the type that they constrain. Add constraints to the pred_info. Add constraint_proofs to the pred_info (so that typeclass.m can annotate the pred_info with the reasons that constraints were eliminated, so that polymorphism.m can in turn generate the typeclass_infos for the constraints). Add the "class_method" marker. compiler/lambda.m: A feable attempt at adding class ontexts to lambda expressions, untested and almost certainly not working. compiler/llds_out.m: Output the code addresses for do_*det_class_method, and output appropriately mangled symbol names for base_typeclass_infos. compiler/make_hlds.m: Add constraints to the types on pred and func decls, and add class and instance declarations to the class_table and instance_table respectively. compiler/mercury_compile.m: Add the check_typeclass pass. compiler/mercury_to_mercury.m: Output constraints of pred and funcs, and output typeclass and instance declarations. compiler/module_qual.m: Module qualify typeclass names in pred class contexts, and qualify the typeclass and instance decls themselves. compiler/modules.m: Output typeclass declarations in the short interface too. compiler/prog_data.m: Add the "typeclass" and "instance" items. Define the types to store information about the declarations, including class contexts on pred and func decls. compiler/prog_io.m: Parse constraints on pred and func declarations. compiler/prod_out.m: Output class contexts on pred and func decls. compiler/type_util.m: Add preds to apply a substitution to a class_constraint, and to a list of class constraints. Add type_list_matches_exactly/2. Also add typeclass_info and base_typeclass_info as types which should not be optimised as no_tag types (seeing that we cheat a bit about their representation). compiler/notes/compiler_design.html: Add notes on module qualification of class contexts. Needs expansion to include more stuff on typeclasses. compiler/*.m: Various minor changes. New Files: compiler/base_typeclass_info.m: Produce one base_typeclass_info for each instance declaration. compiler/prog_io_typeclass.m: Parse typeclass and instance declarations. compiler/check_typeclass.m: Check the conformance of an instance declaration to the typeclass declaration, including building up a proof of how superclass constraints are satisfied so that polymorphism.m is able to construct the typeclass_info, including the superclass typeclass_infos. library/mercury_builtin.m: Implement that base_typeclass_info and typeclass_info types, as well as the predicates type_info_from_typeclass_info/3 to extract a type_info from a typeclass_info, and superclass_from_typeclass_info/3 for extracting superclasses. library/ops.m: Add "typeclass" and "instance" as operators. library/string.m: Add a (in, uo) mode for string__length/3. runtime/mercury_ho_call.c: Implement do_call_*det_class_method, which are the pieces of code responsible for extracting the correct code address from the typeclass_info, setting up the arguments correctly, then executing the code. runtime/mercury_type_info.h: Macros for accessing the typeclass_info structure.	1997-12-19 03:10:47 +00:00
Fergus Henderson	470532637d	Clean up the handling of predicate markers (flags). ... Estimated hours taken: 3 Clean up the handling of predicate markers (flags). compiler/hlds_pred.m: Delete the `marker_status' type. It was just adding complexity which wasn't being used. Change the "markers list" field of the pred_info from a list(marker_status) to an abstract data type representing a set of markers. Add new access predicates for this ADT. Currently the ADT is still implemented as a list, but it might be a good idea to eventually change it to be an int, using a different bit for each flag. compiler/dnf.m: Don't bother to record `done(dnf)' markers, since they're not needed. compiler/make_hlds.m: Change add_pred_marker so that it adds a single marker, rather than a list of markers. Allowing a list of markers was just adding extra complexity which wasn't being used. compiler/dnf.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/lambda.m: compiler/make_hlds.m: compiler/mode_errors.m: compiler/modecheck_call.m: compiler/modes.m: compiler/simplify.m: compiler/stratify.m: compiler/term_util.m: compiler/termination.m: compiler/typecheck.m: compiler/unused_args.m: Update to use the new ADT.	1997-11-24 07:27:14 +00:00
Fergus Henderson	5976f769f7	Fix a bug for the case of a higher-order function call in code ... Estimated hours taken: 1 Fix a bug for the case of a higher-order function call in code with common sub-expression; mercury 0.7 failed this test, reporting "Software Error: modecheck fails when repeated", due to confusion between h.o. _function_ call and h.o. _predicate_ call. compiler/hlds_goal.m: Add `pred_or_func' field to HLDS higher_order_calls. compiler/modes.m: compiler/modecheck_call.m: compiler/hlds_out.m: compiler/*.m: Add code to handle new field for higher_order_call goals. tests/valid/Mmake: tests/valid/ho_func_call.m: Regression test for the above-mentioned bug.	1997-09-01 14:05:44 +00:00
Thomas Conway	2980b59474	Profiling code with lots of lambda goals was painful, because the names ... Estimated hours taken: 1.5 Profiling code with lots of lambda goals was painful, because the names of the predicates contained no information about which piece of the source they correspond to. This change corrects this problem by enabling the profiler to produce output such as: ... 0.00 0.00 <pred/func goal from lp:'pivot', line 362> [10] ... 0.00 0.00 <pred/func goal from lp:'pivot', line 356> [11] ... 0.00 0.00 <pred/func goal from lp:'simplex', line 262> [12] compiler/lambda.m: compiler/polymorphism.m: construct more meaningful predicate names for lambda predicates. this required adding the name of the predicate that contained the lambda goal to the info structures that gets threaded through these modules. profiler/demangle.m: util/mdemangle.c: demangle the names for lambda goals.	1997-08-27 03:36:04 +00:00
Fergus Henderson	04b720630b	Update the copyright messages so that (a) they contain the correct years ... and (b) they say "Copyright (C) ... _The_ University of Melbourne".	1997-07-27 15:09:59 +00:00
Simon Taylor	06c70c62eb	Bug fix. ... Estimated hours taken: 2 Bug fix. compiler/higher_order.m lambda.m reorders the argument variables of lambda expressions so that inputs come before outputs. higher_order.m was not doing the reordering before replacing a higher_order_call with a call to the lambda expression. compiler/lambda.m Export lambda__permute_argvars for use by higher_order.m. tests/hard_coded/Mmake tests/hard_coded/ho_order.m tests/hard_coded/ho_order.exp Regression test.	1997-07-17 04:25:56 +00:00
Andrew Bromage	6dd00b858d	Fix some spelling mistakes. ... Estimated hours taken: 0.4 compiler/det_report.m: compiler/lambda.m: Fix some spelling mistakes.	1997-07-01 04:03:54 +00:00
Fergus Henderson	9b6dab0055	Fix a buggy optimization: the code was assuming that the ... Estimated hours taken: 1 compiler/lambda.m: Fix a buggy optimization: the code was assuming that the argument variables to a procedure call are all distinct, but that is not necessarily the case -- although they are made distinct for type checking and mode analysis, excess assignment elimination (which is done by simplify.m) can reintroduce duplicate args. This fixes a "variable not found" bug.	1997-05-26 17:04:14 +00:00
Fergus Henderson	e3471f333f	Fix a bug in inlining of polymorphic pragma c_code procedures. ... Estimated hours taken: 3 Fix a bug in inlining of polymorphic pragma c_code procedures. The bug was that if the actual argument type has a specific type of say `float', then the C variable for the corresponding formal parameter will be declared to have type `Float', whereas without inlining the argument type would have been polymorphic and so the C variable would have been declared to have type `Word'. Hence we need to keep track of the original argument types, before any inlining or specialization has occurred, and use these original argument types to determine how to declare the C variables, rather than using the actual argument types for this particular specialization. compiler/hlds_goal.m: Add a new field to pragma_c_code goals, holding the original argument types (before any inlining or specialization) of the pragma_c_code procedure. compiler/make_hlds.m: Initialize this field with the declared argument types for the pragma c_code procedure. compiler/polymorphism.m: Update this field to account for the inserted type_info variables. compiler/code_gen.m: Pass this field to pragma_c_gen.m. compiler/pragma_c_gen.m: Use the original argument types field for the pragma variable declarations, rather than looking up the actual types of the arguments. compiler/*.m: Trivial changes to handle new field. compiler/live_vars.m: Comment out some code to avoid a warning about `fail' in the condition of an if-then-else.	1997-05-05 11:17:40 +00:00
Zoltan Somogyi	4c3b0ecb09	Replace calls to map__set with calls to either map__det_insert or ... Estimated hours taken: 3 Replace calls to map__set with calls to either map__det_insert or map__det_update. In some cases this required a small amount of code reorganization.	1997-04-07 05:39:59 +00:00