#!/bin/sh

# parse argument list

thiscmd=$0

FORTRAN_COMPILER_TIMER=""
opt_level="-f"
print_usage=""
chemistry=""
wrf_core=""
while [ $# -ge 1 ]; do
    case $1 in
      -d) opt_level="-d" ;;
      -s) opt_level="-s" ;;
      -f) opt_level="-f" ;;
      -h) print_usage="yes" ;;
      -help) print_usage="yes" ;;
      -os) shift ; WRF_OS=$1 ;;
      -mach) shift ; WRF_MACH=$1 ;;
      -time) shift ; FORTRAN_COMPILER_TIMER=$1 ;;
      chem) WRF_CHEM=1  ;;
      kpp) WRF_KPP=1  ;;
      radardfi) WRF_DFI_RADAR=1  ;;
      wrfda) wrf_core=DA_CORE ;;
      4dvar) wrf_core=4D_DA_CORE ;;
      arw) wrf_core=EM_CORE  ;;
      nmm) wrf_core=NMM_CORE  ;;
      coamps) wrf_core=COAMPS_CORE  ;;
      exp) wrf_core=EXP_CORE  ;;
      titan) WRF_TITAN=1 ; break ;;
      mars) WRF_MARS=1 ; break ;;
      venus) WRF_VENUS=1 ; break ;;
    esac
    shift
done
if [ -n "$print_usage" ] ; then
  echo usage: $thiscmd '[-d|-s|-f|-os os|-mach mach|-time timecommand] [chem] [kpp]'
  exit 
fi

if `pwd | grep ' ' > /dev/null ` ; then
  echo '************************** W A R N I N G ************************************'
  echo The current working directory has spaces in some components of its path name
  echo and this may cause problems for your build.  This can occur, for example, on
  echo Windows systems.  It is strongly recommended that you install WRF and other
  echo related software such as NetCDF in directories whose path names contain no
  echo white space.  On Win, for example, create and install in a directory under C:.
  echo '*****************************************************************************'
fi


# lifted from the configure file for mpich; 00/03/10 jm
#
# Check for perl and perl version
for p in perl5 perl
do
  # Extract the first word of "$p", so it can be a program name with args.
  set dummy $p; ac_word=$2
  if test -z "$ac_echo_n" ; then
    ac_echo_n=yes
    if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
      # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
      if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='        '
      else
        ac_n=-n ac_c= ac_t=
      fi
    else
      ac_n= ac_c='\c' ac_t=
    fi
    ac_echo_test=`echo foo 1>&1`
    if test -z "$ac_echo_test" ; then
       print_error "Your sh shell does not handle the output redirection"
       print_error "1>&1 correctly.  Configure will work around this problem,"
       print_error "but you should report the problem to your vendor."
    fi
  fi
  if test -z "$ac_echo_test" -a 1 = 1 ; then
    echo $ac_n "checking for $ac_word""... $ac_c"
  else
    echo $ac_n "checking for $ac_word""... $ac_c" 1>&1
  fi
  ac_prog_where=""
  if test -n "$PERL"; then
    ac_pg_PERL="$PERL" # Let the user override the test.
  else
    ac_first_char=`expr "$p" : "\(.\)"`
    if test "$ac_first_char" = "/" -a -x "$p" ; then
         ac_pg_PERL="$p"
         ac_prog_where=$p
    else
        IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
        for ac_dir in $PATH; do
          test -z "$ac_dir" && ac_dir=.
          if test -f $ac_dir/$ac_word; then
            ac_pg_PERL="$p"
            ac_prog_where=$ac_dir/$ac_word
            break
          fi
        done
        IFS="$ac_save_ifs"
    fi
  fi;PERL="$ac_pg_PERL"
  if test -n "$ac_prog_where" ; then
    if test -z "$ac_echo_test" -a 1 = 1 ; then
      echo "$ac_t""found $ac_prog_where ($PERL)"
    else
      echo "$ac_t""found $ac_prog_where ($PERL)" 1>&1
    fi
    PERLFULLPATH=$ac_prog_where  
  else
    if test -z "$ac_echo_test" -a 1 = 1 ; then
      echo "$ac_t""no"
    else
      echo "$ac_t""no" 1>&1
    fi
  fi
  test -n "$PERL" && break
done

