# -*- sh -*-
##############################################################
#
# Copyright(c) 1995~2007  Masaharu Goto (cint@pcroot.cern.ch)
#
# For the licensing terms see the file COPYING
#
##############################################################
#
# This is a bash script, which works with any reasonable sh.
# Solaris sh is not, so we have to start bash, and call ourselves again.

[ "x$1" != "x__have_the_proper_shell@" ] && ( \
( ( uname -a | grep -i sunos > /dev/null) || (ls `which sh` | grep dash ) ) \
  && (bash $0 __have_the_proper_shell@ "$@") \
  || (sh $0 __have_the_proper_shell@ "$@" ) \
)

[ "x$1" != "x__have_the_proper_shell@" ] && exit
shift

# configure settings to build CINT

ARCHS=(linux linuxicc macos macosx64 djgpp cygwin mingw mwerks hpux aix msvc7 msvc8 solaris solarisgcc freebsd)

#############################################################
###
###        Architecture Settings
###
#############################################################

# These are the variables that can be set by the different architectures.
# They are prepended by "G__CFG_" when writing out to Makefile.conf and configcint.h.

EXPORTS=(ARCH CC CFLAGS CMACROS COMP CPP COUT COUTEXE INCP CXX CXXFLAGS CXXMACROS \
    LD LDFLAGS LDOUT LIBP LIBL SOFLAGS SOOUT OBJEXT EXEEXT \
    SOEXT LIBEXT IMPLIBEXT DEBUG DEFAULTLIBS CINTEXINCDIR CINTEXLIBDIR REFLEXINCDIR \
    REFLEXLIBDIR MANGLEPATHS STREAMDIR PLATFORMO EXPLLINK \
    READLINELIB CURSESLIB LINK_READLINELIB LINK_CURSESLIB RM MV PREFIX \
    INPUTMODE INPUTMODELOCK AR EXTRACTSYMBOLS MAKEIMPLIB )
unset ${EXPORTS[*]}

# Lines demonstrating the use of the available variables. 
# Only one of DBGFLAGS or OPTFLAGS is actually used, depending 
# on the value of DEBUG (see --debug)

# $CC $CFLAGS $CMACROS $COPTFLAGS $CDBGFLAGS ${COMP}@source@ ${COUT}@object@$OBJEXT ${INCP}@inclpath@ @header@
# $CXX $CXXFLAGS $CXXMACROS $CXXOPTFLAGS $CXXDBGFLAGS ${COMP}@source@ ${COUT}@object@$OBJEXT ${INCP}@inclpath@ @header@
# $LD $LDFLAGS $LDOPTFLAGS $LDDBGFLAGS ${LDOUT}@exe@$EXEEXT ${OBJ}@obj@$OBJEXT ${LIBP}@libpath@ $(subst @lib@,$LIBEXT,${LIBL}) $DEFAULTLIBS
# $LD $SOFLAGS $LDOPTFLAGS $LDDBGFLAGS ${SOOUT}@so@$SOEXT ${OBJ}@obj@$OBJEXT ${LIBP}@libpath@ $(subst @lib@,$LIBEXT,${LIBL}) $DEFAULTLIBS

