mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-11 03:45:33 +00:00
1c61a64b42
Estimated hours taken: 0.3 Branches: main scripts/mmake.in: Fix a bug introduced by Peter where the command `mmake <target>' just hangs if there is no Mmakefile. The problem was that cat was being called with no arguments, causing it to wait for input from stdin.
388 lines
9.5 KiB
Bash
388 lines
9.5 KiB
Bash
#! /bin/sh
|
|
# @configure_input@
|
|
#---------------------------------------------------------------------------#
|
|
# Copyright (C) 1995-1999,2001-2005 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.
|
|
#---------------------------------------------------------------------------#
|
|
#
|
|
# mmake - Mercury Make.
|
|
#
|
|
# Type mmake -h for help.
|
|
#
|
|
#-----------------------------------------------------------------------------#
|
|
|
|
# IMPORTANT: the manpage is produced automatically from this help
|
|
# message, so if you change the help message, don't forget to check
|
|
# that the manpage still looks OK.
|
|
Help="\
|
|
Name: mmake -- Mercury Make
|
|
Usage: mmake [<mmake options>] [-- <make options>] <target>...
|
|
Options:
|
|
--use-mmc-make:
|
|
Use \`mmc --make' to build Mercury targets.
|
|
Implies \`--use-subdirs'.
|
|
--use-subdirs:
|
|
Build intermediate files in a \`Mercury' subdirectory,
|
|
rather than in the current directory.
|
|
(If the current directory already contains a \`Mercury'
|
|
subdirectory, then this option is the default.)
|
|
--target asm:
|
|
Compile directly to assembler, rather than going via C.
|
|
--target c:
|
|
Compile via C, rather than going directly to assembler.
|
|
This is the default."
|
|
# XXX `--target il' is not documented because it is not yet
|
|
# supported.
|
|
#--target il:
|
|
# Compile via IL, rather than going via C or assembler.
|
|
Help="$Help
|
|
--mercury-standard-library-directory <directory>
|
|
--mercury-stdlib-dir <directory>:
|
|
The directory containing the installed Mercury standard
|
|
library.
|
|
--no-mercury-standard-library-directory, --no-mercury-stdlib-dir:
|
|
Don't use an installed Mercury standard library.
|
|
-s, --save-makefile:
|
|
Save the generated makefile to \`Mmake.makefile'.
|
|
This is useful for tracking down syntax errors in
|
|
your Mmake file.
|
|
-f <filename>, --file <filename>:
|
|
Use the specified file as the Mmake file.
|
|
-v, --verbose:
|
|
Print verbose progress messages.
|
|
-w-, --no-warn-undefined-vars:
|
|
Normally Mmake will warn about variables which are used
|
|
but not defined. This option disables that warning.
|
|
(The warning is never enabled when doing \`mmake clean'
|
|
or \`mmake depend' or the like, to avoid spurious
|
|
warnings when the dependencies have not yet been made.)
|
|
-h, --help:
|
|
Print this usage message.
|
|
Targets:
|
|
<module>.depend:
|
|
Make the files \`<module>.dep' and \`<module>.dv'. This
|
|
step is required in preparation for the targets below.
|
|
<module>:
|
|
Compile and link a Mercury program with main module
|
|
\`<module>.m' to produce an executable.
|
|
clean:
|
|
Remove intermediate files.
|
|
realclean:
|
|
Remove all automatically-generated files: intermediate files,
|
|
dependency files, and executables.
|
|
"
|
|
|
|
MERCURY_CONFIG_DIR=${MERCURY_CONFIG_DIR-${MERCURY_STDLIB_DIR-@CONFIG_LIBDIR@}}
|
|
MERCURY_STDLIB_DIR=${MERCURY_STDLIB_DIR-@LIBDIR@}
|
|
MMAKE_MAKE=${MMAKE_MAKE=@GNU_MAKE@}
|
|
MERCURY_DEFAULT_GRADE=${MERCURY_DEFAULT_GRADE=@DEFAULT_GRADE@}
|
|
MKTEMP=@MKTEMP@
|
|
TMPDIR=${TMPDIR=/tmp}
|
|
|
|
# Set the MACOSX_DEPLOYMENT_TARGET environment variable if needed.
|
|
@SET_MACOSX_DEPLOYMENT_TARGET@
|
|
|
|
MMAKE=$0
|
|
include_makefile=
|
|
verbose=false
|
|
save_makefile=false
|
|
if [ -d Mercury ]; then
|
|
use_subdirs=${MMAKE_USE_SUBDIRS=yes}
|
|
else
|
|
use_subdirs=${MMAKE_USE_SUBDIRS=no}
|
|
fi
|
|
use_mmc_make=${MMAKE_USE_MMC_MAKE=no}
|
|
warn_undefined_vars=true
|
|
target_asm=${MMAKE_TARGET_ASM=default}
|
|
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
-h|--help)
|
|
echo "$Help"
|
|
exit 0
|
|
;;
|
|
--use-subdirs)
|
|
use_subdirs=yes
|
|
shift
|
|
;;
|
|
--no-use-subdirs)
|
|
use_subdirs=no
|
|
shift
|
|
;;
|
|
--use-mmc-make)
|
|
use_mmc_make=yes
|
|
shift
|
|
;;
|
|
--no-mmc-make)
|
|
use_mmc_make=no
|
|
shift
|
|
;;
|
|
--target)
|
|
case "$2" in
|
|
asm) target_asm=yes ;;
|
|
c) target_asm=no ;;
|
|
il) # XXX we should do something
|
|
# sensible for `--target il'
|
|
echo "$0: warning: \`--target il'" \
|
|
"option not supported." 1>&2
|
|
target_asm=no ;;
|
|
*) echo "$0: invalid argument to" \
|
|
"\`--target' option" 1>&2
|
|
exit 1 ;;
|
|
esac
|
|
shift; shift
|
|
;;
|
|
-s|--save-makefile)
|
|
save_makefile=true
|
|
MMAKE="$MMAKE $1"
|
|
shift
|
|
;;
|
|
-s-|--no-save-makefile)
|
|
save_makefile=false
|
|
MMAKE="$MMAKE $1"
|
|
shift
|
|
;;
|
|
-f|--file)
|
|
mmake="$2"
|
|
shift
|
|
shift
|
|
;;
|
|
-v|--verbose)
|
|
verbose=true
|
|
MMAKE="$MMAKE $1"
|
|
shift
|
|
;;
|
|
-v-|--no-verbose)
|
|
verbose=false
|
|
MMAKE="$MMAKE $1"
|
|
shift
|
|
;;
|
|
-w|--warn-undefined-vars)
|
|
warn_undefined_vars=true
|
|
shift
|
|
;;
|
|
-w-|--no-warn-undefined-vars)
|
|
warn_undefined_vars=false
|
|
shift
|
|
;;
|
|
--include-makefile)
|
|
# XXX check that $2 exists first
|
|
MMAKE="$MMAKE $1 $2"
|
|
include_makefile="$include_makefile $2"
|
|
shift
|
|
shift
|
|
;;
|
|
|
|
--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)
|
|
unset MERCURY_STDLIB_DIR
|
|
unset MERCURY_CONFIG_DIR
|
|
;;
|
|
|
|
--mercury-config-directory-directory|--mercury-config-dir)
|
|
MERCURY_CONFIG_DIR="$2"
|
|
shift
|
|
;;
|
|
# We don't allow `MERCURY_CONFIG_DIR' to be unset
|
|
# without `MERCURY_STDLIB_DIR' also being unset.
|
|
|
|
--)
|
|
MMAKE="$MMAKE $1"
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# With `mmc --make' we need to use subdirs to avoid make trying to
|
|
# use Mmake rules to build the `.o' files for Mercury modules.
|
|
case $use_mmc_make in
|
|
yes) use_subdirs=yes ;;
|
|
esac
|
|
|
|
if [ "$MERCURY_CONFIG_DIR" != "" ]
|
|
then
|
|
MMAKE_DIR=${MMAKE_DIR=$MERCURY_CONFIG_DIR/mmake}
|
|
export MERCURY_CONFIG_DIR
|
|
export MERCURY_STDLIB_DIR
|
|
fi
|
|
|
|
case "$MMAKE_DIR" in
|
|
"")
|
|
echo "mmake: MMAKE_DIR not set"
|
|
exit 1
|
|
;;
|
|
*)
|
|
MMAKE_VARS=${MMAKE_VARS=$MMAKE_DIR/Mmake.vars}
|
|
MMAKE_RULES=${MMAKE_RULES=$MMAKE_DIR/Mmake.rules}
|
|
;;
|
|
esac
|
|
|
|
if [ "$mmake" = "" ]; then
|
|
if [ "$MMAKEFILE" = "" ]; then
|
|
if [ -f Mmakefile ]; then
|
|
MMAKEFILE="Mmakefile"
|
|
else
|
|
if [ -f Mmake ]; then
|
|
MMAKEFILE="Mmake"
|
|
else
|
|
MMAKEFILE=""
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
MMAKEFILE="$mmake"
|
|
fi
|
|
|
|
case $use_subdirs in
|
|
no)
|
|
dvs="`echo *.dv`"
|
|
if [ "$dvs" = "*.dv" ]; then
|
|
dvs=""
|
|
fi
|
|
deps="`echo *.dep`"
|
|
if [ "$deps" = "*.dep" ]; then
|
|
deps=""
|
|
fi
|
|
ds="`echo *.d`"
|
|
if [ "$ds" = "*.d" ]; then
|
|
ds=""
|
|
fi
|
|
;;
|
|
yes)
|
|
dvs="`echo Mercury/deps/*.dv`"
|
|
if [ "$dvs" = "Mercury/deps/*.dv" ]; then
|
|
dvs=""
|
|
fi
|
|
deps="`echo Mercury/deps/*.dep`"
|
|
if [ "$deps" = "Mercury/deps/*.dep" ]; then
|
|
deps=""
|
|
fi
|
|
ds="`echo Mercury/ds/*.d`"
|
|
if [ "$ds" = "Mercury/ds/*.d" ]; then
|
|
ds=""
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
MMAKE_USE_SUBDIRS=$use_subdirs
|
|
MMAKE_USE_MMC_MAKE=$use_mmc_make
|
|
|
|
if $save_makefile; then
|
|
tmp=Mmake.makefile
|
|
else
|
|
case "$MKTEMP" in
|
|
"") old_umask=`umask`
|
|
umask 022
|
|
try=0
|
|
until
|
|
mmake_tmpdir=$TMPDIR/mmake$$-$try
|
|
tmp=$mmake_tmpdir/mmake
|
|
trap 'rmdir $mmake_tmpdir >/dev/null 2>&1; exit 1' \
|
|
1 2 3 13 15
|
|
mkdir $mmake_tmpdir
|
|
do
|
|
try=`expr $try + 1`
|
|
# give up after 20 tries
|
|
case $try in 20)
|
|
echo "mmake: unable to create directory" \
|
|
"for temporary makefile" 1>&2
|
|
exit 1
|
|
esac
|
|
done
|
|
trap 'status=$?; rm -rf $mmake_tmpdir; exit $status' \
|
|
0 1 2 3 13 15
|
|
umask $old_umask
|
|
;;
|
|
*)
|
|
# mktemp should give its own error message.
|
|
tmp=`$MKTEMP $TMPDIR/mmake.XXXXXX` || exit 1
|
|
trap 'status=$?; rm -f $tmp; exit $status' 0 1 2 3 13 15
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
case $target_asm in
|
|
yes) set_target_asm="TARGET_ASM=yes" ;;
|
|
no) set_target_asm="TARGET_ASM=no" ;;
|
|
default) set_target_asm="" ;;
|
|
esac
|
|
|
|
MMAKE_MAKE_CMD="${MMAKE_MAKE} -f $tmp -r"
|
|
|
|
# Enable checking for undefined variables -- but not when making the
|
|
# dependencies, or when cleaning up, because in either of those two
|
|
# cases the dependencies might not have been made yet, so there may be
|
|
# lots of undefined variables.
|
|
case "$@" in
|
|
dep*|*' dep'*|*.dep*|*clean*)
|
|
MMAKE_MAKE_OPTS=""
|
|
;;
|
|
*)
|
|
case $warn_undefined_vars in
|
|
true) MMAKE_MAKE_OPTS="--warn-undefined-variables" ;;
|
|
false) MMAKE_MAKE_OPTS="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
# For backwards compatibility/bootstrapping:
|
|
# If no `.dv' files exist, use the `.dep' files instead.
|
|
if [ "$dvs" = "" ] ; then
|
|
dvs=$deps
|
|
deps=
|
|
fi
|
|
|
|
if $verbose; then
|
|
echo MMAKE=$MMAKE
|
|
echo export MMAKE
|
|
echo MMAKE_MAKE_CMD=$MMAKE_MAKE_CMD
|
|
echo export MMAKE_MAKE_CMD
|
|
echo MMAKE_USE_SUBDIRS=$MMAKE_USE_SUBDIRS
|
|
echo export MMAKE_USE_SUBDIRS
|
|
echo MMAKE_USE_MMC_MAKE=$MMAKE_USE_MMC_MAKE
|
|
echo export MMAKE_USE_MMC_MAKE
|
|
echo MERCURY_DEFAULT_GRADE=$MERCURY_DEFAULT_GRADE
|
|
echo export MERCURY_DEFAULT_GRADE
|
|
echo MMAKEFILE=$MMAKEFILE
|
|
echo export MMAKEFILE
|
|
echo cat ${MMAKE_VARS} $include_makefile $MMAKEFILE $ds $dvs $deps \
|
|
${MMAKE_RULES}">>" $tmp
|
|
echo ${MMAKE_MAKE} ${MMAKE_MAKE_OPTS} -f $tmp -r ${set_target_asm} "$@"
|
|
fi
|
|
export MMAKE
|
|
export MMAKE_MAKE_CMD
|
|
export MMAKE_USE_SUBDIRS
|
|
export MMAKE_USE_MMC_MAKE
|
|
export MERCURY_DEFAULT_GRADE
|
|
export MMAKEFILE
|
|
# XXX The $dvs and $ds variables can be so long as to overflow the
|
|
# command line size limits, so we use xargs. However echo doesn't quote
|
|
# the file names correctly, but this is not a problem in practice because
|
|
# the way the file names are constructed no special characters are
|
|
# included currently. If fixed, the fix needs to be replicated in
|
|
# `modules.m'.
|
|
{
|
|
cat ${MMAKE_VARS}
|
|
echo $dvs | xargs cat
|
|
echo $include_makefile $MMAKEFILE | xargs cat
|
|
echo 'ifneq ($(MMAKE_AUTO_INCLUDE_DS),no)'
|
|
echo $ds | xargs cat
|
|
echo 'endif'
|
|
cat $deps ${MMAKE_RULES}
|
|
} > $tmp
|
|
case $# in
|
|
# Note that we can't use `exec' here, because if we did that,
|
|
# that `trap' code which removes $tmp would never get executed.
|
|
0) ${MMAKE_MAKE} ${MMAKE_MAKE_OPTS} -f $tmp -r ${set_target_asm} ;;
|
|
*) ${MMAKE_MAKE} ${MMAKE_MAKE_OPTS} -f $tmp -r ${set_target_asm} "$@" ;;
|
|
esac
|