path: root/configure

#!/bin/sh
#
# Some things this script could/should do when finished
#
# * detect the compiler name (g++/c++/...)
# * detect whether its a GNU compiler or not (for compiler settings)
# * detect the host platform and base settings on this:
#   - #defines like -DUNIX and -DMACOSX
#   - required libs like -lmingw32
# * command line options to...
#   - override the host settings (for cross compiles
#   - select the desired backend (sdl, x11, ...)
#   - whether to do a debug build (with -g) or an optimized build (-O3 etc.)
# * detect whether the chosen backend is available (e.g. call sdl-config)
# * generate a config.mak file for use in makefiles
# * ....

# TODO: We should really use mktemp(1) to determine a random tmp file name.
# However, that tool might not be available everywhere.
TMPO=/tmp/scummvm-conf
TMPC=${TMPO}.cpp
TMPLOG=config.log

# use environment vars if set
CXXFLAGS="$CXXFLAGS $CPPFLAGS"

# default lib behaviour yes/no/auto
_vorbis=auto
_mad=auto
_alsa=auto
_zlib=auto
_mpeg2=auto
# default option behaviour yes/no
_build_scumm=yes
_build_simon=yes
_build_sky=yes
_build_sword1=yes
_build_sword2=yes
_build_queen=yes
_need_memalign=no
# more defaults
_backend=sdl
_ranlib=ranlib
_sdlconfig=sdl-config
_host=""
_sdlpath="$PATH"
# config.h defaults
_def_linupy="#undef LINUPY"

cc_check() {
	echo >> "$TMPLOG"
	cat "$TMPC" >> "$TMPLOG"
	echo >> "$TMPLOG"
	echo "$CXX $TMPC -o $TMPO $@" >> "$TMPLOG"
	rm -f "$TMPO"
	( $CXX "$TMPC" -o "$TMPO" "$@" ) >> "$TMPLOG" 2>&1
	TMP="$?"
	echo >> "$TMPLOG"
	return "$TMP"
}

echocheck () {
	echo -n "Checking for $@... "
}

#
# Check whether the given command is a working C++ compiler
#
test_compiler ()
{
cat <<EOF >tmp_cxx_compiler.cpp
class Foo {
  int a;
};
int main(int argc, char **argv)
{
	Foo *a = new Foo();
	delete a;
	return 0;
}
EOF

if test -n "$_host"; then
    # In cross-compiling mode, we cannot run the result
    eval "$1 -o tmp_cxx_compiler tmp_cxx_compiler.cpp 2> /dev/null" && rm -f tmp_cxx_compiler tmp_cxx_compiler.cpp
else
    eval "$1 -o tmp_cxx_compiler tmp_cxx_compiler.cpp 2> /dev/null" && eval "./tmp_cxx_compiler 2> /dev/null" && rm -f tmp_cxx_compiler tmp_cxx_compiler.cpp
fi
}

#
# Determine sdl-config
#
# TODO: small bit of code to test sdl useability
find_sdlconfig()
{
	printf "Looking for sdl-config... "
	sdlconfigs="$_sdlconfig:sdl-config:sdl11-config:sdl12-config"
	_sdlconfig=
	
	IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
	
	for path_dir in $_sdlpath; do
	  for sdlconfig in $sdlconfigs; do
	    if test -x "$path_dir/$sdlconfig" ; then
	      _sdlconfig="$path_dir/$sdlconfig"
	      echo $_sdlconfig
	      break
	    fi
	  done
	done
	
	IFS="$ac_save_ifs"
	
	if test -z "$_sdlconfig"; then
	  echo "none found!"
	  exit 1
	fi
}

#
# Determine a data type with the given length
#
find_type_with_size ()
{
cat <<EOF >tmp_find_type_with_size.cpp
#include <stdio.h>
int main(int argc, char **argv)
{
	int size = argv[1][0] - '0';
	if (size == sizeof(int))
		printf("int\n");
	else if (size == sizeof(short))
		printf("short\n");
	else if (size == sizeof(char))
		printf("char\n");
	else if (size == sizeof(long))
		printf("long\n");
	else {
		printf("unknown\n");
		return 1;
	}

	return 0;
}
EOF
if eval "$CXX -o tmp_find_type_with_size tmp_find_type_with_size.cpp"; then
  datatype=`./tmp_find_type_with_size $1`
  if test "$datatype" = "unknown"; then
	echo "couldn't find data type with $1 bytes"
	exit 1
  fi
fi
rm -f tmp_find_type_with_size tmp_find_type_with_size.cpp
echo $datatype
}