function config_GCC_defaults {
    CC=gcc
    COMP=-c
    CPP="gcc -E -C"
    COUT="-o "
    COUTEXE="-o "
    INCP=-I
    CDBGFLAGS=-g
    COPTFLAGS=-O2
    CMACROS="$CMACROS -DG__SHAREDLIB -DG__OSFDLL -DG__ANSI -DG__ERRORCALLBACK -DG__SIGNEDCHAR -DG__NEWSTDHEADER -DG__CINT_VER6 -DG__NATIVELONGLONG -DG__P2FCAST -DG__STD_EXCEPTION"

    CXX=g++
    CXXDBGFLAGS="$CDBGFLAGS"
    CXXOPTFLAGS="$COPTFLAGS"
    CXXMACROS="$CXXMACROS $CMACROS"

    LD=g++
    DEFAULTLIBS="-lm -ldl"
    LDOUT="-o "
    SOOUT="$LDOUT"
    LIBP=-L
    LIBL=-l@imp@
    LDDBGFLAGS=-g
    LDOPTFLAGS=-O2
    SOFLAGS=-shared
    SODBGFLAGS=-g

    RM="rm -f"
    MV="mv -f"

    OBJEXT=.o
    EXEEXT=
    SOEXT=.so
    LIBEXT=.a
    IMPLIBEXT=.a
    AR="ar qcs"
    [ "x$TAILOPT" = "x" ] && TAILOPT=-n

    GCCVER=`echo __GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__|$CC -E -|tail ${TAILOPT}1`
    if [ ${GCCVER%% *} -gt 3 ]; then 
	STREAMDIR=gcc4strm
    elif [ ${GCCVER%% *} -gt 2 ]; then 
	STREAMDIR=gcc3strm
    else
	STREAMDIR=stream
    fi

    INPUTMODE=cint
    INPUTMODELOCK=off
}

function config_linux {
    config_GCC_defaults
}

function config_freebsd {
    config_GCC_defaults
    CFLAGS="${CFLAGS} -fPIC"
    CXXFLAGS="${CXXFLAGS} -fPIC"
    DEFAULTLIBS="`echo $DEFAULTLIBS | sed 's/-ldl//'`"
}

function config_linuxx8664gcc {
    config_GCC_defaults

    EXTRA_LIB_DIR="/usr/local/lib64 /usr/lib64"
    CPP="gcc -E -C -m64"
    CXXFLAGS="-m64  -fPIC ${CXXFLAGS}"
    CFLAGS="-m64  -fPIC ${CFLAGS}"
    LDFLAGS="-m64 ${LDFLAGS}"
}

function config_linuxicc {
    config_GCC_defaults

    CXX=icc
    CC=icc
    LD=icc
    CPP="icc -E -C"
    CXXFLAGS="${CXXFLAGS} -wd1476 -wd21 -wd191"
    CFLAGS="${CFLAGS} -wd1476 -wd21 -wd191"
    STREAMDIR=iccstrm
}

function config_macos {
    config_GCC_defaults

    CXXFLAGS="${CXXFLAGS} -pipe -W -Wall -Wno-long-double -Woverloaded-virtual -fsigned-char -fno-common"
    CFLAGS="${CFLAGS} -pipe -W -Wall -Wno-long-double -fsigned-char -fno-common"
    SOFLAGS="-dynamiclib -single_module"
    CMACROS="$CMACROS -DG__MACOSX__ -DG__APPLE"

#    PLATFORMO=v6_macos

    AR="ar -q -cs"
    IMPLIBEXT=.dylib

    MAKEIMPLIB="ln -sf @so@ @imp@"
    EXPLLINK=1

    MACOSX_MINOR=`sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2`
    if [ `echo $MACOSX_MINOR | cut -d ' ' -f 2` -gt 4 ]; then
        # this is set for 64 but not for 32  bit
        CFLAGS="${CFLAGS} -D__DARWIN_UNIX03=1"
        CXXFLAGS="${CXXFLAGS} -D__DARWIN_UNIX03=1"
    fi
}

function config_macosx64 {
    config_macos
    CPP="gcc -E -C -m64"
    CFLAGS="-m64 ${CFLAGS}"
    CXXFLAGS="-m64 ${CXXFLAGS}"
    LDFLAGS="-m64 ${LDFLAGS}"
    SOFLAGS="-m64 ${SOFLAGS}"
}

function config_djgpp {
    config_GCC_defaults
    CFLAGS="-I$(DJGPPDIR)/include"
    CMACROS="-DG__DJGPP -DG__DJGPP"
    CXXFLAGS="$CXXFLAGS $CFLAGS"
    CXXMACROS="$CMACROS"
    DEFAULTLIBS="-L$(DJGPPDIR)/lib -lm"
    EXPLLINK=1
}