if test -z "$PERL" ; then
    # We have to set this outside of the loop lest the first failure in 
    # PROGRAM_CHECK set the value (which then terminates the effect of the
    # loop, since autoconf macros only set values that are null, they 
    # don't override them
    PERL=""
fi

if test -n "$PERL" ; then
    PERL="$PERL"
    
    perlversion=`$PERL -v | grep 'This is perl' | \
       sed -e 's/^.*v[a-z ]*\([0-9]\).*$/\1/'`

    # Should do a test first for ch_p4 etc.
    if test "$perlversion" -lt 5 ; then
        echo "WRF build requires perl version 5, which configure did not find."
        echo "You can set the environment variable PERL to contain the "
        echo "location of perl version 5."
        echo "Configure believes that $PERL is version $perlversion ."
        PERL=""
    fi
    
fi

# Look for netcdf
if test -z "$NETCDF" ; then
  for p in /usr/local/netcdf
  do
    if test -d $p ; then
      NETCDF=$p
      break
    fi
  done
fi
if  test -z "$NETCDF"  ; then
 
  if [ `hostname | cut -c 1-2` = "bs" -o \
       `hostname | cut -c 1-2` = "bd" -o \
       `hostname` = "tempest" -o `hostname` = "ute" ] ; then
    echo 'Compiling on an NCAR system with weird paths to NetCDF'
    echo 'Setting up a local NetCDF directory with symlinks'
    if ( test -d ./netcdf_links ) ; then
      echo 'A directory ./netcdf_links already exists. Continuing.'
    else
      mkdir ./netcdf_links
      if [ -z "$OBJECT_MODE" ] ; then
         OBJECT_MODE=32 
         export OBJECT_MODE
      fi
      if [ $OBJECT_MODE -ne 64 -a \( `hostname | cut -c 1-2` = "bd" -o `hostname | cut -c 1-2` = "bs" \) ] ; then
        ( cd ./netcdf_links ; ln -s /usr/local/lib32/r4i4 ./lib ; \
                              ln -s /usr/local/include ./include )
      else
        ( cd ./netcdf_links ; ln -s /usr/local/lib64/r4i4 ./lib ; \
                              ln -s /usr/local/include ./include )
      fi
    fi
    NETCDF=`pwd`/netcdf_links
    export NETCDF


  else
    bedone=""
    if [ -d ./netcdf_links ] ; then
      echo '** There is an existing ./netcdf_links file. Should I use? [y]'
      read resp
      if [ "$resp" = "y" ] ; then
        NETCDF=`pwd`/netcdf_links
        bedone="yes"
      else
        echo 'Removing existing ./netcdf_links directory'
        /bin/rm -fr ./netcdf_links
      fi
    else
      echo '** WARNING: No path to NETCDF and environment variable NETCDF not set.'
      echo '** would you like me to try to fix? [y]'
    fi
    netcdfipath=""
    netcdflpath=""
    while [ -z "$bedone" ] ; do 
      read resp
      if [ "$resp" = "y" -o -z "$resp" ]  ; then
        if [ -d ./netcdf_links ] ; then
          echo 'There is already a ./netcdf_links directory. Okay to use links'
          echo 'in this directory for NetCDF include and lib dirs? [y]'
          read resp
          if [ "$resp" = "y" ] ; then
            NETCDF=`pwd`/netcdf_links
            export NETCDF
            bedone="yes"
            continue
          fi
        fi
        if [ -z "$netcdfipath" ] ; then
          echo 'Enter full path to NetCDF include directory on your system'
          read resp
          if [ ! -d "$resp" ] ; then
            echo "invalid path: $resp. Try again? [y]" ; continue
          fi
          netcdfipath=$resp
        fi
        if  [ -z "$netcdflpath" ] ; then
          echo 'Enter full path to NetCDF library directory on your system'
          read resp
          if [ ! -d "$resp" ] ; then
            echo "invalid path: $resp. Try again? [y]" ; continue
          fi
          netcdflpath=$resp
        fi

        if [ -n "$netcdflpath" -a -n "$netcdfipath" ] ; then
          if [ -d ./netcdf_links ] ; then
            echo 'Existing ./netcdf_links directory. Okay to remove. [y]'
            read resp
            if [ "$resp" = "y" ]  ; then
              /bin/rm -fr ./netcdf_links
            fi
          fi
          mkdir ./netcdf_links
          cd ./netcdf_links 
            ln -s "$netcdfipath" include
            ln -s "$netcdflpath" lib
          cd ..
          echo created new ./netcdf_links directory
          /bin/ls -lF ./netcdf_links
          NETCDF=`pwd`/netcdf_links
          export NETCDF
          bedone="yes"
        fi
      else
        bedone="yes"
      fi
    done
  fi