#
# Greet user
#

echo "Running ScummVM configure..."
echo "Configure run on" `date` > $TMPLOG

#
# Check any parameters we received
#
# TODO:
# * Change --disable-mad / --enable-mad to the way it's done in autoconf:
#  That is, --without-mad / --with-mad=/prefix/to/mad. Useful for people
#  who have Mad/Vorbis/ALSA installed in a non-standard locations.
#

for parm in "$@" ; do
  if test "$parm" = "--help" || test "$parm" = "-help" || test "$parm" = "-h" ; then
    cat << EOF

Usage: $0 [OPTIONS]...

Configuration:
  -h, --help             display this help and exit
  --backend=BACKEND      backend to build (sdl, x11, morphos, dc, gp32) [sdl]

Special configuration feature:
  --host=HOST            cross-compile to target HOST (arm-linux, ...)
                         special targets: linupy for Yopy PDA

Optional Features:
  --disable-scumm          don't build the SCUMM engine
  --disable-simon          don't build the simon engine
  --disable-sky            don't build the Beneath a Steel Sky engine
  --disable-sword1         don't build the Broken Sword I engine
  --disable-sword2         don't build the Broken Sword II engine
  --disable-queen          don't build the Flight of the Amazon Queen engine

Optional Libraries:
  --with-alsa-prefix=PFX   Prefix where alsa is installed (optional)
  --disable-alsa           disable ALSA midi sound support [autodetect]
  --with-ogg-prefix=PFX    Prefix where libogg is installed (optional)
  --with-vorbis-prefix=PFX Prefix where libvorbis is installed (optional)
  --disable-vorbis         disable Ogg Vorbis support [autodetect]
  --with-mad-prefix=PFX    Prefix where libmad is installed (optional)
  --disable-mad            disable libmad (MP3) support [autodetect]
  --with-zlib-prefix=PFX   Prefix where zlib is installed (optional)
  --disable-zlib           disable zlib (compression) support [autodetect]
  --disable-mpeg2          disable mpeg2 codec for cutscenes [autodetect]
  --with-mpeg2-prefix=PFX  Prefix where libmpeg2 is installed (optional)
  --with-sdl-prefix=PFX    Prefix where the sdl-config script is installed

Some influential environment variables:
  LDFLAGS	linker flags, e.g. -L<lib dir> if you have libraries in a
  		nonstandard directory <lib dir>
  CXX		C++ compiler command
  CXXFLAGS	C++ compiler flags
  CPPFLAGS	C++ preprocessor flags, e.g. -I<include dir> if you have
  		headers in a nonstandard directory <include dir>

EOF
    exit 0
  fi
done # for parm in ...

DEBFLAGS="-g"