function config_cygwin {
    config_GCC_defaults

    EXEEXT=.exe
    SOEXT=.dll
    IMPLIBEXT=.dll.a
    CMACROS="-DG__CYGWIN -DG__STD_EXCEPTION"
    CXXMACROS="$CMACROS"
    EXPLLINK=1
    SOFLAGS="$SOFLAGS --export-all-symbols"
}

function config_mingw {
    config_cygwin
    CFLAGS="$CFLAGS -mno-cygwin"
    CMACROS="-DG__MINGW -DG__STD_EXCEPTION"
    CXXFLAGS="$CXXFLAGS $CFLAGS"
    CXXMACROS="$CMACROS"
    EXPLLINK=1
}

function config_mwerks {
    echo "Not implemented yet."
    exit 1
}

function configcint_hpux {
    echo "Not implemented yet."
    exit 1
}

function config_aix {
    echo "Not implemented yet."
    exit 1
}

function config_msvc7 {
    OBJEXT=.obj
    EXEEXT=.exe
    LIBEXT=.lib
    SOEXT=.dll
    IMPLIBEXT=.lib

    CC=cl
    CFLAGS="-G5 -MD -nologo -wd4996 -GX"
    CMACROS="-DG__REDIRECTIO -DG__SHAREDLIB -DG__UNIX -DG__WIN32 -DVISUAL_CPLUSPLUS -DG__NEWSTDHEADER"
    COMP=-c
    CPP="cl -E -C -nologo"
    COUT=-Fo
    COUTEXE=-Fe
    INCP=-I
    COPTFLAGS=-O2
    CDBGFLAGS=-Zi

    CXX=cl
    CXXFLAGS="$CXXFLAGS $CFLAGS -GR -wd4181"
    CXXMACROS="$CMACROS"
    CXXOPTFLAGS="$COPTFLAGS"
    CXXDBGFLAGS="$CDBGFLAGS"

    LD=link
    LDFLAGS="-nologo -ignore:4049 -ignore:4217 -ignore:4221 -incremental:no"
    LDOUT=-out:
    LIBP=-LIBPATH:
    LIBL=lib@imp@$IMPLIBEXT
    LDOPTFLAGS=-OPT:REF
    LDDBGFLAGS=-DEBUG
    DEFAULTLIBS="kernel32.lib user32.lib"
    EXPLLINK=1

    # hack to get the implib and def in
    SOFLAGS="$LDFLAGS -DLL -implib:@so@$LIBEXT"
	SODBGFLAGS="-debug"
    SOOUT=-out:
    EXTRACTSYMBOLS="dumpbin.exe /SYMBOLS @obj@ | grep -e ' notype ()[[:space:]]\{4\}External '| grep -v ' UNDEF ' | grep -v 'AEPAXI@Z ('| sed 's!^[[:xdigit:]]\{3,\}[[:space:]]\+\([[:xdigit:]]\{8\}\)[[:space:]]\+.*\+External[[:space:]]\+|[[:space:]]\+\([^(]\+\).*\$!\1 \2!'| cut -d' ' -f2"

    MANGLEPATHS="cygpath -m"
    STREAMDIR=vc7strm
    PLATFORMO=v6_winnt
    RM="rm -f"
    MV="mv -f"
    INPUTMODE=cint
    INPUTMODELOCK=off

    AR="lib /OUT:"
}

function config_msvc8 {
    config_msvc7
    CFLAGS="${CFLAGS/-G5/}"
    CXXFLAGS="${CXXFLAGS/-G5/}"
    CFLAGS="${CFLAGS/-GX/-EHs}"
    CMACROS="$CMACROS -D_CRT_SECURE_NO_DEPRECATE=1 -D_SECURE_SCL=0 -D_HAS_ITERATOR_DEBUGGING=0"
    CXXFLAGS="${CXXFLAGS/-GX/-EHs}"
    CXXMACROS="$CXXMACROS -D_CRT_SECURE_NO_DEPRECATE=1 -D_SECURE_SCL=0 -D_HAS_ITERATOR_DEBUGGING=0"
}

