#! /bin/sh
# Generated automatically from ml.in by configure.
#---------------------------------------------------------------------------#
# Copyright (C) 1995-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# ML - Mercury Linker.
#
# Invokes GCC with the appropriate options to link in the Mercury library.
#
# Usage: see below.
#
# Environment variables: MERCURY_C_LIB_DIR, MERCURY_DEFAULT_GRADE, ...

Usage="\
Name: ml - Mercury Linker
Usage: ml [<ml options>] [-- <gcc options>] files..."

FULLARCH=i586-mandrake-linux-gnu
DEFAULT_GRADE=${MERCURY_DEFAULT_GRADE=asm_fast.gc}

# include the file `parse_ml_options.sh-subr'

#---------------------------------------------------------------------------#
# Copyright (C) 2001-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# parse_ml_options.sh-subr:
#       An `sh' subroutine for parsing the options for the `ml' and `c2init'
#	scripts. `ml' and `c2init' share the same set of options so that
#	users can mostly ignore the existence of `c2init'.
#
# The invoking script must set the shell variable `Usage' to a string
# containing the name and description of the script and the general
# format of the command line.
#
# The invoking script must also define FULLARCH and DEFAULT_GRADE.
#---------------------------------------------------------------------------#

# initialize common options
mercury_stdlib_dir=${MERCURY_STDLIB_DIR=/usr/lib/mercury}

# initialize ml options
verbose=false
allow_undef=false
trace=false
readline=true
case $FULLARCH in
	*-win95|*-winnt|*-win32|*-cygwin32|*-cygwin)
		# `gcc -s' is broken in gnu-win32
		strip=false
		;;
	*-darwin*)
		# `gcc -s' doesn't seem to do the right thing on Mac OS X
		strip=false
		;;
	*)
		strip=true
		;;
esac
mercury_libs=default
all_libs=default
demangle=true
make_shared_lib=false
leave_shlib_dirs_relative=false
user_shlib_dirs=""
use_thread_libs=false
print_grade=false
print_gc_grade=false
print_link_command=false
print_shared_lib_link_command=false

# initialize c2init options
maxcalls=40	# maximum number of calls to put in a single function
defentry_opt=""
init_opt=""
trace_opt=""
library_opt=""
extra_inits_opt=""
aditi_opt=""
extra_init_dirs=""
trace_init_files=""
init_c_file="-"
runtime_flags=""

# include the file `init_grade_options.sh-subr'

#---------------------------------------------------------------------------#
# Copyright (C) 1997-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# init_grade_options.sh-subr:
#	An `sh' subroutine for initializing grade-related options.
#	Used by the `ml', `mgnuc' and `c2init' scripts.
#
#	The code here should be inserted before a script's option-parsing
#	loop.  The invoking script must define a DEFAULT_GRADE option.
#
# IMPORTANT: any changes to the handling of grades here may also require
# changes to all the files indicated by runtime/mercury_grade.h.
#
# This file must initialize all the shell variables used by
# parse_grade_options.sh-subr, and must list all the options processed in
# parse_grade_options.sh-subr.
#
#---------------------------------------------------------------------------#

grade_usage="\
Grade options:
	-s <grade>, --grade <grade>
	--target {il, c, java, asm}
	--il
	--asm-labels
	--gcc-non-local-gotos
	--gcc-global-registers
	-H, --high-level-code
	--parallel
	--gc {boehm, mps, accurate, none}
	-p, --profiling
	--profile-calls
	--profile-time
	--profile-memory
	--profile-deep
	--use-trail
	--reserve-tag
	--use-minimal-model
	--pic-reg
	--no-stack-trace
	--debug
	--decl-debug
		See the documentation in the \"Invocation\" section
		of the Mercury User's Guide."

# --gcc-nested-functions is not yet documented because it is not yet stable
# --high-level-data is not yet documented because it is not yet implemented
# --high-level is not yet documented because --high-level-data is
#		not yet implemented

target=c
highlevel_code=false
highlevel_data=false
gcc_nested_functions=false
asm_labels=true
non_local_gotos=true
global_regs=true
thread_safe=false
gc_method=boehm
profile_time=false
profile_calls=false
profile_memory=false
profile_deep=false
use_trail=false
reserve_tag=false
use_minimal_model=false
pic_reg=false
stack_trace=false
require_tracing=false
decl_debug=false

case $# in
	0) set - --grade "$DEFAULT_GRADE" ;;
	*) set - --grade "$DEFAULT_GRADE" "$@" ;;
esac

#---------------------------------------------------------------------------#

Help="\
$Usage
Options:
	-h, --help
		Print this help message.