fi

if test -z "$PDHF5" ; then 
  if [ `hostname | cut -c 1-2` = "bb" -o `hostname | cut -c 1-2` = "bf" -o `hostname | cut -c 1-2` = "bs" -o \
       `hostname` = "dataproc" -o `hostname` = "ute" ] ; then
      if [ -d ~michalak/hdf5pbin ] ; then
        PHDF5=~michalak/hdf5pbin
        export PHDF5
      fi
      if [ "$OBJECT_MODE" -eq 64 ] ; then
            if [ -d ~michalak/hdf5pbin-64 ] ; then
              PHDF5=~michalak/hdf5pbin-64
              export PHDF5
            fi
      fi
  fi
fi

USENETCDFF=""  # see below
if [ -n "$NETCDF" ] ; then
  echo "Will use NETCDF in dir: $NETCDF"
# for 3.6.2 and greater there might be a second library, libnetcdff.a .  Check for this and use 
# if available
  if [ -f "$NETCDF/lib/libnetcdff.a" ] ; then
    USENETCDFF="-lnetcdff"
  fi
else
  echo "Will configure for use without NetCDF"
fi

if [ -n "$PNETCDF" ] ; then
  echo "Will use PNETCDF in dir: $PNETCDF"
# experimental, so don't tease the user if it is not there
#else
#  echo "Will configure for use without NetCDF"
fi

if [ -n "$PHDF5" ] ; then
  echo "Will use PHDF5 in dir: $PHDF5"
else
  echo "PHDF5 not set in environment. Will configure WRF for use without."
fi

if [ "$wrf_core" = "DA_CORE" ]; then
   if [ -n "$WRFPLUS_DIR" ] ; then
      echo "To compile WRFDA without 4DVAR, please remove \$WRFPLUS_DIR from environment. "
      exit
   fi
fi

if [ "$wrf_core" = "4D_DA_CORE" ]; then
   if [ -n "$WRFPLUS_DIR" ] ; then
      echo "Will use WRFPLUS in dir: $WRFPLUS_DIR"
   else
      echo "WRFPLUS_DIR not set in environment. Please compile WRFPLUS and set WRFPLUS_DIR."
      exit
   fi
fi
# Users who are cross-compiling can set environment variable 
# $WRF_OS to override the value normally obtained from `uname`.  
# If $WRF_OS is set, then $WRF_MACH can also be set to override 
# the value normally obtained from `uname -m`.  If $WRF_OS is 
# set and $WRF_MACH is not set, then $WRF_MACH defaults to "ARCH".  
# If $WRF_OS is not set then $WRF_MACH is ignored.  
if [ -n "$WRF_OS" ] ; then
  echo "${0}:  WRF operating system set to \"${WRF_OS}\" via environment variable \$WRF_OS"
  os=$WRF_OS
  mach="ARCH"
  if [ -n "$WRF_MACH" ] ; then
    echo "${0}:  WRF machine set to \"${WRF_MACH}\" via environment variable \$WRF_MACH"
    mach=$WRF_MACH
  fi
else
  # if the uname command exists, give it a shot and see if
  # we can narrow the choices; otherwise, spam 'em
  os="ARCH"
  mach="ARCH"
  type uname > /dev/null
  if [ $? -eq 0 ] ; then
    os=`uname`
    if [ "$os" = "AIX" -o "$os" = "IRIX" -o "$os" = "IRIX64" -o "$os" = "SunOS" -o "$os" = "HP-UX"  -o "$os" = "Darwin" -o "$os" = "Interix" ] ; then
      mach="ARCH"
    else
      xxx=`expr "$os" : '\(.........\).*'`
      if [ "$xxx"  = "CYGWIN_NT" ] ; then
        os=$xxx
      fi
      if [ "$os" = "OSF1" -o "$os" = "Linux" -o "$os" = "UNICOS/mp" -o "$os" = "UNIX_System_V" -o  "$os" = "CYGWIN_NT" ] ; then
        mach=`uname -m`
        if [ "$mach" = "ia64" -a -f /etc/sgi-release ] ; then
          mach="Altix"
        fi
      else
        os="ARCH"
        mach="ARCH"
      fi
    fi
  fi