function config_solarisgcc {
    TAILOPT=-
    config_GCC_defaults
    CFLAGS="${CFLAGS} -fPIC"
    CXXFLAGS="${CXXFLAGS} -fPIC"
}

function config_solaris {
    TAILOPT=-
    config_GCC_defaults
    CXX=CC
    CC=cc
    LD=CC
    CPP="CC -E -C"

    CXXFLAGS="$CXXFLAGS -erroff=badargtypel2w,wbadinitl,wbadasgl"
    LDFLAGS=

    COPTFLAGS=-O
    CXXOPTFLAGS=-O
    LDOPTFLAGS=-O
    SOFLAGS="-KPIC -G"
    DEFAULTLIBS="-lm -ltermcap -ldl -L/usr/ccs/lib -lgen"
    STREAMDIR=sunstrm
}

#############################################################
###
###        Option Processing
###
#############################################################

declare -a OPTS_AVAIL
declare -a OPTS_DESCR
let numopts=0;

function add_opt {
  OPTS_AVAIL[$numopts]="$1"
  OPTS_DESCR[$numopts]="$2"
  let numopts=$numopts+1
}

add_opt "--help -h" 'Show this help.'
add_opt "--arch=" "Architecture, one of ${ARCHS[*]}"
add_opt "--prefix=" "where to put Cint for install target "$'\n\t'"(defaults to /usr/local)"
add_opt "--readline=" "Readline library "$'\n\t'"(defaults to /usr/(local)/lib/libreadline.a if it exists)"
add_opt "--reflex-incdir=" "Reflex header directory "$'\n\t'"(defaults to ../reflex/inc if it exists)"
add_opt "--reflex-libdir=" "Reflex library directory "$'\n\t'"(defaults to ../reflex/lib if it exists)"
add_opt "--cintex-incdir=" "Cintex header directory "$'\n\t'"(defaults to ../cintex/inc if reflex-incdir==../reflex/inc, or to reflex-incdir)"
add_opt "--cintex-libdir=" "Cintex library directory "$'\n\t'"(defaults to ../cintex/lib if reflex-libdir==../reflex/lib, or to reflex-libdir)"
add_opt "--debug" "Build non-optimized Cint with debug symbols"
add_opt "--pedantic" "Warn on everything that the compielr allows (only supported for GCC)"

function processflag_help {
    echo CINT configure options:
    let iopt=0
    while [ $iopt -lt $numopts ]; do
	arg=""
	opts=${OPTS_AVAIL[$iopt]}
	[ "${opts/=/}" != "$opts" ] && arg='<argument>'
	echo "  "${OPTS_AVAIL[$iopt]}"$arg": "${OPTS_DESCR[$iopt]}"
	let iopt=$iopt+1
    done
    exit 0
}

function guess_arch {
    arch=`uname -s | tr '[A-Z]' '[a-z]'`
    chip=`uname -m | tr '[A-Z]' '[a-z]'`
    rele=`uname -r`

    case "$arch:$chip:$rele" in
#        aix*)                  arch=aix5            ;;
#        osf1*:alpha:*)         arch=alphacxx6       ;;
#        freebsd*:*:6*)         arch=freebsd5        ;;
#        freebsd*:*:5*)         arch=freebsd5        ;;
#        freebsd*:*:4*)         arch=freebsd4        ;;
        freebsd*:*:*)          arch=freebsd         ;;
#        hp-ux:ia64:*)          arch=hpuxia64acc     ;;
#        hp-ux:*:*)             arch=hpuxacc         ;;
#        hurd*:*:*)             arch=hurddeb         ;;
#        linux:ia64:*)          arch=linuxia64gcc    ;;
        linux:x86_64:*)        arch=linuxx8664gcc   ;;