for ac_option in $@; do
    case "$ac_option" in
      --disable-scumm)		_build_scumm=no ;;
      --disable-simon)		_build_simon=no ;;
      --disable-sky)		_build_sky=no ;;
      --disable-sword1)		_build_sword1=no ;;
      --disable-sword2)		_build_sword2=no ;;
      --disable-queen)		_build_queen=no ;;
      --enable-alsa)		_alsa=yes	;;
      --disable-alsa)		_alsa=no	;;
      --enable-vorbis)		_vorbis=yes	;;
      --disable-vorbis)		_vorbis=no	;;
      --enable-mad)		_mad=yes	;;
      --disable-mad)		_mad=no		;;
      --enable-zlib)		_zlib=yes	;;
      --disable-zlib)		_zlib=no	;;
      --disable-mpeg2)          _mpeg2=no       ;;
      --with-mpeg2-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	MPEG2_CFLAGS="-I$_prefix/include"
	MPEG2_LIBS="-L$_prefix/lib"
        ;;
      --with-alsa-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	ALSA_CFLAGS="-I$_prefix/include"
	ALSA_LIBS="-L$_prefix/lib"
	;;
      --with-ogg-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	OGG_CFLAGS="-I$_prefix/include"
	OGG_LIBS="-L$_prefix/lib"
	;;
      --with-vorbis-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	VORBIS_CFLAGS="-I$_prefix/include"
	VORBIS_LIBS="-L$_prefix/lib"
	;;
      --with-mad-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	MAD_CFLAGS="-I$_prefix/include"
	MAD_LIBS="-L$_prefix/lib"
	;;
      --with-zlib-prefix=*)
	_prefix=`echo $ac_option | cut -d '=' -f 2`
	ZLIB_CFLAGS="-I$_prefix/include"
	ZLIB_LIBS="-L$_prefix/lib"
	;;
      --backend=*)
        _backend=`echo $ac_option | cut -d '=' -f 2`
	;;
      --disable-debug)
	DEBFLAGS=""
        ;;
      --enable-release)
	DEBFLAGS=""
        ;;
      --with-sdl-prefix=*)
	arg=`echo $ac_option | cut -d '=' -f 2`
	_sdlpath="$arg:$arg/bin"
	;;
      --host=*)
	_host=`echo $ac_option | cut -d '=' -f 2`
	;;
      *)
        echo "error: unrecognised option: $ac_option
