configure

#!/bin/bash

# Configure script for CreateRemdDirs

Usage() {
  echo "Usage: ./configure <OPTIONS> [gnu | intel | pgi | clang | cray]"
  echo "  OPTIONS:"
  echo "    --help             : Display this message."
  echo "    -cray              : Use cray compiler wrappers (cc/CC/ftn)."
  echo "    --with-netcdf=<DIR>: Use NetCDF in <DIR>"
  echo "    -nonetcdf          : Disable NetCDF (disables check functionality)."
  echo "    -nolfs             : Disable large file support."
  echo ""
}
# ------------------------------------------------------------------------------
# If arg is Key=Value, separate into Key and Value
ParseArg() {
  KEY=`echo "$1" | awk 'BEGIN{FS = "=";}{print $1;}'`
  VALUE=`echo "$1" | awk 'BEGIN{FS = "=";}{print $2;}'`
  eval VALUE=$VALUE
  if [[ $VALUE = $KEY ]] ; then
    VALUE=""
  fi
}

CompileError() {
  echo "Compile error: $1" > /dev/stderr
  if [[ -f "compile.err" ]] ; then
    cat compile.err > /dev/stderr
    rm compile.err
  fi
  exit 1
}

# TestCxxProgram {required|optional} <TestName> [<Lib>]
# Test compile test program testp.cpp
TestCxxProgram() {
  echo "$2"
  COMPILELINE="$CXX $CXXFLAGS -o testp testp.cpp $3"
  $COMPILELINE > /dev/null 2> compile.err
  if [[ $? -ne 0 ]] ; then
    if [ "$1" = 'required' ] ; then
      CompileError "$COMPILELINE"
    fi
    return 1
  fi
  ./testp | grep "Testing" > /dev/null
  if [[ $? -ne 0 ]] ; then
    if [ "$1" = 'required' ] ; then
      CompileError "$COMPILELINE"
    fi
    return 1
  fi
  /bin/rm -f testp.cpp testp compile.err
  echo "  OK"
  return 0
}

TestNetcdf() {
  if [[ ! -z $NETCDFLIB ]] ; then
    compile_stat=''
    if [ $NETCDF_SPECIFIED -eq 1 ] ; then
      compile_stat='required'
    else
      compile_stat='optional'
    fi
    cat > testp.cpp <<EOF
#include <cstdio>
#include "netcdf.h"
int main() { printf("Testing\n"); printf("%s\n",nc_strerror(0)); return 0; }
EOF
    TestCxxProgram "$compile_stat" "Checking NetCDF" "$NETCDFLIB"
    if [ $? -ne 0 ] ; then
      # If we are here netcdf is optional and failed. Disabled it.
      echo "  NetCDF not found. Disabling."
      NETCDFLIB=""
    fi
  fi
}

TestCompile() {
  cat > testp.cpp <<EOF
#include <cstdio>
int main() { printf("Testing\n"); return 0; }
EOF
  TestCxxProgram 'required' "Testing C++ compiler"
}

# ------------------------------------------------------------------------------
if [[ $1 = "--help"  || $1 = "-h" ]] ; then
  Usage
  exit 0
fi

CONFIGURECMD="./configure $*"

KEY=""
VALUE=""
echo ""

# Process options
if [[ ! -z $CXX ]] ; then
  COMPILER=$CXX
else
  COMPILER=g++
fi
NETCDFLIB=-lnetcdf
NETCDF_HOME=""
NETCDF_SPECIFIED=0
DIRECTIVES=""
INCLUDE=""
LFS="-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
NO_OPT=0
DBG_FLAG=""

while [[ ! -z $1 ]] ; do
  ParseArg $1
  case "$KEY" in
    "gnu"    ) COMPILER=g++ ;;
    "clang"  ) COMPILER=clang++ ;;
    "intel"  ) COMPILER=icpc ;;
    "pgi"    ) COMPILER=pgc++ ;;
    "cray"   ) COMPILER=CC ;;
    "-cray"     ) echo "Using cray compiler wrapper (CC)." ; USECRAY=1 ;;
    "-nonetcdf" ) echo "Not using netcdf." ;  NETCDFLIB="" ;;
    "-nolfs"    ) echo "Disabling large file support." ; LFS="" ;;
    "-noopt"    ) echo "Disabling optimization." ; NO_OPT=1 ;;
    "-debug"    ) echo "Enabling compile debug." ; DBG_FLAG=-g ;;
    "-d"        )
      echo "Disabling optimization and enabling compile debug."
      NO_OPT=1
      DBG_FLAG=-g
      ;;
    "--with-netcdf" )
      NETCDF_SPECIFIED=1
      INCLUDE="$INCLUDE -I$VALUE/include"
      NETCDF_HOME="$VALUE"
      echo "Using NETCDF in $NETCDF_HOME"
      ;;
    * ) echo "Error: Unrecognized option $KEY" > /dev/stderr ; exit 1 ;;
  esac
  shift
done

# Determine compile flags
case "$COMPILER" in
    "g++" )
      echo "Using gnu compilers"
      CXX=g++
      OPTFLAGS="-O3 -Wall"
      PICFLAG="-fPIC"
      ;;
    "clang++" )
      echo "Using clang compilers"
      CXX=clang++
      OPTFLAGS="-O3 -Weverything"
      PICFLAG="-fPIC"
      ;;
    "icpc" )
      echo "Using intel compilers"
      CXX=icpc
      OPTFLAGS="-O3 -Wall"
      PICFLAG="-fpic"
      ;;
    "pgc++" )
      echo "Using PGI compilers"
      CXX=pgc++
      OPTFLAGS="-O2"
      PICFLAG="-fpic"
      ;;
    "CC" )
      echo "Using Cray compilers"
      CXX=CC
      OPTFLAGS=""
      PICFLAG="-fpic"
      ;;
    * ) echo "Error: No compiler." > /dev/stderr ; exit 1 ;;
esac

# Use cray wrappers
if [[ $USECRAY -eq 1 ]] ; then
  CXX=CC
fi

# Remove optimizations
if [[ $NO_OPT -eq 1 ]] ; then
  OPTFLAGS=""
fi

# Set up NETCDF linking
if [[ ! -z $NETCDF_HOME && ! -z $NETCDFLIB ]] ; then
  # Try to link statically if possible
  if [ -f "$NETCDF_HOME/lib/libnetcdf.a" ] ; then
    NETCDFLIB="$NETCDF_HOME/lib/libnetcdf.a"
  else
    NETCDFLIB="-L$NETCDF_HOME/lib $NETCDFLIB"
  fi
fi

# Set up compiler flags
CXXFLAGS="$DBG_FLAG $OPTFLAGS $LFS $INCLUDE"

# Test compilers
TestCompile
TestNetcdf

# Set up directives
if [[ ! -z $NETCDFLIB ]] ; then
  DIRECTIVES="$DIRECTIVES -DHAS_NETCDF"
fi

# Set up linking flags
LDFLAGS="$NETCDFLIB"

# Write config.h
cat > config.h <<EOF
# config.h for CreateRemdDirs
# configured using: $CONFIGURECMD

CXX=$CXX
CXXFLAGS=$CXXFLAGS
DIRECTIVES=$DIRECTIVES
LDFLAGS=$LDFLAGS
EOF

echo "Cleaning source directories."
cd src && make clean > make.log 2>&1
rm make.log

echo ""
exit 0