#        linux:alpha:*)         arch=linuxalphagcc   ;;
#        linux:arm*:*)          arch=linuxarm        ;;
#        linux:ppc64*:*)        arch=linuxppc64gcc   ;;
#        linux:ppc*:*)          arch=linuxppcgcc     ;;
        linux:i*86:*)          arch=linux           ;;
#        openbsd*:*:*)          arch=openbsd         ;;
#        lynx:*:*)              arch=lynxos          ;;
#        darwin:power*:*)       arch=macosx          ;;
#        darwin:*86*:*)         arch=macosx          ;;
#        irix*:sgi*:*)          arch=sgicc           ;;
        sunos:sun*:6*)         arch=solarisCC5      ;;
        sunos:sun*:5*)         arch=solarisCC5      ;;
#        sunos:sun*:4*)         arch=solaris         ;;
        cygwin_*:*86:*)        arch=win32           ;;
        cygwin_*:pentium:*)    arch=win32           ;;
        cygwin_*:ia64)         arch=win32           ;;
#        *)
#            echo "Attempts at guessing your architecture failed."
#            echo "Please specify the architecture as the first argument."
#            echo "Do '$0 --help' for a list of avaliable architectures."
#            exit 1
#            ;;
    esac
    if [ "x`uname -a|grep -i linux`" != "x" ]; then
        GUESSEDARCH=$arch
    elif [ "x`uname -a|grep -i freebsd`" != "x" ]; then
        GUESSEDARCH=$arch
    elif cl.exe >/dev/null 2>&1; then
        if [ "x`cl 2>&1|grep 'Version 14'`" != "x" ]; then
            GUESSEDARCH=msvc8
        else
            GUESSEDARCH=msvc7
        fi
    elif gcc --version >/dev/null 2>&1; then
        if [ "x`uname -a|grep -i mac`" != "x" ]; then
            MACOSX_MINOR=`sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2`
            if [ ${MACOSX_MINOR} -gt 4 ]; then
                GUESSEDARCH=macosx64
            else
                GUESSEDARCH=macos
            fi
        elif [ "x`uname -a|grep -i SunOS`" != "x" ]; then
            GUESSEDARCH=solarisgcc
        fi
    elif [ "x`uname -a|grep -i SunOS`" != "x" ] && CC -V >/dev/null 2>&1; then
        GUESSEDARCH=solaris
    fi
    if [ "x$GUESSEDARCH" = "x" ]; then
        echo 'Cannot guess architecture, please specify --arch=...!'
        processflag_help
    fi
    echo 'Guessing architecture to be '$GUESSEDARCH
}

function processflag_arch {
    if [ "${ARCHS[*]/$1/}" = "${ARCHS[*]}" ]; then
	echo "Error: invalid architecture. Choose one out of"
	echo "  "${ARCHS[*]}
	exit 1
    fi

    ARCH=$1
    config_$ARCH
}

function processflag_prefix {
    PREFIX=$1
}

function processflag_debug {
    DEBUG=1
}

function processflag_pedantic {
    DEBUG=0
    CFLAGS="${CXXFLAGS} -Wall -pedantic -Wextra -Wundef -Wendif-labels -Wshadow -Wbad-function-cast -Wcast-qual -Wcast-align -Wwrite-strings -Wconversion -Wsign-compare -Wstrict-prototypes -Wredundant-decls -Winline -Wno-long-long"
    CXXFLAGS="${CXXFLAGS} -Wall -pedantic -Wextra -Wundef -Wendif-labels -Wshadow -Wcast-qual -Wcast-align -Wwrite-strings -Wconversion -Wsign-compare -Wredundant-decls -Winline -Wno-long-long"
# too much noise in system headers: -Wunreachable-code 
}

