configure

   1 #!/bin/sh
   2
   3 arg1=$1
   4
   5 # Look for netcdf
   6 if test -z "$NETCDF" ; then
   7   for p in /usr/local/netcdf
   8   do
   9     if test -d $p ; then
  10       NETCDF=$p
  11       break
  12     fi
  13   done
  14 fi
  15
  16 if  test -z "$NETCDF"  ; then
  17
  18   if [ `hostname | cut -c 1-2` = "bs" -o \
  19        `hostname | cut -c 1-2` = "bv" -o \
  20        `hostname` = "tempest" -o `hostname` = "lightning" ] ; then
  21     echo 'Compiling on an NCAR system with weird paths to NetCDF'
  22     echo 'Setting up a local NetCDF directory with symlinks'
  23     if ( test -d ./netcdf_links ) ; then
  24       echo 'A directory ./netcdf_links already exists. Continuing.'
  25     else
  26       mkdir ./netcdf_links
  27       if [ -z "$OBJECT_MODE" ] ; then
  28          OBJECT_MODE=32
  29          export OBJECT_MODE
  30       fi
  31       if [ $OBJECT_MODE -ne 64 -a \( `hostname | cut -c 1-2` = "bs" \) ] ; then
  32         ( cd ./netcdf_links ; ln -s /usr/local/lib32/r4i4 ./lib ; \
  33                               ln -s /usr/local/include ./include )
  34       else
  35         ( cd ./netcdf_links ; ln -s /usr/local/lib64/r4i4 ./lib ; \
  36                               ln -s /usr/local/include ./include )
  37       fi
  38     fi
  39     NETCDF=`pwd`/netcdf_links
  40     export NETCDF
  41
  42
  43   else
  44     bedone=""
  45     if [ -d ./netcdf_links ] ; then
  46       echo '** There is an existing ./netcdf_links file. Should I use? [y]'
  47       read resp
  48       if [ "$resp" = "y" ] ; then
  49         NETCDF=`pwd`/netcdf_links
  50         bedone="yes"
  51       else
  52         echo 'Removing existing ./netcdf_links directory'
  53         /bin/rm -fr ./netcdf_links
  54       fi
  55     else
  56       echo '** WARNING: No path to NETCDF and environment variable NETCDF not set.'
  57       echo '** would you like me to try to fix? [y]'
  58     fi
  59     netcdfipath=""
  60     netcdflpath=""
  61     while [ -z "$bedone" ] ; do
  62       read resp
  63       if [ "$resp" = "y" -o -z "$resp" ]  ; then
  64         if [ -d ./netcdf_links ] ; then
  65           echo 'There is already a ./netcdf_links directory. Okay to use links'
  66           echo 'in this directory for NetCDF include and lib dirs? [y]'
  67           read resp
  68           if [ "$resp" = "y" ] ; then
  69             NETCDF=`pwd`/netcdf_links
  70             export NETCDF
  71             bedone="yes"
  72             continue
  73           fi
  74         fi
  75         if [ -z "$netcdfipath" ] ; then
  76           echo 'Enter full path to NetCDF include directory on your system'
  77           read resp
  78           if [ ! -d "$resp" ] ; then
  79             echo "invalid path: $resp. Try again? [y]" ; continue
  80           fi
  81           netcdfipath=$resp
  82         fi
  83         if  [ -z "$netcdflpath" ] ; then
  84           echo 'Enter full path to NetCDF library directory on your system'
  85           read resp
  86           if [ ! -d "$resp" ] ; then
  87             echo "invalid path: $resp. Try again? [y]" ; continue
  88           fi
  89           netcdflpath=$resp
  90         fi
  91
  92         if [ -n "$netcdflpath" -a -n "$netcdfipath" ] ; then
  93           if [ -d ./netcdf_links ] ; then
  94             echo 'Existing ./netcdf_links directory. Okay to remove. [y]'
  95             read resp
  96             if [ "$resp" = "y" ]  ; then
  97               /bin/rm -fr ./netcdf_links
  98             fi
  99           fi
 100           mkdir ./netcdf_links
 101           cd ./netcdf_links
 102             ln -s "$netcdfipath" include
 103             ln -s "$netcdflpath" lib
 104           cd ..
 105           echo created new ./netcdf_links directory
 106           /bin/ls -lF ./netcdf_links
 107           NETCDF=`pwd`/netcdf_links
 108           export NETCDF
 109           bedone="yes"
 110         fi
 111       else
 112         bedone="yes"
 113       fi
 114     done
 115   fi
 116 fi
 117
 118 if [ -n "$NETCDF" ] ; then
 119   echo "Will use NETCDF in dir: $NETCDF"
 120   # for 3.6.2 and greater there might be a second library, libnetcdff.a .  Check for this and use
 121   # if available
 122   NETCDFF=" "
 123   if [ -f "$NETCDF/lib/libnetcdff.a" ] ; then
 124     NETCDFF="-lnetcdff"
 125   fi
 126 else
 127   echo "Will configure for use without NetCDF"
 128 fi
 129
 130   # if the uname command exists, give it a shot and see if
 131   # we can narrow the choices; otherwise, spam 'em
 132   os="ARCH"
 133   mach="ARCH"
 134   type uname > /dev/null
 135 if [ $? -eq 0 ] ; then
 136     os=`uname`
 137     if [ "$os" = "AIX" -o "$os" = "IRIX" -o "$os" = "IRIX64" -o "$os" = "SunOS" -o "$os" = "HP-UX"  -o "$os" = "Darwin" ] ; then
 138       mach="ARCH"
 139     else
 140       xxx=`expr "$os" : '\(.........\).*'`
 141       if [ "$xxx"  = "CYGWIN_NT" ] ; then
 142         os=$xxx
 143       fi
 144       if [ "$os" = "OSF1" -o "$os" = "Linux" -o "$os" = "UNICOS/mp" -o "$os" = "UNIX_System_V" -o "$os" = "CYGWIN_NT" ] ; then
 145         mach=`uname -m`
 146       else
 147         os="ARCH"
 148         mach="ARCH"
 149       fi
 150     fi
 151 fi
 152
 153 # Found perl, so proceed with configuration
 154 perl arch/Config.pl -perl=$PERL -netcdf=$NETCDF -netcdff=$NETCDFF -os=$os -mach=$mach
 155
 156
 157 #Checking cross-compiling capability for some particular environment
 158 #on Linux and Mac box
 159
 160 if [ $os = "Linux" -o $os = "Darwin" ]; then
 161
 162   SFC=`grep '^SFC' configure.wps | awk '{print $3}'`
 163   SCC=`grep '^SCC' configure.wps | awk '{print $3}'`
 164
 165   SFC="`type $SFC 2>/dev/null | awk '{print $NF}' | sed -e 's/(//g;s/)//g'`"
 166   SCC="`type $SCC 2>/dev/null | awk '{print $NF}' | sed -e 's/(//g;s/)//g'`"
 167
 168   if [ -e $NETCDF/lib/libnetcdf.a -a "$SFC" != "" -a "$SCC" != "" ]; then
 169
 170     SFC_MULTI_ABI=0
 171     SCC_MULTI_ABI=0
 172     CROSS_COMPILING=0
 173
 174     foo=foo_$$
 175
 176     echo
 177     echo Testing for NetCDF, C and Fortran compiler
 178     echo
 179
 180 cat > ${foo}.c <<EOF
 181  int main(int argc, char ** argv)
 182  {
 183      return (0);
 184  }
 185 EOF
 186
 187 cat > ${foo}.f <<EOF
 188           program test_exit
 189             integer :: STATUS = 0
 190             call EXIT(STATUS)
 191           end program test_exit
 192 EOF
 193
 194     nct=`nm $NETCDF/lib/libnetcdf.a | grep '^0' | cut -d' ' -f 1 | head -1 | wc -c | awk '{print $1+0}'`
 195     if [ "$nct" -eq "9" ]; then
 196       netcdf_arch="32-bit"
 197     else
 198       netcdf_arch="64-bit"
 199     fi
 200
 201     $SFC -o ${foo} ${foo}.f > /dev/null 2>&1
 202     SFC_arch="`file ${foo} | grep -o -E '[0-9]{2}-bit|i386'`"
 203     rm ${foo} ${foo}.o 2> /dev/null
 204
 205     $SCC -o ${foo} ${foo}.c > /dev/null 2>&1
 206     SCC_arch="`file ${foo} | grep -o -E '[0-9]{2}-bit|i386'`"
 207     rm ${foo} ${foo}.o 2> /dev/null
 208
 209     if [ "$SFC_arch" = "" -o "$SCC_arch" = "" ]; then
 210       echo "  One of compilers testing failed!"
 211       echo "  Please check your compiler"
 212       echo
 213       rm -f ${foo} ${foo}.[cfo] 2> /dev/null
 214       exit
 215     else
 216       cp configure.wps configure.wps.edit
 217     fi
 218
 219     case $netcdf_arch in
 220
 221       32-bit|i386 )
 222
 223       if [ "$SFC_arch" = "64-bit" ] ; then
 224         CROSS_COMPILING=1
 225         $SFC -m32 -o ${foo} ${foo}.f > /dev/null 2>&1
 226         if [ $? = 0 ]; then
 227           SFC_MULTI_ABI=1
 228           sed '/^SFC.*=/s/$/ -m32/' configure.wps.edit > configure.wps.tmp
 229           mv configure.wps.tmp configure.wps.edit
 230         fi
 231       fi
 232       if [ "$SCC_arch" = "64-bit" ] ; then
 233         CROSS_COMPILING=1
 234         $SCC -m32 -o ${foo} ${foo}.c > /dev/null 2>&1
 235         if [ $? = 0 ]; then
 236           SCC_MULTI_ABI=1
 237           sed '/^SCC.*=/s/$/ -m32/' configure.wps.edit > configure.wps.tmp
 238           mv configure.wps.tmp  configure.wps.edit
 239         fi
 240       fi
 241
 242       if [ $CROSS_COMPILING -eq 1 ] ; then
 243         echo NOTE:
 244         echo This installation NetCDF is 32-bit
 245         if [ \( $SFC_MULTI_ABI -ne 1 -a "$SFC_arch" = "64-bit" \) \
 246              -o \( $SCC_MULTI_ABI -ne 1 -a "$SCC_arch" = "64-bit" \) ] ; then
 247              rm configure.wps.edit
 248              echo One of compilers is 64-bit and doesn\'t support cross-compiling.
 249              echo Please check your NETCDF lib and compiler
 250         else
 251           echo -m32 is appended to configure.wps
 252           echo It will be forced to build in 32-bit.
 253           echo If you don\'t want 32-bit binaries, please use 64-bit NetCDF, and re-run the configure script.
 254         fi
 255       fi
 256       ;;
 257
 258       64-bit )
 259
 260       if [ "$SFC_arch" = "32-bit" -o "$SFC_arch" = "i386" ] ; then
 261         CROSS_COMPILING=1
 262         $SFC -m64 -o ${foo} ${foo}.f > /dev/null 2>&1
 263         if [ $? = 0 ]; then
 264           SFC_MULTI_ABI=1
 265           sed '/^SFC.*=/s/$/ -m64/' configure.wps.edit > configure.wps.tmp
 266           mv configure.wps.tmp configure.wps.edit
 267         fi
 268       fi
 269       if [ "$SCC_arch" = "32-bit" -o "$SCC_arch" = "i386" ] ; then
 270         CROSS_COMPILING=1
 271         $SCC -m64 -o ${foo} ${foo}.c > /dev/null 2>&1
 272         if [ $? = 0 ]; then
 273           SCC_MULTI_ABI=1
 274           sed '/^SCC.*=/s/$/ -m64/' configure.wps.edit > configure.wps.tmp
 275           mv configure.wps.tmp configure.wps.edit
 276         fi
 277       fi
 278
 279       if [ $CROSS_COMPILING -eq 1 ] ; then
 280         echo NOTE:
 281         echo This installation NetCDF is 64-bit
 282         if [ \( $SFC_MULTI_ABI -ne 1 -a "$SFC_arch" != "64-bit" \) \
 283             -o \( $SCC_MULTI_ABI -ne 1 -a "$SCC_arch" != "64-bit" \) ]; then
 284             rm configure.wps.edit
 285             echo One of Compilers is 32-bit and doesn\'t support cross-compiling.
 286             echo Please check your NetCDF lib and compiler
 287         else
 288           echo -m64 is appended to configure.wps
 289           echo It will be forced to build in 64-bit.
 290           echo If you don\'t want 64-bit binaries, please use 32-bit NetCDF, and re-run the configure script.
 291         fi
 292       fi
 293       ;;
 294     esac
 295     rm -f ${foo} ${foo}.[cfo] 2> /dev/null
 296
 297     if [ -e configure.wps.edit ]; then
 298       mv configure.wps.edit configure.wps
 299     fi
 300
 301     if [ $CROSS_COMPILING -eq 0 ] ; then
 302       echo This installation NetCDF is $netcdf_arch
 303       echo C compiler is $SCC_arch
 304       echo Fortran compiler is $SFC_arch
 305     fi
 306     echo
 307
 308     #  Does our Fortran work with the given NETCDF library.
 309
 310       /bin/rm -f fort_netcdf.f fort_netcdf
 311 cat > fort_netcdf.f <<EOF
 312         program foo
 313         include 'netcdf.inc'
 314         integer ncid , status
 315         status = nf_open ( 'foo.nc' , 0 , ncid )
 316         print *,'status = ',status
 317         end program
 318 EOF
 319     FFLAGS=`grep ^FFLAGS configure.wps | cut -d"=" -f2-`
 320     cp $NETCDF/include/netcdf.inc .
 321     FC=`grep ^SFC configure.wps | cut -d"=" -f2-`
 322     $FC ${FFLAGS} fort_netcdf.f -o fort_netcdf -L${NETCDF}/lib $NETCDFF -lnetcdf > /dev/null 2>&1
 323     if [ -f "fort_netcdf" ] ; then
 324       ./fort_netcdf > /dev/null 2>&1
 325       if [ $? = 0 ]; then
 326         /bin/rm -f fort_netcdf.f fort_netcdf.o fort_netcdf netcdf.inc
 327       else
 328         echo
 329         echo "Your Fortran + NETCDF did not run successfully."
 330         echo
 331       fi
 332     else
 333       echo
 334       echo "Your versions of Fortran and NETCDF are not consistent."
 335       echo
 336     fi
 337
 338 cat > c_test.c <<EOF
 339 #ifndef CRAY
 340 # ifdef NOUNDERSCORE
 341 #      define C_TEST c_test
 342 # else
 343 #   if defined ( F2CSTYLE ) || defined ( _DOUBLEUNDERSCORE )
 344 #      define C_TEST c_test__
 345 #   else
 346 #      define C_TEST c_test_
 347 #   endif
 348 # endif
 349 #endif
 350 #include <stdio.h>
 351
 352 int C_TEST ( float *xx, int *ii )
 353
 354 {
 355  printf("OK print in C function.  \n" ) ;
 356  printf("Values are xx = %5.2f and ii = %d \n", *xx, *ii ) ;
 357  return(0) ;
 358 }
 359 EOF
 360     CFLAGS=`grep ^CFLAGS configure.wps | cut -d"=" -f2-`
 361     CPPFLAGS=`grep ^CPPFLAGS configure.wps | cut -d"=" -f2-`
 362     CC=`grep ^SCC configure.wps | cut -d"=" -f2-`
 363     ${CC} -c ${CFLAGS} ${CPPFLAGS} c_test.c
 364
 365 cat > f_test.f90 <<EOF
 366 PROGRAM f_test
 367    INTEGER :: ii
 368    REAL    :: xx
 369
 370    ii = 1
 371    xx = 2
 372
 373    CALL c_test ( xx , ii )
 374
 375 END PROGRAM f_test
 376 EOF
 377     $FC ${FFLAGS} f_test.f90 -o cf_test c_test.o > /dev/null 2>&1
 378     if [ -f "cf_test" ] ; then
 379       ./cf_test > /dev/null 2>&1
 380       if [ $? = 0 ]; then
 381         /bin/rm -f cf_test c_test.c c_test.o f_test.f90 f_test.o
 382       else
 383         echo
 384         echo "Your Fortran + C did not run successfully."
 385         echo
 386       fi
 387     else
 388       echo
 389       echo "Your versions of Fortran and C are not consistent."
 390       echo
 391     fi
 392
 393   fi
 394 fi