--no-ansi (mgnuc) and --no-ansi-c (mmc) have not actually done anything for
many years now. Deprecate these options and remove their "use" throughout most
of the Mercury system. (The remaining uses are in the Makefiles for the Boehm
GC, which need to be updated separately.)
Also deprecate the internal compiler option --cflags-for-ansi.
compiler/options.m:
Document that --no-ansi-c is now deprecated.
Document that the internal option --cflags-for-ansi is now
deprecated.
compiler/compile_target_code.m:
Do not pass the ANSI options to the C compiler.
scripts/mgnuc.in:
scripts/mgnuc_file_opts.sh-subr:
Deprecate the --no-ansi option; delete code that no longer does
anything useful.
configure.ac:
Delete the configuration variable CFLAGS_FOR_ANSI; it is only ever
set to be empty. (The comment talks about --no-ansi doing other things
in the mgnuc script. It used to also cause some preprocessor macros
to be defined for compatibility with the system headers on some
platforms -- that has not been the case since 2013.)
doc/user_guide.texi:
Document that --no-ansi-c is deprecated.
bytecode/Mmakefile:
compiler/Mercury.options:
library/Mercury.options:
extras/odbc/odbc.m:
runtime/Mmakefile:
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
tests/hard_coded/Mercury.options:
tests/valid/Mercury.options:
trace/Mmakefile:
util/Mmakefile:
Conform to the above change.
NEWS.md:
Announce the above.
The default optimisation level was implemented by having the
Mercury.config file add a -O<n> option to the DEFAULT_MCFLAGS variable.
This allowed the user to override the default optimisation level
by setting the MERCURY_DEFAULT_OPT_LEVEL environment variable.
Commit 181ada0dbf made it so that -O<n>
options do not reset previously set options. This had the unintended
consequence that any -O<n> options below the default optimisation level
had no effect when passed on the command line or in a Mercury.options
file, because a -O<n> option passed by the user would never undo the
options set by the default optimisation level.
compiler/options.m:
Add new option `--default-opt-level' for use by Mercury.config.
tools/make_optimization_options_end:
Add predicate to parse the value of `--default-opt-level' from the
options table. The option value is a string because the value of the
MERCURY_DEFAULT_OPT_LEVEL environment variable will be passed as
the option value. The existence of the environment variable was
(barely) documented, but the allowable values are not.
Though the user might conceivably have set any Mercury compiler
option in that environment variable, the value was probably only
intended to be a string of the form "-O<int>", and that is all we
will support.
tools/make_optimization_options_middle:
Use `get_default_opt_level'.
compiler/optimization_options.m:
Regenerate this file.
compiler/options_file.m:
Do not automatically add "-O2" to MCFlags.
The comment says this was to set a default optimisation level when
calling the `mercury_compile' binary instead of the `mmc' script,
but `get_default_opt_level' already defaults to optimisation level 2.
scripts/Mercury.config.in:
Pass the value of MERCURY_DEFAULT_OPT_LEVEL using the
`--default-opt-level' option.
The option is disabled by default.
configure.ac:
Add --enable-lto option to the configure script to enable LTO/LTCG.
scripts/mgnuc.in:
scripts/ml.in:
Pass LTO options to the C compiler/linker.
compiler/compile_target_code.m:
compiler/options.m:
scripts/Mercury.config.in:
Add internal options to specify C compiler and linker LTO/LTCG flags.
Add a new internal grade component corresponding to the use of 64-bit integers.
configure.ac:
Test whether we can use unboxed 64-bit integers.
Extend the check for whether previously built C files are compatible with
configure determined settings to cover whether 64-bit integer are boxed
or not.
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
Set the compiler flag for unboxed 64-bit integers if configure determines
they can be used.
runtime/mercury_grade.h:
Add the "ubi64" grade component
configure.ac:
Add configure option --enable-sanitizers.
Mmake.common.in:
scripts/Mercury.config.in:
Add variables to be set when --enable-sanitizers is used.
scripts/mgnuc.in:
scripts/ml.in:
Pass sanitizer options to the C compiler and the linker.
compiler/options.m:
Add options --cflags-for-sanitizers and --linker-sanitizer-flags
for receiving the configuration.
Set --linker-trace-flags and --shlib-linker-trace-flags default
values to empty instead of "-g" (likely copy error).
compiler/compile_target_code.m:
Pass sanitizer options to the C compiler, and the linker when
building an executable or shared library.
runtime/Mmakefile:
trace/Mmakefile:
Pass sanitizer options to linker when building shared libraries.
README.sanitizers:
Add instructions.
For picreg, this is only the first half of the change; it deletes code
that generates references to this grade component. When this diff has been
installed on all our machines, will come the second half, which will delete
the code that understands references to picreg. The delay is needed because
your current installed compiler is still generating such references.
runtime/mercury_grade.h:
Remove both regparm and picreg as grade components.
doc/user_guide.texi:
Remove the (commented out) documentation of picreg; regparm had
no documentation to delete.
runtime/mercury_std.h:
Remove the small bit of code that implemented regparm.
runtime/mercury_conf_param.h:
Don't define MR_PIC_REG.
runtime/machdeps/i386_regs.h:
runtime/mercury_conf_bootstrap.h:
Remove references to picreg.
scripts/canonical_grade.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/mgnuc.in:
scripts/parse_grade_options.sh-subr:
Keep in place the code that accepts picreg grade components,
but make them do nothing. Mark such do-nothing code so that
it can be deleted when this first-half diff has been bootstrapped.
configure.ac:
Delete the autoconfigured variable EXT_FOR_LINK_WITH_PIC_OBJECTS,
which could be set to either 'lpic_o' or just 'o', because it is now
*always* the latter.
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
Remove code that transmitted the value of EXT_FOR_LINK_WITH_PIC_OBJECTS
to the compiler via the --link-with-pic-object-file-extension option.
compiler/options.m:
Keep the --link-with-pic-object-file-extension and --pic-reg options,
but mark them for deletion in the second half of this change.
compiler/compile_target_code.m:
Change the code that dealt with the value of the
--link-with-pic-object-file-extension and --pic-reg options to assume
that the former is always the same as the non-pic file extension,
and that --pic-reg is never needed. The former means that we don't need
to handle link_with_pic as a separate category of object files from
just plain non_pic.
compiler/compute_grade.m:
Keep accepting picreg grades, but mark the code that does this
for deletion.
compiler/make.program_target.m:
compiler/make.module_target.m:
compiler/make.program_target.m:
compiler/make.util.m:
Conform to the changes above.
compiler/mlds_to_il.m:
compiler/mlds_to_ilasm.m:
compiler/mlds_to_managed.m:
compiler/il_peephole.m:
compiler/ilasm.m:
compiler/ilds.m:
Delete the modules making up the MLDS->IL code generator.
compiler/globals.m:
compiler/prog_data.m:
Delete IL as a target and foreign language.
compiler/prog_io_pragma.m:
Delete the max_stack_size/1 foreign proc attribute. This was only
ever required by the IL backend.
compiler/options.m
Delete options used for the IL backend.
compiler/write_deps_file.m:
Don't generate mmake targets for .il files etc.
compiler/*.m:
Conform to the above changes.
compiler/notes/compiler_design.html
compiler/notes/work_in_progress.html
Conform to the above changes.
library/*.m:
Delete IL foreign_proc and foreign_export pragmas.
README.DotNet:
Delete this file.
browser/Mmakefile:
compiler/Mmakefile:
deep_profiler/Mmakefile:
mdbcomp/Mmakefile:
mfilterjavac/Mmakefile:
profiler/Mmakefile:
runtime/Mmakefile:
slice/Mmakefile:
Conform the above changes.
configure.ac:
Don't check that IL is a supported foreign language when performing the
up-to-date check.
Delete the '--enable-dotnet-grades' option.
scripts/Mmake.vars.in:
Delete variables used for the IL backend (and in on case by the Aditi
backend).
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
scripts/Mmake.rules:
scripts/canonical_grade.sh-subr:
tools/bootcheck:
Delete stuff related to the 'il' and 'ilc' grades.
doc/reference_manual.texi:
Delete the documentation of the 'max_stack_size' option.
doc/user_guide.texi:
Delete stuff related to the IL backend.
tests/hard_coded/csharp_test.{m,exp}:
tests/invalid/foreign_type_missing.{m,err_exp}:
tests/valid/csharp_hello.m:
Delete these tests: they are no longer relevant.
tests/hard_coded/equality_pred_which_requires_boxing.m:
tests/hard_coded/foreign_import_module.m:
tests/hard_coded/foreign_import_module_2.m:
tests/hard_coded/foreign_type.m:
tests/hard_coded/foreign_type2.m:
tests/hard_coded/foreign_type3.m:
tests/hard_coded/intermod_foreign_type2.m:
tests/hard_coded/lp.m:
tests/hard_coded/user_compare.m:
tests/invalid/foreign_type_2.m:
tests/invalid/foreign_type_missing.{m,err_exp}:
tests/invalid/foreign_type_visibility.m:
tests/invalid/illtyped_compare.{m,err_exp}:
tests/submodules/external_unification_pred.m
tests/valid/big_foreign_type.m
tests/valid/solver_type_bug.m
tests/valid_seq/foreign_type_spec.m
tests/valid_seq/intermod_impure2.m
Delete IL foreign_procs where necessary.
tests/hard_coded/Mmakefile
tests/invalid/Mercury.options
tests/invalid/Mmakefile
tests/submodules/Mmakefile
tests/valid/Mercury.options
tests/valid/Mmake.valid.common
tests/valid/Mmakefile
tests/valid_seq/Mmakefile
tests/valid_seq/Mercury.options
Conform to the above changes.
The default configuration of Mercury on Windows breaks when using the Java
grade due to the argument we pass to the Java compiler's '-J' option, in order
to set the maximum heap size, not being quoted in the @file we pass to the Java
compiler when '--restricted-command-line' is enabled.
What should be placed in the @file is:
-J"-Xmx1024m"
What we currently put in it is:
-J-Xmx1024m
The reason for this is that the setting of JAVAC_FLAGS_FOR_HEAP_SIZE in
scripts/Mercury.config does not escape the double quotes, consequently they do
not get passed through the Mercury compiler to the aforementioned @file. This
problem was already correctly identified and documented in the comments
accompanying the MERCURY_CHECK_JAVAC_HEAP_SIZE macro in m4/mercury.m4, but the
actual behaviour of that macro is incorrect. In particular, it fails to
account for the fact that the value of JAVAC_FLAGS_FOR_HEAP_SIZE should differ
depending on whether mmake or 'mmc --make' is using that value. The current
value will work for mmake but not with 'mmc --make'
(and '--restricted-command-line').
The fix is to separate the handling of the mmake and 'mmc --make' cases and
correctly escape the version that is put in Mercury.config.
configure.ac:
m4/mercury.m4:
Define separate configuration variables for mmake and 'mmc --make' to
set the Java compiler's maximum heap size.
scripts/Mercury.config.in:
scripts/Mercury.config.bootstrap.in:
scripts/Mmake.vars.in:
Conform to the above change.
configure.ac:
Pass -x to strip when linking an executable against Mercury shared
libraries on Mac OS X.
Make the up-to-date check require {14.01.-beta,rotd}-2014-05-05
or later.
scripts/Mercury.config.in:
Set the default values of --strip-executable-{shared,static}-flags.
We had stopped passing the linker strip flag on Mac OS X because it had
become deprecated and useless there, but we can still strip the binary
with the `strip' tool.
This commit changes compile_target_code.m to do so, but NOT the
`ml' shell script.
compiler/options.m:
doc/user_guide.texi:
Add option --strip-executable-command.
configure.ac:
scripts/Mercury.config.in:
Set --strip-executable-command="strip" on Darwin platforms,
or an empty string elsewhere.
compiler/compile_target_code.m:
Invoke the --strip-executable-command separately after linking
an executable if necessary.
scripts/ml.in:
Fix a bug: use configured value of LD_STRIP_FLAG instead of
assuming "-s".
scripts/Mercury.config.in:
scripts/Mercury.config.boostrap.in:
Add the environment variable MERCURY_TARGET_ARCH, which allows
the compiler's target architecture to be overridden in the
environment.
compiler/options.m:
Add the option --target-arch as a synonym (and eventually, replacement)
for the --fullarch option.
Use -R instead of -r with cp by default.
Fix some documentation errors.
compiler/options.m:
Enable library grade detection by default.
Document the --no-detect-libgrades option.
Make the default install command dir option, -R,
rather than -r. The former is more portable.
scripts/Mercury.config.in:
Do not hardcode the set of library grades at configuration time.
compiler/mercury_compile.m:
Do not clear the library grade set before adding any detected
grades since doing so also prevents additional grades being
specified via the LIBGRADES variable.
doc/user_guide.texi:
Document --no-detect-libgrades.
Replace some uses of `:' as a module qualifier.
Fix a typo: s/outut/output/.
Branches: main, 11.07
Set the host and target environment types at configuration time. By default,
they were both set to "posix" but that is no longer compatible with building
the csharp grade using the Microsoft compiler.
configure.in:
Set the environment type to "cygwin" on Cygwin, to "msys" on MinGW
and to "posix" otherwise. (For Mercury installations that work with
the Windows command interpreter, it will need to be manually set to
"windows".)
scripts/Mercury.config.in:
Set the environment type. (We set the target and host separately
so that is easier for installers to automatically modify this file.)
README.MS-VisualC:
Conform to the above change.
Estimated hours taken: 4
Branches: main, 11.07
The Microsoft C# compiler only accepts paths in the Windows format, so
add code to format file names depending on which host environment we are
compiling and which C# compiler we are using.
compiler/compile_target_code.m:
Convert to file names to use windows paths when required.
compiler/globals.m:
compiler/handle_options.m:
compiler/mercury_compile.m:
compiler/options.m:
doc/user_guide.texi:
m4/mercury.m4:
scripts/Mercury.config.in:
Add code to determine the C# compiler type and pass it to the compiler.
library/Mmakefile:
We no longer need to detect if we are using csc as the compiler
will fix the posix path as part of mmc --make.
Branches: 11.07, main
Improve and update documentation of the MSVC port.
Add batch files for invoking mdb and mprof; avoid problem with mercury.bat.
README.MS-VisualC:
Rewrite this file, it was very much out-of-date.
The major changes are:
+ we now describe how to set up a Cygwin or MSYS shell
with MSVC available.
+ the source distribution now works with MSVC.
+ a list of the limitations of the MSVC port has been added.
+ a description of how to set up the compiler so that it
works from the Windows command prompt has been added.
scripts/mercury/mercury.bat.in:
Delete support for the MERCURY_COMPILER and MERCURY_CONFIG_DIR
enviorment variables; the handling of them in this batch file
doesn't appear to be portable across different versions of
Windows and it's more important that this file work in the
normal case. (Keeping it simple is the way to ensure this.)
scripts/mdb.bat.in:
scripts/mprof.bat.in:
Templates for invoking mdb and mprof on Windows.
(I'm not sure how to reproduce all the functionality of the mdb
script in a batch file, so the command line options provided by
the mdb script aren't currently replicated here.)
configure.in:
scripts/Mmakefile:
Add the new batch files.
scripts/Mercury.config.in:
Use the Windows-style installation prefix on Cygwin systems.
browser/util.m:
Use the conventional name for the I/O state.
Use don't-care variables for the I/O state in foreign procs.
This avoids suprious warnings from MSVC.
reviews.
The configure script now supports the --without-hwloc option to disable the use
of hwloc, even if it is installed.
configure.in:
Allow the use of libhwloc to be disabled with the --without-hwloc option.
Distribute the autoconf macros for pkg-config with Mercury.
This allows mercury to be compiled from CVS on hosts that don't have these
macros in their autoconf installation.
acinclude.m4:
m4/mercury.m4:
Moved acinclude.m4 to m4/mercury.m4. This file contains mercury-specific
macros.
m4/pkg.m4:
Copied pkg.m4 from the autoconf installation on taura. This file contains
pkg-config macros.
INSTALL_CVS:
Mmakefile:
tools/test_mercury:
When calling aclocal pass the -I m4 option.
tools/bootcheck:
Create a link to the m4 directory when setting up stage directories.
Fix static linking with mmc --make and hwloc.
compiler/compile_target_code.m:
Conform to changes in scripts/ml.in (where static linking and hwloc is
already handled correctly).
compiler/options.m:
Create new options so that Mercury.config can tell mmc what options are
needed for linking to hwloc.
scripts/Mercury.config:
Pass hwloc linking options to the compiler.
Packaging Mercury for Debian requires creating some patches to make sure that
Mercury can be built under the control of dpkg-buildpackage. It's recommended
that these patches are pushed upstream (into Mercury) so that everyone can
benefit from them, not just Debian packagers.
Mmake.common.in:
scripts/Mmake.vars.in:
Install Mercury at $DESTDIR/@prefix@, $DESTDIR helps someone setup Mercury
to run from @prefix@ while putting it in $DESTDIR. $DESTDIR/* can easily
be tared up and then deployed on other systems.
Mmakefile:
Makefile:
Pass the $DESTDIR variable to make sub-processes.
scripts/Mercury.config.in:
scripts/Mercury.config.bootstrap.in:
Remove the hash-bang line from these scripts since they are not executable.
This change improves conformance with Debian packaging standards.
Branches: main
Add support for the `csharp' grade to `mmc --make', and make it possible to
install the `csharp' grade with `mmake install'.
Also some miscellaneous fixes.
configure.in:
Require a recent enough bootstrap compiler that recognises C# as a
language for `pragma foreign_type'.
Mmakefile:
Use `mmc --make' to install the standard library in csharp grade.
aclocal.m4:
Search for the Mono C# compiler `gmcs', which is required for generics
at this time. Prefer it over the DotGNU C# compiler, which I have not
tested.
Search for `mono'. If found, it will be used in shell scripts to
launch executables generated via the csharp backend.
Remove "MS_" prefixes on the variables MS_CSC and MS_ILASM, which are
not Microsoft-specific. More importantly, it should be less likely to
make the mistake of adding an extra underscore to CSCFLAGS and
ILASMFLAGS.
README.DotNet:
Conform to variable renamings.
compiler/compile_target_code.m:
Add new linked target types `csharp_executable', `java_launcher' and
`erlang_launcher', instead of overloading `executable'.
Link with `mer_std.dll' and other libraries when generating C#
executables. There is no `mer_rt.dll'.
Pass "/debug" to the C# compiler if `--target-debug' is set.
Create a shell script to launch the executable if necessary.
Delete an unused predicate `standard_library_directory_option'.
compiler/file_names.m:
`.cs' and `.cs_date' are grade-dependent.
compiler/handle_options.m:
Force `.exe' as the executable file extension in csharp grades.
Make the `erlang' grade component imply the same options as MLDS
grades.
compiler/make.m:
Classify executable target types based on the compilation target.
compiler/make.module_target.m:
Handle `mmc --grade csharp --make <target>.dll'.
compiler/make.program_target.m:
Install library DLLs in csharp grades.
Make clean targets remove files for csharp grades.
Conform to changes.
compiler/make.util.m:
Add a stub foreign type.
Conform to changes.
compiler/module_cmds.m:
Factor out code to generate the shell scripts which launch programs
compiled in Java, Erlang and C# grades.
compiler/options.m:
Add `cli_interpreter' option to remember the name of the program which
should be used to run CLI (.NET) programs.
Add C#-related options to the help message.
compiler/options_file.m:
Remove "MS_" prefixes on MS_ILASM_FLAGS and MS_CSC_FLAGS, and remove
the extra underscore before "FLAGS". In all uses of the variables,
they were spelt without the extra underscore.
doc/user_guide.texi:
Document options and file types related to the C# grade.
library/Mmakefile:
Pass `mercury_dotnet.cs' to the C# compiler when building the standard
library. Suppress some warnings.
Allow stubs in this directory for csharp grade.
Conform to variable renamings.
library/builtin.m:
Uncomment foreign language pragmas for C#.
Handle null values in C# implementation of `deep_copy'.
library/private_builtin.m:
library/string.m:
Compare strings by ordinals in C#, instead of culture-specific rules.
Although the latter is allowed according to the documentation, it is
likely to slower, and cause confusion when porting between backends.
Handle negative index in string.set_char.
library/rtti_implementation.m:
Uncomment foreign language pragmas for C#.
`System.Type.GetType' only searches the current executing assembly or
in mscorlib for a type. As we have to be able to find types in other
assemblies (e.g. mer_std.dll or user DLLs), explicitly search through
a list of assemblies.
library/thread.semaphore.m:
Uncomment foreign language pragmas for C#.
Fix missing class qualification.
library/array.m:
library/bitmap.m:
library/bool.m:
library/dir.m:
library/exception.m:
library/io.m:
library/mutvar.m:
library/par_builtin.m:
library/region_builtin.m:
library/store.m:
library/thread.m:
library/time.m:
library/univ.m:
library/version_array.m:
Uncomment foreign language pragmas for C#.
mdbcomp/rtti_access.m:
Add type and procedure stubs.
runtime/mercury_dotnet.cs.in:
Override `Equals(object)' methods in `TypeCtorInfo_Struct' and
`TypeInfo_Struct' classes. This requires we override `GetHashCode' as
well.
Handle nulls arguments to `Equals' methods as is the expected behaviour.
Override `ToString' in `TypeCtorInfo_Struct' to produce more useful
output during debugging.
scripts/Mercury.config.in:
Record the configured CLI_INTERPRETER and pass that to the compiler as
a flag.
Conform to variable renamings.
scripts/Mmake.vars.in:
Pass value of CSCFLAGS from Mmake through to `mmc --make'.
Conform to variable renamings.
scripts/Mercury.config.bootstrap.in:
scripts/Mmake.rules:
Conform to variable renaming.
scripts/canonical_grade.sh-subr:
scripts/final_grade_options.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/parse_grade_options.sh-subr:
Canonicalise high-level code, high-level-data, C# target code to the
`csharp' grade.
Handle erlang grades like other grades.
scripts/prepare_install_dir.in:
Copy `.cs' files from the runtime directory when preparing an install
directory.
browser/Mmakefile:
compiler/Mmakefile:
deep_profiler/Mmakefile:
mdbcomp/Mmakefile:
profiler/Mmakefile:
runtime/Mmakefile:
slice/Mmakefile:
ssdb/Mmakefile:
trace/Mmakefile:
Do as other non-C grades in this directory.
Conform to variable renamings.
tests/hard_coded/foreign_enum_dummy.m:
tests/hard_coded/sub-modules/non_word_mutable.m:
tests/hard_coded/sub-modules/sm_exp_bug.m:
Make these tests work in C#.
tests/mmc_make/Mmakefile:
Update a regular expression to account for `mmc --make' writing
"Making rebuild.exe" on platforms where the .exe suffix is not normally
used.
tests/mmc_make/complex_test.exp2:
Add alternative output (minor difference in floating point precision).
tests/debugger/Mmakefile:
tests/debugger/declarative/Mmakefile:
tests/general/structure_reuse/Mmakefile:
tests/hard_coded/Mmakefile:
tests/hard_coded/sub-modules/Mmakefile:
tests/par_conj/Mmakefile:
tests/stm/Mmakefile:
Disable some tests in the csharp grade.
tests/invalid/Mmakefile:
Disable some tests in the csharp grade.
Enable a test which should work in java grades.
tests/valid/Mmakefile:
Do as other non-C grades in this directory.
When testing the csharp grade in this directory, produce only the C#
target files for now.
tests/run_one_test:
Don't compress a failing test case executable when the executable is
actually only a shell script.
Branches: main, 10.04
Lift some assumptions that the only Java and Erlang grades are `java' and
`erlang'.
Finally use `--force-disable-ssdebug' instead of `--no-ssdb' to disable the
source-to-source debugging tranformation where required. The latter is
incorrect as it changes the grade, which disrupts the install path with `mmc
--make'.
library/Mmakefile:
scripts/Mercury.config.in:
scripts/Mmake.vars.in:
Remove the variable `INSTALL_JAVA_LIBRARY_DIR' as it assumes only one
Java grade is possible.
Don't use default `--java-classpath' options to add Mercury standard
libraries to the Java class path, for the same reason.
compiler/module_cmds.m:
Add a predicate to return the Mercury standard libraries needed for a
Java program as they are no longer listed in Mercury.config.
Add the Mercury standard libraries when creating the shell script to
launch Java programs.
compiler/compile_target_code.m:
Add the Mercury standard libraries when calling the Java compiler.
compiler/make.program_target.m:
Don't hard code `java' and `erlang' grades when installing library
grade files.
browser/MDB_FLAGS.in:
library/LIB_FLAGS.in:
mdbcomp/MDBCOMP_FLAGS.in:
ssdb/SSDB_FLAGS.in:
Use `--force-disable-ssdebug' to disable the transform.
compiler/module_imports.m:
Don't implicitly import the `ssdb' module if `--force-disable-ssdebug'
is enabled.
compiler/handle_options.m:
Reset the `source_to_source_debug' option on encountering a `--grade'
option.
Estimated hours taken: 2
Branches: main
Get the java.ssdebug grade installing and compiling hello world.
Note that currently the jars for the java.ssdebug grade are installed in the
same location as the non-ssdebug jars. That's not a problem for now,
because the standard library currently has the ssdebug transformations
turned off when it's compiled in the ssdebug grade, so the java.ssdebug
jars are the same as the java jars. Changing it so that the java.ssdebug
jars are installed in a different location requires getting mmc to
adjust the classpath depending on the grade, which doesn't seem worth
it at this stage.
Also note that the interface files for the ssdb, browser and mdbcomp
libraries need to be installed in the ssdebug grade otherwise mmc
complains that it cannot find files like ssdb.m when compiling
a program. These interface files are currently only installed
when there is an ssdebug grade.
browser/MDB_FLAGS.in:
mdbcomp/MDBCOMP_FLAGS.in:
ssdb/SSDB_FLAGS.in:
Generate .module_dep files (needed to compile ssdebug transformed
programs).
browser/Mmakefile:
Build and install mer_browser.jar.
Install the interface files when in an ssdebug grade.
browser/browse.m:
Avoid a determinism warning.
browser/cterm.m:
browser/declarative_execution.m:
browser/listing.m:
Get this code compiling in java grades.
The "if (1 == 1)" before throwing an exception is to avoid
"unreachable code" errors from the Java compiler.
library/Mmakefile:
Mention that the ssdebug jars are installed in the
same spot as the non-ssdebug jars.
mdbcomp/Mmakefile:
Build and install mer_mdbcomp.jar.
Install the interface files when in an ssdebug grade.
mdbcomp/rtti_access.m:
Get this code compiling in Java grades.
scripts/Mercury.config.in:
Add the ssdb, mdbcomp and browser jars to the classpath.
If they are not installed they will just be ignored.
ssdb/Mmakefile:
Build and install mer_ssdb.jar.
Install the interface files when in an ssdebug grade.
ssdb/ssdb.m:
Get this code compiling in java grades.
Flush the output buffers after displaying the prompt so that
it's always displayed.
Branches: main
Pass a flag to the Java compiler to increase the maximum heap size of the
JVM. The default size (at least with Sun Java) is too small to build the
Mercury standard library on 32-bit JVMs. We choose a heap size of 256 MB
currently. (There doesn't seem to be an option to just switch off the
maximum.)
As the flag may not work with non-Sun compilers, we have to check during
configuration whether it's accepted by the detected Java compiler.
aclocal.m4:
Add a function to check if the Java compiler accepts the option
`-J-Xmx<n>'.
Bump Java SDK requirement to 1.5 (this was raised previously without
updating the check).
Update some comments.
configure.in:
Add the configure option `--enable-javac-flags-for-heap-size',
enabled by default.
Check if the Java compiler accepts the maximum heap size option.
Substitute the option in scripts.
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
scripts/Mmake.vars.in:
Add @JAVAC_FLAGS_FOR_HEAP_SIZE@ to default javac flags.
Estimated hours taken: 0.5
Branches: main
Automatically determine if we should pass --restricted-command-line
to mmc.
configure.in:
If we are using the MSVC compiler or MinGW compiler then
we should use --restricted-command-line when building.
scripts/Mercury.config.in:
Pass --restricted-command-line.
Estimated hours taken: 6
Branches: main
In trailing grades, pass flags to the C compiler that force it to align
functions on word boundaries. For some architectures, and for some C compiler
optimisation settings, function addresses are not aligned and this breaks
function trailing when using tagged trail entries.
XXX this diff only fixes the problem for gcc, it's not clear what,
if anything, needs to be done for other C compilers.
configure.in:
s/COMPILER/C_COMPILER_TYPE/. The former is ambiguous as
Mercury uses compilers for several languages.
Instantiate the value of C_COMPILER_TYPE in files generated
by the configure script.
Add an XXX comment about how the type of the C compiler
is determined.
Clean up a few things.
compiler/globals.m:
Define a type, c_compiler_type/0, that represents the type
of C compiler we are using. (This type replaces the old
compiler_type/0 type from compile_target_code.m).
Add a new field to the globals structure that stores the
C compiler type.
Add access and utility procedures for the new field.
Delete some business with unique modes that used to be
required when the I/O globals field was unique.
compiler/options.m:
Simplify the implementation of `--c-compiler-type'.
Most of it is now handled by the globals module.
scripts/Mercury.config.in:
Define a new variable MERCURY_C_COMPILER_TYPE, whose value
is set by the configuration script.
Pass the C compiler type to the Mercury compiler.
compiler/compile_target_code.m:
scripts/mgnuc.in:
When in a trailing grade and using gcc as a C compiler align
functions on word boundaries in order to avoid problems
with function trailing.
Delete the unused type compiler_type/0.
tests/trailing/Mercury.options:
Remove a workaround for the function alignment problem.
Estimated hours taken: 4
Branches: main
Fix a bug introduced with the last ssdb change to ml.in. The context of the bug
was the renaming of a bunch of sh variables from TRACE_xxx to TRACE_BASE_xxx
(for several values of xxx). The bug itself was that the defining occurrence
of one such variable (TRACE_LIBS_SYSTEM) was renamed, but a reference to it
(in the true arm of the switch of $trace_base) was not. The result was a
reference to an undefined variable, which the shell replaced with "".
Since $TRACE_LIBS_SYSTEM should have contained -ldl on some systems (including
my laptop), the upshot was that all attempts to link debuggable executables
failed, with the linker unable to find the definitions of the functions defined
in libdl.a.
scripts/ml.in:
Fix that bug.
Change to four-space indentation in order to avoid bad line breaks,
though using tabs (for speed of interpretation) rather than spaces.
Fix deviations from good sh programming style, including missing ;;s
at the end of case arms.
configure.in:
Rename TRACE_LIBS_SYSTEM to TRACE_BASE_LIBS_SYSTEM, since having the
TRACE_BASE_LIBS_SYSTEM sh variable in ml.in get its value from a
configure variable named TRACE_LIBS_SYSTEM is confusing (since ml.in
also has a sh variable named TRACE_LIBS_SYSTEM).
scripts/ml.in:
scripts/Mercury.config.in:
scripts/Mercury.config.bootstrap.in:
Conform to the change to configure.in.
Estimated hours taken: 6
Branches: main
Add more documentation for the Erlang backend.
Make it possible to configure and install the Erlang backend without too
much manual tweaking.
NEWS:
Mention the Erlang backend.
README.Erlang:
Add installation and other notes for Erlang.
doc/reference_manual.texi:
doc/user_guide.texi:
Add documentation for Erlang.
aclocal.m4:
configure.in:
Check that the bootstrap compiler knows about the
builtin_compound_{eq,lt} builtins, and understands
--erlang-native-code.
Make configure check for Erlang tools.
Add configure --enable-erlang-grade option. Erlang support
is disabled by default.
scripts/Mercury.config.in:
Add `--erlang-compiler <erl>' and `--erlang-interpreter <erlc>'
options to be set by configure.
analysis/ANALYSIS_FLAGS.in:
compiler/COMP_FLAGS.in:
mdbcomp/MDBCOMP_FLAGS.in:
Add `--erlang-include-directory <dir>/Mercury/hrls' options so that
the compiler can find Erlang header files from other subdirectories.
compiler/Mercury.options:
library/Mercury.options:
Work around bugs in the HiPE compiler when compiling two modules.
Delete the workaround that was necessary while bootstrapping
builtin_compound_{eq,lt}.
compiler/options.m:
Add notes that two options to check that the compiler is recent enough
won't be recognised because they begin "no-" prefixes, and we have
to use "--no-no-" instead.
compiler/options_file.m:
Support ERLANG_FLAGS, EXTRA_ERLANG_FLAGS variables in options files to
be the same as passing --erlang-flags.
browser/Mmakefile:
compiler/Mmakefile:
deep_profiler/Mmakefile:
library/Mmakefile:
mdbcomp/Mmakefile:
profiler/Mmakefile:
runtime/Mmakefile:
slice/Mmakefile:
trace/Mmakefile:
Make the build system do the same things in the Erlang grade as for
the IL and Java grades.
scripts/final_grade_options.sh-subr:
scripts/parse_grade_options.sh-subr:
Make these scripts know about the erlang grade so that parts of the
build system won't abort on seeing it.
Estimated hours taken: 1.5
Branches: main, release
Fix a bug in mmc --make's handling of ranlib.
configure.in:
Set the value of RANLIBFLAGS.
On most systems it will be empty; on Mac OS X it needs to be set
to "-c".
Check that the installed compiler supports the `--ranlib-flags'
option.
compiler/make.program_target.m:
Fix the problem with the quoting in the command line used to
invoke ranlib on Mac OS X by using the recently introduced
`--ranlib-flags' option.
Remove the workaround for this bug.
scripts/Mercury.config.bootstrap.in:
scripts/Mercury.config.in:
Set the default value of the `--ranlib-flags' option.
scripts/Mmake.vars.in:
scripts/Mmake.rules:
Have mmake conform to the new way of handling flags for
ranlib.
Estimated hours taken: 100
Branches: main
This patch changes the parallel execution mechanism in the low level backend.
The main idea is that, even in programs with only moderate parallelism, we
won't have enough processors to exploit it all. We should try to reduce the
cost in the common case, i.e. when a parallel conjunction gets executed
sequentially. This patch does two things along those lines:
(1) Instead of unconditionally executing all parallel conjuncts (but the last)
in separate Mercury contexts, we allow a context to continue execution of the
next conjunct of a parallel conjunction if it has just finished executing the
previous conjunct. This saves on allocating unnecessary contexts, which can
be a big reduction in memory usage.
We also try to execute conjuncts left-to-right so as to minimise the
need to suspend contexts when there are dependencies between conjuncts.
(2) Conjuncts that *are* executed in parallel still need separate contexts.
We used to pass variable bindings to those conjuncts by flushing input
variable values to stack slots and copying the procedure's stack frame to the
new context. When the conjunct finished, we would copy new variable bindings
back to stack slots in the original context.
What happens now is that we don't do any copying back and forth. We introduce
a new abstract machine register `parent_sp' which points to the location of
the stack pointer at the time that a parallel conjunction began. In parallel
conjuncts we refer to all stack slots via the `parent_sp' pointer, since we
could be running on a different context altogether and `sp' would be pointing
into a new detstack. Since parallel conjuncts now share the procedure's stack
frame, we have to allocate stack slots such that all parallel conjuncts in a
procedure that could be executing simultaneously have distinct sets of stack
slots. We currently use the simplest possible strategy, i.e. don't allow
variables in parallel conjuncts to reuse stack slots.
Note: in effect parent_sp is a frame pointer which is only set for and used by
the code of parallel conjuncts. We don't call it a frame pointer as it can be
confused with "frame variables" which have to do with the nondet stack.
compiler/code_info.m:
Add functionality to keep track of how deep inside of nested parallel
conjunctions the code generator is.
Add functionality to acquire and release "persistent" temporary stack
slots. Unlike normal temporary stack slots, these don't get implicitly
released when the code generator's location-dependent state is reset.
Conform to additions of `parent_sp' and parent stack variables.
compiler/exprn_aux.m:
Generalise the `substitute_lval_in_*' predicates by
`transform_lval_in_*' predicates. Instead of performing a fixed
substitution, these take a higher order predicate which performs some
operation on each lval. Redefine the substitution predicates in terms
of the transformation predicates.
Conform to changes in `fork', `join_and_terminate' and
`join_and_continue' instructions.
Conform to additions of `parent_sp' and parent stack variables.
Remove `substitute_rval_in_args' and `substitute_rval_in_arg' which
were unused.
compiler/live_vars.m:
Introduce a new type `parallel_stackvars' which is threaded through
`build_live_sets_in_goal'. We accumulate the sets of variables which
are assigned stack slots in each parallel conjunct. At the end of
processing a parallel conjunction, use this information to force
variables which are assigned stack slots to have distinct slots.
compiler/llds.m:
Change the semantics of the `fork' instruction. It now takes a single
argument: the label of the next conjunct after the current one. The
instruction now "sparks" the next conjunct to be run, either in a
different context (possibly in parallel, on another Mercury engine) or
is queued to be executed in the current context after the current
conjunct is finished.
Change the semantics of the `join_and_continue' instruction. This
instruction now serves to end all parallel conjuncts, not just the
last one in a parallel conjunction.
Remove the `join_and_terminate' instruction (no longer used).
Add the new abstract machine register `parent_sp'.
Introduce "parent stack slots", which are similar to normal stack
slots but relative to the `parent_sp' register.
compiler/par_conj_gen.m:
Change the code generated for parallel conjunctions. That is:
- use the new `fork' instruction at the beginning of a parallel
conjunct;
- use the `join_and_continue' instruction at the end of all parallel
conjuncts;
- keep track of how deep the code generator currently is in parallel
conjunctions;
- set and restore the `parent_sp' register when entering a non-nested
parallel conjunction;
- after generating the code of a parallel conjunct, replace all
references to stack slots by parent stack slots;
- remove code to copy back output variables when a parallel conjunct
finishes.
Update some comments.
runtime/mercury_context.c:
runtime/mercury_context.h:
Add the type `MR_Spark'. Sparks are allocated on the heap and contain
enough information to begin execution of a single parallel conjunct.
Add globals `MR_spark_queue_head' and `MR_spark_queue_tail'. These
are pointers to the start and end of a global queue of sparks. Idle
engines can pick up work from this queue in the same way that they can
pick up work from the global context queue (the "run queue").
Add new fields to the MR_Context structure. `MR_ctxt_parent_sp' is a
saved copy of the `parent_sp' register for when the context is
suspended. `MR_ctxt_spark_stack' is a stack of sparks that we decided
not to put on the global spark queue.
Update `MR_load_context' and `MR_save_context' to save and restore
`MR_ctxt_parent_sp'.
Add the counters `MR_num_idle_engines' and
`MR_num_outstanding_contexts_and_sparks'. These are used to decide,
when a `fork' instruction is reached, whether a spark should be put on
the global spark queue (with potential for parallelism but also more
overhead) or on the calling context's spark stack (no parallelism and
less overhead).
Rename `MR_init_context' to `MR_init_context_maybe_generator'. When
initialising contexts, don't reset redzones of already allocated
stacks. It seems to be unnecessary (and the reset implementation is
buggy anyway, though it's fine on Linux).
Rename `MR_schedule' to `MR_schedule_context'. Add new functions
`MR_schedule_spark_globally' and `MR_schedule_spark_locally'.
In `MR_do_runnext', add code for idle engines to get work from the
global spark queue. Resuming contexts are prioritised over sparks.
Rename `MR_fork_new_context' to `MR_fork_new_child'. Change the
definitions of `MR_fork_new_child' and `MR_join_and_continue' as per
the new behaviour of the `fork' and `join_and_continue' instructions.
Delete `MR_join_and_terminate'.
Add a new field `MR_st_orig_context' to the MR_SyncTerm structure to
record which context originated the parallel conjunction instance
represented by a MR_SyncTerm instance, and update `MR_init_sync_term'.
This is needed by the new behaviour of `MR_join_and_continue'.
Update some comments.
runtime/mercury_engine.h:
runtime/mercury_regs.c:
runtime/mercury_regs.h:
runtime/mercury_stacks.h:
Add the abstract machine register `parent_sp' and code to copy it to
and from the fake_reg array.
Add a macro `MR_parent_sv' to access stack slots via `parent_sp'.
Add `MR_eng_parent_sp' to the MercuryEngine structure.
runtime/mercury_wrapper.c:
runtime/mercury_wrapper.h:
Add Mercury runtime option `--max-contexts-per-thread' which is saved
in the global variable `MR_max_contexts_per_thread'. The number
`MR_max_outstanding_contexts' is derived from this. It sets a soft
limit on the number of sparks we put in the global spark queue,
relative to the number of threads we are running. We don't want to
put too many sparks on the global queue if there are plenty of ready
contexts or sparks already on the global queues, as they are likely to
result in new contexts being allocated.
When initially creating worker engines, wait until all the worker
engines have acknowledged that they are idle before continuing. This
is mainly so programs (especially benchmarks and test cases) with only
a few fork instructions near the beginning of the program don't
execute the forks before any worker engines are ready, resulting in no
parallelism.
runtime/mercury_engine.c:
runtime/mercury_thread.c:
Don't allocate a context at the time a Mercury engine is created. An
engine only needs a new context when it is about to pick up a spark.
configure.in:
compiler/options.m:
scripts/Mercury.config.in:
Update to reflect the extra field in MR_SyncTerm.
Add the option `--sync-term-size' and actually make use the result of
the sync term size calculated during configuration.
compiler/code_util.m:
compiler/continuation_info.m:
compiler/dupelim.m:
compiler/dupproc.m:
compiler/global_data.m:
compiler/hlds_llds.m:
compiler/jumpopt.m:
compiler/livemap.m:
compiler/llds_out.m:
compiler/middle_rec.m:
compiler/opt_debug.m:
compiler/opt_util.m:
compiler/reassign.m:
compiler/stack_layout.m:
compiler/use_local_vars.m:
compiler/var_locn.m:
Conform to changes in `fork', `join_and_terminate' and
`join_and_continue' instructions.
Conform to additions of `parent_sp' and parent stack variables.
XXX not sure about the changes in stack_layout.m
library/par_builtin.m:
Conform to changes in the runtime system.
Estimated hours taken: 0.5
Branches: main, release
scripts/Mercury.config.in:
Back out my recent change since it breaks mmc --make on Solaris.
configure.in:
Don't try to statically link the configure test on Solaris 2.9.
Estimated hours taken: 6
Branches: main, release
Fix a bug reported by Greg Duck. On x86 systems mmc --make was not building
static executables by default, but was linking in shared versions of some
libraries. This won't work correctly on x86 machines because of our use of the
register ebx as a global register in non-pic code. The following patch
causes mmc --make to invoke the linker with the same default settings as mmake.
scripts/Mercury.config.in:
The default values for the `--linkage' and `--mercury-linkage'
options on x86 should be `static' not `shared'.
Estimated hours taken: 0.2
Branches: main
scripts/Mercury.config.in:
Have configure set the name of the C# compiler, since when
using DotGNU it's cscc rather than csc.
Estimated hours taken: 1
Branches: main
scripts/Mercury.config.in:
Move the default `--grade' option from DEFAULT_MCFLAGS to
DEFAULT_GRADEFLAGS. `mmc --make' generates command-lines with
MCFLAGS options after GRADEFLAGS options, so GRADEFLAGS set by
the user were being overridden by the default `--grade' option
in MCFLAGS.
Estimated hours taken: 0.1
Branches: main
scripts/Mercury.config.in:
Make the `--install-prefix' option take its default value from
the `prefix' autoconf variable instead of the non-existent
`INSTALL_PREFIX' variable.
Estimated hours taken: 20
Branches: main
Changes to get shared libraries to work on Mac OS X (Darwin).
This is phase 2 of 2. Phase 1 added the compiler options described below.
Phase 2 uses these compiler options in the configuration scripts.
Darwin shared libraries have the extension `dylib' instead of `so'. Also
objects that link to a shared library on Darwin don't need to be told the
runtime path in which they should look for the libraries, instead the
shared libraries themselves remember where they will be eventually installed
(called the install-name) and any object which links in the shared library will
get the install-name from the shared library at link time. When a shared
library is built it has to be told where it will be installed which is what
the libtool -install_name option is used for on Darwin.
This diff only enables shared libraries on Darwin, not "bundles" which are
shared objects that can be loaded dynamically at runtime using something like
dlopen. Therefore the interactive query tool in the debugger still doesn't
work on Mac OS X.
Added three new compiler options :
--shlib-linker-use-install-name :
A boolean flag to tell the compiler to use the -install_name option
when building shared libraries. When this flag is set the following
options have no effect: --linker-rpath-flag, --linker-rpath-separator,
--shlib-linker-rpath-flag, --shlib-linker-rpath-separator.
--shlib-linker-install-name-flag :
The flag name to use ("-install_name" for Darwin).
--shlib-linker-install-name-path :
The path where the shared library will eventually end up, excluding the
file name. The file name is appended to the end before the option
is passed on to the linker.
Mmake.common.in
Added variables used for install-name on/off switch and flag name.
NEWS
Mentioned shared libs working now on Mac OS X.
README.MacOS
Removed bit about shared libs not working in Mac OS X.
configure.in
Make shared libs the default when on Darwin and the compiler is gcc.
boehm_gc/Makefile
boehm_gc/Makefile.direct
Added rule to make libgc.dylib and set the install-name correctly.
boehm_gc/Mmakefile
Set variable used in boehm_gc/Makefile to get the final install path
of the gc shared lib.
browser/Mercury.options
Added mer_mdbcomp library for target libmer_browser.dylib.
browser/Mmakefile
Added --shlib-linker-install-name-path option to MC options.
doc/user_guide.texi
Documented the --shlib-linker-install-name-path option. The other
options will be automatically set by the configure script and
should never need to be set by the user, so they're not documented in
the user guide.
runtime/Mmakefile
Added rule to make the Darwin shared library.
scripts/Mercury.config.bootstrap.in
Added default values for --shlib-linker-use-install-name and
--shlib-linker-install-name-flag.
scripts/Mercury.config.in
Added default values for --shlib-linker-use-install-name and
--shlib-linker-install-name-flag.
trace/Mmakefile
Added rule to make the Darwin shared library.
Estimated hours taken: 1.5
Branches: main
Simplify use of the Java grade by automatically setting the classpath.
scripts/Mercury.config.in:
scripts/Mercury.config.bootstrap.in:
Set the --java-classpath option in DEFAULT_MC_FLAGS.
Define STD_LIB_NAME, RT_LIB_NAME.
scripts/c2init.in:
Add the above two files to the list of those which use STD_LIB_NAME and
RT_LIB_NAME.
library/Mmakefile:
Use RT_LIB_NAME instead of STD_LIB_NAME.runtime
compiler/modules.m:
Remove the XXX comment that worries about this issue.
README.Java:
Remove instructions relating to setting the classpath manually.
Estimated hours taken: 8
Branches: main
Have the configure script decide whether to install the Java grade.
configure.in:
Add Java to the list of library grades to install by default,
if the Java SDK is installed.
Add the option to disable the Java grade.
aclocal.m4:
Detect whether the Java SDK is installed. Currently this is done
by checking for javac, java and jar, then testing whether a program
can be compiled which confirms the version is recent enough.
scripts/Mmake.vars.in:
Add JAVAC, JAVA_INTERPRETER and JAR to the generated make variables.
Add JAR_CREATE_FLAGS make variable, set as "cf"
scripts/Mercury.config.in:
scripts/Mercury.config.bootstrap.in:
Define environmental variables MERCURY_JAVA_COMPILER and
MERCURY_JAVA_INTERPRETER.
Have the configure script set the default java compiler and interpreter
as part of DEFAULT_MC_FLAGS.
library/Mmakefile:
Use "$(JAR) $(JAR_CREATE_FLAGS)" instead of "jar cf"
Estimated hours taken: 50
Branches: main
Remove Unix dependencies in the compiler.
Avoid calling passes_aux.invoke_shell_command, which
requires the presence of a Unix shell.
The implementation of fact tables still has dependencies
on Unix utilities (e.g. sort).
aclocal.m4:
Don't pass Unix style paths to MSVC.
configure.in:
Use `cygpath -m' rather than `cygpath -w'.
`cygpath -m' uses '/' as the directory separator,
so it doesn't cause quoting problems in shell
scripts.
Apply $CYGPATH to $PREFIX, $LIBDIR, $CONFIG_PREFIX
and $CONFIG_LIBDIR.
Don't pass `-lm' when linking with MSVC.
configure.in:
compiler/options.m:
scripts/Mercury.config.in:
Add extra configuration options to deal with differences
between linking with gcc and MSVC:
--linker-opt-separator
--linker-link-lib-flag
--linker-link-lib-suffix
--shlib-linker-link-lib-flag
--shlib-linker-link-lib-suffix
--linker-path-flag
NEWS:
doc/user_guide.texi:
compiler/options.m:
compiler/compile_target_code.m:
compiler/make.program_target.m:
Instead of substituting in an arbitrary shell script when
processing `--pre-link-command' and `--extra-init-command',
require that these options specify a command which will
be passed the name of the source file containing the main
module as the first argument, with the source files containing
the remaining modules following. This is simpler and avoids
dependencies on a shell.
Fix quote_arg to handle Windows paths better.
compiler/handle_options.m:
Don't attempt to use symlinks if they're not available.
compiler/compile_target_code.m:
Be more careful about quoting.
Don't call invoke_shell_command where invoke_system_command
would do.
Allow linking using MSVC.
compiler/modules.m:
Remove make_directory, which is now implemented by dir.m.
Use io.make_symlink rather than shell scripts.
Implement mercury_update_interface in Mercury.
compiler/llds_out.m:
compiler/make.program_target.m:
Use dir.make_directory, not modules.make_directory,
which has been removed.
compiler/make.module_target.m:
Invoke mercury_compiler directly, not through the
mmc script to avoid shell dependencies.
If we can't fork() child `mmc --make' processes,
pass the arguments to the child process using a
file to avoid overflowing system limits on Windows.
compiler/mercury_compile.m:
compiler/options_file.m:
Read argument files.
Handle backslash-newline in options files correctly.
compiler/passes_aux.m:
invoke_system_command shouldn't set the exit status --
the caller may be able to try something else.
compiler/process_util.m:
Export can_fork for use by make.module_target.m.
Remove hacks to work around bugs in the implementation
of zero-arity foreign procs.
compiler/prog_io.m:
Handle bizarre file names without aborting.
library/Mmakefile:
library/print_extra_inits:
Move code to find extra initialization functions into
print_extra_inits, due to the change to the handling
of the --extra-init-command option described above.
scripts/mmc.in:
Set the MERCURY_COMPILER environment variable if it is
not already set, so that the mercury_compile executable
knows where to find itself.
scripts/mercury.bat.in:
Make this actually work.
tools/bootcheck:
Set ANALYSIS_LIB_NAME.
Apply cygpath (-m not -w) to $root.
Link print_extra_inits into the stage2 and stage3
library directories.
util/mkinit.c:
Handle '\\' in path names.
Estimated hours taken: 1
Branches: main
Don't create symlinks when installing with a Win32 version
of the compiler. The compiler won't know how to follow the
symlinks.
configure.in:
scripts/Mmake.vars.in:
scripts/Mercury.config.in:
compiler/modules.m:
When using `gcc -mno-cygwin' or MS Visual C++ to
build the compiler, don't create symlinks when installing.
compiler/options.m:
Add an option `--no-use-symlinks'.
Estimated hours taken: 0.5
Branches: main
Make it easier to boostrap the addition of new configuration
options.
scripts/Mercury.config.bootstrap.in:
A version of Mercury.config.in that does not contain
any options which are not understood by the installed
compilers. This is used when building the stage1 compiler.
Mercury.config is used to build the stage2 and stage3
compilers, and when running the tests. Mercury.config is
installed by `mmake install'.
Mercury.config.bootstrap.in is currently the same
as Mercury.config.in.
Mmake.workspace:
tools/bootcheck:
tools/binary_step:
tools/lmc.in:
Work out which configuration file to use.
configure.in:
scripts/Mmakefile:
scripts/mercury_config.in:
Handle Mercury.config.bootstrap.
Estimated hours taken: 0.2
Branches: main
scripts/Mercury.config.in:
Remove quotes which caused problems if the configured
C compiler command consisted of multiple words,
e.g. gcc --no-cpp-precomp.
Estimated hours taken: 0.5
Branches: main
Clean up the handling of environment variables.
scripts/Mmake.rules:
scripts/c2init.in:
scripts/mgnuc.in:
scripts/ml.in:
scripts/mmc.in:
scripts/parse_ml_options.sh-subr.in:
scripts/binary_step.in:
Remove support for the environment variables which were
previously used to override the location of the standard
library (MERCURY_ALL_C_INCL_DIRS, MERCURY_ALL_MC_C_INCL_DIRS,
MERCURY_INT_DIR, MERCURY_C_LIB_DIR, MERCURY_MOD_LIB_MODS,
MERCURY_TRACE_LIB_MODS).
scripts/Mercury.config.in:
Fix syntax errors.
Set the DEFAULT_MERCURY_LINKAGE variable here rather
than in the mmc script.
scripts/mmc.in:
Setting DEFAULT_MCFLAGS is no longer required -- mmc
now reads its configuration information from the
Mercury.config file. This also fixes a bug which
caused failures in the `mmc --make' tests in
debugging grades on mundroo -- `mmc --make' wasn't
including /usr/local/lib and /usr/local/include in
the search paths for libraries and headers.
configure.in:
Check that the installed compiler is capable of
reading the Mercury.config file.
Bootstrap tag: bootstrap_20030413_read_config_file.
NEWS:
doc/user_guide.texi:
Document the change.
Estimated hours taken: 20
Branches: main
Move the setting of configuration options from mmc.in to
an options file Mercury.config. This has a few advantages:
- reduces the duplication between mmc and mercury.bat
- reduces the chance of running out of environment space
on crappy operating systems (although we probably exceed
the command line length limits on those systems anyway).
- makes it easier to bootstrap changes which add new
configuration options.
Always read the options files, even without `--make',
to avoid inconsistent behaviour.
scripts/Mercury.config.in:
New file containing the configuration code from mmc.in.
configure.in:
Create scripts/Mercury.config.
bindist/Mmakefile:
Make sure Mercury.config.in goes in the binary distribution.
Mmakefile:
bindist/Mmakefile:
Mmake.common.in:
Make sure we get the correct setting of INSTALL_PREFIX
when building the binary distribution.
scripts/Mmakefile:
scripts/mercury_config.in:
bindist/bindist.Mmakefile.in:
Install Mercury.config.
compiler/options.m:
doc/user_guide.texi:
Add documentation for the `--config-file' option, which gives
the name of the configuration file to read.
Add an option `read-config-file-2003-03-01' which will be
used in configure.in to test whether the compiler is up
to date after the configuration code is removed from mmc.in
(after this change is installed everywhere).
Add `--mercury-config-dir' as an abbreviation for
`--mercury-configuration-directory'.
Mmake.workspace:
Use the configuration file in scripts/Mercury.config.
browser/Mmakefile:
compiler/Mmakefile:
scripts/Mmake.vars.in:
Always pass ALL_MCFLAGS to mmc so that mmc will
use the configuration file specified in the options.
compiler/handle_options.m:
Handle the default value of `--config-file'.
compiler/mercury_compile.m:
Read the configuration file.
Always read the options files, even without `--make',
to avoid inconsistent behaviour.
compiler/make.m:
Pass the variable settings from the configuration file
to make__process_args.
The options files have already been read in mercury_compile.m,
so don't read them again here.
compiler/make.util.m:
Add a version of build_with_module_options which doesn't
need a make_info, for use by mercury_compile.m.
compiler/options_file.m:
Export a predicate to read a single options file.
Make the predicates to read options files add to an initial
options_variables map, rather than always creating a new one.
Allow MERCURY_STDLIB_DIR and MERCURY_CONFIG_DIR
to be set in the options file or environment.
scripts/mmc.in:
Set MERCURY_STDLIB_DIR and MERCURY_CONFIG_DIR in
mercury_compile's environment.