Diagnostics options:
	-v, --verbose
		Print each command before executing it.
	--no-demangle
		Don't pipe the output of the linker through the Mercury
		demangler.
	--allow-undef
	--allow-undefined
		Don't report an error if there are unresolved symbols.
		This option is only used if you are building a shared
		library (with \`--make-shared-lib); when building
		executables, unresolved symbols are always errors.
		This option is useful when building shared libraries
		that are not intended to be self-contained.
	--print-grade
		Compute the grade of the Mercury libraries to link with based
		on the command line options, print it to the standard output,
		and then exit (don't actually link anything).
	--print-gc-grade
		Compute the base name of the garbage collection library to
		link with based on the command line options, print it to the
		standard output, and then exit (don't actually link anything).
	--print-link-command
		Print the command used to link executables.
	--print-shared-lib-link-command
		Print the command used to link shared libraries.

Dynamic/static linking options:
	--mercury-libs {shared, static, none}
		Specify which version of the standard Mercury libraries to
		link with:
			--mercury-libs shared
				Link with the shared libraries (*.so),
				if possible, otherwise with the static ones.
			--mercury-libs static
				Link with the static libraries (*.a).
			--mercury-libs none
				Don't link in the Mercury standard libraries.
	-shared, --shared
		Similar to \`--mercury-libs shared', but applies to all
		libraries, not just the standard Mercury libraries.
	-static, --static
		Similar to \`--mercury-libs static', but applies to all
		libraries, not just the standard Mercury libraries.
	--make-shared-lib
		Produce a shared library, rather than an executable.

Directory options:
	--mercury-standard-library-directory <directory>
	--mercury-stdlib-dir <directory>
		The directory in which to find the Mercury standard library.
	--no-mercury-standard-library-directory, --no-mercury-stdlib-dir
		Same as \`--mercury-libs none'.
	-L <directory>, --lib-dir <directory>
		Include <directory> in the list of directories that the
		linker will use to search for libraries.
	-R <directory>, --shared-lib-dir <directory>
		Include <directory> in the list of directories that the
		dynamic linker will use to search for shared libraries.
	--leave-shared-lib-dirs-relative
		Don't convert relative shared library directory names
		into absolute paths.
	--no-leave-shared-lib-dirs-relative
		Convert relative shared library directory names into
		absolute paths.  This is the default.

Debugging options:
	-t, --trace
		Link in the Mercury debugging libraries.
		This option is needed if any of the modules being linked
		were compiled with tracing enabled.  However, \`--debug'
		implies \`--trace', so if you're using \`--debug',
		then you don't need to explicitly specify \`--trace'.
		Note that \`--trace' is incompatible with \`--static'
		on some platforms (e.g. sparc-sun-solaris2.6).
		Implies \`--include-initialization-code'.
	-r-, --no-readline
		Don't link in the GPL'd GNU Readline Library.
	-g, --c-debug, --no-strip
		Do not strip C debugging information.

Initialization options:
	--no-main, --library
		Don't generate a \`main()' function.
		Instead, generate a function
			mercury_main(int argc, char **argv);
		(declared in \"mercury_init.h\") that can be called
		from C code.
		(A more fine-grained interface is also available;
		see \"mercury_init.h\" for details.)
	-I <directory>, --init-file-directory <directory>
		Include <directory> in the list of directories searched to
		locate \`.init' files.
	-w <label>, --entry-point <label>
		Set entry point to <label>.
		(Default value corresponds to main/2.)
	--runtime-flags <flags>
		Add <flags> to the list of flags to pass to the
		Mercury runtime.  Flags can also be passed at runtime
		in the MERCURY_OPTIONS environment variable.
		For the list of available flags, see the documentation
		for MERCURY_OPTIONS in the "Environment" chapter
		of the Mercury User's Guide.
	--init-c-file <filename>
		Output the generated C initialization program to the
		specified file, rather than sending it to the standard
		output.
	-a, --aditi
		Generate a function to upload Aditi-RL data to a database.
		This option is needed when interfacing with the Aditi
		deductive database system.
	-x, --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.)

Threads options:
	--use-thread-libs
		Link with the POSIX thread libraries. This option is useful
		if a C library being linked with uses threads, but the
		Mercury code being linked doesn't.

$grade_usage

Environment variables:
		MERCURY_DEFAULT_GRADE, MERCURY_C_COMPILER,
		MERCURY_C_LIB_DIR, MERCURY_NONSHARED_LIB_DIR,
		MERCURY_MOD_LIB_MODS, MERCURY_TRACE_LIB_MODS,
		MERCURY_MKINIT."

# The following options are not generally useful, so they are not documented:
# -i, --include-initialization-code
# 	Always include code that calls the initialization functions
# 	of the various modules. With this option, the debugger can use
# 	information from any modules that were compiled with execution
# 	tracing to print (partial) stack traces, and to print the
# 	values of variables in ancestors of the current call, even
# 	in grades in which this not normally possible.
#	(It's usually better just to use `--trace').
# -c <n>, --max-calls <n>
#         Break up the initialization into groups of at most <n> function
#         calls.  (Default value of <n> is 40.)
 
while : ; do
    case "$1" in
	-h|--help|"-?")
		echo "$Help"
		exit 0
		;;
	-v|--verbose)
		verbose=true
		;;

	#
	# ml options.
	#
	--demangle)
		demangle=true
		;;
	--no-demangle)
		demangle=false
		;;
	--allow-undef|--allow-undefined)
		allow_undef=true
		;;
	--no-allow-undef|--no-allow-undefined)
		allow_undef=false
		;;
	-t|--trace)
		trace=true
		trace_opt="-t"
		;;
	-t-|--no-trace)
		trace=false
		trace_opt=""
		;;
	-r|--readline)
		readline=true
		;;
	-r-|--no-readline)
		readline=false
		;;
	-g-|--no-c-debug|--strip)
		strip=true
		;;
	-g|--c-debug|--no-strip)
		strip=false
		;;
	--make-shared-lib)
		make_shared_lib=true
		# on some targets, stripping shared libraries will
		# make them unusable, I think, so don't strip
		strip=false
		;;
	--no-libs)
		progname=`basename $0`
		cat 1>&2 << EOF
