mmc - Error reading options file `/usr/lib/mercury/conf/Mercury.config'.

Error reading options file `/usr/lib/mercury/conf/Mercury.config'.
Mercury Compiler, version rotd-2004-05-11, configured for i686-pc-linux-gnu
Copyright (C) 1993-2004 The University of Melbourne

mmc [<options>] <arguments>

mmc is one of the development tools that are part of the Mercury distribution.

This manual page is limited to a brief summary. For further information see the Mercury User's Guide.

Arguments ending in `.m' are assumed to be source file names. Arguments that do not end in `.m' are assumed to be module names.

 -?, -h, --help

	Print this usage message.

 -w, --inhibit-warnings

	Disable all warning messages.

 --halt-at-warn

	This option causes the compiler to treat all 
	warnings as if they were errors.  This means that
	if any warning is issued, the compiler will not
	generate code --- instead, it will return a
	non-zero exit status.

 --halt-at-syntax-errors

	This option causes the compiler to halt immediately
	after syntax checking and not do any semantic checking
	if it finds any syntax errors in the program.

 --inhibit-accumulator-warnings

	Don't warn about argument order rearrangement caused
	by --introduce-accumulators.

 --no-warn-singleton-variables

	Don't warn about variables which only occur once.

 --no-warn-overlapping-scopes

	Don't warn about variables which occur in overlapping scopes.

 --no-warn-det-decls-too-lax

	Don't warn about determinism declarations
	which could have been stricter.

 --no-warn-inferred-erroneous

	Don't warn about procedures whose determinism is inferred
	erroneous but whose determinism declarations are laxer.

 --no-warn-nothing-exported

	Don't warn about modules which export nothing.

 --warn-unused-args

	Warn about predicate arguments which are not used.

 --warn-interface-imports

	Warn about modules imported in the interface, but
	which are not used in the interface.

 --no-warn-missing-opt-files

	Disable warnings about `.opt' files which cannot be opened.

 --warn-missing-trans-opt-files

	Enable warnings about `.trans_opt' files which cannot
	be opened.

 --no-warn-missing-trans-opt-deps

	Disable warnings produced when the information required
	to allow `.trans_opt' files to be read when creating other
	`.trans_opt' files has been lost.  The information can be
	recreated by running `mmake <mainmodule>.depend'

 --warn-non-stratification

	Warn about possible non-stratification in the module.
	Non-stratification occurs when a predicate/function can call
	itself negatively through some path along its call graph.

 --no-warn-simple-code

	Disable warnings about constructs which are so
	simple that they are likely to be programming errors.

 --warn-duplicate-calls

	Warn about multiple calls to a predicate with the
	same input arguments.

 --no-warn-missing-module-name

	Disable warnings for modules that do no start with
	a `:- module' declaration.

 --no-warn-wrong-module-name

	Disable warnings for modules whose `:- module'
	declaration does not match the module's file name.

 --no-warn-smart-recompilation

	Disable warnings from the smart recompilation system.

 --no-warn-undefined-options-variables

	Warn about references to undefined variables in
	options files with `--make'.

 --warn-non-tail-recursion

	Warn about any directly recursive calls that are not tail calls.
	This requires --high-level-code.

 --no-warn-up-to-date

	Don't warn if targets specified on the command line
	with `--make' are already up to date.

 --no-warn-stubs

	Disable warnings about procedures for which there are no
	clauses.  Note that this option only has any effect if
	the `--allow-stubs' option (described in the "Language
	Semantics Options" section below) is enabled.

 --warn-dead-procs

	Warn about procedures which are never called.

 --no-warn-target-code

	Disable warnings from the compiler used to process the
	target code (e.g. gcc).

 -v, --verbose

	Output progress messages at each stage in the compilation.

 -V, --very-verbose

	Output very verbose progress messages.

 -E, --verbose-error-messages

	Explain error messages.  Asks the compiler to give you a more
	detailed explanation of any errors it finds in your program.

 --no-verbose-make

	Disable messages about the progress of builds using
	the `--make' option.

 --output-compile-error-lines <n>

	With `--make', output the first <n> lines of the `.err'
	file after compiling a module (default: 15).

 --verbose-commands

	Output each external command before it is run.
	Note that some commands will only be printed
	printed with `--verbose'.

 --verbose-recompilation

	When using `--smart-recompilation', output messages
	explaining why a module needs to be recompiled.

 --find-all-recompilation-reasons

	Find all the reasons why a module needs to be recompiled,
	not just the first.  Implies `--verbose-recompilation'.

 -S, --statistics

	Output messages about the compiler's time/space usage.
	At the moment this option implies `--no-trad-passes', so you get
	information at the boundaries between phases of the compiler.

 -T, --debug-types

	Output detailed debugging traces of the type checking.

 -N, --debug-modes

	Output detailed debugging traces of the mode checking.

 --debug-det, --debug-determinism

	Output detailed debugging traces of determinism analysis.

 --debug-opt

	Output detailed debugging traces of the optimization process.

 --debug-opt-pred-id <n>

	Output detailed debugging traces of the optimization process
	only for the predicate/function with the specified pred id.

 --debug-pd

	Output detailed debugging traces of the partial
	deduction and deforestation process.

 --debug-rl-gen

	Output detailed debugging traces of Aditi-RL code generation.

 --debug-rl-opt

	Output detailed debugging traces of Aditi-RL optimization.

 --debug-liveness <pred_id>

	Output detailed debugging traces of the liveness analysis
	of the predicate with the given predicate id.

 --debug-make

	Output detailed debugging traces of the `--make' option.

These options are mutually exclusive. Only the first one specified will apply. If none of these options are specified, the default action is to link the named modules to produce an executable.

 -f, --generate-source-file-mapping

	Output the module name to file name mapping for the list
	of source files given as non-option arguments to mmc
	to `Mercury.modules'. This must be done before
	`mmc --generate-dependencies' if there are any modules
	for which the file name does not match the module name.
	If there are no such modules the mapping need not be
	generated.

 -M, --generate-dependencies

	Output `Make'-style dependencies for the module
	and all of its dependencies to `<module>.dep'.

 --generate-module-order

	Output the strongly connected components of the module
	dependency graph in top-down order to `<module>.order'.
	Implies --generate-dependencies.

 -i, --make-int, --make-interface

	Write the module interface to `<module>.int',
	and write the short interface to `<module>.int2'
	This option should only be used by mmake.

 --make-priv-int, --make-private-interface

	Write the private interface to `<module>.int0'.
	This option should only be used by mmake.

 --make-short-int, --make-short-interface

	Write the unqualified short interface to `<module>.int3'.
	This option should only be used by mmake.

 --make-opt-int, --make-optimization-interface

	Write inter-module optimization information to
	`<module>.opt'.
	This option should only be used by mmake.

 --make-trans-opt

 --make-transitive-optimization-interface

	Output transitive optimization information
	into the `<module>.trans_opt' file.
	This option should only be used by mmake.

 -P, --convert-to-mercury

	Convert to Mercury. Output to file `<module>.ugly'
	This option acts as a Mercury ugly-printer.

 -t, --typecheck-only

	Just check that the code is syntactically correct and
	type-correct. Don't check modes or determinism,
	and don't generate any code.

 -e, --errorcheck-only

	Check the module for errors, but do not generate any code.

 -C, --target-code-only

	Generate target code (i.e. C code in `<module>.c',
	assembler code in `<module>.s' or `<module>.pic_s',
	IL code in `<module>.il', or Java code in
	`<module>.java'), but not object code.

 -c, --compile-only

	Generate C code in `<module>.c' and object code in `<module>.o'
	but do not attempt to link the named modules.

 --aditi-only

	Write Aditi-RL bytecode to `<module>.rlo' and
	do not compile to C.

 --output-grade-string

	Compute the grade of the library to link with based on
	the command line options, and print it to the standard
	output.

 --output-link-command

	Print the command used to link executables to the
	standard output.

 --output-shared-lib-link-command

	Print the command used to link shared libraries to the
	standard output.

 --smart-recompilation

	When compiling, write program dependency information
	to be used to avoid unnecessary recompilations if an
	imported module's interface changes in a way which does
	not invalidate the compiled code. `--smart-recompilation'
	does not yet work with `--intermodule-optimization'.

 --no-assume-gmake

	When generating `.dep' files, generate Makefile
	fragments that use only the features of standard make;
	do not assume the availability of GNU Make extensions.
	When generating `.dep' files, generate dependencies
	for use by `mmc --make' in addition to the dependencies
	used by mmake.

 --generate-mmc-deps

 --generate-mmc-make-module-dependencies

	Generate dependencies for use by `mmc --make' even
	when using Mmake. This is recommended when building a
	library for installation.

 --trace {minimum, shallow, deep, rep, default}

	Generate code that includes the specified level
	of execution tracing.
	See the Debugging chapter of the Mercury User's Guide
	for details.

 --trace-optimized

	Do not disable optimizations that can change the trace.

 --no-delay-death

	When the trace level is `deep', the compiler normally
	preserves the values of variables as long as possible, even
	beyond the point of their last use, in order to make them
	accessible from as many debugger events as possible.
	However, it will not do this if this option is given.

 --stack-trace-higher-order

	Enable stack traces through predicates and functions with
	higher-order arguments, even if stack tracing is not
	supported in general.

 --generate-bytecode

	Output a bytecode form of the module for use
	by an experimental debugger.

 -n-, --no-line-numbers

	Do not put source line numbers in the generated code.
	The generated code may be in C (the usual case),
	or in Mercury (with the option --convert-to-mercury).

 --auto-comments

	Output comments in the `<module>.c' file.
	(The code may be easier to understand if you also
	use the `--no-llds-optimize' option.)

 --show-dependency-graph

	Write out the dependency graph to `<module>.dependency_graph'.

 -d <n>, --dump-hlds <stage number or name>

	Dump the HLDS (high level intermediate representation) after
	the specified stage to `<module>.hlds_dump.<num>-<name>'.
	Stage numbers range from 1-99.
	Multiple dump options accumulate.

 --dump-hlds-pred-id <n>

	Dump the HLDS only of the predicate/function with the given
	pred id.

 --dump-hlds-options <options>

	With `--dump-hlds', include extra detail in the dump.
	Each type of detail is included in the dump if its
	corresponding letter occurs in the option argument
	(see the Mercury User's Guide for details).

 --dump-mlds <stage number or name>

	Dump the MLDS (medium level intermediate representation)
	after the specified stage, as C code,
	to`<module>.c_dump.<num>-<name>',
	and `<module>.h_dump.<num>-<name>'.
	Stage numbers range from 1-99.
	Multiple dump options accumulate.

 --verbose-dump-mlds <stage number or name>

	Dump the internal compiler representation of the MLDS, after
	the specified stage, to `<module>.mlds_dump.<num>-<name>'.

 --dump-rl

	Output a human readable form of the compiler's internal
	representation of the generated Aditi-RL code to
	`<module>.rl_dump'.

 --dump-rl-bytecode

	Output a human readable representation of the generated
	Aditi-RL bytecodes to `<module>.rla'.
	Aditi-RL bytecodes are directly executed by the Aditi system.

 --generate-schemas

	Output schema strings for Aditi base relations
	to `<module>.base_schema' and for Aditi derived
	relations to `<module>.derived_schema'.
	A schema string is a representation of the types
	of a relation.

 --sign-assembly

	Sign the current assembly with the Mercury strong name.
	To use assemblies created with this command all the Mercury
	modules must be compiled with this option enabled.
	This option is specific to the IL backend, and is likely
	to be deprecated at a later date.