fi

# an IBM specific hack to adjust the bmaxstack and bmaxdata options if addressing is 32-bit
if [ "$os" = "AIX" ] ; then
      if [ -z "$OBJECT_MODE" ] ; then
         OBJECT_MODE=32
         export OBJECT_MODE
      fi
      if [ "$OBJECT_MODE" = "32" ] ; then
# the bang means nothing to sh in this context; use to represent spaces (perl will unbang)
         ldflags=-bmaxstack:256000000!-bmaxdata:2048000000
      fi
fi

# compile options that come from the environment, such as chemistry
# the "!" is removed by Config_new.pl
if [ -n "$WRF_MARS" ] ; then
  if [ $WRF_MARS = 1 ] ; then
    echo building WRF for Mars
    compileflags="${compileflags}!-DPLANET!-DMARS"
    echo $compileflags
  fi
fi

if [ -n "$WRF_TITAN" ] ; then
  if [ $WRF_TITAN = 1 ] ; then
    echo building WRF for Mars
    compileflags="${compileflags}!-DPLANET!-DTITAN"
  fi
fi

if [ -n "$WRF_VENUS" ] ; then
  if [ $WRF_VENUS = 1 ] ; then
    echo building WRF for Mars
    compileflags="${compileflags}!-DPLANET!-DVENUS"
  fi
fi
if [ -n "$WRF_NMM_CORE" ]; then
  if [ $WRF_NMM_CORE = 1 ]; then
    if [ -n "$HWRF" ]; then
      if [ $HWRF = 1 ]; then
        echo building WRF with HWRF option
        compileflags="${compileflags}!-DHWRF=1"
        if [ -n "$HWRFX" ]; then
          if [ $HWRFX = 1 ]; then
            compileflags="${compileflags}!-DHWRFX=1"
          fi
        fi
      fi
    fi
  fi
fi
if [ -n "$WRF_DFI_RADAR" ] ; then
  if [ $WRF_DFI_RADAR = 1 ] ; then
    echo building WRF with radar dfi option
    compileflags="${compileflags}!-DWRF_DFI_RADAR=1"
  fi
fi
if [ -n "$WRF_CHEM" ] ; then
  if [ $WRF_CHEM = 1 ] ; then
    echo building WRF with chemistry option
    compileflags="${compileflags}!-DWRF_CHEM!-DBUILD_CHEM=1"
    if [ -n "$WRF_KPP" ] ; then
      if [ $WRF_KPP = 1 ] ; then    
        echo building WRF with KPP chemistry option
        compileflags="${compileflags}!-DWRF_KPP"
      fi
    fi 
  else
    compileflags="${compileflags} "
  fi
else
  compileflags="${compileflags} "
fi

if [ `which timex` ] ; then
  FORTRAN_COMPILER_TIMER=timex
fi

# Found perl, so proceed with configuration
if test -n "$PERL" ; then
   srch=`grep -i "^#ARCH.*$os" arch/configure_new.defaults | grep -i "$mach"`
   if [ -n "$srch" ] ; then
     $PERL arch/Config_new.pl -dmparallel=$COMMLIB -ompparallel=$OMP -perl=$PERL \
          -netcdf=$NETCDF -pnetcdf=$PNETCDF -phdf5=$PHDF5 -os=$os -mach=$mach -ldflags=$ldflags \
          -compileflags=$compileflags -opt_level=$opt_level -USENETCDFF=$USENETCDFF -time=$FORTRAN_COMPILER_TIMER \
          -wrf_core=$wrf_core
     if test ! -f configure.wrf ; then
       exit 1
     fi
     if [ "$opt_level" = "-d" ] ; then
        sed -e 's/FCOPTIM[	 ]*=/& # /' -e '/FCDEBUG[	 ]*=/s/#//g' configure.wrf > configure.wrf.edit
        /bin/mv configure.wrf.edit configure.wrf
     fi
   else
     WRF_OS=$os ; export WRF_OS
     WRF_MACH=$mach ; export WRF_MACH
     echo '*** Configuration not found in configure_new.defaults; checking configure_old.defaults ***'

     # see if we still have an old setting laying around from v2
     if [ "$opt_level" = "-d" ] ; then
       arch/config_old $opt_level 
     else
       arch/config_old
     fi

   fi
fi