$progname: Warning: option \`--no-libs' is deprecated --
$progname:   please use the new option \`--mercury-libs none' instead.
$progname:   Support for \`--no-libs' may be removed in a future release.
EOF
		mercury_libs=none
		;;
	--mercury-libs)
		case "$2" in
			shared|static|default)
				mercury_libs="$2"
				shift ;;
			none)
				mercury_libs=none
				unset mercury_stdlib_dir
				shift ;;
			*)
				progname=`basename $0`
				cat 1>&2 << EOF
$progname: Error: parameter to \`--mercury-libs' option should be either
$progname:   \`shared', \`static', \`none', or \`default', not \`$2'.
$progname: Try \`$0 --help' for help.
EOF
				exit 1
				;;
		esac
		;;
	-shared|--shared)
		all_libs=shared
		case $mercury_libs in static|default)
			mercury_libs=shared ;;
		esac
		;;
	-static|--static)
		all_libs=static
		case $mercury_libs in shared|default)
			mercury_libs=static ;;
		esac
		;;

	--mercury-standard-library-directory|--mercury-stdlib-dir)
		mercury_stdlib_dir="$2"
		shift
		;;
	--no-mercury-standard-library-directory|--no-mercury-stdlib-dir)
		mercury_libs=none
		unset mercury_stdlib_dir
		;;

	-L|--lib-dir)
		dir="$2"
		user_libdir_opts="$user_libdir_opts -L$dir"
		shift
		;;
	-L*)
		user_libdir_opts="$user_libdir_opts $1"
		;;
	--leave-shared-lib-dirs-relative)
		leave_shlib_dirs_relative=true
		;;
	--no-leave-shared-lib-dirs-relative)
		leave_shlib_dirs_relative=false
		;;
	-R|--shared-lib-dir)
		dir="$2"
		case $leave_shlib_dirs_relative in false)
			case "$dir" in
				/*) ;;
				*)  dir="`pwd`/$dir" ;;
			esac
			;;
		esac
		user_shlib_dirs="$user_shlib_dirs $dir"
		shift
		;;
	-R*)
		dir="` expr $1 : '-R\(.*\)' `"
		case $leave_shlib_dirs_relative in false)
			case "$dir" in
				/*) ;;
				*)  dir="`pwd`/$dir" ;;
			esac
			;;
		esac
		user_shlib_dirs="$user_shlib_dirs $dir"
		;;

	--use-thread-libs)
		use_thread_libs=true
		;;
	--no-use-thread-libs)
		use_thread_libs=false
		;;

	--print-grade)
		print_grade=true
		;;
	--no-print-grade)
		print_grade=false
		;;
	--print-gc-grade)
		print_gc_grade=true
		;;
	--no-print-gc-grade)
		print_gc_grade=false
		;;
	--print-link-command)
		print_link_command=true
		;;
	--no-print-link-command)
		print_link_command=false
		;;
	--print-shared-lib-link-command)
		print_shared_lib_link_command=true
		;;
	--no-print-shared-lib-link-command)
		print_shared_lib_link_command=false
		;;

	#
	# c2init options.
	#
	-a|--aditi)
		aditi_opt="-a";;	
	-a-|--no-aditi)
		aditi_opt="";;	
	-c|--max-calls)
		maxcalls="$2"; shift;;

	-i|--include-initialization-code)
		init_opt="-i";;

	--no-main|--library)
		library_opt="-l";;

	--main|--no-library)
		library_opt="";;

	-I|--init-file-directory)
		extra_init_dirs="$extra_init_dirs -I $2"; shift;;

	--init-c-file)
		init_c_file="$2"; shift;;

	--trace-init-file)
		trace_init_files="$trace_init_files $2"; shift;;

	--runtime-flags)
		runtime_flags="$runtime_flags $2"; shift;;

	-w|--entry-point)
		defentry_opt="-w$2"; shift;;

	-x|--extra-inits)
		extra_inits_opt="-x";;

	-x-|--no-extra-inits)
		extra_inits_opt="";;

	# include the file `parse_grade_options.sh-subr'
	
#---------------------------------------------------------------------------#
# Copyright (C) 1997-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# parse_grade_options.sh-subr:
#	An `sh' subroutine for parsing grade-related options.
#	Used by the `ml', `mgnuc' and `c2init' scripts.
#
#	The code here should be inserted in the case statement in a script's
#	option-parsing loop.
#
# IMPORTANT: any changes to the handling of grades here may also require
# changes to all the files indicated by runtime/mercury_grade.h.
#
# This file should handle the setting of all the shell variables defined by
# init_grade_options.sh-subr.
#
#---------------------------------------------------------------------------#

	--target)
		shift
		case "$1" in
			asm)
				target=asm ;;
			c|C)
				target=c ;;
			il|IL)
				target=il ;;
			java|Java)
				target=java ;;
			*)
				echo "$0: invalid target \`$1'" 1>&2
				exit 1
				;;
		esac
		;;

	--il|--IL|--il-only|--IL-only)
		target=il ;;

	--high-level-code|-H)
		highlevel_code=true ;;
	--no-high-level-code|-H-)
		highlevel_code=false ;;

	--high-level-data)
		highlevel_data=true ;;
	--no-high-level-data)
		highlevel_data=false ;;

	--gcc-nested-functions)
		gcc_nested_functions=true ;;
	--no-gcc-nested-functions)
		gcc_nested_functions=false ;;

	--asm-labels)
		asm_labels=true ;;
	--no-asm-labels)
		asm_labels=false ;;

	--gcc-non-local-gotos)
		non_local_gotos=true ;;
	--no-gcc-non-local-gotos)
		non_local_gotos=false ;;

	--gcc-global-registers)
		global_regs=true ;;
	--no-gcc-global-registers)
		global_regs=false ;;

	--gc)
		shift
		case "$1" in
			accurate|conservative|boehm|mps|none)
				gc_method=$1 ;;
			*)
				echo "$0: invalid gc method \`$1'" 1>&2
				exit 1
				;;
		esac
		;;

	--parallel)
		thread_safe=true ;;

	-p|--profiling|--time-profiling)
		profile_time=true
		profile_calls=true
		profile_memory=false
		profile_deep=false
		;;
	--memory-profiling)
		profile_time=false
		profile_calls=true
		profile_memory=true
		profile_deep=false
		;;
	--deep-profiling)
		profile_time=false
		profile_calls=false
		profile_memory=false
		profile_deep=true
		;;
	-p-|--no-profiling)
		profile_time=false
		profile_calls=false
		profile_memory=false
		profile_deep=false
		;;
	--profile-time)
		profile_time=true ;;
	--no-profile-time)
		profile_time=false ;;
	--profile-calls)
		profile_calls=true ;;
	--no-profile-calls)
		profile_calls=false ;;
	--profile-memory)
		profile_memory=true ;;
	--no-profile-memory)
		profile_memory=false ;;
	--profile-deep)
		profile_deep=true ;;
	--no-profile-deep)
		profile_deep=false ;;

	--use-trail)
		use_trail=true ;;
	--no-use-trail)
		use_trail=false ;;

	--reserve-tag)
		reserve_tag=true ;;
	--no-reserve-tag)
		reserve_tag=false ;;

	--use-minimal-model)
		use_minimal_model=true ;;
	--no-use-minimal-model)
		use_minimal_model=false ;;

	--pic-reg)
		pic_reg=true ;;
	--no-pic-reg)
		pic_reg=false ;;

