Estimated hours taken: 2
Branches: main
compiler/simplify.m:
Change the names of some predicates so that they are meaningful without
the module name as prefix. Delete module prefixes to shorten some
lines.
compiler/magic.m:
compiler/mercury_compile.m:
compiler/size_prof.m:
Conform to the new names of simplify's predicates.
compiler/typecheck.m:
Misc cleanups.
library/rtti_implementation.m:
library/store.m:
Convert to four-space indentation.
Estimated hours taken: 30
Branches: main
Consider types of the form
:- type x ---> f.
to be dummy types, since they contain no information. Optimize them the same
way we currently optimize io.state and store.store.
runtime/mercury_type_info.h:
Add a new type_ctor_rep for dummy types.
runtime/mercury_tabling.h:
Add a representation for "tabled" dummy types, which don't actually
have a level in the trie, so that the runtime system can handle that
fact.
runtime/mercury_ml_expand_body.h:
When deconstructing a value of a dummy type, ignore the actual value
(since it will contain garbage) and instead return the only possible
value of the type.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
runtime/mercury_deep_copy_body.c:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
library/rtti_implementation.m:
Handle the type_ctor_rep of dummy types.
runtime/mercury_builtin_types.c:
Provide a place to record profiling information about unifications and
comparisons for dummy types.
runtime/mercury_mcpp.h:
java/runtime/TypeCtorRep.java:
library/private_builtin.m:
Add a new type_ctor_rep for dummy types, and fix some previous
discrepancies in type_ctor_reps.
mdbcomp/prim_data.m:
Move a bunch of predicates for manipulating special_pred_ids here from
the browser and compiler directories.
Rename the function symbols of the special_pred_id type to avoid the
need to parenthesize the old `initialise' function symbol.
Convert to four-space indentation.
mdbcomp/rtti_access.m:
Don't hardcode the names of special preds: use the predicates in
prim_data.m.
Convert to four-space indentation.
browser/declarative_execution.m:
Delete some predicates whose functionality is now in
mdbcomp/prim_data.m.
compiler/hlds_data.m:
Replace the part of du type that says whether a type an enum, which
used to be a bool, with something that also says whether the type is a
dummy type.
Convert to four-space indentation.
compiler/make_tags.m:
Compute the value for the new field of du type definitions.
compiler/hlds_out.m:
Write out the new field of du type definitions.
compiler/rtti.m:
Modify the data structures we use to create type_ctor_infos to allow
for dummy types.
Convert to four-space indentation.
compiler/type_ctor_info.m:
Modify the code that generates type_ctor_infos to handle dummy types.
compiler/type_util.m:
Provide predicates for recognizing dummy types.
Convert to four-space indentation.
compiler/unify_proc.m:
Generate the unify and compare predicates of dummy types using a new
code scheme that avoids referencing arguments that contain garbage.
When generating code for unifying or comparing other types, ignore
any arguments of function symbols that are dummy types.
Don't use DCG style access predicates.
compiler/higher_order.m:
Specialize the unification and comparison of values of dummy types.
Break up an excessively large predicate, and factor out common code
from the conditions of a chain of if-then-elses.
compiler/llds.m:
For each input and output of a foreign_proc, include a field saying
whether the value is of a dummy type.
compiler/pragma_c_gen.m:
Fill in the new fields in foreign_proc arguments.
compiler/hlds_goal.m:
Rename some predicates for constructing unifications to avoid
unnecessary ad-hoc overloading. Clarify their documentation.
Rename a predicate to make clear the restriction on its use,
and document the restriction.
Add a predicate for creating simple tests.
Add a utility predicate for setting the context of a goal directly.
compiler/modules.m:
Include dummy types interface files, even if they are private to the
module. This is necessary because with the MLDS backend, the generated
code inside the module and outside the module must agree whether a
function returning a value of the type returns a real value or a void
value, and this requires them to agree on whether the type is dummy
or not.
The impact on interface files is minimal, since very few types are
dummy types, and changing a type from a dummy type to a non-dummy type
or vice versa is an ever rarer change.
compiler/hlds_pred.m:
Provide a representation in the compiler of the trie step for dummy
types.
compiler/layout_out.m:
Print the trie step for dummy types.
compiler/table_gen.m:
Don't table values of dummy types, and record the fact that we don't
by including a dummy trie step in the list of trie steps.
compiler/add_pragma.m:
compiler/add_special_pred.m:
compiler/add_type.m:
compiler/aditi_builtin_ops.m:
compiler/bytecode.m:
compiler/bytecode_gen.m:
compiler/code_gen.m:
compiler/code_info.m:
compiler/continuation_info.m:
compiler/cse_detection.m:
compiler/det_report.m:
compiler/exception_analysis.m:
compiler/inst_match.m:
compiler/livemap.m:
compiler/llds_out.m:
compiler/llds_out.m:
compiler/middle_rec.m:
compiler/ml_call_gen.m:
compiler/ml_closure_gen.m:
compiler/ml_code_gen.m:
compiler/ml_code_util.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_il.m:
compiler/modecheck_unify.m:
compiler/modes.m:
compiler/opt_util.m:
compiler/post_term_analysis.m:
compiler/post_typecheck.m:
compiler/qual_info.m:
compiler/rl.m:
compiler/rl_exprn.m:
compiler/rl_key.m:
compiler/rtti_out.m:
compiler/simplify.m:
compiler/size_prof.m:
compiler/term_constr_initial.m:
compiler/term_constr_util.m:
compiler/term_norm.m:
compiler/termination.m:
compiler/trace.m:
compiler/typecheck.m:
compiler/unify_gen.m:
Conform to the changes above.
compiler/export.m:
compiler/exprn_aux.m:
compiler/foreign.m:
compiler/polymorphism.m:
compiler/proc_label.m:
compiler/rtti_to_mlds.m:
compiler/special_pred.m:
compiler/stack_alloc.m:
compiler/stack_layout.m:
compiler/state_var.m:
compiler/switch_util.m:
compiler/trace_params.m:
Conform to the changes above.
Convert to four-space indentation.
compiler/mlds_to_java.m:
compiler/var_locn.m:
Conform to the changes above, which requires threading the module_info
through the module.
Convert to four-space indentation.
compiler/mercury_compile.m:
Pass the module_info to mlds_to_java.m.
compiler/ml_util.m:
compiler/polymorphism.m:
compiler/type_ctor_info.m:
compiler/type_util.m:
Delete some previously missed references to the temporary types used
to bootstrap the change to the type_info type's arity.
compiler/polymorphism.m:
Turn back on an optimization that avoids passing parameters (such as
type_infos) to foreign_procs if they are not actually referred to.
compiler/prog_data.m:
Convert to four-space indentation.
library/svvarset.m:
Add a missing predicate.
trace/mercury_trace.c:
Delete the unused function that used to check for dummy types.
tests/debugger/field_names.{m,inp,exp}:
Add to this test case a test of the handling of dummy types. Check that
their values can be printed out during normal execution, and that the
debugger doesn't consider them live nondummy variables, just as it
doesn't consider I/O states live nondummy variables.
Estimated hours taken: 8
Branches: main
This is step 2 of eliminating the arguments of the type_ctor_info, type_info,
base_typeclass_info and typeclass_info type constructors. This step changes
the arity of those type constructors from 1 to 0, and starts generating
references to them again. Due to bootstrapping issues, we can't delete the
zero_type_ctor_info, zero_type_info, zero_base_typeclass_info and
zero_typeclass_info types yet; that will be step 3.
library/private_builtin.m:
Change the arity of those type constructors.
runtime/mercury_builtin_types.m:
Update the unify and compare predicates of the old type constructors
for their new arity.
compiler/polymorphism.m:
compiler/size_prof.m:
compiler/type_util.m:
Generate references to the newly arity-0 old type constructions.
compiler/type_ctor_info.m:
compiler/type_util.m:
trace/mercury_trace_vars.c:
Update references to the old types to reflect their new arities.
compiler/type_ctor_info.m:
There are no more fake arities.
library/io.m:
library/rtti_implementation.m:
library/string.m:
library/table_builtin.m:
Update references to the old types for their new arities.
Estimated hours taken: 30
Branches: main
Change the representation of types in the compiler.
We also add some support for handling kinds, which will be used later when we
have a kind system. There are a number of places where kinds are not yet
handled correctly -- we assume that all kinds will be `star'. Each of these
locations is flagged with a comment that contains "XXX kind inference:".
compiler/prog_data.m:
Implement the new version of type (type).
Change the definition of type_param to be a variable instead of a
term, since all parameters must be variables anyway.
Implement versions of varset.merge_* which work with tvarsets and
produce renamings instead of substitutions. Renamings are more
convenient than substitutions because we don't need to know the
kinds of type variables in order to build the renaming, and in any
case the substitutions shouldn't have anything other than variables
in the range so renamings will be more efficient and safe.
Define the type of kinds, and provide a couple of utility predicates
to operate on them.
compiler/prog_io.m:
Parse type definition heads as a sym_name and list of type_params,
rather than a functor. Handle this change in other predicates.
Allow parse errors to be returned by get_with_type/3, and handle
these errors.
Remove parse_type/2. This predicate didn't do any processing, it
just forwarded handling to convert_type/2.
compiler/prog_io_typeclass.m:
Change type_is_functor_and_vars to handle the new representation
of types. In doing so, we retain the old behaviour that pure
predicates pass this test, but no other pred or func types. This
behaviour is arguably incorrect, but there is little point changing
the behaviour at the moment. Instead we should remove these kind of
restrictions entirely, but that should be done later.
compiler/prog_io_util.m:
Provide predicates to both parse and unparse types. We need to
unparse types before printing them out, since we do a lot of special
case handling when printing out terms and we don't want to duplicate
this functionality for types.
compiler/module_qual.m:
Remove report_invalid_type. We now report ill-formed types during
parsing.
compiler/superhomogeneous.m:
Handle errors from the parsing of type expressions.
compiler/prog_out.m:
Provide a predicate to convert builtin_types to their string names,
and vice-versa.
compiler/prog_type.m:
Add a bunch of simple tests to use on types which may have kind
annotations present. In such cases, types do not have a canonical
representation so the simple handling of these tests is not what we
want. (Note that these are only required in early phases. The kind
annotations -- when they are implemented -- will be removed before
type checking.)
Consistently handle the application of renamings, substitutions and
recursive substitutions to various data structures.
compiler/mercury_to_mercury.m:
Implement mercury_output_type, mercury_format_type and
mercury_type_to_string. These convert the type to a term before
formatting -- the reason for this is so that appropriate parentheses
are used when formatting operators. This results in some slight
changes to error messages, which are reflected in changes to the
expected output files in the tests.
Remove the old version of mercury_type_to_string.
Change the argument ordering of mercury_format_var to be consistent
with mercury_format_type. (Other predicates in this module should
probably be changed in a similar way, since this argument ordering
is more amenable to higher-order programming. But that can be left
for another change.)
compiler/type_util.m:
Implement type unification. The behaviour is much the same as the
previous behaviour, except that we now handle apply/N types properly,
and we also allow for kind annotations.
Implement an occurs check for types.
Remove the example definition of replace_eqv_type. It isn't used and
would no longer work anyway even if it would have worked before.
Add a tvar_kind_map field to ctor_defn.
The functions type_info_type and type_ctor_info_type now return
types with `void' as their argument, rather than the type that the
type_info or type_ctor_info was for.
Remove type_util.real_vars/2, since it no longer does anything
different from prog_type.vars/2.
Remove the commented out implementation of type_to_ctor_and_args/3.
Its implementation is in prog_type.m, and has changed significantly
in any case.
compiler/add_clause.m:
Move parse_purity_annotation/3 to prog_io_util.m.
compiler/check_typeclass.m:
Remove apply_substitution_to_var_list/3, since we now have predicates
in prog_type.m to handle such things.
compiler/continuation_info.m:
compiler/trace.m:
Use prog_type.vars/2 instead of type_util.real_vars/2. The two
predicates have the same meaning now since type_infos don't contain
any type variables.
compiler/hlds_data.m:
Add tvar_kind_map fields to hlds_type_defn and hlds_class_defn.
compiler/hlds_pred.m:
Add a tvar_kind_map field to pred_info.
compiler/polymorphism.m:
Add a tvar_kind_map field to poly_info.
Remove unify_corresponding_types, which is no longer used.
compiler/hlds_out.m:
Use mercury_output_type/5 instead of term_io__write_term/4 and
mercury_output_term/5.
compiler/post_typecheck.m:
Build the void substitution directly rather than building intermediate
lists.
compiler/recompilation.version.m:
Use term__list_subsumes instead of type_list_subsumes, which now
operates only on types. This follows up on what was suggested in
an XXX comment.
compiler/typecheck_errors.m:
Use unparse_type/2 to format error messages.
compiler/typecheck_info.m:
Don't export write_type_with_bindings/5. It is no longer used
outside of this module.
compiler/*.m:
Conform to the above changes.
library/rtti_implementation.m:
Fix a syntax error that went undetected in our previous
implementation, and amazingly enough was compiled correctly anyway.
library/term.m:
Move the versions of term__unify, term__unify_list and
term__list_subsumes that were implemented specifically for types
to here. The version of term_unify that takes a list of bound
variables (i.e., variables that should not be bound any further)
is used by the subsumption check, which in turn is used by
recompilation.version.m.
tests/invalid/kind.err_exp:
tests/invalid/tc_err1.err_exp:
tests/invalid/tc_err2.err_exp:
tests/misc_tests/pretty_print_test.exp:
Update the expected output of these tests to match what we now do.
Estimated hours taken: 1.5
Branches: main
Fix some compilation errors for the library in the non-C grades.
Provide a workaround for a problem with the library in the java
grade.
library/rtti_implementation.m:
s/get_functor_2/get_functor_with_names/ since that is
how it is referred to in the calls from the construct
module.
library/type_desc.m:
Import std_util since semidet_fail is now used in this
module.
Provide a foreign type definition for pseudo_type_desc.
XXX This is not correct but something is amiss with
either the Java backend and/or the Java runtime. Providing
a foreign type definition means that the library will at
least compile in grade java.
Estimated hours taken: 16
Branches: main
Type_desc__get_functor looks up the types of the arguments of a function
symbol. This predicate used to abort when an argument has an existential
type. This diff makes type_desc__get_functor work even in that case.
However, since in such cases the type of an argument is not a ground type,
this diff has to add the concept of a pseudo_type_desc, a descriptor for
a not necessarily ground type. Pseudo_type_descs are implemented as
MR_PseudoTypeInfos.
runtime/mercury_type_info.[ch]:
Add new macros to operate on pseudo_type_infos. Most have a structure
modelled on corresponding macros operating on type_infos.
Provide versions of MR_get_arg_type_info, MR_compare_type_info,
MR_unify_type_info, MR_collapse_equivalences,
MR_type_params_vector_to_list, MR_create_type_info and
MR_create_type_info_maybe_existq that work on pseudo_type_infos,
not type_infos.
Change MR_pseudo_type_info_vector_to_type_info_list, which implements
the core of get_functor, to return pseudo_type_infos instead of
type_infos, and rename it to reflect this fact.
Change to four-space indentation to reduce the number of lines
that have to be wrapped.
runtime/mercury_make_type_info_body.h:
Generalize the code for creating type_infos to also be handle
pseudo_type_infos.
Change to four-space indentation to reduce the number of lines
that have to be wrapped.
runtime/mercury_type_desc.[ch]:
Provide versions of MR_make_type_ctor_desc and MR_type_ctor_and_args
that work on pseudo_type_infos, not type_infos.
Change to four-space indentation to reduce the number of lines
that have to be wrapped.
runtime/mercury_builtin_types.[ch]:
runtime/mercury_builtin_types_proc_layouts.h:
runtime/mercury_hlc_types.h:
runtime/mercury_unify_compare_body.h:
Add the C types, global variables and functions necessary for the
new builtin Mercury type pseudo_type_desc. This type must be builtin,
because its structure (MR_PseudoTypeInfo) is defined in C, and as such
cannot be unified, compared, deconstructed etc without hand-written
C code.
runtime/mercury_deep_copy.c:
runtime/mercury_deep_copy_body.h:
Handle the copying of pseudo_type_infos/pseudo_type_descs. This code
is almost the same as the code to copy type_infos, but must of course
handle type variables, and the arguments are themselves copied as
pseudo_type_infos, not type_infos.
runtime/mercury_types.h:
Since deep copy needs to create pseudo_type_infos, provide a version
of the MR_PseudoTypeInfo type without const.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
Handle pseudo_type_descs just as we handle type_descs: neither can be
constructed, nor do they have function symbols with named arguments.
runtime/mercury_ml_expand_body.c:
Provide code to deconstruct pseudo_type_descs. This code is almost
the same as the code to deconstruct type_descs, but must of course
handle type variables, and the arguments are themselves
pseudo_type_descs, not type_descs.
runtime/mercury_tabling.c:
Catch attempts to table pseudo_type_infos.
runtime/mercury_tags.h:
Add macros for constructing lists of
pseudo_type_infos/pseudo_type_descs.
runtime/mercury_wrapper.[ch]:
Define global variables holding the addresses of the typeinfos for
describing pseudo_type_descs and lists of pseudo_type_descs.
runtime/mercury_init.c:
Add the extern declarations required by new code in mkinit.c.
util/mkinit.c:
Make the addresses of the typeinfos for describing pseudo_type_descs
and lists of pseudo_type_descs, defined in the library, known to the
runtime.
library/type_desc.m:
Add a new builtin type, pseudo_type_desc, for describing possibly
nonground types.
Add utility predicates for operating on pseudo_type_descs.
library/private_builtin.m:
Handle the new builtin type.
Add builtin typeinfos for describing pseudo_type_descs and lists of
pseudo_type_descs, since some functions in the runtime need them
for memory profiling.
library/rtti_implementation.m:
Handle the new builtin type, mostly by ignoring it, since the backends
that use this module do not have any notion of pseudo_type_infos.
Bring the module up to date with our formatting guidelines.
library/construct.m:
Make get_functor return a list of pseudo_type_descs instead of
type_descs.
Change the name of the version of get_functor that returns argument
names, to distinguish it from the base version by more than just the
arity.
Make the order of predicates more logical.
library/std_util.m:
Change the name of the version of get_functor that returns argument
names, to distinguish it from the base version by more than just the
arity.
However, this name change is effectively the only change: both
get_functor and get_functor_with_names still return lists of
type_descs. This means that they will throw exceptions in the presence
of existential types, but code using them need no algorithmic changes.
library/term.m:
library/term_to_xml.m:
Add module qualifiers as necessary; no algorithmic changes.
library/list.m:
Add two general-purpose predicates, all_true and all_false,
for use in the other library modules.
compiler/ml_util.m:
compiler/mlds_to_gcc.m:
compiler/rtti.m:
compiler/type_ctor_info.m:
Make sure we handle the new builtin type as a builtin type, and not
try to have the compiler create a type_ctor_info for it.
deep_profiler/canonical.m:
Delete the local definition of all_true.
tests/hard_coded/construct_test.{m,exp}:
Update this test case to test the ability to retrieve the names of the
fields of function symbols with existential types.
Add module qualifications as necessary.
tests/hard_coded/construct_test_exist.{m,exp}:
Add a tougher test case to print the types of the arguments of
function symbols with existential types.
tests/hard_coded/Mmakefile:
Add the new test case, and sort the names of the tests.
Estimated hours taken: 24
Branches: main
Some work towards getting the "browser" directory to build in grade java.
In particular, this is a step towards fixing a problem in the Java
back-end with sub-modules. When compiling code that uses sub-modules,
we run up against a Java restriction that a class which is in a package
is not allowed to have the same name as the package. The work-around
is to use names starting with an uppercase letter for Java class names,
and names starting with a lower-case letter for Java package names.
XXX This diff is a partial step: it uses names starting with an
uppercase letter for Java class names that correspond to Mercury types.
It does not yet use an uppercase letter for Java classes that correspond
to Mercury modules.
XXX With this diff, we just flip the case of the initial letter,
which just works around the problem by avoiding the clashing cases,
rather than eliminating them. We should use a more complicated mangling
that eliminates the problem completely, e.g. map lowercase Mercury names
to uppercase, map uppercase Mercury names to "U_" followed by the name.
compiler/mlds_to_java.m:
Output type names with an initial uppercase letter.
compiler/mlds.m:
Add a new enumeration type qual_kind, with values type_qual
and module_qual.
Add a qual_kind field to the fully_qualified_type type.
Add a qual_kind argument to the append_class_qualifier function,
and if the qual_kind is module_qual, adjust the case of the
qualifier appropriately for the back-end.
compiler/ml*.m:
compiler/rtti_to_mlds.m:
Fill in the new qual_kind field, and pass qual_kind to
append_class_qualifier.
library/builtin.m:
library/private_builtin.m:
library/type_desc.m:
library/io.m:
library/rtti_implementation.m:
Use type names with an initial uppercase letter.
browser/Mmakefile:
Work around problems where Java compilers don't like the file names
generated by mmc for code using sub-modules.
For IL and Java, build with --allow-stubs --no-warn-stubs.
browser/declarative_execution.m:
Give a Java definition for the "proc_layout" type.
This is needed to avoid compilation errors in grade java.
Estimated hours taken: 4
Branches: main
Provide a mechanism for declaring foreign types that can be operated on by
compare_representation. The intended use of the mechanism is to declare
a foreign type to represent proc_layouts in the declarative debugger,
as part of the representation of atoms; since atoms are keys in maps
in the oracle, they are input to compare_representation.
Since we don't want the result of compare_representation to change as
execution proceeds, we require an assertion that the foreign value is
stable, i.e. that the value of the foreign type variable completely
determines the data it points to, directly and indirectly. Proc_layouts
are static, so this is not a problem. Being able to do the comparison
requires the foreign type to be an integral type or a pointer, which
is what the existing can_pass_as_mercury_type assertion promises.
The stability is promised by a new assertion.
For foreign types that have both assertions, we use a new type_ctor_rep,
which differs from the existing type_ctor_rep for foreign types by doing
a real comparison instead of an abort in compare_representation.
doc/reference_manual.texi:
Document the new kind of assertion.
compiler/prog_data.m:
Add the new kind of assertion.
compiler/prog_io_pragma.m:
Parse the new kind of assertion.
compiler/rtti.m:
Add the representation of the new type_ctor_rep. Factor out the
stability of c_pointers as well as foreign types.
compiler/type_ctor_info.m:
Generate the new type_ctor_rep for types with both assertions.
compiler/foreign.m:
Export a predicate for use by type_ctor_info.m.
compiler/mercury_to_mercury.m:
Print the new assertion.
compiler/*.m:
Minor changes to conform to the diffs above.
Use state variable notation.
library/rtti_implementation.m:
Handle the new type_ctor_rep.
runtime/mercury_mcpp.h:
runtime/mercury_type_info.h:
java/runtime/TypeCtorRep.java:
Add the new type_ctor_rep to the runtime.
runtime/mercury_mcpp.h:
runtime/mercury_type_info.h:
compiler/type_ctor_info.m:
Increment the rtti version number.
When we rely on the availability of this new capability,
we should add a test for the new rtti version number to configure.in.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
runtime/mercury_ml_expand_body.h:
runtime/mercury_term_size.h:
Handle stable foreign types the same way as other foreign types.
runtime/mercury_deep_copy_body.h:
runtime/mercury_tabling.h:
runtime/mercury_unify_compare_body.h:
Handle stable foreign types in a useful manner, relying on the
assertions behind them.
tests/hard_coded/stable_foreign.{m,exp}:
A test case for the handling of values of a stable foreign type.
tests/hard_coded/Mmakefile:
Enable the new test case.
Estimated hours taken: 30
Branches: main
Implement RTTI for the Java-backend (incomplete)
java/runtime/PseudoTypeInfo.java:
java/runtime/TypeCtorInfo_Struct.java:
java/runtime/TypeInfo_Struct.java:
Implement the `unify' operation for these classes. This implementation
actually just compares them.
library/rtti_implementation.m:
Document a bug in notag_functor_arg_type/1
Define the foreign type of `type_layout' as `TypeLayout' in Java.
Correct an off-by-one error in type_ctor_and_args/3.
Implement deconstruct/8 for TypeCtorRep = enum.
Implement the following predicates in Java:
get_var_arity_typeinfo_arity/1
get_pti_from_arg_types/2
typeinfo_is_variable/2
get_type_ctor_info/1
get_primary_tag/1
get_remote_secondary_tag/1
ptag_index/2
sectag_locn/1
du_sectag_alternatives/2
type_info_index/2
type_ctor_arity/1
type_ctor_rep/1
type_ctor_module_name/1
type_ctor_name/1
type_ctor_functors/1
type_layout/1
unsafe_cast/1
du_functor_desc/3
du_functor_name/1
du_functor_arity/1
du_functor_arg_type_contains_var/1
du_functor_sectag_locn/1
du_functor_primary/1
du_functor_secondary/1
du_functor_ordinal/1
du_functor_arg_types/1
du_functor_arg_names/1
du_functor_exist_info/1
enum_functor_desc/3
enum_functor_name/1
enum_functor_ordinal/1
notag_functor_desc/3
notag_functor_name/1
notag_functor_arg_type/1
notag_functor_arg_name/1
null/1
null_string/0
unsafe_get_enum_value/1
library/type_desc.m:
Implement the following procedures for Java:
type_of/1
has_type/1
type_ctor_and_args/3
type_ctor_name_and_arity/4
Implement the Java classes `type_desc_0' and `type_ctor_desc_0'.
Estimated hours taken: 1.25
Branches: main
Another step towards implementing RTTI support for Java.
library/rtti_implementation.m:
Add Java `foreign_type' declarations for all the abstract types
defined here, and provide Java `foreign_proc' definitions for
get_type_info and high_level_data.
Estimated hours taken: 0.1
Branches: main
library/rtti_implementation.m:
Swap the order of some C# statements in typeinfo_is_variable/2
so that the line which can cause an exception occurs first.
Estimated hours taken: 2
Branches: main
Fix a bug where the null function was returning an object, while it
was meant to return a string. This lead to failures when the mercury
generated code attempted to do a "castclass string".
library/rtti_implementation.m:
Rename null to null_string and make it return a string.
Estimated hours taken: 2
Branches: main
Begin porting the the library just to use C# as its foreign_proc
language.
library/array.m:
library/char.m:
library/exception.m:
library/float.m:
library/int.m:
library/math.m:
library/private_builtin.m:
library/rtti_implementation.m:
library/std_util.m:
Trivial changes to convert MC++ to C#.
library/table_builtin.m:
Delete some unused MC++ functions.
Estimated hours taken: 2
Branches: main
Delete the univ type_ctor_rep, since we haven't used it in a long time,
and add two new type_ctor_reps: one for subgoals, so that they won't have
to be treated specially when deconstructed, and one for a future type,
stable_c_pointer, which is the same as c_pointer except that it guarantees
that the entire data structure it points to, directly and indirectly is
read only, which means that its values can be tabled. The intention is
to use stable_c_pointers to represent robdds.
runtime/mercury_type_info.h:
Make the change above.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
runtime/mercury_deep_copy_body.h:
runtime/mercury_ml_expand_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle the two new type_ctor_reps, and delete the code handling univs.
compiler/mlds_to_gcc.m:
java/runtime/TypeCtorRep.java:
library/private_builtin.m:
runtime/mercury_mcpp.h:
runtime/mercury_mcpp.cpp:
Update the list of type_ctor_reps, including fixing some old errors
in some files.
library/rtti_implementation.m:
Update the list of type_ctor_reps, and modify the routines that
interpret the RTTI accordingly.
Estimated hours taken: 4
Branches: main
Add a facility for recording boolean flags in the RTTI structures
of type constructors. At the moment, the only flag records whether
the type constructor has a tag value reserved for HAL variables.
The flag is not used yet.
runtime/mercury_type_info.h:
Add the extra field if MR_TYPE_CTOR_INFO_HAS_FLAG is defined.
(The #ifdef will be deleted once bootstrapping is complete.)
runtime/mercury_mcpp.h:
Add the extra field, since it will be needed after bootstrapping.
compiler/llds_out.m:
compiler/mlds_to_c.m:
Define MR_TYPE_CTOR_INFO_HAS_FLAG for bootstrapping.
compiler/rtti.m:
Add the field to the backend-independent RTTI description of
type_ctor_infos, together with its encoding function.
compiler/type_ctor_info.m:
Gather the information about the flags, for use when constructing
the RTTI structure.
compiler/rtti_out.m:
Add the flag field to the type_ctor_info structure for the LLDS backend.
compiler/rtti_to_mlds.m:
Add the flag field to the type_ctor_info structure for the MLDS
backends.
compiler/mlds_to_gcc.m:
Add the flag field to the type_ctor_info structure for the gcc backend.
library/rtti_implementation.m:
Add the flag field to list of fields of the type_ctor_info structure.
Estimated hours taken: 4
Branches: main
library/*.m:
Delete Mercury clauses that just call sorry/1.
I applied this change to all files except the following:
rtti_implementation.m (because in that case, there is no C
implementation) and profiling_builtin.m and table_builtin.m
(because new back-ends needn't support profiling or tabling;
the warnings with `--warn-stubs' for those would be just noise.)
library/array.m:
Provide C# code for the (in, array_uo) mode of array__copy/2,
by copying the code for the (array_ui, array_uo) mode.
library/math.m:
Provide Mercury implementations of some of the math functions.
Estimated hours taken: 0.5
Branches: main
library/rtti_implementation.m:
Fix a bug introduced by petdr in revision 1.38: there were some
type errors in the C and MC++ code for null/0 and null/1, which
resulted in warnings from GCC (and potentially errors from other
C compilers).
Estimated hours taken: 14
Branches: main
Change the compiler and tools so that `.' and not `:' is now used as the
module separator in all output.
Infix `.' now has associativity yfx and priority 10.
NEWS:
Report the change.
configure.in:
Amend the test for an up-to-date Mercury compiler to check whether
it recognises `.' as a module qualifier.
compiler/code_gen.m:
compiler/error_util.m:
compiler/hlds_out.m:
compiler/prog_out.m:
compiler/prog_util.m:
compiler/rl_exprn.m:
compiler/rl_gen.m:
compiler/source_file_map.m:
compiler/unused_args.m:
library/io.m:
library/rtti_implementation.m:
library/type_desc.m:
runtime/mercury_debug.c:
runtime/mercury_deconstruct.c:
runtime/mercury_stack_trace.c:
Change `:' to `.' as module separator for output.
compiler/mercury_to_mercury.m:
compiler/prog_io_typeclass.m:
As above.
Fixed a bug where `.' was not being recognised as a module separator.
doc/reference_manual.texi:
Report the change.
library/term_io.m:
Ensure that infix `.' is written without surrounding spaces.
tests/hard_coded/dot_separator.m:
tests/hard_coded/dot_separator.exp:
tests/hard_coded/Mmakefile:
Test case added.
Estimated hours taken: 16
Branches: main
Implement construct__get_functor/5 and construct__get_functor/6 on the
IL backend.
library/construct.m:
Forward get_functor/5 and get_functor/6 to the respective
calls in rtti_implementation.
library/rtti_implementation.m:
Implement get_functor/5 and get_functor/6.
Implemenent all the access predicates for du_functor_desc,
enum_functor_desc and notag_functor_desc in a type-safe
manner.
Estimated hours taken: 0.1
Branches: main
library/rtti_implementation.m:
Back out the change to make rtti_implementatation:type_info
and rtti_implementatation:type_ctor_info equivalent to
type_desc:type_desc to type_desc:type_ctor_desc.
See runtime/mercury_type_desc.h for why they cannot be
equivalent.
Estimated hours taken: 2
Branches: main
Implement construct__num_functors in Mercury.
libray/rtti_implementation.m:
Implement num_functors in Mercury.
Make type_info and type_ctor_info be synonyms for type_desc
and type_ctor_desc, seeing that they are.
library/construct.m:
Call the rtti_implementation version of num_functors.
Estimated hours taken: 0.5
Branches: main
library/rtti_implementation.m:
Change handle_usereq_type so that we explicitly list in the
mode the type_ctor_reps that we handle, and move the
calculation of the base type_ctor_rep into handle_usereq_type.
Estimated hours taken: 1
Branches: main
library/rtti_implementation.m:
library/deconstruct.m:
Add the ability to handle noncanonical types.
library/deconstruct.m:
Note that the cc_nondet modes of limited_deconstruct_idcc of
univ_arg_idcc are incorrect. These two predicates need to be
altered so that they return maybe(result) so that we can make
them cc_multi.
Estimated hours taken: 2
Branches: main
library/rtti_implementation.m:
Put the framework in place for handling noncanonical terms.
Handle the specific case of types with a user-defined equality.
Estimated hours taken: 3
Branches: main
Implement compare and unify for tuples and handle variable arity
type_infos in rtti_implementatation.
library/rtti_implementation.m:
Implement compare and unify for tuples.
Implement compare_collapsed_type_infos for the case where the
type_infos are variable arity.
Handle variable arity type_infos in type_ctor_and_args.
Estimated hours taken: 2
Branches: main
library/rtti_implementation.m:
Implement the trivial to implement branches of deconstruct.
Mark all the noncanonical branches to remind me that they need
to be handled specially.
Estimated hours taken: 8
Branches: main
Fix bugs in get_arg when used with high-level data on the il backend.
These bugs fixed in this change were exercised by the first two io__write's
in `tests/hard_coded/typeclasses/existential_rtti.m'.
library/rtti_implementation.m:
Fix a bug where the number of extra args in a functor where
being calculated according to whether or not a particular arg
of that functor was an existentially quantified type variable,
instead of just calculating the number of extra args from the
information in the exist_info for that functor when it exists.
Fix a bug where with high-level data the type of the secondary
tag doesn't matter for determing the offset to find a functors
arg.
Estimated hours taken: 3
Branches: main
Fix a bug in C# implementation get_subterm.
library/rtti_implementation.m:
Fix a bug where for the high-level data case we weren't
indexing into the array after any extra arguments.
s/TagOffset/ExtraArgs/ as IMHO the new name is more
descriptive.
Estimated hours taken: 3
Branches: main
Fix a bug where `mercury.dll' was not being found by the C# compiler.
when you configured with a non-MS C compiler. This bug broke
tests/hard_coded/foreign_type in grade il.
configure.in:
bindist/bindist.build_vars.in:
Rename CYGPATH as FIX_PATH_FOR_CC.
scripts/Mmake.vars.in:
Rename CYGPATH as FIX_PATH_FOR_CC,
and add new variables FIX_PATH_FOR_CL and FIX_PATH_FOR_CSC.
The new variables are currently hard-wired as `cygpath -w',
since currently we only support the MS versions of CL and CSC.
Also, change the definition of MERC_DLL_DIR to use $(GRADE)
rather than hard-coding "ilc".
scripts/Mmake.rules:
Use the new variables, rather than $(CYGPATH).
Also, update various comments, and delete the unnecessary version
number from the MS_VC7_INCLUDES_DIR and MS_VC7_INCLUDES variable
names.
scripts/mmake.in:
Use the new variables, rather than $(CYGPATH).
Estimated hours taken: 32
Branches: main
Another step towards RTTI in Mercury.
This step redefines the representation of type_ctor_infos inside the compiler
to be identical to the representation we will need for efficient interpretation
of RTTI data structures in Mercury, following on from an earlier step which
did the same for (pseudo)typeinfos.
Instead of the type_ctor_info being broken down into its components in
type_ctor_info.m, the breakdown process is now performed in rtti_out.m (for the
LLDS backend) and rtti_to_mlds.m (for the MLDS backend). Eventually, the IL and
Java backends will stop using rtti_to_mlds.m for this purpose, and will instead
write out the type_ctor_data structures as static data to be interpreted
directly.
We now predefine the C types representing type_info and pseudo_type_infos
for types of arity up to 20 for the LLDS C backend as well as for the
MLDS C backend. The LLDS backend can define them for higher arities
on demand; the MLDS backend (for now) still cannot.
runtime/mercury_type_info.h:
To be able to represent all the kinds of types we now support
- add a data structure for converting values of reserved_addr types
from their printable representation to their internal representation
(it was previously missing), and
- add a type_ctor_rep to represent foreign types.
Add missing MR_ prefixes on some field names.
Add typedefs for all the types that the rtti_names can refer to.
There were already such typedefs in runtime/mercury.h for the MLDS
grades, we now have them for the LLDS grades too.
Predefine the C types representing type_info and pseudo_type_infos
for types of arity up to 20. There were already such typedefs in
runtime/mercury.h for the MLDS grades, we now have them for the
LLDS grades too.
runtime/mercury.h:
Delete the typedefs that are now in mercury_type_info.h.
runtime/mercury.h:
Delete the definitions of the C types representing type_info and
pseudo_type_infos, since these are now in mercury_type_info.h.
#include mercury_type_info.h.
compiler/rtti.m:
Add new, purely Mercury data structures for representing
type_ctor_infos and their components, designed both for efficient
interpretation and as a source for the generation of static data
structures in C.
This entailed deleting most of the alternatives of the rtti_data type
while preserving their rtti_name equivalents; the deleted alternatives
represent tables are no longer created in type_ctor_info.m but which
are created dynamically in rtti_out.m and rtti_to_mlds.m (which need
a way for one table to refer to another).
Centralize the correspondence between rtti_names and the C and Java
types of the corresponding structures (the C and Java names differ in
prefixes only). Among other things, this remove the double maintenance
problem we have previously with the LLDS and MLDS backends maintaining
their own maps of the correspondence.
Add utility predicates on the new data structures for use by both
rtti_out.m and rtti_to_mlds.m.
compiler/hlds_module.m:
Always store the ids of unification and comparison procedures in
type_ctor_gen_infos, to simplify their handling.
compiler/type_ctor_info.m:
Generate the new data structures for representing type_ctor_infos.
Conform to the changed data structures for type_ctor_gen_infos.
compiler/rtti_out.m:
compiler/rtti_to_mlds.m:
Rewrite substantial parts of these modules to convert the new data
structures for representing type_ctor_infos to sets of discrete
structures dynamically.
Most of the dynamically created structures are unique by construction,
but this is not true for typeinfos and pseudo-typeinfos. Therefore
add mechanisms to ensure that we don't generate redundant structures
representing typeinfos and pseudo-typeinfos.
compiler/mlds_to_c.m:
compiler/mlds_to_java.m:
Use the standard mechanisms for creating C and Java type names.
compiler/mlds_to_gcc.m:
Conform to the changed data structures in rtti.m and
mercury_type_info.h.
compiler/opt_debug.m:
Conform to the changed data structures in rtti.m.
compiler/dead_proc_elim.m:
Conform to the changed data structures for type_ctor_gen_infos.
compiler/pseudo_type_info.m:
Add a predicate to construct a representation of a type that may or may
not be ground.
compiler/mlds_to_gcc.m:
java/runtime/TypeCtorRep.java:
library/private_builtin.m:
library/rtti_implemenation.m:
runtime/mercury_mcpp.{cpp,h}:
Add the type_ctor_rep for foreign types to the lists of type_ctor_reps.
library/construct.m:
library/deconstruct.m:
Add missing MR_ prefixes on field names.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
runtime/mercury_deep_copy_body.h:
runtime/mercury_ml_expand_body.h:
runtime/mercury_tabling.c:
runtime/mercury_type_info.c:
runtime/mercury_unify_compare_body.h:
Handle the type_ctor_rep for foreign types.
Add missing MR_ prefixes on field names.
library/list.m:
Add two utility predicates, is_empty and is_not_empty, for use with
higher order code.
NEWS:
Mention the new predicates in list.m. Delete a duplicate entry.
Estimated hours taken: 120
Branches: main
Allow the library to compile in the grade il (high level data).
compiler/ml_util.m:
Add more types which need to be represented using the low level
representation because of how they are handled in the library.
compiler/mlds_to_il.m:
Remove an XXX which is no longer necessary.
Add the heap_pointer type to the list of types whose RTTI is defined
by hand.
library/exception.m:
Move the definition of Exception from the runtime to the local module.
This is needed for when univ/0 is no longer represented as a low level
type.
runtime/mercury_mcpp.cpp:
Remove the implementation of Exception that is now in exception.m.
library/Mmakefile:
The lowlevel Exception type is now defined in the library not the
runtime, so add rules to ensure that the foreign code is built in
the correct order.
library/io.m:
Reimplement io__stream as a foreign_type. This makes the code more
type safe and avoids problems with the different representation of
the io__stream type when using high and low level data.
Change io__command_line_arguments so that it throws an exception
when we use high level data, as I am yet to work out how to access
high level lists.
library/rtti_implementation.m:
Add a comment that get_subterm doesn't work with high level data.
Fix some bugs with the default versions of type_ctor_compare_pred and
type_ctor_unify_pred.
library/sparse_bitset.m:
Remove the foreign_proc implementation of make_bitset_elem as it
will not work with both data representations and their is a Mercury
implementation.
library/string.m:
Remove the foreign_proc implementation of all the predicates which
manipulate lists as they all have a Mercury implementation, as I am yet
to work out how to access high level lists.
Add a Mercury implementation for string__join_list.
runtime/mercury_mcpp.h:
library/array.m:
library/builtin.m:
library/private_builtin.m:
library/type_desc.m:
Define and use typedefs where appropiate for type_info/0, type_info/1,
comparison_result/0 and univ/0, as there representation may change in
the future between using high level and low level data.
Estimated hours taken: 20
Branches: main
The tag bootstrap_20020613_intermod can be used to get a compiler which
compiles this change.
configure.in:
Test that the option --bug-intermod-2002-06-13 exists. This signifies
that the a bug in intermodule optimization for predicates which are
defined as both mercury and foreign code clauses.
library/array.m:
library/benchmarking.m:
library/builtin.m:
library/char.m:
library/construct.m:
library/deconstruct.m:
library/float.m:
library/gc.m:
library/int.m:
library/io.m:
library/library.m:
library/math.m:
library/private_builtin.m:
library/profiling_builtin.m:
library/rtti_implementation.m:
library/sparse_bitset.m:
library/std_util.m:
library/store.m:
library/table_builtin.m:
library/time.m:
library/type_desc.m:
Define a mercury version of every pragma foreign_proc.
Remove any foreign_procs which are not implemented yet.
Estimated hours taken: 0.2
Branches: main
library/*.m
Back out Pete's unreviewed change from yesterday.
It doesn't compile without a recent bug fix, but no
CVS tag was added.
Estimated hours taken: 16
Branches: main
Define a mercury version of every pragma foreign_proc, and remove any
foreign_procs which just throw an exception that the code is not implemented.
library/array.m:
library/benchmarking.m:
library/builtin.m:
library/char.m:
library/construct.m:
library/deconstruct.m:
library/exception.m:
library/float.m:
library/gc.m:
library/int.m:
library/io.m:
library/library.m:
library/math.m:
library/private_builtin.m:
library/profiling_builtin.m:
library/rtti_implementation.m:
library/sparse_bitset.m:
library/std_util.m:
library/store.m:
library/string.m:
library/table_builtin.m:
library/time.m:
library/type_desc.m:
Define a mercury version of every pragma foreign_proc, and remove any
foreign_procs which just throw an exception that the code is not
implemented.
Estimated hours taken: 6
Branches: main
Fix test case failures involving type_ctor_descs in .rt grades.
The cause of the failures was that the type_ctor_rep for type_ctor_descs (which
happens to be 35) does not fit into a signed 8-bit integer in .rt grades,
since those grade require 2 bits for a primary tag (3 bits on 64-bit machines).
The fix is to make the type_ctor_rep field in type_ctor_infos 16 bits in size.
To maintain alignment, this requires swapping that field with the num_ptags
field.
The second part of this change will remove the bootstrapping code and raise
the binary compatibility version number. That part cannot be committed until
this part has been installed on all our machines.
runtime/mercury_type_info.h:
Define a new version of the type_ctor_info structure with this swap
and size increase. Provide backward compatibility for bootstrapping.
runtime/mercury_mcpp.h:
library/rtti_implementation.m:
java/runtime/TypeCtorInfo_Struct.m:
Make the same change.
compiler/rtti_out.m:
compiler/rtti_to_mlds.m:
compiler/mlds_to_gcc.m:
Generate the new type_ctor_info structure.
compiler/llds_out.m:
compiler/mlds_to_c.m:
Generate a macro that selects the new version of the type_ctor_info
structure.
compiler/type_ctor_info.m:
Update the type_ctor_info version number.
Estimated hours taken: 40
Branches: main
Fix the RTTI of type_descs and type_ctor_descs. Make comparisons between
type_ctor_descs and type_ctor_infos (and therefore between type_descs and
type_infos) more predictable and consistent across backends by basing them
on programmer-visible attributes instead of accident of location in the
executable.
runtime/mercury_type_desc.[ch]:
Implement unification and comparison functions for type_ctor_descs.
(The unification and comparison functions for type_infos also double
as the unification and comparison functions for type_descs.)
Make the comparison function work on the module name, type name and
arity instead of the address of the type_ctor_info structure. This
ensures consistency across back ends.
Add some useful macros.
runtime/mercury_type_info.[ch]:
Make the comparison function on type_ctor_infos also work on module
name, type name and arity. Since this makes comparison slower, add
specialized unification functions for type_infos and type_ctor_infos.
runtime/mercury_type_info.h:
runtime/mercury_mcpp.{h,cpp}:
runtime/mercury.h:
library/private_builtin.m:
library/rtti_implementation.m:
java/runtime/TypeCtorRep.java:
compiler/mlds_to_gcc.m:
Add type_ctor_reps for type_descs and type_ctor_descs. Type_ctor_descs
definitely need it, since their representation is very low level and
not shared with anything else. Type_descs could use the type_ctor_rep
of type_infos, since type_descs and type_infos share the same
representation at the moment. However, we add a new one because
profiling cares about the conceptual distinction between type_infos
and type_descs.
library/type_desc.m:
Delete the Mercury "definition" of type_desc, because it is misleading.
Implement it as a builtin type.
runtime/mercury.[ch]:
Implement type_ctor_desc as a builtin type.
Add missing implementations of unify/compare on type_ctor_infos.
runtime/mercury_deconstruct.c:
runtime/mercury_ml_expand_body.h:
Implement deconstruction for type_descs and type_ctor_descs.
runtime/mercury_ho_call.c:
runtime/mercury_unify_compare_body.h:
Implement unify and compare for type_descs and type_ctor_descs.
Implement unify for type_infos, type_ctor_infos, type_descs and
type_ctor_descs by calling the relevant unification function,
not the relevant comparison function, since the unification
function will be faster.
runtime/mercury_deep_copy_body.h:
runtime/mercury_construct.c:
runtime/mercury_tabling.c:
Minor changes to handle type_descs and type_ctor_descs.
trace/mercury_trace_vars.c:
Enable the printing of type_descs and type_ctor_descs.
tests/debugger/type_desc_test.{m,inp,exp,exp2}:
New test case to check the printing of type_descs and type_ctor_descs.
tests/debugger/Mmakefile:
Enable the new test case.
tests/hard_coded/type_ctor_desc_manip.{m,exp}:
New test case to check the deconstruction and comparison of type_descs
and (especially) type_ctor_descs. Before this change, we got different
results for comparisons of type_ctor_descs, results that were
inconsistent with the results of comparisons of the type_descs
that the type_ctor_descs were derived from.
tests/hard_coded/Mmakefile:
Enable the new test case.
Estimated hours taken: 1
Branches: main
Various changes to get the library to compile in the ilc grade.
library/deconstruct.m:
Add a missing private_builtin module_specifier to the calls to
sorry.
library/float.m:
library/int.m:
library/math.m:
library/rtti_implementation.m:
Add missing promise_pures to the foreign_procs.
library/private_builtin.m:
Add a predicate imp which is a do nothing predicate which is impure.
This is used to make calls to sorry/1 impure when needed.
library/type_desc.m:
Add calls to private_builtin__sorry/1 where needed.
Get namespace qualifiers correct for calls to
ML_call_rtti_compare_type_infos.
runtime/mercury_il.il:
Add get_ftn_ptr_heap_pointer_unify and get_ftn_ptr_heap_pointer_compare.
Estimated hours taken: 8
Branches: main
Move the RTTI-related parts of std_util.m to three new modules in the standard
library, and (in the case of embedded C code) to new modules in the runtime.
The main reason for this is to allow a reorganization of some of the
RTTi-related functionality without breaking backward compatibility. However,
the new arrangement should also be easier to maintain.
Use a separate type_ctor_rep for functions, to distinguish them from predicates
for RTTI code. (At one point, I thought this could avoid the need for the
change to the initialization files mentioned below. It can't, but it is a good
idea in any case.)
library/std_util.m:
Remove the functionality moved to the new modules, and replace them
with type equivalences and forwarding code. There are no changes in
the meanings of the user-visible predicates, with two exceptions.
- First, the true, equivalence-expanded names of what used to be
std_util:type_desc and std_util:type_ctor_desc are now
type_desc:type_desc and type_desc: type_ctor_desc.
- Second, deconstructing a function term now yields
"<<function>>" instead of "<<predicate>>".
The intention is that the RTTI predicates in std_util.m will continue
to work in a backwards-compatible manner for the near future, i.e. as
the new modules are updated, the code in std_util will be updated to
maintain the same functionality, modulo improvements such as avoiding
unwanted exceptions. When the RTTI functionality in the other modules
has stabilised, the RTTI predicates in std_util.m should be marked
obsolete.
The exported but non-documented functionality of std_util has been
moved to one of the new modules without forwarding code, with one
of the moved predicates being turned into the function it should have
been in the first place.
library/construct.m:
library/deconstruct.m:
library/type_desc.m:
Three new modules for the code moved from std_util.m.
library/library.m:
compiler/modules.m:
Record the names of the three new library modules.
runtime/mercury.[ch]:
compiler/mlds_to_il.m:
Record that type_desc is now in type_desc.m, not std_util.m.
compiler/static_term.m:
Import the deconstruct module, since we are using its undocumented
facilities.
runtime/Mmakefile:
Mention the two new modules.
runtime/mercury_construct.[ch]:
runtime/mercury_type_desc.[ch]:
Two new modules holding the C functions that used to be in foreign_code
in std_util, now using MR_ instead of ML_ prefixes, and being more
consistent about indentation.
runtime/mercury_type_info.h:
Add a new type_ctor_rep for functions, separate from predicates.
(It reuses the EQUIV_VAR type_ctor_rep, which hasn't been used
in ages.)
Use type_ctor_reps to distinguish between the type_ctor_infos of
pred/0 and func/0. However, to create higher order typeinfos, we
still need to know the addresses of the type_ctor_infos for
pred/0 and func/0, and we still need to know the address of the
type_ctor_info for tuples to create typeinfos for tuples. Since
these three type_ctor_infos are defined in the library,
we cannot access them directly from the runtime. We therefore need
to access them indirectly in the usual manner, via address_of
variables initialized by mkinit-generated code.
library/builtin.m:
library/private_builtin.m:
library/rtti_implementation.m:
runtime/mercury.c:
runtime/mercury_mcpp.{h,cpp}:
java/TypeCtorRep.java:
Updates to accommondate the new function type_ctor_rep.
runtime/mercury_type_info.[ch]:
Add some functions from foreign_code in std_util that fit in best here.
runtime/mercury_ml_expand_body.h:
runtime/mercury_tabling.h:
runtime/mercury_unify_compare_body.h:
Delete the code for handling EQUIV_VAR, and add code for handling
functions.
runtime/mercury_init.h:
runtime/mercury_wrapper.[ch]:
Add three variables holding the address of the type_ctor_infos
representing functions, predicates and tuples.
util/mkinit.c:
Fill in these three variables.
tests/general/accumulator/construct.{m,exp}:
tests/general/accumulator/deconstruct.{m,exp}:
tests/hard_coded/construct.{m,exp}:
Rename these tests by adding a _test at the ends of their names,
in order to avoid collisions with the names of the new standard library
modules. The test cases have not changed, with the exception of the :-
module declaration of course.
tests/general/accumulator/Mmakefile:
tests/general/accumulator/INTRODUCED:
tests/hard_coded/Mmakefile:
Record the name changes.
tests/hard_coded/existential_float.exp:
Updated the expected output to reflect that deconstructions now print
"<<function>>" instead of "<<predicate>>" when appropriate.
tests/hard_coded/higher_order_type_manip.exp:
Updated the expected output to reflect the new name of what used to be
std_util:type_desc.
trace/mercury_trace_browse.c:
trace/mercury_trace_external.c:
trace/mercury_trace_help.c:
#include type_desc.h instead of std_util.h, since the C functions
we want to call are now defined there.
trace/mercury_trace_vars.c:
Update to account for the movement of type_desc from std_util to
type_desc, and ensure that we don't refer to any type_ctor_infos
in MLDS grades.
Estimated hours taken: 12
Branches: main
Fix a bug by distinguishing the type_ctor_reps of type_infos and
type_ctor_infos. The type_ctor_infos of types with nonzero arity
cannot be printed, copied etc like type_infos; any attempt to do so
causes a core dump.
For similar reasons, add a separate type_ctor_rep for
base_typeclass_infos separate from typeclass_infos.
runtime/mercury_type_info.h:
runtime/mercury_mcpp.h:
compiler/mlds_to_gcc.m:
library/rtti_implementation.m:
java/TypeCtorRep.java:
Add new type_ctor_reps for type_ctor_infos and base_typeclass_infos.
library/private_builtin.m:
runtime/mercury.c:
Use the new type_ctor_reps in the type_ctor_infos of the builtin types
type_ctor_info and base_typeclass_info.
runtime/mercury_type_info.[ch]:
Add a function for comparing type_ctor_infos.
Move some interface documentation from the source file to the header
file.
runtime/mercury_deep_copy_body.h:
Add code to handle the new type_ctor_reps.
Simplify some code.
Make the whole file use 4-space indentation.
library/std_util.m:
runtime/mercury_ml_expand_body.h:
runtime/mercury_unify_compare_body.h:
runtime/mercury_ho_call.c:
runtime/mercury_tabling.c:
Add code to handle the new type_ctor_reps.
Estimated hours taken: 12
Branches: main
This is the first half of a change that removes redundant fields from
type_ctor_info structures.
configure.in:
Do not require an exact match on the RTTI version number.
runtime/mercury_type_info.h:
Update the RTTI version number.
Add the new definition of type_ctor_infos.
Add prefixes to the fields in type_ctor_infos that did not already have
them.
Provide macros to access the fields in the changed part of
type_ctor_infos in a way that works with both the old and new
type_ctor_info structures.
Move some stuff so that macros that logically belong together are next
to each other.
runtime/mercury_mcpp.h:
Update the RTTI version number and the macros for defining
type_ctor_infos.
library/rtti_implementation.m:
Update the mechanism for access to type_ctor_info fields.
Add prefixes to field names and use RTTI-version-independent macros
as necessary.
compiler/hlds_module.m:
compiler/rtti.m:
Delete obsolete fields from the terms from which type_ctor_info
structures are derived.
compiler/dead_proc_elim.m:
Minor changes to conform to this change in data structure.
compiler/type_ctor_info.m:
Minor changes to conform to this change in data structure.
Update the RTTI version number.
compiler/rtti_out.m:
compiler/rtti_to_mlds.m:
Output the new type_ctor_info structure.
compiler/llds_out.m:
compiler/mlds_to_c.m:
Emit a #define to select the new type_ctor_info structure.
library/std_util.m:
runtime/mercury.c:
runtime/mercury_deconstruct.c:
runtime/mercury_deep_copy_body.h:
runtime/mercury_ho_call.c:
runtime/mercury_ml_expand_body.h:
runtime/mercury_tabling.c:
runtime/mercury_type_info.c:
runtime/mercury_type_tables.c:
runtime/mercury_unify_compare_body.h:
tests/hard_coded/type_tables.m:
trace/mercury_trace.c:
Add prefixes to field names and use RTTI-version-independent macros
as necessary.
