mercury/scripts/ml.in

#! /bin/sh
# @configure_input@
#---------------------------------------------------------------------------#
# 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=@FULLARCH@
DEFAULT_GRADE=${MERCURY_DEFAULT_GRADE=@DEFAULT_GRADE@}

# include the file `parse_ml_options.sh-subr'
@PARSE_ML_OPTIONS@


NONSHARED_LIB_DIR=${MERCURY_NONSHARED_LIB_DIR=@NONSHARED_LIB_DIR@}
DEMANGLER=${MERCURY_DEMANGLER=mdemangle}
CC=${MERCURY_C_COMPILER="@CC@"}
MKFIFO=${MERCURY_MKFIFO="@MKFIFO@"}
ERROR_UNDEFINED="@ERROR_UNDEFINED@"
ALLOW_UNDEFINED="@ALLOW_UNDEFINED@"
EXE_RPATH_OPT=${MERCURY_EXE_RPATH_OPT="@EXE_RPATH_OPT@"}
EXE_RPATH_SEP=${MERCURY_EXE_RPATH_SEP="@EXE_RPATH_SEP@"}
EXT_FOR_SHARED_LIB=${MERCURY_EXT_FOR_SHARED_LIB="@EXT_FOR_SHARED_LIB@"}
LINK_SHARED_OBJ=${MERCURY_LINK_SHARED_OBJ="@LINK_SHARED_OBJ_SH@"}
SHLIB_RPATH_OPT=${MERCURY_SHLIB_RPATH_OPT="@SHLIB_RPATH_OPT@"}
SHLIB_RPATH_SEP=${MERCURY_SHLIB_RPATH_SEP="@SHLIB_RPATH_SEP@"}
TMPDIR=${TMPDIR=/tmp}
MATH_LIB=${MERCURY_MATH_LIB="@MATH_LIB@"}
# Note: the setting of SHARED_LIBS needs to come after the setting of MATH_LIB,
# since @SHARED_LIBS_SH@ may refer to $MATH_LIB.
SHARED_LIBS=${MERCURY_SHARED_LIBS="@SHARED_LIBS_SH@"}

# 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="@SOCKET_LIBRARY@"
NSL_LIBRARY="@NSL_LIBRARY@"

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

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

# 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) 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*)
		# shared libraries are not the default on Linux
		# -- see README.Linux
		# Likewise for FreeBSD
		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
		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'
@CANONICAL_GRADE@

# 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=`@CYGPATH@ $LIBDIR/$FULLARCH/lib$gc_grade.@LIB_SUFFIX@`
		;;
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="\
		  `@CYGPATH@ $LIBDIR/$GRADE/$FULLARCH/lib$TRACE_LIB_NAME.@LIB_SUFFIX@` \
		  `@CYGPATH@ $LIBDIR/$GRADE/$FULLARCH/lib$BROWSER_LIB_NAME.@LIB_SUFFIX@`"
		;;
	false)	TRACE_LIBS=
		TRACE_LIBS_SYSTEM=
		TRACE_STATIC_LIBS=
		;;
esac
		
case $strip in
	true)	STRIP_OPTS="-s" ;;
	false)  STRIP_OPTS="" ;;
esac

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="\
	@LIB_LIBPATH@$LIBDIR/$GRADE/$FULLARCH
	@LIB_LIBPATH@$LIBDIR/$FULLARCH
	@LIB_LIBPATH@/usr/local/lib
"
LIBDIR_OPTS="$user_libdir_opts $merc_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
			`@CYGPATH@ $LIBDIR/$GRADE/$FULLARCH/lib$STD_LIB_NAME.@LIB_SUFFIX@` \
			`@CYGPATH@ $LIBDIR/$GRADE/$FULLARCH/lib$RT_LIB_NAME.@LIB_SUFFIX@` \
			$LIBGC_STATIC"}
		LIBS=${LIBS="$MERCURY_LIBS $TRACE_LIBS_SYSTEM $STDLIBS"}
		merc_shlib_dirs=""
		;;
	none)	LIBS="$TRACE_LIBS_SYSTEM $STDLIBS"
		LIBDIR_OPTS="$user_libdir_opts"
		merc_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 '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="@LINK_OPT_SEP@ $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