# The following more fine-grained options have been omitted
# since they are not very useful and would probably only confuse people.
#	--stack-trace)
#		stack_trace=true ;;
#	--no-stack-trace)
#		stack_trace=false ;;
#	--require-tracing)
#		require_tracing=true ;;
#	--no-require-tracing)
#		require_tracing=false ;;

	--debug)
		stack_trace=true
		require_tracing=true ;;
	--no-debug)
		stack_trace=false
		require_tracing=false ;;

	--decl-debug)
		decl_debug=true ;;
	--no-decl-debug)
		decl_debug=false ;;

	-s|--grade)
		shift
		grade="$1";

		# Convert a grade to a set of options.
		#
		# IMPORTANT: any changes to the handling of grades here
		# may also require changes to all the files indicated by
		# runtime/mercury_grade.h.

		target=c
		highlevel_code=false
		gcc_nested_functions=false
		highlevel_data=false
		asm_labels=false
		non_local_gotos=false
		global_regs=false
		thread_safe=false
		gc_method=none
		profile_time=false
		profile_calls=false
		profile_memory=false
		profile_deep=false
		use_trail=false
		reserve_tag=false
		use_minimal_model=false
		pic_reg=false
		stack_trace=false
		require_tracing=false
		decl_debug=false

		grade_pieces=`echo $grade | tr '.' ' '`
		for grade_piece in $grade_pieces
		do
			case "$grade_piece" in
				il)
					target=il
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=false
					highlevel_data=true
					;;
				ilc)
					target=il
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=false
					highlevel_data=false
					;;
				java)
					target=java
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=false
					highlevel_data=true
					;;
				hl)
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=false
					highlevel_data=true
					;;
				hlc)
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=false
					highlevel_data=false
					;;
				hl_nest)
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=true
					highlevel_data=true
					;;
				hlc_nest)
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=true
					gcc_nested_functions=true
					highlevel_data=false
					;;
				asm_fast)
					target=c
					asm_labels=true
					non_local_gotos=true
					global_regs=true
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;
				asm_jump)
					target=c
					asm_labels=true
					non_local_gotos=true
					global_regs=false
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;
				fast)
					target=c
					asm_labels=false
					non_local_gotos=true
					global_regs=true
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;
				jump)
					target=c
					asm_labels=false
					non_local_gotos=true
					global_regs=false
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;
				reg)
					target=c
					asm_labels=false
					non_local_gotos=false
					global_regs=true
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;
				none)
					target=c
					asm_labels=false
					non_local_gotos=false
					global_regs=false
					highlevel_code=false
					gcc_nested_functions=false
					highlevel_data=false
					;;

				par)
					thread_safe=true
					;;

				agc)
					gc_method=accurate
					;;
				mps)
					gc_method=mps
					;;
				gc)
					gc_method=boehm
					;;
				nogc)
					gc_method=none
					;;

				memprof)
					profile_time=false
					profile_calls=true
					profile_memory=true
					profile_deep=false
					;;
				prof)
					profile_time=true
					profile_calls=true
					profile_memory=false
					profile_deep=false
					;;
				proftime)	
					profile_time=true
					profile_calls=false
					profile_memory=false
					profile_deep=false
					;;
				profcalls)	
					profile_time=false
					profile_calls=true
					profile_memory=false
					profile_deep=false
					;;
				profall)
					profile_time=true
					profile_calls=true
					profile_memory=true
					profile_deep=false
					;;
				profdeep)
					profile_time=false
					profile_calls=false
					profile_memory=false
					profile_deep=true
					;;

				tr)
					use_trail=true
					;;

				rt)
					reserve_tag=true
					;;

				mm)
					use_minimal_model=true
					;;

				picreg)
					pic_reg=true
					;;

# The following more fine-grained options have been omitted
# since they are not very useful and would probably only confuse people.
#				trace)
#					stack_trace=false
#					require_tracing=true
#
#				strce)
#					stack_trace=true
#					require_tracing=false

				debug)
					stack_trace=true
					require_tracing=true
					;;
				decldebug)
					stack_trace=true
					require_tracing=true
					decl_debug=true
					;;

				*)
					echo "$0: unknown grade component" \
						"\`$grade_piece'" 1>&2
					exit 1
					;;
			esac
		done
		;;

	-s*)
		grade="` expr $1 : '-s\(.*\)' `"
		# just insert it as `--grade $grade' and then reparse it
		shift
		case $# in
			0) set - x --grade "$grade" ;;
			*) set - x --grade "$grade" "$@" ;;
		esac
		;;


	--)
		shift
		break ;;
	*)
		break ;;
    esac
    shift
done

# include the file `final_grade_options.sh-subr'

#---------------------------------------------------------------------------#
# Copyright (C) 1998-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# final_grade_options.sh-subr:
#	An `sh' subroutine for handling implications between grade-related
#	options. Used by the `ml', `mgnuc' and `c2init' scripts.
#
#	The code here should be inserted after a script's option-parsing
#	loop.
#
# IMPORTANT: any changes to the handling of grades here may also require
# changes to compiler/handle_options.m.
#
# This file should only use the shell variables initialized by
# init_grade_options.sh-subr.
#
#---------------------------------------------------------------------------#