function processflag_reflex_incdir {
    REFLEXINCDIR=$1
}
function processflag_reflex_libdir {
    REFLEXLIBDIR=$1
}

function processflag_cintex_incdir {
    CINTEXINCDIR=$1
}
function processflag_cintex_libdir {
    CINTEXLIBDIR=$1
}

function processflag_readline {
    READLINELIB=$1
}

# process options
ALLOPTIONS=(${*:1})

while [ "$1" != "" ]; do
    let iopt=0;
    found=0
    while [ $found = 0 -a $iopt -lt $numopts ]; do
	flags=( ${OPTS_AVAIL[$iopt]} )
	let numflags=${#flags[*]}
	let iflag=0
	while [ $iflag -lt $numflags ]; do
	    flag=${flags[$iflag]}
	    if [ "${1#$flag}" != "$1" ]; then
		found=1
                # remove leading "-"s, trailing =, replace "-" by "_"
		func=`echo start ${flags[0]}|sed -e 's,start ,,' -e 's,^-*,,' -e 's,=$,,' -e 's,-,_,g'`
		if [ ${flag/=/} = $flag ]; then
		    # simple flag without value
		    processflag_$func
		else
		    value=${1#$flag}
		    processflag_$func "$value"
		fi
		break
	    fi
	    let iflag=$iflag+1
	done
	let iopt=$iopt+1
    done
    if [ $found = 0 ]; then
	echo "Unknown argument $1."
	echo ""
	processflag_help
    fi
    shift
done

if [ "$ARCH" = "" ]; then
    guess_arch
    ARCH=$GUESSEDARCH
    config_$ARCH
fi

if [ "$DEBUG" = "1" ]; then
    LDFLAGS="$LDDBGFLAGS $LDFLAGS"
    SOFLAGS="$SODBGFLAGS $SOFLAGS"
    CFLAGS="$CDBGFLAGS $CFLAGS"
    CXXFLAGS="$CXXDBGFLAGS $CXXFLAGS"
else
    LDFLAGS="$LDOPTFLAGS $LDFLAGS"
    SOFLAGS="$SOOPTFLAGS $SOFLAGS"
    CFLAGS="$COPTFLAGS $CFLAGS"
    CXXFLAGS="$CXXOPTFLAGS $CXXFLAGS"
fi

CMACROS="$CMACROS -DG__HAVE_CONFIG -DG__NOMAKEINFO"
CXXMACROS="$CXXMACROS -DG__HAVE_CONFIG -DG__NOMAKEINFO"

if [ "$REFLEXINCDIR" = "" -a -d ../reflex ]; then 
	REFLEXINCDIR=$PWD/../reflex/inc
	echo Setting reflex-incdir=../reflex/inc
fi
if [ "$REFLEXLIBDIR" = "" -a -d ../reflex ]; then
	REFLEXLIBDIR=$PWD/../reflex/lib
	echo Setting reflex-libdir=../reflex/lib
fi
if [ "$CINTEXINCDIR" = "" -a "$REFLEXINCDIR" = "$PWD/../reflex/inc" ]; then 
	CINTEXINCDIR=$PWD/../cintex/inc
	echo Setting cintex-incdir=../cintex/inc
fi
if [ "$CINTEXLIBDIR" = "" -a "$REFLEXLIBDIR" = "$PWD/../reflex/lib" ]; then 
	CINTEXLIBDIR=$PWD/../cintex/lib
	echo Setting cintex-libdir=../cintex/lib
fi
if [ "$REFLEXINCDIR" != "" -a "$CINTEXINCDIR" = "" ]; then
	CINTEXINCDIR=$REFLEXINCDIR
	echo Setting cintex-incdir=$REFLEXINCDIR
fi
if [ "$REFLEXLIBDIR" != "" -a "$CINTEXLIBDIR" = "" ]; then
	CINTEXLIBDIR=$REFLEXLIBDIR
	echo Setting cintex-incdir=$REFLEXLIBDIR
fi

if [ "$READLINELIB" = "" ]; then
    for d in $EXTRA_LIB_DIR /usr/local/lib /usr/lib /sw/lib; do 
        if [ -f ${d}/libreadline$IMPLIBEXT ]; then
            READLINELIB=$d/libreadline$IMPLIBEXT
            break
        fi
    done
    if [ "x$READLINELIB" = "x" ]; then
        echo 'Please install the package "libreadline-dev"!'
        exit 1
    fi
    LINK_READLINELIB="$LIBP`dirname $READLINELIB` ${LIBL/@imp@/readline} "
fi
if [ "$READLINELIB" != "" ]; then
    CXXFLAGS="$CXXFLAGS -DG__GNUREADLINE"
    echo "Using $READLINELIB"

    # look for curses
    if [ "$CURSESLIB" = "" ]; then
        for d in $EXTRA_LIB_DIR /usr/local/lib /usr/lib /sw/lib /sw/lib/ncurses; do 
            if [ -f ${d}/libncurses$IMPLIBEXT ]; then
                CURSESLIB=$d/libncurses$IMPLIBEXT
                NCURSES=n
                break
            elif [ -f ${d}/libcurses$IMPLIBEXT ]; then
                CURSESLIB=$d/libcurses$IMPLIBEXT
                NCURSES=
                break
            fi
        done
    fi
    if [ "$CURSESLIB" != "" ]; then
        LINK_CURSESLIB="$LIBP`dirname $CURSESLIB` ${LIBL/@imp@/${NCURSES}curses}"
        echo "Using $CURSESLIB"
    fi
fi


[ "$STREAMDIR" = "" ]   && STREAMDIR=stream
[ "$MANGLEPATHS" = "" ] && MANGLEPATHS="echo "

# do path name mangling to windows, if requested by $MANGLEPATHS
#if [ "$MANGLEPATHS" = "1" ]; then
#    [ $CINTEXINCDIR ] && CINTEXINCDIR=`cygpath -w $CINTEXINCDIR`
#    [ $CINTEXLIBDIR ] && CINTEXLIBDIR=`cygpath -w $CINTEXLIBDIR`
#    [ $REFLEXINCDIR ] && REFLEXINCDIR=`cygpath -w $REFLEXINCDIR`
#    [ $REFLEXLIBDIR ] && REFLEXLIBDIR=`cygpath -w $REFLEXLIBDIR`
#fi

HAVE_CONFIG=1

EXPORTS=(${EXPORTS[*]} HAVE_CONFIG)

echo ""
# generate Makefile.conf
file=Makefile.conf
echo Writing $file...
echo "# Makefile.conf for Cint" > $file
echo "# generated by configure with options" >> $file
echo "# "${ALLOPTIONS[*]} >> $file

for exp in ${EXPORTS[*]}; do
    # Write out e.g. "CXX:=cl"
    value="`echo start \"${!exp}\"|sed -e 's,start ,,' -e 's,[$],$$,g'`"
    [ "$value" != "" ] && echo G__CFG_$exp := "$value" >> $file
done

# Now do the same for configcint.h - but here we need to write _all_ vars
file=inc/configcint.h
echo Writing $file...
echo "/* configcint.h for Cint */" > $file
echo "/* generated by configure with options */" >> $file
echo "/* "${ALLOPTIONS[*]}" */">> $file

for exp in ${EXPORTS[*]}; do
    # Write out e.g. "CXX:=cl"
    [ $exp = EXTRACTSYMBOLS ] && continue
    value="`echo start \"${!exp}\"|sed -e 's,start ,,' -e 's,\\\\,\\\\\\\\,g'`"
    echo '#define 'G__CFG_$exp \""$value"\" >> $file
done

echo ${ALLOPTIONS[*]} > config.status
echo Done.
echo Run \"make\" to build cint.
echo Run \"make help\" to see the available build targets.

# -*- mode:sh -*-