#! /bin/sh
# scripts/c2init.  Generated from c2init.in by configure.
#---------------------------------------------------------------------------#
# Copyright (C) 1995-2004 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.
#---------------------------------------------------------------------------#

# C2INIT - Convert *.c to *_init.c
#
# This script outputs an appropriate init.c, given the .c files.
# Type `c2init --help' for usage message.
#
# *************************************************************************
# *** IMPORTANT NOTE: any changes to this file may also require similar ***
# *** changes to compiler/compile_target_code.m                         ***
# *************************************************************************

Usage="\
Name:	c2init - Create Mercury initialization file.
Usage:	c2init [options] *.c *.init ..."

FULLARCH=i686-pc-linux-gnu
DEFAULT_GRADE=${MERCURY_DEFAULT_GRADE=reg.gc}

# include the file `parse_ml_options.sh-subr', which in turn includes
# the sh-subr files dealing with grades

#---------------------------------------------------------------------------#
# Copyright (C) 2001-2004 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_config_dir=${MERCURY_STDLIB_DIR-/usr/lib/mercury}
mercury_config_dir=${MERCURY_CONFIG_DIR=$mercury_config_dir}
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
print_map=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-2003 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
	--record-term-sizes-as-words
	--record-term-sizes-as-cells
	--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
record_term_sizes_as_words=false
record_term_sizes_as_cells=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.
	--print-map
		Print a link map, via \`ld --print-map'.

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'.
	--mercury-config-directory <directory>
	--mercury-config-dir <directory>
		The location of an alternative configuration
		(created with mercury_config) to use.
	-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_NONSHARED_LIB_DIR, 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"
		mercury_config_dir="$2"
		shift
		;;
	--no-mercury-standard-library-directory|--no-mercury-stdlib-dir)
		mercury_libs=none
		unset mercury_stdlib_dir
		unset mercury_config_dir
		;;

	--mercury-config-directory|--mercury-config-dir)
		mercury_config_dir="$2"
		shift
		;;

	-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
		;;
	--print-map)
		print_map=true
		;;
	--no-print-map)
		print_map=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-2004 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 ;;

	--java|--Java|--java-only|--Java-only)
		target=java ;;

	--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|automatic)
				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 ;;

	--record-term-sizes-as-words)
		record_term_sizes_as_words=true ;;
	--no-record-term-sizes-as-words)
		record_term_sizes_as_words=false ;;
	--record-term-sizes-as-cells)
		record_term_sizes_as_cells=true ;;
	--no-record-term-sizes-as-cells)
		record_term_sizes_as_cells=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
		record_term_sizes_as_words=false
		record_term_sizes_as_cells=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
					;;

				tsw)
					record_term_sizes_as_words=true
					record_term_sizes_as_cells=false
					;;

				tsc)
					record_term_sizes_as_words=false
					record_term_sizes_as_cells=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, 2004 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

#
# --target IL or Java implies --high-level-data
#
case $target in il|java)
	highlevel_data=true ;;
esac

#
# --target IL or Java implies --gc automatic
#
case $target in il|java)
	gc_method=automatic ;;
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

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


# include the file `canonical_grade.sh-subr'

#---------------------------------------------------------------------------#
# Copyright (C) 2000-2003 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,$target in
	true,true,none,*)		
		case $target in
			c|asm)	GRADE="hl" ;;
			il)	GRADE="il" ;;
			java)	GRADE="java" ;;
			*)
				progname=`basename $0`
				echo "$progname: unknown target: $target"
				exit 1
				;;
		esac
		;;
	true,false,none,*)	
		case $target in
			c|asm)	GRADE="hlc" ;;
			il)	GRADE="ilc" ;;
			*)
				progname=`basename $0`
				echo "$progname: unsupported target: $target"
				exit 1
				;;
		esac
		;;
	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)	;;
	*)			progname=`basename $0`
				echo "$progname: error: invalid combination of debugging options." 1>&2
				exit 1
				;;
esac

case $record_term_sizes_as_words,$record_term_sizes_as_cells in
	true,false)		GRADE="$GRADE.tsw" ;;
	false,true)		GRADE="$GRADE.tsc" ;;
	false,false)		;;
	*)			progname=`basename $0`
				echo "$progname: error: invalid combination of term size profiling options." 1>&2
				exit 1
				;;
esac

# If you change one of these, or if you add a new one, you will also need
# to check the following files to see if corresponding changes are needed
# there as well:
#
#	Mmake.workspace
#	Mmakefile
#	compiler/compile_target_code.m
#	scripts/c2init.in
#	scripts/ml.in
#	scripts/Mercury.config.in
#	scripts/Mercury.config.bootstrap.in
#	tools/bootcheck,
#	tools/binary
#	tools/binary_step
#	tools/linear
#	tools/lmc
#	tools/lml

RT_LIB_NAME=mer_rt
STD_LIB_NAME=mer_std
TRACE_LIB_NAME=mer_trace
BROWSER_LIB_NAME=mer_browser
MDBCOMP_LIB_NAME=mer_mdbcomp
ANALYSIS_LIB_NAME=mer_analysis

MKINIT=${MERCURY_MKINIT=mkinit}

case $require_tracing in
	true)
		trace_opt="-t" ;;
esac

case $stack_trace in
	true)
		init_opt="-i" ;;
esac

if [ "$mercury_stdlib_dir" != "" ]
then
	MERCURY_MOD_LIB_MODS="$mercury_stdlib_dir/modules/$RT_LIB_NAME.init \
		$mercury_stdlib_dir/modules/$STD_LIB_NAME.init"
	MERCURY_TRACE_LIB_MODS="\
		$mercury_stdlib_dir/modules/$BROWSER_LIB_NAME.init \
		$mercury_stdlib_dir/modules/$MDBCOMP_LIB_NAME.init"
fi
MERCURY_TRACE_LIB_MODS="$MERCURY_TRACE_LIB_MODS $trace_init_files"

case "$trace_opt" in
	-t)
		init_opt="-i"
		MERCURY_ALL_LIB_MODS="$MERCURY_MOD_LIB_MODS\
			$MERCURY_TRACE_LIB_MODS"
		;;
	*)
		MERCURY_ALL_LIB_MODS="$MERCURY_MOD_LIB_MODS"
		;;
esac

case $# in
	0) exec $MKINIT $aditi_opt -c"$maxcalls" $init_opt $trace_opt \
		$library_opt $defentry_opt $extra_inits_opt \
		-g "$GRADE" -o "$init_c_file" \
		$extra_init_dirs $EXTRA_INIT_FILES $TRACE_INIT_FILES \
		$MERCURY_ALL_LIB_MODS
	   ;;
	*) exec $MKINIT $aditi_opt -c"$maxcalls" $init_opt $trace_opt \
		$library_opt $defentry_opt $extra_inits_opt \
		-g "$GRADE" -o "$init_c_file" -r "$runtime_flags" \
		$extra_init_dirs "$@" $EXTRA_INIT_FILES $TRACE_INIT_FILES \
		$MERCURY_ALL_LIB_MODS
	   ;;
esac