#
# .tr grade is not compatible with .mm
#	(see comment in runtime/mercury_tabling.c for rationale)
#
case $use_trail,$use_minimal_model in
	true,true)
		echo "trailing and minimal model tabling are not compatible" 1>&2
		exit 1 ;;
esac

#
# .debug grade implies --use-trail in the absence of .mm
#	(see comment in compiler/handle_options.m for rationale)
#
case $stack_trace,$require_tracing,$use_minimal_model in
	true,true,false)
		use_trail=true ;;
esac

#
# --decl-debug implies --debug
#
case $decl_debug in true)
	require_tracing=true
	stack_trace=true
	;;
esac

#
# --target asm, IL or Java implies --high-level-code
#
case $target in asm|il|java)
	highlevel_code=true ;;
esac

#
# --high-level-code disables the use of low-level gcc extensions
#
case $highlevel_code in true)
	non_local_gotos=false
	asm_labels=false
	global_regs=false
	;;
esac

#---------------------------------------------------------------------------#


# add /usr/local/lib to the default search path, if needed
ALL_LOCAL_C_LIB_DIRS=${MERCURY_ALL_LOCAL_C_LIB_DIRS=/usr/local/lib}
NONSHARED_LIB_DIR=${MERCURY_NONSHARED_LIB_DIR=/usr/lib/nonshared}
DEMANGLER=${MERCURY_DEMANGLER=mdemangle}
CC=${MERCURY_C_COMPILER="gcc"}
MKFIFO=${MERCURY_MKFIFO="/usr/bin/mkfifo"}
ERROR_UNDEFINED="-Wl,--no-undefined"
ALLOW_UNDEFINED=""
EXE_RPATH_OPT=${MERCURY_EXE_RPATH_OPT="-Wl,-rpath,"}
EXE_RPATH_SEP=${MERCURY_EXE_RPATH_SEP=" -Wl,-rpath,"}
EXT_FOR_SHARED_LIB=${MERCURY_EXT_FOR_SHARED_LIB="so"}
LINK_SHARED_OBJ=${MERCURY_LINK_SHARED_OBJ="gcc -shared"}
SHLIB_RPATH_OPT=${MERCURY_SHLIB_RPATH_OPT="-Wl,-rpath,"}
SHLIB_RPATH_SEP=${MERCURY_SHLIB_RPATH_SEP=" -Wl,-rpath,"}
FIX_PATH_FOR_LINKER=${MERCURY_PATH_FOR_LINKER="echo"}
TMPDIR=${TMPDIR=/tmp}
MATH_LIB=${MERCURY_MATH_LIB="-lm"}
# Note: the setting of SHARED_LIBS needs to come after the setting of MATH_LIB,
# since `gcc -print-libgcc-file-name` $MATH_LIB -lc /lib/ld-linux.so.2 may refer to $MATH_LIB.
SHARED_LIBS=${MERCURY_SHARED_LIBS="`gcc -print-libgcc-file-name` $MATH_LIB -lc /lib/ld-linux.so.2"}

# When compiling in the hlc.gc grade using the Microsoft Visual C
# compiler, the default maximum stack size of 4Mb is too low for a
# recursive language.
# XXX at some stage this should become an option to ml
LINK=${LINK=/stack:10485760}   # 10 Mb
export LINK

case "$CC" in
    *gcc*)
	COMPILER=gcc
	;;
    *lcc*)
	COMPILER=lcc
	;;
    *cl* | *CL*)
	COMPILER=cl
	;;
    cc* | */cc*)
	COMPILER=cc
	;;
    *)
	COMPILER=unknown
	;;
esac

# On some systems (Solaris for exemple), we need libraries to be able to 
# use sockets. The name of the needed libraries is determined by autoconf
# and passed through this variable.
SOCKET_LIBRARY=""
NSL_LIBRARY="-lnsl"

# Likewise for -ldl (libdl.so), which is often needed for dlopen() etc.
DL_LIBRARY="-ldl"

# Likewise for -lreadline -l{termcap,curses,ncurses}
READLINE_LIBRARIES="-lreadline -ltermcap"

# If you change these, you will also need to change Mmake.workspace,
# scripts/c2init.in, tools/bootcheck, tools/binary, tools/binary_step
# and tools/linear.
RT_LIB_NAME=mer_rt
STD_LIB_NAME=mer_std
TRACE_LIB_NAME=mer_trace
BROWSER_LIB_NAME=mer_browser

MAYBE_STATIC_OPT=""

# --require-tracing (which is implied by --debug and by --decl-debug)
# implies --trace
case $require_tracing in
	true)	trace=true ;;
	false)	;;
esac

case "$mercury_stdlib_dir" in
    "")	LIBDIR=$MERCURY_C_LIB_DIR ;;
    *)	LIBDIR=${MERCURY_C_LIB_DIR=$mercury_stdlib_dir/lib} ;;
esac

# If you haven't set mercury_libs, set it to the default value
# (shared on most systems). Note that if you have set all_libs,
# it will also have set mercury_libs.
case $mercury_libs in default)
	mercury_libs=shared
	case $FULLARCH in i*86-*-linux*|i*86-*-freebsd*|i*86-*-cygwin*|i*86-*-solaris*)
		# shared libraries are not the default on x86 systems that
		# use ELF -- see README.Linux
		case $make_shared_lib in false)
			mercury_libs=static
			;;
		esac
		;;
	esac
	;;
esac

# If you haven't set all_libs, set it to the default value
# (shared on most systems).
case $all_libs in default)
	all_libs=shared
	case $FULLARCH in i*86-*-linux*|i*86-*-freebsd*|i*86-*-cygwin*)
		# shared libraries are not the default on Linux
		# -- see README.Linux
		# Likewise for FreeBSD and Cygwin
		#
		# We don't do this for Solaris/x86 because -ldl is
		# only available for dynamically linked executables
		# XXX With these defaults linking with Mercury libraries
		# other than the standard library will fail.
		case $make_shared_lib in false)
			all_libs=static
			;;
		esac
		;;
	esac
	;;