# new feb 2005.  test whether MPI-2
if test -f configure.wrf ; then
  grep 'DMPARALLEL *= *1' configure.wrf > /dev/null
  if [ $? = 0 ] ; then
    echo testing for MPI_Comm_f2c and MPI_Comm_c2f 
    /bin/rm -f tools/mpi2_test
    ( make mpi2_test 2> /dev/null ) 1> /dev/null
    if test -e tools/mpi2_test.o ; then
      echo "  " MPI_Comm_f2c and MPI_Comm_c2f are supported
      sed '/^DM_CC.*=/s/$/ -DMPI2_SUPPORT/' configure.wrf > xx$$ ; /bin/mv xx$$ configure.wrf
      if [ `hostname | cut -c 1-2` = "be" ] ; then
         sed '/^ARCH_LOCAL.*=/s/$/ -DUSE_MPI_IN_PLACE/' configure.wrf > xx$$ ; /bin/mv xx$$ configure.wrf
      fi
    else
      echo "  " MPI_Comm_f2c and MPI_Comm_c2f are not supported
    fi
    grep 'OMPCPP *= *-D_OPENMP' configure.wrf > /dev/null
    if [ $? = 0 ] ; then
      echo testing for MPI_Init_thread
      /bin/rm -f tools/mpi2_thread_test
      ( make mpi2_thread_test 2> /dev/null ) 1> /dev/null
      if test -e tools/mpi2_thread_test.o ; then
        echo "  " MPI_Init_thread is supported
        sed '/^DM_CC.*=/s/$/ -DMPI2_THREAD_SUPPORT/' configure.wrf > xx$$ ; /bin/mv xx$$ configure.wrf
      else 
        echo "  " MPI_Init_thread is not supported
      fi
    fi
  fi
# new dec 2005.  test what fseek is supported (needed for share/landread.c to work correctly)
  echo testing for fseeko and fseeko64
  /bin/rm -f tools/fseeko_test tools/fseeko64_test
  ( make fseek_test 2> /dev/null ) 1> /dev/null
  if [ "$os" = "Darwin" ] ; then
    # fseeko64 does not exist under Darwin fseeko does. Remove the 0 length executable
    # file that might get generated anyway, even though the compiler complains about missing reference.
    /bin/rm -f tools/fseeko64_test 
  fi
  if test -x tools/fseeko64_test ; then
    ( tools/fseeko64_test 2> /dev/null ) 1> /dev/null
    if [ $? = 0 ] ; then
       echo fseeko64 is supported
       sed '/^CC .*=/s/$/ -DFSEEKO64_OK /' configure.wrf > xx$$ ; /bin/mv xx$$ configure.wrf
    fi
  else
    if test -x tools/fseeko_test ; then
      ( tools/fseeko_test 2> /dev/null ) 1> /dev/null
      if [ $? = 0 ] ; then
        echo fseeko is supported and handles 64 bit offsets
        sed '/^CC .*=/s/$/ -DFSEEKO_OK /' configure.wrf > xx$$ ; /bin/mv xx$$ configure.wrf
      else
        echo neither fseeko64 nor fseeko with 64 bit offsets works, landread will be compiled with fseek
        echo but may not work correctly for very high resolution terrain datasets
      fi
    else
      echo neither fseeko64 nor fseeko with 64 bit offsets works, landread will be compiled with fseek
      echo but may not work correctly for very high resolution terrain datasets
    fi
  fi
fi

echo "------------------------------------------------------------------------"
sed -e '1,/#### Architecture specific settings ####/d' -e '/^externals/,$d' configure.wrf

echo "------------------------------------------------------------------------"
echo "Settings listed above are written to configure.wrf."
echo "If you wish to change settings, please edit that file."
echo "If you wish to change the default options, edit the file:"
echo "     arch/configure_new.defaults"

if test -n $NETCDF ; then
  grep nf_format_64bit $NETCDF/include/netcdf.inc > /dev/null
  configure_aaaa=$? ; export configure_aaaa
  if [ $configure_aaaa -a -z "$WRFIO_NCD_LARGE_FILE_SUPPORT" ] ; then
    echo "NetCDF users note:"
    echo " This installation of NetCDF supports large file support.  To enable large file" 
    echo " support in NetCDF, set the environment variable WRFIO_NCD_LARGE_FILE_SUPPORT"
    echo " to 1 and run configure again. Set to any other value to avoid this message."
  fi
