#! /bin/sh

PROJECT=glaze
PROJECT_BLURB="a shiny way to wrap OpenGL"

MAJOR=0
MINOR=0
RELEASE=0
VERSION=${MAJOR}.${MINOR}.${RELEASE}

srcdir=$(dirname "$0")

# For a non-srcdir configure invocation (such as ../configure), create
# the directory structure and copy Makefiles.
if [ "$srcdir" != "." ]; then

    for dir in . $(grep "^subdirs *=" "$srcdir"/Makefile | sed -e "s/subdirs *= *//"); do
	mkdir -p "$dir"
	cp "$srcdir"/"$dir"/Makefile.local "$dir"
	cp "$srcdir"/"$dir"/Makefile "$dir"
    done
fi

# Set several defaults (optionally specified by the user in
# environment variables)
CC=${CC:-gcc}
CFLAGS=${CFLAGS:--O2}
LDFLAGS=${LDFLAGS:-}

# Set the defaults for values the user can specify with command-line
# options.
PREFIX=/usr/local

usage ()
{
    cat <<EOF
Usage: ./configure [options]...

This script configures ${PROJECT} to build on your system.

It verifies that dependencies are available, determines flags needed
to compile and link against various required libraries, and identifies
whether various system functions can be used or if locally-provided
replacements will be built instead.

Finally, it allows you to control various aspects of the build and
installation process.

First, some common variables can specified via environment variables:

	CC		The C compiler to use
	CFLAGS		Flags to pass to the C compiler
	LDFLAGS		Flags to pass when linking

Each of these values can further be controlled by specifying them
later on the "make" command line.

Additionally, various options can be specified on the configure
command line.

	--prefix=PREFIX	Install files in PREFIX [$PREFIX]

By default, "make install" will install the resulting program to
$PREFIX/bin, documentation to $PREFIX/man, etc. You can
specify an installation prefix other than $PREFIX using
--prefix, for instance:

	./configure --prefix=\$HOME

Fine tuning of some installation directories is available:

	--bindir=DIR		Install executables to DIR [PREFIX/bin]
	--libdir=DIR		Install libraries to DIR [PREFIX/lib]
	--mandir=DIR		Install man pages to DIR [PREFIX/share/man]
	--sysconfdir=DIR	Read-only single-machine data [PREFIX/etc]

Additional options are accepted for compatibility with other
configure-script calling conventions, but don't do anything yet:

	--build=<cpu>-<vendor>-<os>	Currently ignored
	--host=<cpu>-<vendor>-<os>	Currently ignored
	--infodir=DIR			Currently ignored
	--datadir=DIR			Currently ignored
	--localstatedir=DIR		Currently ignored
	--libexecdir=DIR		Currently ignored
	--disable-maintainer-mode	Currently ignored
	--disable-dependency-tracking	Currently ignored

EOF
}

# Parse command-line options
for option; do
    if [ "${option}" = '--help' ] ; then
	usage
	exit 0
    elif [ "${option%%=*}" = '--prefix' ] ; then
	PREFIX="${option#*=}"
    elif [ "${option%%=*}" = '--bindir' ] ; then
	BINDIR="${option#*=}"
    elif [ "${option%%=*}" = '--libdir' ] ; then
	LIBDIR="${option#*=}"
    elif [ "${option%%=*}" = '--mandir' ] ; then
	MANDIR="${option#*=}"
    elif [ "${option%%=*}" = '--sysconfdir' ] ; then
	SYSCONFDIR="${option#*=}"
    elif [ "${option%%=*}" = '--build' ] ; then
	true
    elif [ "${option%%=*}" = '--host' ] ; then
	true
    elif [ "${option%%=*}" = '--infodir' ] ; then
	true
    elif [ "${option%%=*}" = '--datadir' ] ; then
	true
    elif [ "${option%%=*}" = '--localstatedir' ] ; then
	true
    elif [ "${option%%=*}" = '--libexecdir' ] ; then
	true
    elif [ "${option}" = '--disable-maintainer-mode' ] ; then
	true
    elif [ "${option}" = '--disable-dependency-tracking' ] ; then
	true
    else
	echo "Unrecognized option: ${option}"
	echo "See:"
	echo "	$0 --help"
	echo ""
	exit 1
    fi
done

printf "Checking for working C compiler (${CC})... "
printf "int main(void){return 42;}\n" > minimal.c
if ${CC} -o minimal minimal.c > /dev/null 2>&1
then
    printf "Yes.\n"
else
    printf "No.\n"
    cat <<EOF

*** Error: No functioning C compiler found. Either set the CC environment
to a working C compiler, or else install gcc:

	http://gcc.gnu.org/

You may be able to install gcc with a command such as:

	sudo apt-get install build-essential
    or:
	sudo yum install make automake gcc gcc-c++ kernel-devel

EOF

exit 1

fi

WARN_CFLAGS=""
printf "Checking for available C compiler warning flags:\n"
for flag in -Wall -Wextra -Wmissing-declarations -Werror=attributes; do
    if ${CC} $flag -o minimal minimal.c > /dev/null 2>&1
    then
	WARN_CFLAGS="${WARN_CFLAGS}${WARN_CFLAGS:+ }${flag}"
    fi
done
printf "\t${WARN_CFLAGS}\n"

rm -f minimal minimal.c

printf "#include <features.h>\nint main(void){return 0;}\n" > arch-minimal.c

printf "Checking for machine-dependent compiler support:\n"