esac

# Defaults have been set, now set options.

case $all_libs in static)
	case $COMPILER in gcc|lcc)
		MAYBE_STATIC_OPT=-static
		;;
	esac
	case $FULLARCH in
		*-linux*)
			# On Linux, if we're linking statically, we need to
			# pass `-defsym _DYNAMIC=0' to the linker, to avoid
			# undefined references to _DYNAMIC in
			# boehm_gc/dyn_load.c.
			# (We might eventually need similar treatment
			# for other OSs too)
			case $COMPILER in
	 		gcc)
				MAYBE_STATIC_OPT="-static \
					-Wl-defsym -Wl_DYNAMIC=0"
				;;
			lcc)
				MAYBE_STATIC_OPT="-static \
					-Wl,-defsym -Wl,_DYNAMIC=0"
				;;
			esac
			;;
		alpha*-dec-osf*)
			case $COMPILER in cc)
				MAYBE_STATIC_OPT=-non_shared
				;;
			esac
			;;
		*-sun-solaris*)
			case $COMPILER in cc)
				MAYBE_STATIC_OPT="-B static"
				;;
			esac
			;;
	esac
	case "$MAYBE_STATIC_OPT" in "")
		echo "ml: warning: \`--static' ignored, since I don't" 1>&2
		echo "	know how to enable static linking with this" 1>&2
		echo "	C compiler (\`$CC')." 1>&2
		echo "	Using \`--mercury-libs static' instead." 1>&2
		;;
	esac
esac

#
# compute the canonical grade name from the options settings
#

# include the file `canonical_grade.sh-subr'

#---------------------------------------------------------------------------#
# Copyright (C) 2000-2002 The University of Melbourne.
# This file may only be copied under the terms of the GNU General
# Public License - see the file COPYING in the Mercury distribution.
#---------------------------------------------------------------------------#
#
# canonical_grade.sh-subr:
#	An `sh' subroutine for computing a canonical grade string based on
#	the values of grade-related options.
#	It is used by the `ml', `c2init' and `canonical_grade' scripts.
#
#	The code here should be inserted after init_grade_options.sh-subr,
#	parse_grade_options.sh-subr and final_grade_options.sh-subr, which
#	together define a set of shell variables giving the values of the
#	various grade options.
#
#	Canonical_grade.sh-subr defines the variable GRADE, which will contain
#	the canonical string for the grade implied by the option values.
#
#	If the option values are inconsistent, this script fragment will
#	print an error message and exit with failure.
#
# IMPORTANT: any changes to the handling of grades here may also require
# changes to all the files indicated by runtime/mercury_grade.h.

case $non_local_gotos,$global_regs in
	true,true) 	GRADE="fast" ;;
	true,false)  	GRADE="jump" ;;
	false,true)  	GRADE="reg" ;;
	false,false)   	GRADE="none" ;;
esac

case $asm_labels in
	true)		GRADE="asm_$GRADE" ;;
	false)		;;
esac

case $highlevel_code,$highlevel_data,$GRADE in
	true,true,none)		
		GRADE="hl" ;;
	true,false,none)	
		GRADE="hlc" ;;
	false,false,*)
		# GRADE was set above
		;;
	false,true,*)
		progname=`basename $0`
		echo "$progname: error: \`--high-level-data' requires \`--high-level-code'" 1>&2
		exit 1
		;;
	*)
		echo "$progname: error: \`--high-level-code' is incompatible with the use of" 1>&2
		echo "$progname: error: low-level gcc extensions implied by grade \`$GRADE'" 1>&2
		exit 1
		;;
esac

case $gcc_nested_functions,$highlevel_code in
	true,true)	GRADE="${GRADE}_nest" ;;
	*)		;;
esac
	
case $thread_safe in
	true)	GRADE="$GRADE.par" ;;
	false)	;;
esac

case $gc_method in
	conservative)	GRADE="$GRADE.gc" ;;	# deprecated; alias for boehm
	boehm)		GRADE="$GRADE.gc" ;;
	mps)		GRADE="$GRADE.mps" ;;
	accurate)	GRADE="$GRADE.agc" ;;
esac

case $profile_time,$profile_calls,$profile_memory,$profile_deep in
	true,true,false,false)	GRADE="$GRADE.prof" ;;
	true,false,false,false)	GRADE="$GRADE.proftime" ;;
	false,true,false,false)	GRADE="$GRADE.profcalls" ;;
	true,true,true,false)	GRADE="$GRADE.profall" ;;
	false,true,true,false)	GRADE="$GRADE.memprof" ;;
	false,false,false,true)	GRADE="$GRADE.profdeep" ;;
	false,false,false,false)	;;
	*)			progname=`basename $0`
				echo "$progname: error: invalid combination of profiling options." 1>&2
				exit 1
				;;
esac

case $use_trail in
	true)		GRADE="$GRADE.tr" ;;
	false)		;;
esac

case $reserve_tag in
	true)		GRADE="$GRADE.rt" ;;
	false)		;;
esac

case $use_minimal_model in
	true)	GRADE="$GRADE.mm" ;;
	false)	;;
esac

# We ignore the value of $picreg in computing the name of the grade
# that we will use as a directory name in the Mercury linker.
# case $picreg in
# 	true)	GRADE="$GRADE.picreg" ;;
# 	false)	;;
# esac

case $stack_trace,$require_tracing,$decl_debug in
	true,true,true)		GRADE="$GRADE.decldebug" ;;
	true,true,false)	GRADE="$GRADE.debug" ;;
	false,true,false)	GRADE="$GRADE.trace" ;;
	true,false,false)	GRADE="$GRADE.strce" ;;
	false,false,false)	;;
	*)			echo "$progname: error: invalid combination of debugging options." 1>&2
				exit 1
				;;
esac

# if the --print-grade option is specified,
# then all we do is print the grade and then exit
case "$print_grade" in true)
	echo $GRADE
	exit 0