fi
echo "  "

if [ "$wrf_core" = "DA_CORE" ]; then
  if [ "`grep '^SFC' configure.wrf | grep -i 'gfortran'`" != "" ]; then
    echo "WRFDA using gfortran needs realsize=8"
    sed -e '/^PROMOTION.*=/s/#//' configure.wrf > configure.wrf.edit
    /bin/mv configure.wrf.edit configure.wrf
  fi
fi

#Checking cross-compiling capability for some particular environment 
#on Linux and Mac box

if [ $os = "Linux" -o $os = "Darwin" ]; then

  SFC=`grep '^SFC' configure.wrf | awk '{print $3}'`
  SCC=`grep '^SCC' configure.wrf | awk '{print $3}'`
  CCOMP=`grep '^CCOMP' configure.wrf | awk '{print $3}'`

  SFC="`type $SFC 2>/dev/null | awk '{print $NF}' | sed -e 's/(//g;s/)//g'`"
  SCC="`type $SCC 2>/dev/null | awk '{print $NF}' | sed -e 's/(//g;s/)//g'`"
  CCOMP="`type $CCOMP 2>/dev/null | awk '{print $NF}' | sed -e 's/(//g;s/)//g'`"

  if [ -e $NETCDF/lib/libnetcdf.a -a "$SFC" != "" -a "$SCC" != "" -a "$CCOMP" != "" ]; then

    SFC_MULTI_ABI=0
    SCC_MULTI_ABI=0
    CCOMP_MULTI_ABI=0
    CROSS_COMPILING=0

    foo=`mktemp foo_$$`

    echo
    echo Testing for NetCDF, C and Fortran compiler
    echo

cat > ${foo}.c <<EOF 
 int main(int argc, char ** argv)
 {
     return (0);
 }
EOF

cat > ${foo}.f <<EOF
          program test_exit
            integer :: STATUS = 0
            call EXIT(STATUS)
          end program test_exit