printf "	Compiler can create 32-bit binaries... "
have_m32=Yes
if ${CC} -m32 -o arch-minimal arch-minimal.c > /dev/null 2>&1
then
    printf "Yes.\n"

    printf "	Target directory for 32-bit targets... "

    lib32_dir=$(gcc -m32 --print-multiarch)

    if [ "$lib32_dir" = "" ]; then
	lib32_dir="i386-linux-gnu"
	printf "\n\n"
	printf "\t\t*** Warning: Failed to query target directory.\n"
	printf "\t\tHard-coding to $lib32_dir\n"
	printf "\t\tFix  LIB32_DIR in Makefile.config as needed.\n\n"
    else
	printf "${lib32_dir}\n"
    fi

else
    printf "No.\n"
    have_m32=No
fi

printf "	Compiler can create 64-bit binaries... "
have_m64=Yes
if ${CC} -m64 -o arch-minimal arch-minimal.c > /dev/null 2>&1
then
    printf "Yes.\n"

    printf "	Target directory for 64-bit targets... "

    lib64_dir=$(gcc -m64 --print-multiarch)

    if [ "$lib64_dir" = "" ]; then
	lib64_dir="x86_64-linux-gnu"
	printf "\n\n"
	printf "\t\t*** Warning: Failed to query target directory.\n"
	printf "\t\tHard-coding to $lib64_dir\n"
	printf "\t\tFix LIB64_DIR in Makefile.config as needed.\n\n"
    else
	printf "${lib64_dir}\n"
    fi

else
    printf "No.\n"
    have_m64=No
fi

if [ "$have_m32" = "No" ] || [ "$have_m64" = "No" ]; then
    cat <<EOF

* Warning: Cannot create both 32 and 64-bit glaze libraries. Glaze will not
           support applications of the non-native size. Fixing this may be
           as simple as running a command such as:

		sudo apt-get install gcc-multilib
EOF
fi

rm -f arch-minimal arch-minimal.c

cat <<EOF

You may now run the following commands to compile and install ${PROJECT}:

	make
	sudo make install

EOF

# construct the Makefile.config
cat > Makefile.config <<EOF
# This Makefile.config was automatically generated by the ./configure
# script of ${PROJECT}. If the configure script identified anything
# incorrectly, then you can edit this file to try to correct things,
# but be warned that if configure is run again it will destroy your
# changes, (and this could happen by simply calling "make" if the
# configure script is updated).

# The top-level directory for the source, (the directory containing
# the configure script). This may be different than the build
# directory (the current directory at the time configure was run).
srcdir = ${srcdir}

configure_options = $@

# We use vpath directives (rather than the VPATH variable) since the
# VPATH variable matches targets as well as prerequisites, (which is
# not useful since then a target left-over from a srcdir build would
# cause a target to not be built in the non-srcdir build).
vpath % \$(srcdir)

# The C compiler to use
CC = ${CC}

# Default FLAGS for C compiler (can be overridden by user such as "make CFLAGS=-g")
CFLAGS = ${CFLAGS}

# Default FLAGS for the linker (can be overridden by user such as "make LDFLAGS=-znow")
LDFLAGS = ${LDFLAGS}

# Flags to enable warnings when using the C compiler
WARN_CFLAGS = ${WARN_CFLAGS}

# The prefix to which ${PROJECT} should be installed
PREFIX = ${PREFIX}

# The directory to which executables should be installed
BINDIR = ${BINDIR:-\$(PREFIX)/bin}

# The directory to which libraries should be installed
LIBDIR = ${LIBDIR:-\$(PREFIX)/lib}

# The directory to which headers should be installed
INCLUDEDIR = ${INCLUDEDIR:-\$(PREFIX)/include}

# Whether compiler can create 32 or 64-bit binaries
COMPILER_SUPPORTS_32 = ${have_m32}
LIB32_DIR = lib/${lib32_dir}
COMPILER_SUPPORTS_64 = ${have_m64}
LIB64_DIR = lib/${lib64_dir}

# Version information for glaze library
MAJOR   = ${MAJOR}
MINOR   = ${MINOR}
RELEASE = ${RELEASE}
VERSION = ${VERSION}

EOF

# construct config.h
QQ='"'
cat > config.h <<EOF
/* Generated by configure */

/* The prefix to which ${PROJECT} should be installed */
#define CONFIG_PREFIX "${PREFIX}"

/* The directory to which libraries should be installed */
#define CONFIG_LIBDIR "${LIBDIR:-${QQ} CONFIG_PREFIX ${QQ}/lib}"

/* The directory to which executables should be installed */
#define CONFIG_BINDIR "${BINDIR:-${QQ} CONFIG_PREFIX ${QQ}/bin}"

EOF

# construct the glaze.pc and glaze-32.pc files
if [ "$have_m64" = "Yes" ]; then
    cat > glaze.pc <<EOF
prefix=${PREFIX}
exec_prefix=\${prefix}
libdir=${LIBDIR:-\${exec_prefix\}/lib}
includedir=${INCLUDEDIR:-\${prefix\}/include}

Name: ${PROJECT}
Description: ${PROJECT_BLURB}
Version: ${VERSION}

Libs: -L\${libdir} -lglaze
Cflags: -I\${includedir}/glaze
EOF
fi

if [ "$have_m32" = "Yes" ]; then
    cat > glaze-32.pc <<EOF
prefix=${PREFIX}
exec_prefix=\${prefix}
libdir=${LIBDIR:-\${exec_prefix\}/lib}
includedir=${INCLUDEDIR:-\${prefix\}/include}

Name: ${PROJECT}
Description: ${PROJECT_BLURB}
Version: ${VERSION}

Libs: -L\${libdir} -lglaze-32
Cflags: -I\${includedir}/glaze
EOF
fi