esac

# Compute the gc grade from the grade
case "$GRADE" in
	*.par*.gc*.prof*)
		gc_grade=par_gc_prof ;;
	*.par*.gc*)
		gc_grade=par_gc ;;
	*.gc*.prof*)
		gc_grade=gc_prof ;;
	*.gc*)
		gc_grade=gc ;;
	*.mps*)
		gc_grade=mps ;;
	*)
		gc_grade=nogc ;;
esac

# if the --print-gc-grade option is specified,
# then all we do is print the gc grade and then exit
case "$print_gc_grade" in true)
	echo $gc_grade
	exit 0
esac

case "$gc_grade" in
	nogc)	
		LIBGC=
		LIBGC_STATIC=
		;;
	*)
		LIBGC="-l$gc_grade"
		LIBGC_STATIC=`$FIX_PATH_FOR_LINKER \
			$LIBDIR/$FULLARCH/lib$gc_grade.a`
		;;
esac


case $readline in
	true)	;;
	false)	READLINE_LIBRARIES=
		;;
esac

case $trace in
	true)	TRACE_LIBS="-l$TRACE_LIB_NAME -l$BROWSER_LIB_NAME"
		TRACE_LIBS_SYSTEM="$SOCKET_LIBRARY $NSL_LIBRARY $DL_LIBRARY \
			$READLINE_LIBRARIES"
		TRACE_STATIC_LIBS="\
		  `$FIX_PATH_FOR_LINKER \
		    $LIBDIR/$GRADE/$FULLARCH/lib$TRACE_LIB_NAME.a` \
		  `$FIX_PATH_FOR_LINKER \
		    $LIBDIR/$GRADE/$FULLARCH/lib$BROWSER_LIB_NAME.a`"
		;;
	false)	TRACE_LIBS=
		TRACE_LIBS_SYSTEM=
		TRACE_STATIC_LIBS=
		;;
esac
		
case $strip in
	true)	STRIP_OPTS="-s" ;;
	false)  STRIP_OPTS="" ;;
esac

# Determine whether to link the executable with debugging symbols when using
# MSVC.
if [ $strip = "false" -a $COMPILER = "cl" ]
then
    DEBUG_FLAG="/DEBUG"
else
    DEBUG_FLAG=""
fi

case $gc_method in mps)
	use_thread_libs=true ;;
esac
case $thread_safe in true)
	use_thread_libs=true ;;
esac

case $use_thread_libs in
	true)
		# For Linux, Irix, Solaris, and HPUX,
		# the thread-enabled version of the Boehm
		# collector contains a reference to dlopen(), so 
		# if threads are enabled, we need to link with the
		# appropriate extra library for that (-ldl on Linux
		# and Solaris, -lrt on HPUX, and nothing on Irix).
		# XXX That should only be done if conservative GC
		#     is enabled.

		case "$FULLARCH" in
 		*-osf*)		THREAD_LIBS="-lpthreads -lmach -lc_r" ;;
		*-linux*)	THREAD_LIBS="-lpthread -ldl" ;;
		*-solaris*)	THREAD_LIBS="-lpthread -ldl" ;;
		### We don't yet support threads on HPUX and IRIX
		### *-hpux*)	THREAD_LIBS="-lpthread -lrt" ;;
		### *-irix*)	THREAD_LIBS="-lpthread" ;;
		*cygwin*)
			case $COMPILER in
				cl)	ARCH_OPTS="/MD"
					;;

			esac
			;;
		*)		echo "$0: warning: don't know which" \
					"library to use for pthreads" 1>&2
				THREAD_LIBS=""
				;;
		esac ;;
	false)	THREAD_LIBS="" ;;
esac

case $make_shared_lib in
    true)
	LINKER="$LINK_SHARED_OBJ"
	case $allow_undef in
	    true)  UNDEF_OPT="$ALLOW_UNDEFINED" ;;
	    false) UNDEF_OPT="$ERROR_UNDEFINED" ;;
	esac
	RPATH_OPT="$SHLIB_RPATH_OPT"
	RPATH_SEP="$SHLIB_RPATH_SEP"
	STDLIBS="$SHARED_LIBS $THREAD_LIBS"
	;;
    false)
	LINKER="$CC"
	UNDEF_OPT=""
	RPATH_OPT="$EXE_RPATH_OPT"
	RPATH_SEP="$EXE_RPATH_SEP"
	STDLIBS="$MATH_LIB $THREAD_LIBS"
	;;
esac

# if the --print-link-command option is specified,
# then all we do is print the command used to link executables
# and then exit.
case "$print_link_command" in true)
	echo $LINKER
	exit 0
esac

# if the --print-shared-lib-command option is specified,
# then all we do is print the command used to link executables
# and then exit.
case "$print_shared_lib_link_command" in true)
	echo $LINK_SHARED_OBJ
	exit 0
esac

merc_libdir_opts="\
	-L$LIBDIR/$GRADE/$FULLARCH
	-L$LIBDIR/$FULLARCH
"
system_libdir_opts=
for dir in $ALL_LOCAL_C_LIB_DIRS kludge_for_broken_shells; do
	if [ "$dir" != "kludge_for_broken_shells" ]; then
		system_libdir_opts="-L$dir $system_libdir_opts"
	fi
done
LIBDIR_OPTS="$user_libdir_opts $merc_libdir_opts $system_libdir_opts"