EOF

    ar p $NETCDF/lib/libnetcdf.a netcdf.o > ${foo}.o
    netcdf_arch="`file ${foo}.o | grep -o -E '[0-9]{2}-bit|i386'`"
    rm ${foo}.o

    $SFC -o ${foo} ${foo}.f > /dev/null 2>&1 
    SFC_arch="`file ${foo} | grep -o -E '[0-9]{2}-bit|i386'`"
    rm ${foo} 2> /dev/null

    $SCC -o ${foo} ${foo}.c > /dev/null 2>&1
    SCC_arch="`file ${foo} | grep -o -E '[0-9]{2}-bit|i386'`"
    CCOMP_arch=$SCC_arch
    rm ${foo} 2> /dev/null

    if [ "$SCC" != "$CCOMP" ]; then
      $CCOMP -o ${foo} ${foo}.c > /dev/null 2>&1
      CCOMP_arch="`file ${foo} | grep -o -E '[0-9]{2}-bit|i386'`"
      rm ${foo} 2> /dev/null
    fi

    if [ "$SFC_arch" = "" -o "$SCC_arch" = "" -o "$CCOMP_arch" = "" ]; then
      echo "  One of compilers testing failed!"
      echo "  Please check your compiler"
      echo 
      rm ${foo}* 2> /dev/null
      exit
    else
      cp configure.wrf configure.wrf.edit
    fi

    case $netcdf_arch in

      32-bit|i386 )

      if [ "$SFC_arch" = "64-bit" ] ; then
        CROSS_COMPILING=1
        $SFC -m32 -o ${foo} ${foo}.f > /dev/null 2>&1
        if [ $? = 0 ]; then
          SFC_MULTI_ABI=1
          sed '/^SFC.*=/s/$/ -m32/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp configure.wrf.edit
        fi
      fi
      if [ "$SCC_arch" = "64-bit" ] ; then
        CROSS_COMPILING=1
        $SCC -m32 -o ${foo} ${foo}.c > /dev/null 2>&1
        if [ $? = 0 ]; then
          SCC_MULTI_ABI=1
          sed '/^SCC.*=/s/$/ -m32/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp  configure.wrf.edit
        fi
      fi

      if [ "$CCOMP_arch" = "64-bit" ] ; then
        CROSS_COMPILING=1
        if [ "$CCOMP" != "$SCC" ]; then
          $CCOMP -m32 -o ${foo} ${foo}.c > /dev/null 2>&1
          if [ $? = 0 ]; then
            CCOMP_MULTI_ABI=1
            sed '/^CCOMP/ s/$/ -m32/' configure.wrf.edit > configure.wrf.tmp
            mv configure.wrf.tmp  configure.wrf.edit
          fi
        else
          CCOMP_MULTI_ABI=1
          sed '/^CCOMP/ s/$/ -m32/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp  configure.wrf.edit
        fi
      fi

      if [ $CROSS_COMPILING -eq 1 ] ; then
        echo NOTE:
        echo This installation NetCDF is 32-bit
        if [ \( $SFC_MULTI_ABI -ne 1 -a "$SFC_arch" = "64-bit" \) \
             -o \( $SCC_MULTI_ABI -ne 1 -a "$SCC_arch" = "64-bit" \) \
             -o \( $CCOMP_MULTI_ABI -ne 1 -a "$CCOMP_arch" = "64-bit" \) ] ; then
             rm configure.wrf.edit
             echo One of compilers is 64-bit and doesn\'t support cross-compiling.
             echo Please check your NETCDF lib and compiler
        else
          echo -m32 is appended to configure.wrf
          echo It will be forced to build in 32-bit.
          echo If you don\'t want 32-bit binaries, please use 64-bit NetCDF, and re-run the configure script.
        fi
      fi
      ;;

      64-bit )

      if [ "$SFC_arch" = "32-bit" -o "$SFC_arch" = "i386" ] ; then
        CROSS_COMPILING=1
        $SFC -m64 -o ${foo} ${foo}.f > /dev/null 2>&1
        if [ $? = 0 ]; then
          SFC_MULTI_ABI=1
          sed '/^SFC.*=/s/$/ -m64/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp configure.wrf.edit
        fi
      fi
      if [ "$SCC_arch" = "32-bit" -o "$SCC_arch" = "i386" ] ; then
        CROSS_COMPILING=1
        $SCC -m64 -o ${foo} ${foo}.c > /dev/null 2>&1
        if [ $? = 0 ]; then
          SCC_MULTI_ABI=1
          sed '/^SCC.*=/s/$/ -m64/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp configure.wrf.edit
        fi
      fi

      if [ "$CCOMP_arch" = "32-bit" -o "$CCOMP_arch" = "i386" ] ; then
        CROSS_COMPILING=1
        if [ "$CCOMP" != "$SCC" ]; then
          $CCOMP -m64 -o ${foo} ${foo}.c > /dev/null 2>&1
          if [ $? = 0 ]; then
            CCOMP_MULTI_ABI=1
            sed '/^CCOMP/ s/$/ -m64/' configure.wrf.edit > configure.wrf.tmp
            mv configure.wrf.tmp  configure.wrf.edit
          fi
        else
          CCOMP_MULTI_ABI=1
          sed '/^CCOMP/ s/$/ -m64/' configure.wrf.edit > configure.wrf.tmp
          mv configure.wrf.tmp  configure.wrf.edit
        fi
      fi

      if [ $CROSS_COMPILING -eq 1 ] ; then
        echo NOTE:
        echo This installation NetCDF is 64-bit
        if [ \( $SFC_MULTI_ABI -ne 1 -a "$SFC_arch" != "64-bit" \) \
            -o \( $SCC_MULTI_ABI -ne 1 -a "$SCC_arch" != "64-bit" \) \
            -o \( $CCOMP_MULTI_ABI -ne 1 -a "CCOMP_arch" != "64-bit" \) ]; then
            rm configure.wrf.edit
            echo One of Compilers is 32-bit and doesn\'t support cross-compiling.
            echo Please check your NetCDF lib and compiler
        else
          echo -m64 is appended to configure.wrf
          echo It will be forced to build in 64-bit. 
          echo If you don\'t want 64-bit binaries, please use 32-bit NetCDF, and re-run the configure script.
        fi
      fi
      ;;
    esac

    if [ -e configure.wrf.edit ]; then 
      mv configure.wrf.edit configure.wrf
    fi

    rm ${foo}* 2> /dev/null

    if [ $CROSS_COMPILING -eq 0 ] ; then
      echo This installation NetCDF is $netcdf_arch
      echo C compiler is $SCC_arch
      echo Fortran compiler is $SFC_arch
      echo It will build in $netcdf_arch
    fi
    echo
  fi
fi