260 Commits

Author	SHA1	Message	Date
Simon Taylor	404cff2c64	Read in the `.opt' files transitively, so that we get all the definitions ... Estimated hours taken: 6 (+12 by fjh) Branches: main Read in the `.opt' files transitively, so that we get all the definitions of equivalence types. This is needed to support --high-level-data for the .NET / Java back-ends. compiler/options.m: Add an option `--read-opt-files-transitively' (on by default). compiler/intermod.m: Read in the `.opt' files transitively. compiler/modules.m: `mmake depend' now assumes the target code for a module depends on the `.opt', `.int' and `.int2' files for all transitively imported modules. compiler/make.dependencies.m: Handle the extra dependencies. compiler/make_hlds.m: Process `pragma termination_info' pragmas in pass 3, *after* we've handled default modes for functions. This avoids a problem where the compiler was reporting spurious errors for the `pragma termination_info' pragmas for functions, when the `.opt' file for that module was read in before the `.int' file. I'm not sure if this problem was introduced by the changes above or whether the changes above just exposed an existing problem. compiler/deep_profiling.m: compiler/llds.m: compiler/mercury_compile.m: compiler/modes.m: compiler/modules.m: compiler/term_pass2.m: Add module qualifiers to calls to `member' and `map'. These are needed now that the equivalence `:- type set(T) == list(T)' is exposed with inter-module optimization. NEWS: doc/user_guide.texi: Document the change. tests/invalid/Mmakefile: Avoid reporting errors when creating the `.opt' file for the `missing_parent_import' test case.	2002-05-09 16:31:13 +00:00
Simon Taylor	811c0af920	Make inter-module optimization work properly with sub-modules. ... Estimated hours taken: 15 Branches: main Make inter-module optimization work properly with sub-modules. compiler/intermod.m: Write `exported_to_submodules' predicates to the `.opt' file. Read `.int0' files needed by the `.opt' files. compiler/make.dependencies.m: compiler/modules.m: Handle dependencies on the extra `.int0' files when compiling with `--intermodule-optimization'. compiler/modules.m: compiler/prog_io.m: compiler/*.m: Handle partially qualified file names when searching for the `.m' file for a module when checking whether there should be a dependency on the `.opt' file for the module. Separate out the code to find for the source file for a module from the code to read the source file for a module. Remove an unnecessary argument from prog_io__read_opt_file (`.opt' files are always searched for). compiler/modules.m: Export process_module_private_interfaces, for use by intermod.m. Remove process_module_indirect_imports, which isn't used anywhere. Change get_ancestors from a predicate to a function. compiler/make_hlds.m: Don't report duplicate declaration errors for items imported for inter-module optimization. Sometimes both the `.int' and `.int0' file for a module are read, and the `.int0' file contains everything in the `.int' file.. compiler/modes.m: compiler/post_typecheck.m: Don't report errors for duplicate mode declarations for imported predicates when performing inter-module optimization. If the `.int' and `.int0' files for a module are both read, the mode declarations for a predicate can be read twice. Where there are duplicate mode declarations, remove the duplicate procedures. Move the code to check for indistinguishable modes into post_typecheck.m. It only needs to be done once, not on every iteration of mode inference. compiler/hlds_pred.m: Add a predicate pred_info_remove_procid, for use by post_typecheck.m. compiler/mercury_to_mercury.m: Improve the comment generated for module_defn items which shouldn't appear in Mercury source. compiler/notes/compiler_design.html: Improve the documentation of post_typecheck.m. tests/invalid/qualified_cons_id2.err_exp: Update expected output.	2002-04-07 10:23:06 +00:00
Zoltan Somogyi	189b9215ae	This diff implements stack slot optimization for the LLDS back end based on ... Estimated hours taken: 400 Branches: main This diff implements stack slot optimization for the LLDS back end based on the idea that after a unification such as A = f(B, C, D), saving the variable A on the stack indirectly also saves the values of B, C and D. Figuring out what subset of {B,C,D} to access via A and what subset to access via their own stack slots is a tricky optimization problem. The algorithm we use to solve it is described in the paper "Using the heap to eliminate stack accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot. That paper also describes (and has examples of) the source-to-source transformation that implements the optimization. The optimization needs to know what variables are flushed at call sites and at program points that establish resume points (e.g. entries to disjunctions and if-then-elses). We already had code to compute this information in live_vars.m, but this code was being invoked too late. This diff modifies live_vars.m to allow it to be invoked both by the stack slot optimization transformation and by the code generator, and allows its function to be tailored to the requirements of each invocation. The information computed by live_vars.m is specific to the LLDS back end, since the MLDS back ends do not (yet) have the same control over stack frame layout. We therefore store this information in a new back end specific field in goal_infos. For uniformity, we make all the other existing back end specific fields in goal_infos, as well as the similarly back end specific store map field of goal_exprs, subfields of this new field. This happens to significantly reduce the sizes of goal_infos. To allow a more meaningful comparison of the gains produced by the new optimization, do not save any variables across erroneous calls even if the new optimization is not enabled. compiler/stack_opt.m: New module containing the code that performs the transformation to optimize stack slot usage. compiler/matching.m: New module containing an algorithm for maximal matching in bipartite graphs, specialized for the graphs needed by stack_opt.m. compiler/mercury_compile.m: Invoke the new optimization if the options ask for it. compiler/stack_alloc.m: New module containing code that is shared between the old, non-optimizing stack slot allocation system and the new, optimizing stack slot allocation system, and the code for actually allocating stack slots in the absence of optimization. Live_vars.m used to have two tasks: find out what variables need to be saved on the stack, and allocating those variables to stack slots. Live_vars.m now does only the first task; stack_alloc.m now does the second, using code that used to be in live_vars.m. compiler/trace_params: Add a new function to test the trace level, which returns yes if we want to preserve the values of the input headvars. compiler/notes/compiler_design.html: Document the new modules (as well as trace_params.m, which wasn't documented earlier). compiler/live_vars.m: Delete the code that is now in stack_alloc.m and graph_colour.m. Separate out the kinds of stack uses due to nondeterminism: the stack slots used by nondet calls, and the stack slots used by resumption points, in order to allow the reuse of stack slots used by resumption points after execution has left their scope. This should allow the same stack slots to be used by different variables in the resumption point at the start of an else branch and nondet calls in the then branch, since the resumption point of the else branch is not in effect when the then branch is executed. If the new option --opt-no-return-calls is set, then say that we do not need to save any values across erroneous calls. Use type classes to allow the information generated by this module to be recorded in the way required by its invoker. Package up the data structures being passed around readonly into a single tuple. compiler/store_alloc.m: Allow this module to be invoked by stack_opt.m without invoking the follow_vars transformation, since applying follow_vars before the form of the HLDS code is otherwise final can be a pessimization. Make the module_info a part of the record containing the readonly data passed around during the traversal. compiler/common.m: Do not delete or move around unifications created by stack_opt.m. compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/var_locn.m: Allow the code generator to delete its last record of the location of a value when generating code to make an erroneous call, if the new --opt-no-return-calls option is set. compiler/code_gen.m: Use a more useful algorithm to create the messages/comments that we put into incr_sp instructions, e.g. by distinguishing between predicates and functions. This is to allow the new scripts in the tool directory to gather statistics about the effect of the optimization on stack frame sizes. library/exception.m: Make a hand-written incr_sp follow the new pattern. compiler/arg_info.m: Add predicates to figure out the set of input, output and unused arguments of a procedure in several different circumstances. Previously, variants of these predicates were repeated in several places. compiler/goal_util.m: Export some previously private utility predicates. compiler/handle_options.m: Turn off stack slot optimizations when debugging, unless --trace-optimized is set. Add a new dump format useful for debugging --optimize-saved-vars. compiler/hlds_llds.m: New module for handling all the stuff specific to the LLDS back end in HLDS goal_infos. compiler/hlds_goal.m: Move all the relevant stuff into the new back end specific field in goal_infos. compiler/notes/allocation.html: Update the documentation of store maps to reflect their movement into a subfield of goal_infos. compiler/*.m: Minor changes to accomodate the placement of all back end specific information about goals from goal_exprs and individual fields of goal_infos into a new field in goal_infos that gathers together all back end specific information. compiler/use_local_vars.m: Look for sequences in which several instructions use a fake register or stack slot as a base register pointing to a cell, and make those instructions use a local variable instead. Without this, a key assumption of the stack slot optimization, that accessing a field in a cell costs only one load or store instruction, would be much less likely to be true. (With this optimization, the assumption will be false only if the C compiler's code generator runs out of registers in a basic block, which for the code we generate should be unlikely even on x86s.) compiler/options.m: Make the old option --optimize-saved-vars ask for both the old stack slot optimization (implemented by saved_vars.m) that only eliminates the storing of constants in stack slots, and the new optimization. Add two new options --optimize-saved-vars-{const,cell} to turn on the two optimizations separately. Add a bunch of options to specify the parameters of the new optimizations, both in stack_opt.m and use_local_vars.m. These are for implementors only; they are deliberately not documented. Add a new option, --opt-no-return-cells, that governs whether we avoid saving variables on the stack at calls that cannot return, either by succeeding or by failing. This is for implementors only, and thus deliberately documented only in comments. It is enabled by default. compiler/optimize.m: Transmit the value of a new option to use_local_vars.m. doc/user_guide.texi: Update the documentation of --optimize-saved-vars. library/tree234.m: Undo a previous change of mine that effectively applied this optimization by hand. That change complicated the code, and now the compiler can do the optimization automatically. tools/extract_incr_sp: A new script for extracting stack frame sizes and messages from stack increment operations in the C code for LLDS grades. tools/frame_sizes: A new script that uses extract_incr_sp to extract information about stack frame sizes from the C files saved from a stage 2 directory by makebatch and summarizes the resulting information. tools/avg_frame_size: A new script that computes average stack frame sizes from the files created by frame_sizes. tools/compare_frame_sizes: A new script that compares the stack frame size information extracted from two different stage 2 directories by frame_sizes, reporting on both average stack frame sizes and on specific procedures that have different stack frame sizes in the two versions.	2002-03-28 03:44:41 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Simon Taylor	9c9601808d	Add an alternative implementation of Mmake as part of the compiler. ... Estimated hours taken: 500 Add an alternative implementation of Mmake as part of the compiler. The advantages of this are - more accurate dependencies - no `mmake depend' step - less process creation (no processes are created to build interface files). Still to do: - handle --split-c-files - handle the IL backend properly - library installation - allow the compiler to be built and the nightly tests to be run with `mmc --make' compiler/make.m: Control the build process. compiler/make.program_target.m: Build executables and libraries. compiler/make.module_target.m: Build C files, object files, interface files etc. compiler/make.dependencies.m: Work out the depenendencies between targets. compiler/make.module_dep_file.m: Record the inter-module dependencies between invocations of mmc. compiler/make.util.m: Utility predicates used by `mmc --make'. compiler/compile_target_code.m: This module will eventually contain the predicates used to compile the target code files generated by the compiler which are now in mercury_compile.m. (That will be done as a separate change for ease of reviewing). For now compile_target_code.m compiler/mercury_compile.m: Export the predicates used to compile target code. Call make.m. Pass the name of the top-level module in the source file to modules.m. It is needed when generating the `.module_dep' files. Lookup the option defaults (which will eventually be stored in DEFAULT_MCFLAGS by the mmc script) before compiling. Up until now the option defaults have been passed on the command line by the mmc script, but with `mmc --make' the default options need to be overridden by the value of the MCFLAGS make variable, but the MCFLAGS make variable is overridden by command line options. Pass the value of `--link-flags' to c2init. Remove some uninformative messages printed when a C, IL, etc. compilation fails. compiler/options_file.m: Read files containing Make style variable assignments. compiler/options.m: doc/user_guide.texi: Add a new options category: build system options. Add some extra options: --warn-undefined-options-variables - like mmake --warn-undefined-vars --verbose-commands - print commands that the user might be interested in, like C compilation, but not things like mercury_update_interface. --output-compile-error-lines - print the first n lines of the error file generated by a command. --generate-mmc-make-modules-dependencies - generate dependencies for use by `mmc --make' even when using Mmake. --il-assembler, --ilasm-flags, --mcpp-compiler, --mcpp-flags, --csharp-compiler, --csharp-flags, --install-prefix, --install-command, --libgrades, --options-files, --options-search-directories. compiler/modules.m: Add fields to the `module_imports' type for use by make.*m. Don't try to fill in fields of the module_imports structure lazily. It's error prone, and probably doesn't save much anyway. Clean up the code to compute what foreign languages are used by a list of item. Simplify the handling of fact tables by recording that a module containing fact tables has foreign code to implement them, rather than requiring separate checks everywhere. Generalise predicates like get_interface so that they work even after the imported items have been read. Fix the handling of header files with the LLDS backend. Install the `.module_dep' files created for use by `mmc --make'. compiler/*.m: Use record syntax rather than explicit deconstruction to refer to fields of the `module_imports' type. compiler/*.m: Be more careful about where output goes. mercury_compile.m sets the output stream to be io__stderr_stream at the start of compilation, so remove all explicit writes to io__stderr_stream (with `--make' the error output stream may be a `.err' file, not io__stderr_stream). Change all occurrences of io__tell/io__told to use io__open_output/io__close_output (io__told restores the current output stream to io__stdout_stream, not the previous value). compiler/passes_aux.m: Make the output from system commands go to the current output stream, not C stdout and stderr. Allow commands to be printed with `--verbose-commands'. Remove uninformative error messages when a command fails. compiler/timestamp.m: Add functions oldest_timestamp and newest_timestamp. compiler/llds_out.m: Record the number of C files written with `--split-c-files' in <module>.num_split. compiler/prog_io.m: compiler/*.m: `search_for_file' now returns the directory in which the file was found. compiler/foreign.m: Use sub-typing to make some calls to predicates in this module `det' rather than `semidet'. compiler/handle_options.m: Return the option arguments. compiler/Mmakefile: make.util.m refers to kill() and `struct sigaction' which are not exported from <signal.h> unless `--no-ansi' is passed to gcc. compiler/notes/compiler_design.html: Document the new modules. runtime/mercury_signal.h: runtime/mercury_signal.c: Add a function MR_signal_should_restart() which alters whether a signal restarts or interrupts system calls. In general restarting is the preferred behaviour, but the wait() for a child process needs to be interruptible. scripts/Mmake.vars.in: Add subdirs for `.module_dep', `.err_date' and `.num_split' files. library/io.m: Add a version of io_call_system which returns the signal that killed the command rather than converting it into an error message. Add a predicate to interpret the result of system() or wait(). library/list.m: Add list__map_foldl2 and a unique mode for list__foldl3. NEWS: Document the new library predicates. configure.in: runtime/mercury_conf.h.in: Check for siginterrupt(). doc/user_guide.texi: Document the new options. Add a description of `mmc --make' to the "Using Mmake" chapter.	2002-03-12 16:33:37 +00:00
Zoltan Somogyi	41a27af862	Change type_id to the more descriptive type_ctor everywhere. ... Estimated hours taken: 6 Branches: main compiler/*.m: Change type_id to the more descriptive type_ctor everywhere.	2002-03-07 08:30:28 +00:00
Tyson Dowd	cdbbaa5ac2	Support multiple language foreign_procs in the one file. ... Estimated hours taken: 16 Branches: main Support multiple language foreign_procs in the one file. If there is more then one applicable foreign_proc for a given clause, select the most "preferred" programming language to use as the implementation. Currently only the IL backend has multiple languages supported by the backend, and C# is preferred over MC++. compiler/options.m: compiler/handle_options.m: Rename backend_foreign_language as backend_foreign_languages, and use it to record the list of foreign languages the selected backend can handle. Remove --use-foreign-language as it doesn't do anything right now. compiler/foreign.m: Update code to use the list of backend foreign languages. Add prefer_foreign_language function, to compute the preferred foreign language ordering for each backend. Move simple_foreign_language_string here from globals.m, and add foreign_language_file_extension and foreign_language_module_name functions. (much of the rest of the code in this module is intended to deal with the case where the backend *doesn't* handle the foreign language, but we don't have any working support for that at the moment). compiler/globals.m: Add globals__io_get_backend_foreign_languages and globals__get_backend_foreign_languages. compiler/make_hlds.m: Handle selection of foreign_proc code depending upon the preferred language. Rename a few *_foreign_code predicates as *_foreign_proc predicates. Handle the extra field in clause. compiler/ml_code_gen.m: compiler/mlds.m: Generate different mlds__foreign_code for each language (only one language is selected for each predicate, but there can be multiple languages in the onle module). and put them in a map which is indexed on foreign language. compiler/modules.m: Generate appropriate dependencies for foreign language modules. We now record which languages a list of items uses (taking into account the preferred foreign language for foreign_proc). We also allow for the fact that some foreign_proc declarations won't generate any external modules. compiler/hlds_pred.m: Add an extra field to clause which records which language this clause has been implemented in. compiler/assertion.m: compiler/clause_to_proc.m: compiler/dead_proc_elim.m: compiler/goal_util.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/modes.m: compiler/polymorphism.m: compiler/purity.m: compiler/typecheck.m: compiler/unify_proc.m: Handle the extra field in clause. compiler/mlds_to_c.m: compiler/mlds_to_csharp.m: compiler/mlds_to_gcc.m: compiler/mlds_to_mcpp.m: Select the appropriate mlds__foreign code from the map and generate code for it.	2001-07-20 14:14:30 +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	d593f527e9	Change mode inference so that it supports reordering of conjunctions. ... Estimated hours taken: 12 Change mode inference so that it supports reordering of conjunctions. For predicates with inferred modes, if we get a mode error, we don't report it straight away; instead, we just store the mode error(s) in the proc_info. Any call to a procedure for which we have recorded a mode error will itself result in a mode error, which will then cause reordering of conjunctions as usual. compiler/hlds_pred.m: Add a new `mode_errors' field to the proc_info. For predicates with inferred modes, this field records the mode errors that we detected for that procedure. Add a new predicate proc_info_is_invalid_mode that succeeds iff the list of mode errors is not empty. Change pred_info_procids and pred_info_non_imported_procids so that they skip invalid modes. Add new predicates pred_info_all_procids and pred_info_all_non_imported_procids that are like those two but that do not skip invalid modes. compiler/modes.m: For predicates with inferred modes, if we get a mode error, don't report it straight away; instead, just store the mode error in the proc_info. compiler/modecheck_call.m: compiler/unique_modes.m: When modechecking calls, check the mode_errors field in the callee's proc_info, and if it is non-empty, return a `mode_error_in_callee' mode error. compiler/mode_errors.m: Add a new error `mode_error_in_callee', along with code to report such errors. Also change `write_inference_messages', which prints out the the "Inferred :- mode ..." messages when --infer-modes is set, so that if `--verbose-errors' is set, it also prints out lines of the form "Rejected :- mode ..." for each candidate mode that we added but got a mode error for. compiler/mode_info.m: Add procedures `set_pred_id' and `set_proc_id'; these are used by mode_errors.m to print out the error message for the callee when printing messages for `mode_error_in_callee' errors. compiler/clause_to_proc.m: compiler/hlds_module.m: compiler/hlds_out.m: compiler/make_hlds.m: compiler/termination.m: Improve abstraction a little by using `pred_info_all_procids' or `pred_info_procids' rather than just using `map__keys' on the proc_table. compiler/modes.m: compiler/modecheck_unify.m: compiler/modecheck_call.m: compiler/unique_modes.m: Change modecheck_var_has_inst_list so that it takes an extra argument saying whether you want an exact match (rather than an implied mode). This is needed to avoid matching implied versions of invalid modes: when matching against an invalid mode, we only allow exact matches; for calls that would be implied modes of the invalid mode, we'll generate a new inferred mode for the procedure.	2001-01-17 01:42:12 +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
David Overton	5e669de11c	Fix some mode errors in a couple of uses of the mode_info type. ... Estimated hours taken: 2 Fix some mode errors in a couple of uses of the mode_info type. These mode errors can't actually be detected by the compiler without alias tracking, but they cause problems in later compilation phases. In particular, the excess assignnment optimisation was producing code that caused the compiler to abort when recomputing the instmap deltas. compiler/modes.m: compiler/unique_modes.m: Make sure that at most one version of the mode_info exists at any point during compilation.	2000-10-14 13:41:29 +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
Simon Taylor	5578b5ef61	Add a comment explaining why `true' goals need to be treated ... Estimated hours taken: 0.1 compiler/modes.m: Add a comment explaining why `true' goals need to be treated specially when computing instmap_deltas.	2000-09-16 00:08:29 +00:00
Simon Taylor	9bf77b6ed3	Fix bugs which caused compilation of Tom Conway's XML parser ... Estimated hours taken: 2 Fix bugs which caused compilation of Tom Conway's XML parser to fail during deforestation. compiler/inlining.m: If some of the output variables of an inlined call are not used by the caller, run quantification on the goal to push that information into the inlined goal. compiler/modes.m: compiler/unique_modes.m: When a unification with a dead variable is replaced with `true', make sure the instmap_delta of the goal is empty. tests/valid/Mmakefile: tests/valid/deforest_bug.m: Test case.	2000-09-16 00:08:24 +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	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	3ed3421f49	Fix a bug reported by Peter Ross <peter.ross@miscrit.be>: ... Estimated hours taken: 3 Fix a bug reported by Peter Ross <peter.ross@miscrit.be>: check that type, mode, and determinism of main/2 conform to what the Mercury language reference manual requires. compiler/post_typecheck.m: Check that the arguments of main/2 have type `io__state'. compiler/type_util.m: Add predicate `type_is_io_state', for use by post_typecheck.m. compiler/modes.m: Check the the arguments of main/2 have mode `di, uo'. Also split some of the code in proc_check_eval_methods out into separate procedures. compiler/det_report.m: Check that main/2 has determinism `det' or `cc_multi', rather than just checking that it doesn't fail. (We don't want to allow main/2 to have determinism `multi', since that doesn't work in MLDS grades, for which `multi' procedures have a different calling convention than `det' or `cc_multi' procedures. Similarly we don't want to allow main/2 to have determinism `erroneous', since a future back-end might use a different calling convention for that.) tests/general/partition.m: Change the declared determinism of main/2 from `multi' to `det', to make this test case conform to the language reference manual. This is needed now that the compiler checks the determinism of main/2 properly. tests/invalid/Mmakefile: tests/invalid/invalid_main.m: tests/invalid/invalid_main.err_exp: A regression test.	2000-07-24 11:36:17 +00:00
Fergus Henderson	572cd092cf	Fix some incorrect indentation in `proc_check_eval_methods'. ... Estimated hours taken: 0.1 compiler/modes.m: Fix some incorrect indentation in `proc_check_eval_methods'.	2000-07-24 10:28:06 +00:00
Zoltan Somogyi	6feb0b95f2	Make a separate enquiry function for each possible semantic test on ... Estimated hours taken: 1 Make a separate enquiry function for each possible semantic test on eval_methods. The answers are the same now, but will be different when tabled I/O is implemented. compiler/hlds_pred.m: Make a separate enquiry function for each possible semantic test on eval_methods. compiler/code_gen.m: compiler/ml_code_gen.m: compiler/make_hlds.m: compiler/modes.m: compiler/table_gen.m: Use the new functions.	2000-03-13 02:23:08 +00:00
Fergus Henderson	bdf35481e3	Improve the performance of mode analysis on modules containing large terms, ... Estimated hours taken: 12 Improve the performance of mode analysis on modules containing large terms, e.g. samples/eliza.m, for which it currently performs badly. This change speeds up compilation of samples/eliza.m by about 15%, while the speed of compilation for compiler/[a-d]*.m and compiler/options.m remains pretty much unaffected (the slowdown, if any, is less than 1%). compiler/modes.m: Ensure that we insert the live_vars sets in reverse order, so that when we come to removing them (using list__delete_first), in the typical case where no delaying is involved the one we want to remove will be at the front of the list.	2000-02-24 18:36:35 +00:00
Fergus Henderson	d43750667c	Add a new function eval_method_uses_table/1. ... Estimated hours taken: 0.75 compiler/hlds_pred.m: Add a new function eval_method_uses_table/1. compiler/code_gen.m: compiler/ml_code_gen.m: compiler/modes.m: compiler/table_gen.m: Use eval_method_uses_table, rather than just assuming that every eval method other than eval_normal uses a table.	2000-01-26 02:04:29 +00:00
Fergus Henderson	5bf94ffe94	Fix a bug with unique mode analysis of negations ... Estimated hours taken: 1.5 Fix a bug with unique mode analysis of negations that was reported by Ralph Becket. compiler/modes.m: compiler/unique_modes.m: When processing negations, set the forward-live variables set to empty, because nothing is forward-live after the negated goal -- if the negated goal succeeds, execution will immediately backtrack. tests/valid/Mmakefile: tests/valid/mostly_uniq_neg.m: Add a regression test to make sure that the compiler now accepts the code that it should, i.e. code using backtrackable destructive assignment inside a negation. tests/invalid/Mmakefile: tests/invalid/uniq_neg.m: tests/invalid/uniq_neg.err_exp: Add a test to make sure that the above change does not make the compiler accept code that it shouldn't, i.e. code using non-backtrackable destructive assignment inside a negation.	1999-11-19 13:22:25 +00:00
Fergus Henderson	ec1ad6365d	Fix typo in error message: s/impemented/implemented/ ... Estimated hours taken: 0.1 compiler/modes.m: Fix typo in error message: s/impemented/implemented/	1999-10-29 07:22:25 +00:00
Fergus Henderson	e76ce4151d	Change the format of a couple of error messages to match the ... Estimated hours taken: 0.25 compiler/modes.m: Change the format of a couple of error messages to match the guidelines specified in notes/coding_standards.html.	1999-10-29 05:59:25 +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	34d52a4091	Fix a bug with switches on existential types. ... Estimated hours taken: 12 Fix a bug with switches on existential types. This bug meant that existential types with two or more functors did not work at all, due to internal compiler errors when compiling the unification and comparison predicates for those types. compiler/type_util.m: Add new function cons_id_adjusted_arity, which computes the arity _including_ the extra typeinfo and typeclassinfo arguments inserted for existential data types. compiler/type_util.m: compiler/polymorphism.m: Move the predicates constraint_list_get_tvars and constraint_get_tvars from polymorphism.m into type_util.m, for use in cons_id_adjusted_arity. compiler/modes.m: compiler/unique_modes.m: When modechecking the functor test in switch statements, use cons_id_adjusted_arity to compute the arity of the inst, compiler/instmap.m: In instmap__bind_var_to_functor (and the instmap_delta version), use cons_id_adjusted_arity to compute the arity of the inst. compiler/goal_util.m: compiler/pd_info.m: compiler/pd_util.m: compiler/saved_vars.m: compiler/mode_util.m: compiler/deforest.m: compiler/follow_code.m: compiler/higher_order.m: compiler/simplify.m: Pass the type(s) down to recompute_instmap_delta and instmap__bind_var_to_functor, since cons_id_adjusted_arity needs to know the type. compiler/hlds_pred.m: compiler/hlds_out.m: Add a `vartypes' typedef, defined by `:- type vartypes == map(prog_var, type)', and make use of it. Rename the `vartypes' type in hlds_out as `maybe_vartypes'. tests/hard_coded/Mmakefile: tests/hard_coded/existential_type_switch.m: tests/hard_coded/existential_type_switch.exp: Add a regression test. tests/hard_coded/Mmakefile: Enable the existential_types_test.m test case, which should have been enabled previously. (The reason that it wasn't seems to be that I made a mistake when merging in the changes from the existential types branch.)	1999-10-15 03:45:27 +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	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
Simon Taylor	5f7880aca3	Fix a code generator abort reported by Stephane Marie ... Estimated hours taken: 10 Fix a code generator abort reported by Stephane Marie <stephane.marie@detexis.thomson-csf.com>. The bug was in the code to work out the instmap after a deconstruction unification with complicated sub-unifications. The instmap_delta for the unification contained only the bindings for the first argument for which a new variable was created. The test case now gives an error during mode analysis rather than a code generator abort (for unification procedures of imported types) or a mode error during unique mode analysis (for local types). compiler/modes.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: Simplify the code to handle extra goals by not attempting to bodge together the instmap after the main goal. Instead, the code now creates the extra unifications and rechecks the goal with the unifications added. compiler/mode_info.m: Add a field to say whether we are reprocessing a goal after adding extra goals. Abort if the reprocessing adds more extra goals. The `may_changed_called_proc' field is now separate from the `how_to_check_goal' field. This is used to avoid repeating the search for the best procedure when rerunning mode analysis after adding the extra goals. compiler/modecheck_unify.m: Removed predicate unify_vars - it is no longer used. compiler/unify_proc.m: Call module_info_remove_predid if there are mode errors in a unification procedure to avoid spurious determinism errors. tests/hard_coded/Mmakefile: tests/hard_coded/partial_implied_mode.m: tests/hard_coded/partial_implied_mode.err_exp: Test case. It would be nicer if the error message pointed to the unification which caused the unification procedure to be created, rather than the type declaration in the interface file.	1999-05-18 03:09:21 +00:00
Fergus Henderson	3018d7abb2	Perform some minor simplifications in mode analysis, ... Estimated hours taken: 1.5 Perform some minor simplifications in mode analysis, so as to provide more information to unique mode analysis. Previously unique_modes.m was reporting spurious errors for tests/hard_coded/bidirectional.m, because modes.m produced output containing a subgoal of the form `disj([Goal, conj([disj([])]])' instead of just `Goal', and the presence of a disjunction then caused unique mode analysis to make overly conservative assumptions. compiler/modes.m: Ensure that we do not produce singleton conjunctions or disjunctions. Also, if the result of mode checking a disjunct is a (nested) disjunction, then merge it with the containing disjunction. If the nested disjunction is the empty disjunction (fail), then this means it will be deleted. tests/hard_coded/Mmakefile: Re-enable the test case bidirectional.m, since the compiler now accepts it, due to the above change. tests/warnings/simple_code.m: tests/warnings/simple_code.exp: Update this test case, because the above change meant that the compiler no longer issues the warning about "this disjunct can never succeed" in cases like this -- mode analysis will already have optimized it away, before we even get to simplify.m (which handles those kinds of warnings). This warning is not as important as allowing bidirectional code.	1999-04-16 08:08:08 +00:00
Thomas Conway	5c955626f2	These changes make var' and term' polymorphic. ... Estimated hours taken: 20 These changes make `var' and `term' polymorphic. This allows us to make variables and terms representing types of a different type to those representing program terms and those representing insts. These changes do not *fix* any existing problems (for instance there was a messy conflation of program variables and inst variables, and where necessary I've just called varset__init(InstVarSet) with an XXX comment). NEWS: Mention the changes to the standard library. library/term.m: Make term, var and var_supply polymorphic. Add new predicates: term__generic_term/1 term__coerce/2 term__coerce_var/2 term__coerce_var_supply/2 library/varset.m: Make varset polymorphic. Add the new predicate: varset__coerce/2 compiler/prog_data.m: Introduce type equivalences for the different kinds of vars, terms, and varsets that we use (tvar and tvarset were already there but have been changed to use the polymorphic var and term). Also change the various kinds of items to use the appropriate kinds of var/varset. compiler/*.m: Thousands of boring changes to make the compiler type correct with the different types for type, program and inst vars and varsets.	1998-11-20 04:10:36 +00:00
Fergus Henderson	c62f8aa480	Fix a bug with unique mode inference. ... Estimated hours taken: 4 Fix a bug with unique mode inference. compiler/modes.m: compiler/unify_proc.m: When doing unique mode inference, save a copy of the old procedure bodies, and use this to restore the old procedure bodies before each pass. This avoids problems where modes.m was doing optimizations based on incomplete information obtained in passes before the fixpoint. Note that we already did this for ordinary mode inference, by copying the clauses from the clauses_info, so this was only a problem for unique mode inference. But I've also changed that code so that doesn't copies stuff from the clauses_info before the first pass, since that is already done by post_typecheck.m. Now it only does does the copying for the second and subsequent passes. tests/valid/Mmakefile: tests/valid/uniq_mode_inf_bug.m: Add a test case for the above-mentioned bug.	1998-11-11 00:28:02 +00:00
Fergus Henderson	9e2b5c3463	Fix a couple of bugs that resulted in error messages containing ... Estimated hours taken: 1 Fix a couple of bugs that resulted in error messages containing incorrect argument numbers. compiler/modes.m: Change modecheck_set_var_inst_list to set the argument number, so that error messages reported by handle_implied_mode report the correct argument number. compiler/modecheck_call.m: Fix an off-by-one error: the initial value of the argument counter in modecheck_var_has_inst_inst should be 0, not 1.	1998-08-04 13:08:04 +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
Oliver Hutchison	bcf7dbf9f8	Add support for tabling. ... Estimated hours taken: 250 Add support for tabling. This change allows for model_det, model_semidet and model_non memoing, minimal model and loop detection tabling. compiler/base_type_layout.m: Update comments to reflect new runtime naming standard. compiler/det_analysis.m: Allow tabling to change the result of det analysis. This is necessary in the case of minimal model tabling which can turn a det procedure into a semidet one. compiler/det_report.m: compiler/hlds_data.m: Add code to report error messages for various non compatible tabling methods and determinism. compiler/hlds_out.m: compiler/modules.m: Remove reference to the old memo marker. compiler/hlds_pred.m: Create new type (eval_method) to define which of the available evaluation methods should be used each procedure. Add new field to the proc_info structure. Add several new predicates relating to the new eval_method type. compiler/inlining.m: compiler/intermod.m: Make sure only procedures with normal evaluation are inlined. compiler/make_hlds.m: Add code to process new tabling pragmas. compiler/mercury_compile.m: Call the tabling transformation code. compiler/modes.m: Make sure that all procedures with non normal evaluation have no unique/partially instantiated modes. Produce error messages if they do. Support for partially instantiated modes is currently missing as it represents a large amount of work for a case that is currently not used. compiler/module_qual.m: compile/prog_data.m: compiler/prog_io_pragma.m: Add three new pragma types: `memo' `loop_check' `minimal_model' and code to support them. compiler/simplify.m: Don't report infinite recursion warning if a procedure has minimal model evaluation. compiler/stratify.m: Change the stratification analyser so that it reports cases of definite non-stratification. Rather than reporting warnings for any code that is not definitely stratified. Remove reference to the old memo marker. compiler/switch_detection.m: Fix a small bug where goal were being placed in reverse order. Call list__reverse on the list of goals. compiler/table_gen.m: New module to do the actual tabling transformation. compiler/notes/compiler_design.html: Document addition of new tabling pass to the compiler. doc/reference_manual.texi: Fix mistake in example. library/mercury_builtin.m: Add many new predicates for support of tabling. library/std_util.m: library/store.m: Move the functions : ML_compare_type_info ML_collapse_equivalences ML_create_type_info to the runtime. runtime/mercury_deep_copy.c: runtime/mercury_type_info.h: runtime/mercury_type_info.c: Move the make_type_info function into the mercury_type_info module and make it public. runtime/Mmakefile: runtime/mercury_imp.h: Add references to new files added for tabling support. runtime/mercury_string.h: Change hash macro so it does not cause a name clash with any variable called "hash". runtime/mercury_type_info.c: runtime/mercury_type_info.h: Add three new functions taken from the library : MR_compare_type_info MR_collapse_equivalences MR_create_type_info. runtime/mercury_table_any.c: runtime/mercury_table_any.h: runtime/mercury_table_enum.c: runtime/mercury_table_enum.h: runtime/mercury_table_int_float_string.c: runtime/mercury_table_int_float_string.h: runtime/mercury_table_type_info.c: runtime/mercury_table_type_info.h: runtime/mercury_tabling.h: New modules for the support of tabling.	1998-05-15 07:09:29 +00:00
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
Andrew Bromage	b5dfd26ebd	Miscellaneous small changes. ... Estimated hours taken: 1.5 Miscellaneous small changes. compiler/modes.m: Fix a couple of mode errors which were caught by the new mode checker: use of clobbered mode_infos. compiler/simplify.m: Optimise away unifications of the form X = X. (These can be created by excess assignment elimination.) compiler/follow_vars.m: compiler/hlds_goal.m: compiler/inst_match.m: compiler/prog_data.m: compiler/store_alloc.m: Minor documentation fixes.	1998-03-24 00:06:59 +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
Fergus Henderson	081f73e3b7	When reporting impurity errors, report all such errors; ... Estimated hours taken: 0.75 compiler/modes.m: When reporting impurity errors, report all such errors; the previous code tried to report only the first one, but due to a bug only reported the *last* one, which I found quite confusing.	1998-02-15 06:49:17 +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
Andrew Bromage	513132f8a8	Better error reporting for variables bound in illegal places. ... Estimated hours taken: 2 Better error reporting for variables bound in illegal places. compiler/mode_info.m: Add a var_lock_reason, specifying the reason why a variable is locked during mode checking. compiler/modecheck_unify.m: compiler/modes.m: compiler/unique_modes.m: Specify the reason when locking some variables. compiler/mode_errors.m: When reporting var locking errors, give the reason why the var was locked. tests/invalid/Mmakefile: tests/invalid/bind_var_errors.err_exp: tests/invalid/bind_var_errors.m: Regression tests for the above changes.	1998-01-30 06:13:35 +00:00
Fergus Henderson	968b084fbe	Delete all the obsolete code using magic numbers (e.g. 10000) ... Estimated hours taken: 0.75 compiler/bytecode.m: compiler/code_util.m: compiler/const_prop.m: compiler/hlds_out.m: compiler/intermod.m: compiler/llds_out.m: compiler/make_hlds.m: compiler/mercury_to_c.m: compiler/modes.m: compiler/special_pred.m: compiler/term_errors.m: compiler/trace.m: Delete all the obsolete code using magic numbers (e.g. 10000) for proc_ids. This old hack, whereby make_hlds.m assigned mode numbers based on the priority given to the determinism of each mode, is not needed anymore. It is no longer needed because modecheck_call.m now chooses the mode that is the best fit (based on a variety of factors) rather than just picking the first allowable mode. tests/invalid/duplicate_modes.err_exp: The output for this test changed, in insignificant ways: the order in which it reported the duplicates modes changed, because the mode numbers had changed.	1998-01-24 05:44:33 +00:00
Fergus Henderson	6db3f94609	Fix a bug that caused the compiler to report spurious unique mode ... Estimated hours taken: 4 Fix a bug that caused the compiler to report spurious unique mode errors for cases involving nested conjunctions, reordering, and unique modes. compiler/modes.m: When modechecking conjunctions, if the conjunction as a whole delays, make sure that we restore the original live_vars set. compiler/mode_info.m: Add mode_info_get_live_vars/2 and mode_info_set_live_vars/3, for use by modes.m. tests/hard_coded/Mmakefile: tests/hard_coded/reorder_di.m: tests/hard_coded/reorder_di.exp: Regression test for the above-mentioned bug.	1998-01-21 06:11:20 +00:00
Fergus Henderson	9887fc2493	Extend the support for `any' insts. In particular, allow users to pass ... Estimated hours taken: 20 Extend the support for `any' insts. In particular, allow users to pass a variable with inst `free' to a procedure that expects an argument of inst `any' without needing to explicitly initialize it with a call to cfloat__init/1 or the like. compiler/inst_match.m: compiler/modes.m: Allow `free' insts to be passed where `any' insts are expected. This is basically a special case of implied modes. We insert code to initialize the variable to inst `any' by calling `<mod>:<type>_init_any'/1, where `<mod>:<type>' is the type of the variable. compiler/modes.m: compiler/modecheck_unify.m: Change the `extra_goals' type to allow goals to be inserted before the main goal, as well as appended after it. This is needed for inserting calls to `<mod>:<type>_init_any'/1. compiler/dead_proc_elim.m: Don't eliminate `<foo>_init_any/1' predicates, since modes.m may insert calls to them. compiler/modecheck_call.m: Change the algorithm for choosing which mode to call so that it takes the inst of the actual argument into account when choosing between pairs of initial insts such as `free' and `any'. This is necessary now that `free' can be passed to `any' and vice versa. Without this change, mode analysis picks the wrong modes. extras/clpr/cfloat.m: Add `cfloat__cfloat_init_any/1'. extras/clpr/samples/fib.m: extras/clpr/samples/mortgage.m: extras/clpr/samples/sum_list.m: Delete some calls to cfloat__init/1 that are now unnecessary. extras/clpr/samples/mortgage.exp: Update the expected output, because the `_v<n>' variable numbers have changed -- we now create fewer solver variables for this test case.	1998-01-16 06:44:41 +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
Fergus Henderson	0b337ee174	Handle inference of mostly-unique (not just unique) modes. ... Estimated hours taken: 25 Handle inference of mostly-unique (not just unique) modes. compiler/unique_modes.m: Change the handling of calls so that if the mode originally selected by ordinary mode analysis (modes.m) won't work, then it now calls modecheck_call_pred to introduce a new mode for the predicate. compiler/unify_proc.m: Generalize the existing "unify request queue" so that it can handle requests for any kind of predicate, not just for unification predicates, and hence rename the `unify_request' table which contains it as the `proc_request' table. compiler/hlds_module.m: Rename the `unify_request' table as the `proc_request' table. compiler/modecheck_call.m: When introducing new modes for predicates, do this by adding them to the request queue. This ensures that when we do get around to processing predicates added in unique mode analysis, we will run mode analysis, switch detection, and determinism analysis before doing unique mode analysis. To make this work, we need to pass down a `maybe(determinism)' argument indicating the determinism of the newly added procedure. unique_modes.m sets this to the determinism inferred for the mode originally inferred by modes.m. That should be OK, because uniqueness should not affect determinism. Also change modecheck_call_proc to return a `Changed' flag indicating whether we need to rerun fixpoint analysis. And change `get_var_insts_and_lives' to return `dead' for mostly_unique modes, not just for unique modes, so that we can infer `mdi' modes. compiler/modes.m: Instead of analyzing everything to a fixpoint, and then analyzing the queued unification procedures, change it so that analysis of queued procedures is part of each fixpoint iteration. When doing ordinary mode analysis for calls, pass `no' as the new `maybe(determinism)' argument to modecheck_call_pred. compiler/constraint.m: compiler/cse_detection.m: Ignore the new output argument for modecheck_call_proc. compiler/mode_util.m: Add code to insts_to_mode to recognize `muo', `mui', and `mdi' modes and use the corresponding abbreviations (previously this was done only for `uo', `ui', `di', `in' and `out'). tests/valid/mostly_uniq_mode_inf.m: A test case for the above change.	1998-01-05 07:26:32 +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