case $mercury_libs in
	shared)
		MERCURY_LIBS=${MERCURY_LIBS="$TRACE_LIBS -l$STD_LIB_NAME -l$RT_LIB_NAME $LIBGC"}
		LIBS=${LIBS="$MERCURY_LIBS $TRACE_LIBS_SYSTEM $STDLIBS"}
		merc_shlib_dirs="$merc_shlib_dirs $LIBDIR/$GRADE/$FULLARCH"
		merc_shlib_dirs="$merc_shlib_dirs $LIBDIR/$FULLARCH"
		;;
	static)
		MERCURY_LIBS=${MERCURY_LIBS="$TRACE_STATIC_LIBS
		`$FIX_PATH_FOR_LINKER \
		  $LIBDIR/$GRADE/$FULLARCH/lib$STD_LIB_NAME.a` \
		`$FIX_PATH_FOR_LINKER \
		  $LIBDIR/$GRADE/$FULLARCH/lib$RT_LIB_NAME.a` \
		$LIBGC_STATIC"}
		LIBS=${LIBS="$MERCURY_LIBS $TRACE_LIBS_SYSTEM $STDLIBS"}
		merc_shlib_dirs=""
		;;
	none)	LIBS="$TRACE_LIBS_SYSTEM $STDLIBS"
		LIBDIR_OPTS="$user_libdir_opts $system_libdir_opts"
		merc_shlib_dirs=""
		;;
esac

case $all_libs in
	shared) system_shlib_dirs=$ALL_LOCAL_C_LIB_DIRS ;;
	static)	system_shlib_dirs="" ;;
esac

RPATH_OPT_LIST=
# only set RPATH_OPT_LIST if the system supports shared libraries
case $EXT_FOR_SHARED_LIB in so)
	prev=""
	for dir in $user_shlib_dirs $merc_shlib_dirs \
			$system_shlib_dirs 'kludge for broken shells'
	do
	    case "$dir" in
		'kludge for broken shells')
		    ;;
		*)
		    case "$prev" in
			"") RPATH_OPT_LIST="$RPATH_OPT$dir" ;;
			*)  RPATH_OPT_LIST="$RPATH_OPT_LIST$RPATH_SEP$dir" ;;
		    esac
		    ;;
	    esac
	    prev=$dir
	done
	;;
esac

case $FULLARCH in
    #
    # On Irix 5, grades `fast' and `jump' only work in non_shared mode.
    #
    *-sgi-irix5*)
	case $non_local_gotos in
	    true)
		ARCH_OPTS=-non_shared
		NONSHARED_PATH="$NONSHARED_LIB_DIR:/usr/lib/nonshared"
		LIBRARY_PATH="$NONSHARED_PATH:$LIBRARY_PATH"
		export LIBRARY_PATH
		;;
	esac
	;;
    #
    # On Linux ELF, `-rdynamic' is needed to make symbols
    # exported for use in code linked in with dlopen(),
    # which is used for interactive queries in the
    # Mercury debugger.
    #
    *-linux*aout*)
	# Linux a.out -- no special options needed
	;;
    *-linux*)
	# Linux ELF -- need to add `-rdynamic' if using the debugger
	case $trace in true)
		ARCH_OPTS=-rdynamic
	esac
	;;
esac

case "$MKFIFO" in
    none) demangle=false ;;
esac

#
# The MLDS (--high-level-code) back-end uses a different
# name mangling scheme which the current demangler doesn't
# know how to demangle.
#
case "$highlevel_code" in
    true) demangle=false ;;
esac

LINKER_PRE_FLAGS="$UNDEF_OPT $STRIP_OPTS $MAYBE_STATIC_OPT $ARCH_OPTS"
LINKER_POST_FLAGS=" $DEBUG_FLAG $LIBDIR_OPTS $RPATH_OPT_LIST $LIBS"

case $verbose in
    true)
	echo "ml: using grade \`$GRADE'"
	case $demangle in
	    false)
		echo $LINKER $LINKER_PRE_FLAGS "$@" $LINKER_POST_FLAGS
		;;
	    true)
		echo $LINKER $LINKER_PRE_FLAGS "$@" $LINKER_POST_FLAGS "|"
		echo "$DEMANGLER"
		;;
	esac
	;;
esac

case $demangle in
    true)
	# we would like to just run $CC and pipe the result into $DEMANGLER,
	# but `$CC | $DEMANGLER' would return the wrong exit status, so
	# we need to use a named pipe; if the system doesn't have named
	# pipes, then we don't use the demangler

		# create the pipe, making sure we remove it if interrupted
	old_umask=`umask`
	umask 022
	try=0
	until 
		ML_TMPDIR=$TMPDIR/ml$$
		PIPE=$ML_TMPDIR/pipe
		trap 'rmdir $ML_TMPDIR >/dev/null 2>&1; exit 1' 1 2 3 13 15 
		mkdir $ML_TMPDIR
	do
		try="`expr $try + 1`"
		# give up after 20 tries
		case "$try" in 20)
			echo "ml: unable to create temporary directory" \
				"for pipe" 1>&2
			exit 1
		esac
	done
	trap 'rm -rf $ML_TMPDIR; exit 1' 1 2 3 13 15 
	umask $old_umask
	$MKFIFO $PIPE
		# execute the demangler in the background, with stdin 
		# coming from the pipe and with stdout redirected to stderr
	exec $DEMANGLER --explain-link-errors 1>&2 < $PIPE &
		# execute $CC with stdout & stderr redirected to
		# go via the pipe to $DEMANGLER and then to stderr
	case $# in
    		0) $LINKER $LINKER_PRE_FLAGS $LINKER_POST_FLAGS >$PIPE 2>&1 ;;
    		*) $LINKER $LINKER_PRE_FLAGS "$@" $LINKER_POST_FLAGS \
			>$PIPE 2>&1 ;;
	esac
	linker_status=$?
		# now we can remove the pipe; since is an open file, it will
		# stay around until $DEMANGLER exits
	rm -rf $ML_TMPDIR
		# wait for the demangler to exit before exiting ourselves
	wait
	exit $linker_status
	;;
false)
	case $# in
    		0) exec $LINKER $LINKER_PRE_FLAGS $LINKER_POST_FLAGS ;;
    		*) exec $LINKER $LINKER_PRE_FLAGS "$@" $LINKER_POST_FLAGS ;;
	esac
	;;
esac