Try \`$0 --help' for more information." >&2
	exit 1
        ;;
    esac;
done;

CXXFLAGS="$CXXFLAGS $DEBFLAGS"

if test "$_host" = "linupy"; then
    _host=arm-linux
    def_linupy="#define DLINUPY"
fi

#
# Determine the C++ compiler
#
printf "Looking for C++ compiler... "
if test -n "$_host"; then
    compilers="$CXX $_host-g++ $_host-c++"
else
    compilers="$CXX g++ c++"
fi

CXX=
for compiler in $compilers; do
    if test_compiler $compiler; then
	CXX=$compiler
	echo $CXX
	break
    fi
done
if test -z $CXX; then
    echo "none found!"
    exit 1
fi

#
# Determine the compiler version

echocheck "compiler version"

cxx_name=`( $cc -v ) 2>&1 | tail -1 | cut -d ' ' -f 1`
cxx_version=`( $CXX -dumpversion ) 2>&1`
if test "$?" -gt 0; then
	cxx_version="not found"
fi

case $cxx_version in
	2.95.[2-9]|2.95.[2-9][-.]*|3.[0-9]|3.[0-9].[0-9])
		_cxx_major=`echo $cxx_version | cut -d '.' -f 1`
		_cxx_minor=`echo $cxx_version | cut -d '.' -f 2`
		cxx_version="$cxx_version, ok"
		cxx_verc_fail=no
		;;
	# whacky beos version strings
	2.9-beos-991026*|2.9-beos-000224*)	
		_cxx_major=2
		_cxx_minor=95
		cxx_version="$cxx_version, ok"
		cxx_verc_fail=no
		;;
	'not found')
		cxx_verc_fail=yes
		;;
	*)
		cxx_version="$cxx_version, bad"
		cxx_verc_fail=yes
		;;
esac

echo "$cxx_version"

if test "$cxx_verc_fail" = yes ; then
	echo
	echo "The version of your compiler is not supported at this time"
	echo "Please ensure you are using GCC 2.95.x or GCC 3.x"
	exit 1	
fi

#
# Do CXXFLAGS now we know the compiler version
#

if test "$_cxx_major" -ge "3" ; then
	CXXFLAGS="$CXXFLAGS -ansi -W -Wno-unused-parameter"
	_make_def_HAVE_GCC3='HAVE_GCC3 = 1'
fi;

#
# Engine selection
#
if test "$_build_scumm" = no ; then
	_mak_scumm='DISABLE_SCUMM = 1'
else
	_mak_scumm='# DISABLE_SCUMM = 1'
fi

if test "$_build_simon" = no ; then
	_mak_simon='DISABLE_SIMON = 1'
else
	_mak_simon='# DISABLE_SIMON = 1'
fi

if test "$_build_sky" = no ; then
	_mak_sky='DISABLE_SKY = 1'
else
	_mak_sky='# DISABLE_SKY = 1'
fi

if test "$_build_sword1" = no ; then
	_mak_sword1='DISABLE_SWORD1 = 1'
else
	_mak_sword1='# DISABLE_SWORD1 = 1'
fi

if test "$_build_sword2" = no ; then
	_mak_sword2='DISABLE_SWORD2 = 1'
else
	_mak_sword2='# DISABLE_SWORD2 = 1'
fi

if test "$_build_queen" = no ; then
	_mak_queen='DISABLE_QUEEN = 1'
else
	_mak_queen='# DISABLE_QUEEN = 1'
fi


if test -n "$_host"; then
    # Cross-compiling mode - add your target here if needed
    case "$_host" in
	arm-linux)
	    echo "Cross-compiling to $_host, forcing endianness, alignment and type sizes"
	    DEFINES="$DEFINES -DUNIX"
	    _def_endianess='#define SCUMM_LITTLE_ENDIAN'
	    _def_align='#define SCUMM_NEED_ALIGNMENT'
	    type_1_byte='char'
	    type_2_byte='short'
	    type_4_byte='int'
	    ;;
	*)
	    echo "Cross-compiling to unknown target, please add your target to configure."
	    exit 1
	    ;;
    esac
	    
else
    #
    # Determine hosttype
    #
    # TODO - also add an command line option to override this?!?
    # TODO - recognize more systems, e.g. *BSD
    printf "Checking hosttype... "
    hosttype=`uname -s`
    echo $hosttype
    case $hosttype in
	Linux | OpenBSD | FreeBSD | NetBSD | BSD/OS | SunOS | HP-UX | BeOS)
		DEFINES="$DEFINES -DUNIX"
		;;
	IRIX)
		DEFINES="$DEFINES -DUNIX"
		ranlib=ar -r
		;;
	Darwin)
		DEFINES="$DEFINES -DUNIX -DMACOSX"
		LIBS="$LIBS -framework QuickTime -framework AudioUnit -framework Carbon"
		# TODO: Add proper check for Altivec support in the compiler...
		DEFINES="$DEFINES -DHAS_ALTIVEC"
		CXXFLAGS="$CXXFLAGS -faltivec"
		;;
	MINGW32*)
		echo "mingw32 not supported by configure script"
		echo "Try 'make -f Makefile.mingw'"
		exit 1
		;;
	CYGWIN*)
		echo "cygwin not supported by configure script"
		exit 1
		;;
	# given this is a shell script assume some type of unix
	*)
		echo "WARNING: could not establish system type, assuming unix like"
		DEFINES="$DEFINES -DUNIX"
		;;
    esac

    #
    # Check for endianess
    #
    printf "Checking endianess... "
    cat <<EOF >tmp_endianess_check.cpp
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
	unsigned int data = 0x01234567;
	char *ptr = (char *)&data;
	if (ptr[0] == 0x01 && ptr[1] == 0x23 && ptr[2] == 0x45 && ptr[3] == 0x67)
		printf("big\n");
	else if (ptr[3] == 0x01 && ptr[2] == 0x23 && ptr[1] == 0x45 && ptr[0] == 0x67)
		printf("little\n");
	else
		printf("unknown\n");
	return 0;
}
EOF
    $CXX -o tmp_endianess_check tmp_endianess_check.cpp
    endianess=`./tmp_endianess_check`
    echo $endianess;
    case $endianess in
	big)
	    _def_endianess='#define SCUMM_BIG_ENDIAN'
	    ;;
	little)
	    _def_endianess='#define SCUMM_LITTLE_ENDIAN'
	    ;;
	*)
	    exit 1
	    ;;
    esac
    rm -f tmp_endianess_check tmp_endianess_check.cpp

    #
    # Check whether memory alignment is required
    #
    echo -n "Alignment required... "
    cat > $TMPC << EOF
#include <stdlib.h>
#include <signal.h>
int main(int argc, char **argv)
{
	unsigned char test[8] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 };
	signal(SIGBUS, exit);
	signal(SIGABRT, exit);
	signal(SIGSEGV, exit);
	if (*((unsigned int *)(test + 1)) != 0x55443322 && *((unsigned int *)(test + 1)) != 0x22334455) {
		return 1;
	}
	return 0;
}
EOF
    _need_memalign=yes
    cc_check && $TMPO && _need_memalign=no
    if test "$_need_memalign" = yes ; then
	_def_align='#define SCUMM_NEED_ALIGNMENT'
    else
	_def_align='#undef SCUMM_NEED_ALIGNMENT'
    fi
    echo "$_need_memalign"

    #
    # Determine data type sizes
    # TODO: proper error checking
    #
    printf "Type with 1 byte... "
    type_1_byte=`find_type_with_size 1`
    echo "$type_1_byte"
    
    printf "Type with 2 bytes... "
    type_2_byte=`find_type_with_size 2`
    echo "$type_2_byte"
    
    printf "Type with 4 bytes... "
    type_4_byte=`find_type_with_size 4`
    echo "$type_4_byte"
    
fi

echocheck "Ogg Vorbis"
if test "$_vorbis" = auto ; then
  _vorbis=no
  cat > $TMPC << EOF
#include <vorbis/codec.h>
int main(void) { vorbis_packet_blocksize(0,0); return 0; }
EOF
  cc_check $LDFLAGS $CXXFLAGS $OGG_CFLAGS $OGG_LIBS $VORBIS_CFLAGS $VORBIS_LIBS \
  -lvorbis -logg -lm && _vorbis=yes
fi
if test "$_vorbis" = yes ; then
  _def_vorbis='#define USE_VORBIS'
  LIBS="$LIBS $OGG_LIBS $VORBIS_LIBS -lvorbisfile -lvorbis -logg"
  INCLUDES="$INCLUDES $OGG_CFLAGS $VORBIS_CFLAGS"
else
  _def_vorbis='#undef USE_VORBIS'
fi
echo "$_vorbis"

echocheck "MAD"
if test "$_mad" = auto ; then
  _mad=no
  cat > $TMPC << EOF
#include <mad.h>
int main(void) {return 0; }
EOF
  cc_check $LDFLAGS $CXXFLAGS $MAD_CFLAGS $MAD_LIBS -lmad && _mad=yes
fi
if test "$_mad" = yes ; then
  _def_mad='#define USE_MAD'
  LIBS="$LIBS $MAD_LIBS -lmad"
  INCLUDES="$INCLUDES $MAD_CFLAGS"
else
  _def_mad='#undef USE_MAD'
fi
echo "$_mad"

echocheck "ALSA 0.9"
if test "$_alsa" = auto ; then
  _alsa=no
  cat > $TMPC << EOF
#include <alsa/asoundlib.h>
int main(void) { return (!(SND_LIB_MAJOR==0 && SND_LIB_MINOR==9)); }
EOF
  cc_check $LDFLAGS $CXXFLAGS $ALSA_CFLAGS $ALSA_LIBS -lasound && _alsa=yes
fi
if test "$_alsa" = yes ; then
  _def_alsa='#define USE_ALSA'
  LIBS="$LIBS $ALSA_LIBS -lasound"
  INCLUDES="$INCLUDES $ALSA_CFLAGS"
else
  _def_alsa='#undef USE_ALSA'
fi
echo "$_alsa"

echocheck "zlib"
if test "$_zlib" = auto ; then
  _zlib=no
  cat > $TMPC << EOF
#include <string.h>
#include <zlib.h>
int main(void) { return strcmp(ZLIB_VERSION, zlibVersion()); }
EOF
  cc_check $LDFLAGS $CXXFLAGS $ZLIB_CFLAGS $ZLIB_LIBS -lz && _zlib=yes
fi
if test "$_zlib" = yes ; then
  _def_zlib='#define USE_ZLIB'
  LIBS="$LIBS $ZLIB_LIBS -lz"
  INCLUDES="$INCLUDES $ZLIB_CFLAGS"
else
  _def_zlib='#undef USE_ZLIB'
fi
echo "$_zlib"

echocheck "libmpeg2 >= 0.3.2"
if test "$_mpeg2" = auto ; then
  _mpeg2=no
  cat > $TMPC << EOF
#include <inttypes.h>
#include <mpeg2dec/mpeg2.h>
int main(void) {
	/* mpeg2_state_t first appears in 0.4.0 */
	mpeg2_state_t state;

        #ifdef MPEG2_RELEASE
		if (MPEG2_RELEASE >= MPEG2_VERSION(0, 3, 2))
			return 0;
	#endif
	return 1;
}
EOF
  cc_check $LDFLAGS $CXXFLAGS $MPEG2_CFLAGS $MPEG2_LIBS -lmpeg2 && $TMPO && _mpeg2=yes
fi
if test "$_mpeg2" = yes ; then
  _def_mpeg2='#define USE_MPEG2'
  INCLUDES="$INCLUDES $MPEG2_CFLAGS"
  LIBS="$LIBS $MPEG2_LIBS -lmpeg2"
else
  _def_mpeg2='#undef USE_MPEG2'
fi
echo "$_mpeg2"
rm -f $TMPC $TMPO

echo
echo "Engines:"
if test "$_build_scumm" = yes ; then
  echo "    SCUMM"
fi
if test "$_build_simon" = yes ; then
  echo "    Simon the Sorcerer"
fi
if test "$_build_sky" = yes ; then
  echo "    Beneath a Steel Sky"
fi
if test "$_build_sword1" = yes ; then
  echo -n "    Broken Sword I"
  if test "$_mpeg2" = yes ; then
	echo " (w/ mpeg2 cutscenes)"
  else
	echo "  (without mpeg2 cutscenes)"
  fi
fi
if test "$_build_sword2" = yes ; then
  echo -n "    Broken Sword II"
  if test "$_mpeg2" = yes ; then
	echo " (w/ mpeg2 cutscenes)"
  else
	echo " (without mpeg2 cutscenes)"
  fi
fi
if test "$_build_queen" = yes ; then
  echo "    Flight of the Amazon Queen"
fi
echo

echo -n "Backend... "
echo "$_backend"

#
# Backend related stuff
#
case $_backend in
  sdl)
    find_sdlconfig
    INCLUDES="$INCLUDES `$_sdlconfig --cflags`"
    LIBS="$LIBS `$_sdlconfig --libs`"
    OBJS="$OBJS backends/sdl/sdl-common.o backends/sdl/sdl.o"
    MODULES="$MODULES backends/sdl"
    MODULE_DIRS="$MODULE_DIRS backends/sdl"
    ;;
  x11)
    INCLUDES="$INCLUDES -I/usr/X11R6/include"
    LIBS="$LIBS -lpthread -lXext -lX11"
    LDFLAGS="$LDFLAGS -L/usr/X11R6/lib -L/usr/local/lib"
    OBJS="$OBJS backends/x11/x11.o"
    DEFINES="$DEFINES -DX11_BACKEND"
    MODULES="$MODULES backends/x11"
    MODULE_DIRS="$MODULE_DIRS backends/x11"
    ;;
  *)
    echo "support for $_backend backend not implemented in configure script yet"
    exit 1
  ;;
esac

echo
echo "Creating config.h"
cat > config.h << EOF
/* This file is automatically generated by configure */
/* DO NOT EDIT MANUALLY */

#ifndef CONFIG_H
#define CONFIG_H

$_def_endianess
$_def_align

$_def_linupy

/* Data types */
typedef unsigned $type_1_byte byte;
typedef unsigned int uint;
typedef unsigned $type_1_byte uint8;
typedef unsigned $type_2_byte uint16;
typedef unsigned $type_4_byte uint32;
typedef signed $type_1_byte int8;
typedef signed $type_2_byte int16;
typedef signed $type_4_byte int32;

/* Libs */
$_def_vorbis
$_def_mad
$_def_alsa
$_def_zlib
$_def_mpeg2

#endif /* CONFIG_H */
EOF

echo "Creating config.mak"
cat > config.mak << EOF
# -------- Generated by configure -----------

CXX := $CXX
CXXFLAGS += $CXXFLAGS
LIBS += $LIBS
RANLIB := $_ranlib
BACKEND := $_backend
MODULES += $MODULES
MODULE_DIRS += $MODULE_DIRS

$_make_def_HAVE_GCC3
$_mak_scumm
$_mak_simon
$_mak_sky
$_mak_sword1
$_mak_sword2
$_mak_queen

INCLUDES += $INCLUDES
OBJS += $OBJS
DEFINES += $DEFINES
LDFLAGS += $LDFLAGS
EOF