(See the Mercury language reference manual for detailed explanations.)

 --no-reorder-conj

	Execute conjunctions left-to-right except where the modes imply
	that reordering is unavoidable.

 --no-reorder-disj

	Execute disjunctions strictly left-to-right.

 --fully-strict

	Don't optimize away loops or calls to error/1.

 --allow-stubs

	Allow procedures to have no clauses.  Any calls to
	such procedures will raise an exception at run-time.
	This option is sometimes useful during program development.
	(See also the documentation for the `--warn-stubs' option
	in the "Warning Options" section.)

 --infer-all

	Abbreviation for `--infer-types --infer-modes --infer-det'.

 --infer-types

	If there is no type declaration for a predicate or function,
	try to infer the type, rather than just reporting an error.

 --infer-modes

	If there is no mode declaration for a predicate,
	try to infer the modes, rather than just reporting an error.

 --no-infer-det, --no-infer-determinism

	If there is no determinism declaration for a procedure,
	don't try to infer the determinism, just report an error.

 --type-inference-iteration-limit <n>

	Perform at most <n> passes of type inference (default: 60).

 --mode-inference-iteration-limit <n>

	Perform at most <n> passes of mode inference (default: 30).

 --enable-term, --enable-termination

	Analyse each predicate to discover if it terminates.

 --chk-term, --check-term, --check-termination

	Enable termination analysis, and emit warnings for some
	predicates or functions that cannot be proved to terminate.  In
	many cases where the compiler is unable to prove termination
	the problem is either a lack of information about the
	termination properties of other predicates, or because language
	constructs (such as higher order calls) were used which could
	not be analysed.  In these cases the compiler does not emit a
	warning of non-termination, as it is likely to be spurious.

 --verb-chk-term, --verb-check-term, --verbose-check-termination

	Enable termination analysis, and emit warnings for all
	predicates or functions that cannot be proved to terminate.

 --term-single-arg <n>, --termination-single-argument-analysis <n>

	When performing termination analysis, try analyzing
	recursion on single arguments in strongly connected
	components of the call graph that have up to <n> procedures.
	Setting this limit to zero disables single argument analysis.

 --termination-norm {simple, total, num-data-elems}

	The norm defines how termination analysis measures the size
	of a memory cell. The `simple' norm says that size is always
	one.  The `total' norm says that it is the number of words
	in the cell.  The `num-data-elems' norm says that it is the
	number of words in the cell that contain something other
	than pointers to cells of the same type.

 --term-err-limit <n>, --termination-error-limit <n>

	Print at most <n> reasons for any single termination error
	(default: 3).

 --term-path-limit <n>, --termination-path-limit <n>

	Perform termination analysis only on predicates
	with at most <n> paths (default: 256).

The following compilation options affect the generated code in such a way that the entire program must be compiled with the same setting of these options, and it must be linked to a version of the Mercury library which has been compiled with the same setting.

 -s <grade>, --grade <grade>

	Select the compilation model. The <grade> should be one of
	the base grades `none', `reg', `jump', `asm_jump', `fast', 
	`asm_fast', `hl', `hlc', `il', or `java',
	or one of those with one or more of the grade modifiers
	`.gc', `.mps', `.prof', `.memprof', `.profdeep', `.tr',
	`rt', `.debug', `.par' and/or `.pic_reg' appended.
	Depending on your particular installation, only a subset
	of these possible grades will have been installed.
	Attempting to use a grade which has not been installed
	will result in an error at link time.

 --target c			(grades: none, reg, jump, fast,

					asm_jump, asm_fast, hl, hlc)

 --target asm			(grades: hlc)

 --target il			(grades: il)

 --target java			(grades: java)

	Specify the target language: C, assembler, IL or Java.
	The default is C.  "IL" (also known as "CIL" or "MSIL")
	is the Intermediate Language for the .NET Common Language
	Runtime.
	Targets other than C imply `--high-level-code' (see below).
	As an exception to the usual rule for options in this section,
	where different option settings normally correspond to different
	ABIs, code generated using `--target asm' is binary compatible
	with code generated using `--target c --high-level code', so
	these both use grade `hlc'.

 --il

	An abbreviation for `--target il'.

 --il-only

	An abbreviation for `--target il --target-code-only'.
	Generate IL code in `<module>.il', but do not generate
	object code.

 --dotnet-library-version <version-number>

	The version number for the mscorlib assembly distributed
	with the Microsoft .NET SDK.

 --no-support-ms-clr

	Don't use MS CLR specific workarounds in the generated code.

 --support-rotor-clr

	Use specific workarounds for the ROTOR CLR in the generated
	code.

 --java

	An abbreviation for `--target java'.

 --java-only

	An abbreviation for `--target java --target-code-only'.
	Generate Java code in `<module>.java', but do not generate
	object code.

 --compile-to-c

	An abbreviation for `--target c --target-code-only'.
	Generate C code in `<module>.c', but do not generate object
	code.

 --debug				(grade modifier: `.debug')

	Enable Mercury-level debugging.
	See the Debugging chapter of the Mercury User's Guide
	for details.
	This option is not yet supported for the `--high-level-code'
	back-ends.

 -p, --profiling, --time-profiling

				(grade modifier: `.prof')
	Enable time and call profiling.  Insert profiling hooks in the
	generated code, and also output some profiling
	information (the static call graph) to the file
	`<module>.prof'.
	This option is not supported for the IL or Java back-ends.

 --memory-profiling		(grade modifier: `.memprof')

	Enable memory and call profiling.
	This option is not supported for the IL or Java back-ends.

 --deep-profiling		(grade modifier: `.profdeep')

	Enable deep profiling.
	This option is not supported for the high-level C, IL
	or Java back-ends.

 --gc {none, boehm, mps, accurate, automatic}

 --garbage-collection {none, boehm, mps, accurate, automatic}

				(`java' and `il' grades use
					`--gc automatic',
				`.gc' grades use `--gc boehm',
				`.mps' grades use `--gc mps',
				other grades use `--gc none'.)
	Specify which method of garbage collection to use
	(default: boehm).
	`boehm' is Hans Boehm et al's conservative collector.
	`accurate' is our own type-accurate copying GC;
	it requires `--high-level-code'.
	`mps' is a different conservative collector, based on
	Ravenbrook Limited's MPS (Memory Pool System) kit.
	`automatic' means the target language provides it.
	This is the case for the IL and Java back-ends,
	which always use the garbage collector of the underlying
	IL or Java implementation.

 --use-trail			(grade modifier: `.tr')

	Enable use of a trail.
	This is necessary for interfacing with constraint solvers,
	or for backtrackable destructive update.
	This option is not yet supported for the IL or Java back-ends.

 --gcc-global-registers		(grades: reg, fast, asm_fast)

 --no-gcc-global-registers	(grades: none, jump, asm_jump)

	Specify whether or not to use GNU C's
	global register variables extension.
	This option is ignored if the `--high-level-code' option is
	enabled.

 --gcc-non-local-gotos		(grades: jump, fast, asm_jump, asm_fast)

 --no-gcc-non-local-gotos	(grades: none, reg)

	Specify whether or not to use GNU C's
	"labels as values" extension.
	This option is ignored if the `--high-level-code' option is
	enabled.

 --asm-labels			(grades: asm_jump, asm_fast)

 --no-asm-labels			(grades: none, reg, jump, fast)

	Specify whether or not to use GNU C's
	asm extensions for inline assembler labels.
	This option is ignored if the `--high-level-code' option is
	enabled.

 --pic-reg			(grade modifier: `.pic_reg')

[For Unix with intel x86 architecture only]
	Select a register usage convention that is compatible,
	with position-independent code (gcc's `-fpic' option).
	This is necessary when using shared libraries on Intel x86
	systems running Unix.  On other systems it has no effect.

 -H, --high-level-code			(grades: hl, hlc, il, java)

	Use an alternative back-end that generates high-level code
	rather than the very low-level code that is generated by our
	original back-end.

 --high-level-data			(grades: hl, il, java)

	Use an alternative higher-level data representation.

 --high-level			(grades: hl, il, java)

	An abbreviation for `--high-level-code --high-level-data'.

 --tags {none, low, high}      (This option is not for general use.)

	Specify whether to use the low bits or the high bits of 
	each word as tag bits (default: low).

 --num-tag-bits <n>            (This option is not for general use.)

	Use <n> tag bits.

 --num-reserved-addresses <n>  (This option is not for general use.)

	Treat the integer values from 0 up to <n> - 1 as reserved
	addresses that can be used to represent nullary constructors
	(constants) of discriminated union types.

 --num-reserved-objects <n>    (This option is not for general use.)

	Allocate up to <n> global objects per type,
	for representing nullary constructors
	(constants) of discriminated union types.

 --reserve-tag			(grade modifier: `.rt')

	Reserve a tag in the data representation of the generated 
	code. This tag is intended to be used to give an explicit
	representation to free variables.
	This is necessary for a seamless Herbrand constraint solver -
	for use with HAL.

 --unboxed-float

(This option is not for general use.)
	Don't box floating point numbers.
	This assumes that a Mercury float will fit in a word.
	The C code needs to be compiled with `-UBOXED_FLOAT'.
	It may also need to be compiled with
	`-DUSE_SINGLE_PREC_FLOAT', if double precision
	floats don't fit into a word.

 --use-minimal-model

(This option is not for general use.)
	Enable the use of minimal model tabling.

 --no-type-layout

(This option is not for general use.)
	Don't output type_ctor_layout structures or references
	to them. (The C code also needs to be compiled with
	`-DNO_TYPE_LAYOUT').

 --low-level-debug

	Enables various low-level debugging stuff, that was in
	the distant past used to debug the low-level code generation.
	You don't want to use this option unless you are hacking
	the Mercury compiler itself (and probably not even then).
	Causes the generated code to become VERY big and VERY
	inefficient.  Slows down compilation a LOT.

 --pic

	Generate position-independent code.
	This option is only used by the `--target asm' back-end.
	The generated assembler code will be written to
	`<module>.pic_s' rather than to `<module>.s'.

 --no-trad-passes

	The default `--trad-passes' completely processes each predicate
	before going on to the next predicate.
	This option tells the compiler
	to complete each phase of code generation on all predicates
	before going on the next phase on all predicates.

 --no-reclaim-heap-on-nondet-failure

	Don't reclaim heap on backtracking in nondet code.

 --no-reclaim-heap-on-semidet-failure

	Don't reclaim heap on backtracking in semidet code.

 --no-reclaim-heap-on-failure

	Combines the effect of the two options above.

 --max-jump-table-size

	The maximum number of entries a jump table can have.
	The special value 0 indicates the table size is unlimited.
	This option can be useful to avoid exceeding fixed limits
	imposed by some C compilers.

 --fact-table-max-array-size <n>

	Specify the maximum number of elements in a single
	`:- pragma fact_table' data array (default: 1024).

 --fact-table-hash-percent-full <percentage>

	Specify how full the `:- pragma fact_table' hash tables
	should be allowed to get.  Given as an integer percentage
	(valid range: 1 to 100, default: 90).

 --branch-delay-slot    	(This option is not for general use.)

	Assume that branch instructions have a delay slot.

 --num-real-r-regs <n>  	(This option is not for general use.)

	Assume registers r1 up to r<n> are real general purpose
	registers.

 --num-real-f-regs <n>  	(This option is not for general use.)

	Assume registers f1 up to f<n> are real floating point
	registers.

 --num-real-r-temps <n> 	(This option is not for general use.)

	Assume that <n> non-float temporaries will fit into
	real machine registers.

 --num-real-f-temps <n> 	(This option is not for general use.)

	Assume that <n> float temporaries will fit into
	real machine registers.

 -O <n>, --opt-level <n>, --optimization-level <n>

	Set optimization level to <n>.
	Optimization level -1 means no optimization
	while optimization level 6 means full optimization.

 --opt-space, --optimize-space

	Turn on optimizations that reduce code size
	and turn off optimizations that significantly
	increase code size.

 --intermodule-optimization

	Perform inlining and higher-order specialization of
	the code for predicates imported from other modules.
	This option must be set throughout the compilation process.

 --trans-intermod-opt

 --transitive-intermodule-optimization

	Import the transitive intermodule optimization data.
	This data is imported from `<module>.trans_opt' files.

 --no-read-opt-files-transitively

	Only read the inter-module optimization information
	for directly imported modules, not the transitive
	closure of the imports.

 --use-opt-files

	Perform inter-module optimization using any
	`.opt' files which are already built,
	e.g. those for the standard library, but do
	not build any others.

 --use-trans-opt-files

	Perform inter-module optimization using any
	`.trans_opt' files which are already built,
	e.g. those for the standard library, but do
	not build any others.

 --intermodule-analysis

	Perform analyses such as termination analysis and
	unused argument elimination across module boundaries.
	This option is not yet fully implemented.

 --split-c-files

	Generate each C function in its own C file,
	so that the linker will optimize away unused code.
	This option significantly increases compilation time,
	link time, and intermediate disk space requirements,
	but in return reduces the size of the final
	executable, typically by about 10-20%.
	This option is only useful with `--procs-per-c-function 1',
	so this option automatically sets `--procs-per-c-function 1'.
	The `--high-level-code' back-end does not support
	`--split-c-files'.

 --no-inlining

	Disable all forms of inlining.

 --no-inline-simple

	Disable the inlining of simple procedures.

 --no-inline-builtins

	Generate builtins (e.g. arithmetic operators) as calls to
	out of line procedures.  This is done by default when,
	debugging, as without this option the execution of
	builtins is not traced.

 --no-inline-single-use

	Disable the inlining of procedures called only once.

 --inline-compound-threshold <threshold>

	Inline a procedure if its size (measured roughly
	in terms of the number of connectives in its internal form),
	multiplied by the number of times it is called,
	is below the given threshold.

 --inline-simple-threshold <threshold>

	Inline a procedure if its size is less than the
	given threshold.

 --intermod-inline-simple-threshold

	Similar to `--inline-simple-threshold', except used to
	determine which predicates should be included in
	`.opt' files. Note that changing this between writing
	the `.opt' file and compiling to C may cause link errors,
	and too high a value may result in reduced performance.

 --inline-vars-threshold <threshold>

	Don't inline a call if it would result in a procedure
	containing more than <threshold> variables. Procedures
	containing large numbers of variables can cause
	slow compilation.

 --no-common-struct

	Disable optimization of common term structures.

 --no-common-goal

	Disable optimization of common goals.
	At the moment this optimization
	detects only common deconstruction unifications.
	Disabling this optimization reduces the class of predicates
	that the compiler considers to be deterministic.

 --constraint-propagation

	Enable the constraint propagation transformation,
	which attempts to transform the code so that goals
	which can fail are executed as early as possible.

 --local-constraint-propagation

	Enable the constraint propagation transformation,
	but only rearrange goals within each procedure.
	Specialized versions of procedures will not be created.

 --prev-code

	Migrate into the start of branched goals.

 --no-follow-code

	Don't migrate into the end of branched goals.

 --excess-assign

	Remove excess assignment unifications.

 --optimize-duplicate-calls

	Optimize away multiple calls to a predicate
	with the same input arguments.

 --loop-invariants

	Hoist loop invariants out of loops.

 --delay-constructs

	Reorder goals to move construction unifications after
	primitive goals that can fail.

 --optimize-saved-vars

	Minimize the number of variables saved across calls.

 --optimize-unused-args

	Remove unused predicate arguments.
	This will cause the compiler to generate more
	efficient code for many polymorphic predicates.

 --intermod-unused-args

	Perform unused argument removal across module boundaries.
	This option implies `--optimize-unused-args' and
	`--intermodule-optimization'.

 --optimize-higher-order

	Enable specialization of higher-order predicates.

 --type-specialization

	Enable specialization of polymorphic predicates where the
	polymorphic types are known.

 --user-guided-type-specialization

	Enable specialization of polymorphic predicates for which
	there are `:- pragma type_spec' declarations.

 --higher-order-size-limit

	Set the maximum goal size of specialized versions created by
	`--optimize-higher-order' and `--type-specialization'.
	Goal size is measured as the number of calls, unifications
	and branched goals.

 --higher-order-arg-limit

	Set the maximum size of higher-order arguments to
	be specialized by `--optimize-higher-order' and
	`--type-specialization'.

 --unneeded-code

	Remove goals from computation paths where their outputs are
	not needed, provided the semantics options allow the deletion
	or movement of the goal.

 --unneeded-code-copy-limit

	Gives the maximum number of places to which a goal may be copied
	when removing it from computation paths on which its outputs are
	not needed. A value of zero forbids goal movement and allows
	only goal deletion; a value of one prevents any increase in the
	size of the code.

 --introduce-accumulators

	Attempt to introduce accumulating variables into
	procedures, so as to make them tail recursive.

 --optimize-constructor-last-call

	Enable the optimization of "last" calls that are followed by
	constructor application.

 --deforestation

	Enable deforestation. Deforestation is a program
	transformation whose aim is to avoid the construction of
	intermediate data structures and to avoid repeated traversals
	over data structures within a conjunction.

 --deforestation-depth-limit <limit>

	Specify a depth limit to prevent infinite loops in the
	deforestation algorithm.
	A value of -1 specifies no depth limit. The default is 4.

 --deforestation-vars-threshold <threshold>

	Specify a rough limit on the number of variables
	in a procedure created by deforestation.
	A value of -1 specifies no limit. The default is 200.

 --deforestation-size-threshold <threshold>

	Specify a rough limit on the size of a goal
	to be optimized by deforestation.
	A value of -1 specifies no limit. The default is 15.

 --no-smart-indexing

	Generate switches as a simple if-then-else chains;
	disable string hashing and integer table-lookup indexing.

 --dense-switch-req-density <percentage>

	The jump table generated for an atomic switch
	must have at least this percentage of full slots (default: 25).

 --lookup-switch-req-density <percentage>

	The jump table generated for an atomic switch
	in which all the outputs are constant terms
	must have at least this percentage of full slots (default: 25).

 --dense-switch-size <n>

	The jump table generated for an atomic switch
	must have at least this many entries (default: 4).

 --lookup-switch-size <n>

	The lookup table generated for an atomic switch
	must have at least this many entries (default: 4).

 --string-switch-size <n>

	The hash table generated for a string switch
	must have at least this many entries (default: 8).

 --tag-switch-size <n>

	The number of alternatives in a tag switch
	must be at least this number (default: 3).

 --try-switch-size <n>

	The number of alternatives in a try/retry chain switch
	must be at least this number (default: 3).

 --binary-switch-size <n>

	The number of alternatives in a binary search switch
	must be at least this number (default: 4).

 --no-static-ground-terms

	Disable the optimization of constructing constant ground terms
	at compile time and storing them as static constants.
	Note that auxiliary data structures created by the compiler
	for purposes such as debugging will still be created as
	static constants.

 --no-middle-rec

	Disable the middle recursion optimization.

 --no-simple-neg

	Don't generate simplified code for simple negations.

 --no-common-data

	Disable optimization of common data structures.

 --no-llds-optimize

	Disable the low-level optimization passes.

 --optimize-dead-procs

	Enable dead predicate elimination.

 --no-optimize-peep

	Disable local peephole optimizations.

 --no-optimize-jumps

	Disable elimination of jumps to jumps.

 --no-optimize-fulljumps

	Disable elimination of jumps to ordinary code.

 --pessimize-tailcalls

	Disable the optimization of tailcalls.

 --checked-nondet-tailcalls

	Convert nondet calls into tail calls whenever possible, even
	when this requires a runtime check. This option tries to
	minimize stack consumption, possibly at the expense of speed.

 --use-local-vars

	Disable the transformation to use local variables in C code
	blocks wherever possible.

 --no-optimize-labels

	Disable elimination of dead labels and code.

 --optimize-dups

	Enable elimination of duplicate code.

 --no-optimize-frames

	Disable stack frame optimizations.

 --no-optimize-delay-slot

	Disable branch delay slot optimizations.

 --optimize-reassign

	Optimize away assignments to locations that already hold
	the assigned value.

 --optimize-repeat <n>

	Iterate most optimizations at most <n> times (default: 3).

 --no-mlds-optimize

	Disable the MLDS->MLDS optimization passes.

 --no-optimize-tailcalls

	Treat tailcalls as ordinary calls, rather than optimizing
	by turning self-tailcalls into loops.

 --no-optimize-initializations

	Leave initializations of local variables as
	assignment statements, rather than converting such
	assignment statements into initializers.

 --eliminate-local-vars

	Eliminate local variables with known values, where possible,
	by replacing occurrences of such variables with their values.

 --optimize-rl

	Enable the optimizations of Aditi-RL procedures
	described below.
	--optimize-rl-invariants
	Optimize loop invariants in Aditi-RL procedures.
	--optimize-rl-index
	Use indexing to optimize access to relations in Aditi-RL
	procedures.
	--detect-rl-streams
	Detect cases where intermediate results in Aditi-RL
	procedures do not need to be materialised.

 --use-macro-for-redo-fail

	Emit the fail or redo macro instead of a branch
	to the fail or redo code in the runtime system.
	This produces slightly bigger but slightly faster code.

 --no-emit-c-loops

	Use only gotos, don't emit C loop constructs.

 --procs-per-c-function <n>

	Put the code for up to <n> Mercury
	procedures in a single C function.  The default
	value of <n> is one.  Increasing <n> can produce
	slightly more efficient code, but makes compilation slower.

 --everything-in-one-c-function

	This option has the effect of putting the code for all
	the Mercury procedures in a single C function,
	which produces the most efficient code but tends to
	severely stress the C compiler on large modules.

Note that if you are using Mmake, you need to pass these options to the target code compiler (e.g. `mgnuc') rather than to `mmc'.

 --target-debug

	Enable debugging of the generated target code.
	If the target language is C, this has the same effect as
	`--c-debug' (see below).
	If the target language is IL, this causes the compiler to
	pass `/debug' to the IL assembler.)

 --cc <compiler-name>

	Specify which C compiler to use.

 --no-c-optimize

	Don't enable the C compiler's optimizations.

 --no-ansi-c

	Don't specify to the C compiler that the ANSI dialect
	of C should be used.  Use the full contents of system
	headers, rather than the ANSI subset.

 --c-debug

	Enable debugging of the generated C code.
	(This has the same effect as `--cflags "-g"'
	and disables stripping of the executable.)

 --c-include-directory <dir>

	Append <dir> to the list of directories to be searched for
	C header files.  Note that if you want to override
	this list, rather than append to it, then you can set the
	`MERCURY_MC_ALL_C_INCL_DIRS' environment variable to a
	sequence of `--c-include-directory' options.

 --inline-alloc

	Inline calls to GC_malloc().
	This can improve performance a fair bit,
	but may significantly increase code size.
	This option has no effect if `--gc boehm'
	is not set or if the C compiler is not GNU C.

 --cflags <options>, --cflag <option>

	Specify options to be passed to the C compiler.
	`--cflag' should be used for single words which need
	to be quoted when passed to the shell.

 --javac <javac>

 --java-compiler <javac>

	Specify which Java compiler to use.  The default is `javac'.

 --java-interpreter <java>

	Specify which Java interpreter to use.
	The default is `java'

 --java-flags <options>, --java-flag <option>

	Specify options to be passed to the Java compiler.
	`--java-flag' should be used for single words which need
	to be quoted when passed to the shell.

 --java-classpath <path>

	Set the classpath for the Java compiler.

 --java-object-file-extension <ext>

	Specify an extension for Java object (bytecode) files
	By default this is `.class'.

 --il-assembler <ilasm>

	Specify the name of the .NET IL Assembler command.

 --ilasm-flags <options>, --ilasm-flag <options>

	Specify options to be passed to the IL assembler.
	`--ilasm-flag' should be used for single words which need
	to be quoted when passed to the shell.

 --mcpp-compiler <cl>

	Specify the name of the Microsoft Managed C++ Compiler.

 --mcpp-flags <options>, --mcpp-flag <option>

	Specify options to be passed to the Managed C++ compiler.
	`--mcpp-flag' should be used for single words which need
	to be quoted when passed to the shell.

 --csharp-compiler <csc>

	Specify the name of the C# Compiler.  The default is `csc'.

 --csharp-flags <options>, --csharp-flag <option>

	Specify options to be passed to the C# compiler.
	`--csharp-flag' should be used for single words which need
	to be quoted when passed to the shell.

 -o <filename>, --output-file <filename>

	Specify the name of the final executable.
	(The default executable name is the same as the name
	of the first module on the command line.)
	This option is ignored by `mmc --make'.

 --ld-flags <options>, --ld-flags <option>

	Specify options to be passed to the linker command
	invoked by ml to link an executable.
	Use `ml --print-link-command' to find out which
	command is used.
	`--ld-flag' should be used for single words which need
	to be quoted when passed to the shell.

 --ld-libflags <options>, --ld-libflag <option>

	Specify options to be passed to the linker command
	invoked by ml to link a shared library.
	Use `ml --print-shared-lib-link-command' to find out
	which command is used.
	`--ld-libflags' should be used for single words which need
	to be quoted when passed to the shell.

 -L <directory>, --library-directory <directory>

	Append <directory> to the list of directories in which
	to search for libraries.

 -R <directory>, --runtime-library-directory <directory>

	Append <directory> to the list of directories in which
	to search for shared libraries at runtime.

 -l <library>, --library <library>

	Link with the specified library.

 --link-object <object-file>

	Link with the specified object file.

 --mld <directory>, --mercury-library-directory <directory>

	Append <directory> to the list of directories to
	be searched for Mercury libraries. This will add
	`--search-directory', `--library-directory',
	`--init-file-directory' and `--c-include-directory'
	options as needed.

 --mercury-standard-library-directory <directory>

 --mercury-stdlib-dir <directory>

	Search <directory> for the Mercury standard library.
	Implies `--mercury-library-directory <directory>'
	and `--mercury-configuration-directory <directory>'.

 --no-mercury-standard-library-directory

 --no-mercury-stdlib-dir

	Don't use the Mercury standard library.
	Implies `--no-mercury-configuration-directory'.

 --ml <library>, --mercury-library <library>

	Link with the specified Mercury library.

 --linkage {shared|static}

	Specify whether to use shared or static linking for
	executables.  Shared libraries are always linked
	with `--linkage shared'.

 --mercury-linkage {shared|static}

	Specify whether to use shared or static linking when
	linking an executable with Mercury libraries.
	Shared libraries are always linked with
	`--mercury-linkage shared'.

 --init-file-directory <directory>

	Append <directory> to the list of directories to
	be searched for `.init' files by c2init.

 --init-file <init-file>

	Append <init-file> to the list of `.init' files to
	be passed to c2init.

 --trace-init-file <init-file>

	Append <init-file> to the list of `.init' files to
	be passed to c2init when tracing is enabled.

 --no-strip

	Don't strip executables.

 --no-demangle

	Don't pipe link errors through the Mercury demangler.

 --no-main

	Don't generate a C main() function.  The user's code must
	provide a main() function.

 --allow-undefined

	Allow undefined symbols in shared libraries.

 --no-use-readline

	Disable use of the readline library in the debugger.

 --runtime-flags <flags>

	Specify flags to pass to the Mercury runtime.

 --extra-initialization-functions, --extra-inits

	Search `.c' files for extra initialization functions.
	(This may be necessary if the C files contain
	hand-coded C code with `INIT' comments, rather than
	containing only C code that was automatically generated
	by the Mercury compiler.)

 -m, --make

	Treat the non-option arguments to `mmc' as files to
	make, rather than source files.  Create the specified
	files, if they are not already up-to-date.
	Note that this option also enables `--use-subdirs'.

 -r, --rebuild

	Same as `--make', but always rebuild the target files
	even if they are up to date.

 -k, --keep-going

	With `--make', keep going as far as
	possible even if an error is detected.

 --pre-link-command <command>

	Specify a command to run before linking with `mmc --make'.
	This can be used to compile C source files which rely on
	header files generated by the Mercury compiler.
	The command will be passed the names of all of the source
	files in the program or library, with the source file
	containing the main module given first.

 --extra-init-command <command>

	Specify a command to produce extra entries in the `.init'
	file for a library.
	The command will be passed the names of all of the source
	files in the program or library, with the source file
	containing the main module given first.

 --install-prefix <dir>

	The directory under which to install Mercury libraries.

 --install-command <command>

	Specify the command to use to install the files in
	Mercury libraries. The given command will be invoked as
	`<command> <source> <target>' to install each file
	in a Mercury library. The default command is `cp'.

 --libgrade <grade>

	Add <grade> to the list of compilation grades in
	which a library to be installed should be built.

 --options-file <file>

	Add <file> to the list of options files to be processed.
	If <file> is `-', an options file will be read from the
	standard input.  By default the file `Mercury.options'
	in the current directory will be read.

 --options-search-directory <dir>

	Add <dir> to the list of directories to be searched for
	options files.

 --mercury-configuration-directory <directory>

 --mercury-config-dir <directory>

	Search <directory> for Mercury system's configuration files.

 --config-file <file>

	Read the Mercury compiler's configuration information
	from <file>.  If the `--config-file' option is not set,
	a default configuration will be used, unless
	`--no-mercury-stdlib-dir' is passed to mmc.
	The configuration file is just an options file.

 -I <dir>, --search-directory <dir>

	Append <dir> to the list of directories to be searched for
	imported modules.

 --intermod-directory <dir>

	Add <dir> to the list of directories to be
	searched for `.opt' files.

 --no-use-search-directories-for-intermod

	Don't add arguments to `--search-directory' to the list
	of directories to search for `.opt' files - use only the
	directories given by `--intermod-directory'.

 --use-subdirs

	Generate intermediate files in a `Mercury' subdirectory,
	rather than generating them in the current directory.

 --use-grade-subdirs

	Generate intermediate files in a `Mercury' subdirectory,
	laid out so that multiple grades can be built simultaneously.
	Executables and libraries will be symlinked or copied into
	the current directory.
	`--use-grade-subdirs' does not work with Mmake (it does
	work with `mmc --make').

 --filenames-from-stdin

	Read then compile a newline terminated module name or
	file name from the standard input. Repeat this until EOF
	is reached. (This allows a program or user to interactively
	compile several modules without the overhead of process
	creation for each one.)

 --aditi

	Enable Aditi compilation. You need to enable this
	option if you are making use of the Aditi deductive
	database interface.

 --aditi-user

	Specify the Aditi login of the owner of the predicates
	in any Aditi RL files produced. The owner field is
	used along with module, name and arity to identify
	predicates, and is also used for security checks.
	Defaults to the value of the `USER' environment
	variable. If `$USER' is not set, `--aditi-user'
	defaults to the string "guest".

The Mercury team.

See <http://www.cs.mu.oz.au/mercury/contact/people.html>.

This program and its documentation are copyright by the University of Melbourne. They may be copied only under the terms of the GNU General Public License - see the file COPYING in the Mercury distribution.

<http://www.cs.mu.oz.au/mercury/information/documentation.html>

The Mercury User's Guide.

The GNU General Public License.