Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

executable file 914 lines (785 sloc) 25.318 kb
#! /bin/sh
#
# Copyright (c) 2003-2005 The University of Wroclaw.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. The name of the University may not be used to endorse or promote
# products derived from this software without specific prior
# written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
# NO EVENT SHALL THE UNIVERSITY BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
############################################################
# VARIABLES
############################################################
# frequently changed stuff
nem_version=0.9
nem_revision=3.99
use_ngen=0
# this variable is used to return values from functions
result=
config_log="configure.log"
python=
install="install"
prefix="/usr/local"
bindir="$prefix/bin"
scrdir="$prefix/bin"
mandir="$prefix/man/man1"
libdir="$prefix/lib"
pkgconfig_dir=
dll_path=
nem_tmp_file=
mono_libdir=
time=
peverify=
quiet=@
bar=true
ignore_errors=no
netSDK=
netFRAMEWORK=
netVERSION="2.0"
generics=true
force_old=0
broken_swf=0
monopath=
antlr=
antlr_path=antlr
nant_path=nant
mono_gacutil=no
vsplugindir=vsplugin
wixpath=
############################################################
# FUNCTIONS
############################################################
abort () {
echo
echo
echo "*** $@ ***"
if test -f $config_log; then
echo "*** Check $config_log for details. ***"
fi
echo
if [ "$ignore_errors" = yes ] ; then
echo "*** Ignoring error. ***"
else
echo "Aborting..."
rm -f $config_mak
exit 1
fi
}
echo_check_for () {
echo "--------------- Checking for $@ ---------------" >> $config_log
echo -n "Checking for $@... "
}
echo_check_if () {
echo "--------------- Checking if $@ ----------------" >> $config_log
echo -n "Checking if $@... "
}
echo_result () {
echo "Result: $@" >> $config_log
echo "-----------------------------------------------" >> $config_log
echo >> $config_log
echo "$@"
}
# This function tries to execute command given as an argument and returns
# shell exit code. If the program doesn't exist in a path shell returns
# 127. If the program is not a valid executable shell returns 126.
# If the program lacks some arguments it usually returns 1, otherwise
# this function should return 0.
#
# E.g.
# try_execute cc --version
# if test $? = 0; then
# echo "found"
# else
# echo "not found"
# fi
try_execute () {
echo "Trying execute: $@" >> $config_log
"$@" >> $config_log 2>&1
ret=$?
echo "Execution status code: $ret." >> $config_log
return $ret;
}
nem_try_compile () {
echo "<<<<<<<<<<<<<<<" >> $config_log
cat "$nem_tmp_file" >> $config_log
echo ">>>>>>>>>>>>>>>" >> $config_log
old_mono_path=$MONO_PATH
MONO_PATH=boot
$engine $net_flags boot/ncc.exe -q -no-color -texe -out:out.exe "$@" "$nem_tmp_file_aux" >> $config_log 2>&1
MONO_PATH=$old_mono_path
if test -f out.exe; then
rm -f out.exe
echo_result "yes"
return 0
else
echo_result "no"
return 1
fi
}
# dash check
if (( 1 < 2 )) ; then
:
else
echo "It appears you are running not supported shell. Please use:"
echo " bash ./configure"
echo "or"
echo " ksh ./configure"
exit 1
fi
############################################################
# PARAMETERS SCAN
############################################################
for i in $@; do
if test "$i" = "--help" || test "$i" = "-help" || test "$i" = "-h"; then
if [ $use_ngen = 0 ] ; then
ngen_yes=
ngen_no="(default)"
else
ngen_yes="(default)"
ngen_no=
fi
cat << EOF
Usage: $0 [OPTIONS]...
Defaults for the options are specified in brackets.
Configuration:
-h, --help display this help and exit
Installation directories:
--prefix=DIR use this prefix for installing Nemerle [/usr/local]
--bindir=DIR use this prefix for installing executables
[PREFIX/bin]
--scrdir=DIR use this prefix for installing shell wrappers for CLI
binaries [PREFIX/bin]
--mandir=DIR use this prefix for installing manpages
[PREFIX/man/man1]
--libdir=DIR object code libraries [PREFIX/lib]
--pkgconfigdir=DIR specify directory where nemerle.pc is to be installed
[LIBDIR/pkgconfig]
Miscellaneous options:
--nemerle-flags=FLAGS pass these flags to nemerle compiler
--net-engine=ENGINE use this .NET engine
--net-version=[1.1|2.0] use tools from this .NET runtime version
--net-flags=FLAGS pass these flags to .NET engine
--install-path=PATH the path to a custom install program
--dll-path=PATH the path to dlls directory
--antlr-path=PATH/CMD command to execute AntLR [default: antlr]
--nant-path=PATH/CMD command to execute NAnt [default: nant]
--wix-path=PATH path to directory, where your Wix is installed
--vsplugin-dir=PATH relative path to directory containing Visual Studio plugin directory [default: vsplugin]
--force-old-mono use this switch to force using your version of
Mono .NET environment or if you don't use Mono
at all but have it installed
--mono-from=PATH use this path prefix when referencing tools from
mono, like /usr/local/bin/ [default empty]
--ignore-errors do not exit on errors
--disable-aot do not try to mono --aot/ngen the assemblies $ngen_no
--enable-aot try to mono --aot/ngen the assemblies $ngen_yes
Optional features:
--enable-debug adds --debug to net-flags and -debug to compiler flags
--enable-time enable compilation times statistics
--disable-quiet disable beautiful output
--disable-bar disable progress bar
EOF
exit 0
fi
done
for ac_option do
case "$ac_option" in
--prefix=*)
prefix=`echo $ac_option | cut -d '=' -f 2`
bindir="$prefix/bin"
mandir="$prefix/man/man1"
libdir="$prefix/lib"
scrdir="$bindir"
;;
--bindir=*)
bindir=`echo $ac_option | cut -d '=' -f 2`
;;
--scrdir=*)
scrdir=`echo $ac_option | cut -d '=' -f 2`
;;
--mandir=*)
mandir=`echo $ac_option | cut -d '=' -f 2`
;;
--libdir=*)
libdir=`echo $ac_option | cut -d '=' -f 2`
mono_libdir="$libdir"
;;
--pkgconfigdir=*)
pkgconfig_dir=`echo $ac_option | cut -d '=' -f 2`
;;
--nemerle-flags=*)
nem_flags=`echo $ac_option | cut -d '=' -f 2`
;;
--net-engine=*)
engine=`echo $ac_option | cut -d '=' -f 2`
;;
--net-flags=*)
net_flags=`echo $ac_option | cut -d '=' -f 2`
;;
--install-path=*)
install=`echo $ac_option | cut -d '=' -f 2 | sed 's/\/$//'`"/install"
;;
--dll-path=*)
dll_path=`echo $ac_option | cut -d '=' -f 2`
;;
--antlr-path=*)
antlr_path=`echo $ac_option | cut -d '=' -f 2`
;;
--nant-path=*)
nant_path=`echo $ac_option | cut -d '=' -f 2`
;;
--wix-path=*)
wixpath=`echo $ac_option | cut -d '=' -f 2`
;;
--vsplugin-dir=*)
vsplugindir=`echo $ac_option | cut -d '=' -f 2`
;;
--enable-debug)
csc_flags="$csc_flags -debug+"
net_flags="$net_flags --debug"
nem_flags="$nem_flags -debug -def:DEBUG"
;;
--force-old-mono)
force_old=1
;;
--enable-time)
time=time
;;
--disable-quiet)
quiet=
;;
--disable-aot)
use_ngen=0
;;
--disable-bar)
bar=false
;;
--enable-aot)
use_ngen=1
;;
--ignore-errors)
ignore_errors=yes
;;
--mono-from=*)
monopath=`echo $ac_option | cut -d '=' -f 2`"/"
engine="$monopath/mono"
;;
*)
echo "Unknown parameter: $ac_option"
echo "Try: ./configure --help"
exit 1
;;
esac
done
############################################################
# INITIALIZATION
############################################################
rm -f $config_log $config_mak
if [ "$pkgconfig_dir" = "" ] ; then
pkgconfig_dir="$libdir/pkgconfig"
fi
nem_tmp_file="`pwd`/config-tmp.n"
trap "rm -f $nem_tmp_file" EXIT
if [ "X`cygpath -wp ${nem_tmp_file} 2>/dev/null`" != "X" ] ; then
nem_tmp_file_aux="`cygpath -wp "${nem_tmp_file}"`"
else
nem_tmp_file_aux=${nem_tmp_file}
fi
############################################################
# TESTS
############################################################
# Step 1.
# Check if user has any nemerle compiler. Don't run it yet
# as we don't know how to do it yet.
if test -f boot/ncc.exe; then
true
elif test -f boot/ncc-boot.exe; then
mv boot/ncc-boot.exe boot/ncc.exe
else
echo "*** You need a working Nemerle compiler. ***"
echo "*** http://nemerle.org/download/ncc-boot.exe ***"
echo "*** Place it in boot/ncc.exe ***"
abort "Haven't found Nemerle compiler."
fi
# Step 2.
# Determine how to invoke .NET binaries.
if test -z "$engine"; then
echo_check_for ".NET environment"
if test -x boot/ncc.exe; then
true
else
chmod u+x boot/ncc.exe 2> /dev/null
fi
if test -x boot/true.exe; then
true
else
chmod u+x boot/true.exe 2> /dev/null
fi
if try_execute boot/true.exe; then
engine=none
echo_result "none required"
elif try_execute "${monopath}mono" boot/true.exe; then
engine="${monopath}mono"
echo_result "${monopath}mono"
fi
fi
if test -z "$engine"; then
abort "Haven't found any .NET environment on your system."
elif test "$engine" = none; then
engine=
net_flags=
fi
# Step 3.
# Require MONO >= 1.2.4
echo_check_if "we are using Mono < 1.2.4"
version=`"${monopath}mono" --version 2> /dev/null`
if test "$?" = 0; then
ver=`echo $version | sed 's/.*version \([0-9]*\.[0-9]*\(\.[0-9]*\)\?\).*/\1/g'`
m_major=`echo $ver | cut -d . -f 1`
m_minor=`echo $ver | cut -d . -f 2`
m_revision=`echo $ver | cut -d . -f 3`
if ((m_major < 1 ||
m_major == 1 && m_minor < 2 ||
m_major == 1 && m_minor == 2 && m_revision < 4)); then
echo_result "yes"
if test "$force_old" = 1; then
echo "Forcing Mono ${ver}... "
echo "Hope you know, what you are doing..."
else
echo "*** Mono $ver is unsupported. ***"
echo "*** If you still want to try running Nemerle ***"
echo "*** please use --force-old-mono switch. ***"
abort "Too old version of Mono."
fi
else
echo_result "no"
fi
else
echo_result "no"
fi
# Step 3a.
# Check if there is regtool.exe available in the system and configure paths
# to .NET SDK and Framework according to choosen version
echo_check_for "presence of regtool in the system"
try_execute regtool
if test $? -lt 126; then
echo_result "found"
echo_check_for ".NET SDK path"
try_execute regtool.exe get "/machine/SOFTWARE/Microsoft/.NETFramework/sdkInstallRootv${netVERSION}"
if test "$?" != 127 -a "$?" != 1; then
echo_result "found"
netSDK="`regtool.exe get "/machine/SOFTWARE/Microsoft/.NETFramework/sdkInstallRootv${netVERSION}"`Bin\\"
else
try_execute regtool.exe get "/machine/SOFTWARE/Microsoft/Microsoft SDKs/Windows/CurrentInstallFolder"
if test "$?" != 127 -a "$?" != 1; then
echo_result "found"
netSDK="`regtool.exe get "/machine/SOFTWARE/Microsoft/Microsoft SDKs/Windows/CurrentInstallFolder"`Bin\\"
else
echo_result "not found"
fi
fi
echo_check_for ".NET Framework path"
try_execute regtool.exe get "/machine/SOFTWARE/Microsoft/.NETFramework/InstallRoot"
if test "$?" != 127 -a "$?" != 1; then
echo_result "found"
netFRAMEWORK="`regtool.exe get "/machine/SOFTWARE/Microsoft/.NETFramework/InstallRoot"`"
netFRAMEWORK="`cygpath $netFRAMEWORK`"
netFRAMEWORK="`echo ${netFRAMEWORK}v${netVERSION}.* | head -n 1`""/"
else
echo_result "not found"
fi
else
echo_result "not found"
fi
# Step 4.
# Check how to invoke .NET disassembler
echo_check_for ".NET disassembler"
try_execute "`cygpath "${netSDK}ildasm.exe"`" -?
if test "$?" != 127 -a "$?" != 126; then
echo_result "ildasm"
dasm="\""`cygpath "${netSDK}ildasm.exe"`"\" -text"
else
try_execute "${monopath}monodis"
if test "$?" != 127 -a "$?" != 126; then
echo_result "${monopath}monodis"
dasm="${monopath}monodis"
else
try_execute "${netSDK}ildasm.exe" -text
if test "$?" != 127 -a "$?" != 126; then
echo "ildasm [PATH]"
dasm="ildasm.exe -text"
else
echo_result "not found"
echo "*** Please make sure that the .Net disassembler is ***"
echo "*** available somewhere in PATH. ***"
abort "Haven't found any disassembler on your system."
fi
fi
fi
# Step 5.
# Check how to invoke native image generator.
echo_check_for "native image generator"
if test "$use_ngen" = 0 ; then
echo_result disabled
ngen="true"
else
try_execute "${netFRAMEWORK}ngen.exe"
if test "$?" != 127 -a "$?" != 126; then
echo_result "ngen.exe"
ngen="${netFRAMEWORK}ngen.exe"
else
try_execute "${monopath}mono" --aot
if test "$?" != 127 -a "$?" != 126; then
echo_result "${monopath}mono --aot"
ngen="${monopath}mono --aot"
else
echo_result "not found"
echo "*** Please make sure that the native image generator is ***"
echo "*** available as a single executable file, somewhere in PATH. ***"
ngen="true"
use_ngen=0
fi
fi
fi
# Step 6.
# Try to compile an empty program with nemerle compiler to be sure,
# that it works.
echo_check_if "Nemerle compiler works"
cat > $nem_tmp_file << EOF
class M {
public static Main () : void {}
}
EOF
nem_try_compile
if test "$?" = 1; then
if test "$force_old" = 1; then
echo "*** You have requested to force old version of Mono. ***"
echo "*** Please don't submit bugs. ***"
fi
abort "Nemerle compiler seems to be broken."
fi
# Step 7.
# Check things for gacutil installation.
echo_check_for "gacutil"
try_execute "${monopath}${netFRAMEWORK}gacutil"
if test $? -lt 126; then
echo_result found
echo_check_if "we are using mono gacutil"
if "${monopath}${netFRAMEWORK}gacutil" --help 2>/dev/null | grep -q Mono ; then
echo_result yes
if [ "X$mono_libdir" = "X" -a "X$monopath" != "X" ] ; then
case $monopath in
*/bin | */bin/ )
mono_libdir=$(echo $monopath | sed -e 's/bin\/\?$/lib/')
;;
esac
fi
if [ "X$mono_libdir" = "X" ] ; then
echo_check_for "mono libdir"
if pkg-config --version >/dev/null 2>&1 ; then
mono_libdir=`pkg-config --variable=libdir mono 2>/dev/null`
if [ "X$mono_libdir" = "X" ] ; then
echo_result "no mono.pc, forcing /usr/lib"
mono_libdir=/usr/lib
else
if test -d $mono_libdir/mono/gac ; then
echo_result "$mono_libdir"
else
mono_libdir="`pkg-config --variable=prefix mono 2>/dev/null`/lib"
if test -d $mono_libdir/mono/gac ; then
echo_result "$mono_libdir"
else
mono_libdir=/usr/lib
echo_result "none is valid, forcing /usr/lib"
fi
fi
fi
else
echo_result "no pkg-config found, forcing /usr/lib"
mono_libdir=/usr/lib
fi
fi
gacutil_base="${monopath}gacutil -root \$(DESTDIR)$mono_libdir"
gacutil_command="$gacutil_base -package nemerle -i"
gacutil_uninstall_command="$gacutil_base -package nemerle -u"
if [ "$use_ngen" = "0" ] ; then
ngen_gac="true"
else
#ngen_gac="for f in \$(DESTDIR)$mono_libdir/mono/gac/Nemerle*/*/*.dll ; do mono --aot \$\$f ; done"
ngen_gac="true"
fi
mono_gacutil=yes
else
echo_result no
gacutil_command="${netFRAMEWORK}gacutil.exe -f -i"
gacutil_uninstall_command="${netFRAMEWORK}gacutil.exe -f -u"
ngen_gac="true"
fi
else
try_execute cygpath "${netSDK}"gacutil.exe
if test $? -lt 126; then
echo_result found
dasm="\""`cygpath "${netSDK}ildasm.exe"`"\" -text"
gacutil_command="\""`cygpath "${netSDK}gacutil.exe"`"\" -f -i"
gacutil_uninstall_command="\""`cygpath "${netSDK}gacutil.exe"`"\" -f -u"
ngen_gac="true"
else
echo_result "not found"
echo "*** ''make install'' won't work for you ***"
gacutil_command="echo 'gacutil has not been found, installation can not continue'; false"
fi
fi
# Step 8.
# Check if we have PEVerify.exe tool available
echo_check_for "PEVerify"
try_execute cygpath "${netSDK}"PEVerify.exe
if test $? -lt 126; then
echo_result found
peverify="\""`cygpath "${netSDK}PEVerify.exe"`"\""
else
echo_result "not found"
fi
# Step 9.
# Check if we have ilasm tool available
echo_check_for "ilasm2"
try_execute "${monopath}${netFRAMEWORK}ilasm2"
if test $? -lt 126; then
echo_result found
asm="${monopath}${netFRAMEWORK}ilasm2"
else
echo_result "not found"
echo_check_for "ilasm"
try_execute "${monopath}${netFRAMEWORK}ilasm"
if test $? -lt 126; then
echo_result found
asm="${monopath}${netFRAMEWORK}ilasm"
else
echo_result "not found"
fi
fi
# Step 10.
# Check if we have C# compiler available
echo_check_for "C# compiler"
cat > conftest.cs <<EOF
class M {
public static void foo<T>() { }
public static void Main () {}
}
EOF
if try_execute "${netFRAMEWORK}csc" conftest.cs ; then
echo_result "found, csc"
csc="${netFRAMEWORK}csc"
else
if try_execute "${monopath}gmcs" conftest.cs ; then
echo_result "found, gmcs"
csc="${monopath}gmcs"
else
echo_result "not found"
fi
fi
rm -f conftest.cs conftest.exe
# Step 11.
# Check for Python >= 2.3, and other programs required to build
# complete documentation.
echo_check_for "Python version"
for i in python2.3 python; do
str=`$i -V 2>&1`
if test "$?" -gt 0; then
continue
fi
ver=`echo $str | sed 's/.* \([0-9]\.[0-9]\).*/\1/g'`
case $ver in
2.[3456789] | [3456789].* )
echo_result "$ver, ok"
python=$i
;;
*)
echo_result "$ver, too_old"
;;
esac
break
done
if test -z $ver; then
echo_result "none"
fi
# Step 12.
# check for antlr for generating cs2n C# parser
echo_check_for "antlr >= 2.7.5"
# the debian antlr package uses a `runantlr' binary
antlrcommand=`which $antlr_path 2>/dev/null || which runantlr 2>/dev/null`
# and the debian antlr version also didn't match with this
# ver=`antlr 2>&1| head -1 | sed 's/.* \([0-9]*\.[0-9]\.[0-9]*\).*/\1/g'`
# this should be more general
ver=`"$antlrcommand" 2>&1 | grep -i version | sed 's/.*\([0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}\).*/\1/g'`
case $ver in
2.7.[5-9])
antlr="$antlrcommand"
cp tools/cs2n/antlr/antlr.runtime-2.7.5.dll tools/cs2n/antlr/antlr.runtime.dll
echo_result "yes, 2.7.5+"
;;
*)
# also copy it for pregenerated parser!
cp tools/cs2n/antlr/antlr.runtime-2.7.5.dll tools/cs2n/antlr/antlr.runtime.dll
echo_result "not supported"
if find tools/cs2n/CSharpParser.cs -cnewer tools/cs2n/csharpgrammar.g 2> /dev/null | grep -q "" ; then
:
else
echo "*** You won't be able to build CS2N! ***"
fi
;;
esac
# Step 13.
echo_check_for "nant"
try_execute $nant_path
if test $? -lt 126; then
echo_result yes
nant=$nant_path
echo_check_for "nant plugin directory"
rm -f misc/nant.dir
try_execute $nant_path -buildfile:misc/print-dir.build
nant_dir=`cat misc/nant.dir 2>/dev/null`
rm -f misc/nant.dir
if test "$nant_dir" ; then
echo "found, $nant_dir"
else
echo_result "not found, plugin disabled"
nant=
fi
else
echo_result no
nant=
fi
try_nunit_version_2 () {
echo "Trying execute: $@" >> $config_log
eval ""$@" /help | grep 'Version: 2'" >> $config_log 2>&1
ret=$?
echo "Execution status code: $ret." >> $config_log
if test $ret -eq 0; then
nunit="$@"
fi
}
# Step 14.
echo_check_for "nunit-console for .NET 2.0"
try_nunit_version_2 nunit-console;
try_nunit_version_2 nunit-console2;
try_nunit_version_2 "${monopath}nunit-console";
try_nunit_version_2 "${monopath}nunit-console2";
if test "$nunit"; then
echo_result "found, $nunit"
if pkg-config --exists mono-nunit 2>/dev/null; then
nunit_lib="-pkg:mono-nunit"
else
np=`which nunit-console 2>/dev/null | sed 's/\(.*\)nunit-conso.*/\1nunit.framework.dll/'`; np=`cygpath -w "$np" 2>/dev/null`;
nunit_lib="-r:\"$np\""
fi
else
echo_result "not found, some tests will be disabled"
fi
# Step 15.
# Check if we have MSBuild available
echo_check_for "MSBuild"
try_execute "${netFRAMEWORK}MSBuild.exe"
if (($? < 126)); then
echo_result found
msbuild="${netFRAMEWORK}MSBuild.exe"
else
try_execute "${monopath}xbuild"
res=$?
if ((res < 126 && res != 2)); then
if ((m_major > 1 || m_major == 1 && m_minor >= 2 || m_major == 1 && m_minor == 1 && m_revision > 14)); then
echo_result found
msbuild="${monopath}xbuild"
else
echo_result "found, but mono is too old (at least 1.1.15 required), won't use it"
fi
else
echo_result "not found"
fi
fi
if test -d .svn; then
svn_revision=`svn info . | awk '/^Revision:/ { print $2 }'`
else
svn_revision=
fi
if test $bar = "true"; then
nem_flags="$nem_flags -bar+"
fi
case "$csc" in
*csc) nem_flags="$nem_flags -def:RUNTIME_MS";;
*gmcs) nem_flags="$nem_flags -def:RUNTIME_MONO";;
*cscc) nem_flags="$nem_flags -def:RUNTIME_PNET";;
*) ;;
esac
############################################################
# CONFIG GENERATION
############################################################
echo "Creating config.mak"
cat > config.mak <<EOF
# Generated by configure
Q = $quiet
PACKAGE = nemerle
VERSION = $nem_version
REVISION = $nem_revision
SVN_REV = $svn_revision
NET_ENGINE = $engine
NET_VERSION = $netVERSION
NET_FLAGS = $net_flags
DLL_PATH = $dll_path
NGEN = $ngen
DASM = $dasm
ASM = $asm
CSC = $csc
PEVERIFY = $peverify
TIME = $time
ANTLR = $antlr
MSBUILD = $msbuild
MONO_GACUTIL = $mono_gacutil
NANT = $nant
NANT_DIR = $nant_dir
VSPLUGINDIR = $vsplugindir
WIXPATH = $wixpath
NUNIT_CONSOLE = $nunit
NUNIT_LIB_FLAG = $nunit_lib
NEM_FLAGS = $nem_flags
PYTHON = $python
XSPP = $xspp
XSLT = $xsltproc
INSTALL = $install
prefix = $prefix
BINDIR = $bindir
SCRDIR = $scrdir
MANDIR = $mandir
LIBDIR = $libdir
PKGCONFIGDIR = $pkgconfig_dir
GACUTIL_COMMAND = $gacutil_command
GACUTIL_UNINSTALL_COMMAND = $gacutil_uninstall_command
NGEN_GAC = $ngen_gac
EOF
echo "Creating nemerle.pc"
cat > nemerle.pc <<EOF
prefix=${prefix}
exec_prefix=\${prefix}
libdir=${libdir}
Name: Nemerle
Description: Nemerle - a .NET object-functional language
Version: $nem_version.$nem_revision
Libs: -r:${mono_libdir}/mono/nemerle/Nemerle.dll -r:${mono_libdir}/mono/nemerle/Nemerle.Compiler.dll -r:${mono_libdir}/mono/nemerle/Nemerle.Macros.dll
EOF
Jump to Line
Something went wrong with that request. Please try again.