PROJECT( add_fortran Fortran C CXX )
ENABLE_TESTING()
SUBDIRS(src tests examples ) 
INCLUDE(Dart)

# The build system will set ARCH64 for 64 bit builds, which require
# use of the lib64/ library directories rather than lib/.
SET( ARCH64 OFF CACHE BOOL "ON for 64bit builds, OFF for 32bit builds")

# If GENERIC_BUILD  is set to true then ATLAS will be built without using any
# instruction set extensions (SSE, SSE2, 3DNow, AtiVec)
SET( GENERIC_BUILD OFF CACHE BOOL "ON building generic libraries, OFF for optimized libraries")
SET( BUILD_ATLAS ON CACHE BOOL "ON build the ATLAS libraries, OFF for build only SimTKlapack library")
MARK_AS_ADVANCED(  ARCH64 GENERIC_BUILD BUILD_ATLAS)

# If doing an generic build set the bitfield for wich instruciton sets are
# supported to 1 to prevent flags from getting set. (setting to 0 did not  work)
IF( GENERIC_BUILD )
   SET( GENERIC_BUILD_FLAG -G )
   SET( ISA_OVERRIDE -V 1 )
ELSE( GENERIC_BUILD )
   SET( ISA_OVERRIDE )
ENDIF( GENERIC_BUILD )

IF( ARCH64 )
   MESSAGE( "Building 64bit libraries") 
   SET( LIB64 64 )
   SET( PTRBITS 64 )
   SET( M32 -m64 )
   SET( LIB32  -D '-DAdd__ -DStringSunStyle' )
ELSE( ARCH64 )
   MESSAGE( "Building 32bit libraries") 
   SET( M32 -m32 )
   SET( PTRBITS 32 )
   SET( LIB32   -D '-DAdd__ -DStringSunStyle' )
ENDIF( ARCH64 )

IF( WIN32 )
   SET( LIB_SUFFIX dll )
   SET( LIB_PREFIX )
ELSE( WIN32 ) 
#
#  use gfortran for Mac and Linux, will use for Windows when stable
#
   SET( CMAKE_Fortran_COMPILER gfortran )

   IF( APPLE )
      SET( LIB_SUFFIX dylib )
      SET( LIB_PREFIX lib)
   ELSE( APPLE ) 
      SET( LIB_SUFFIX so )
      SET( LIB_PREFIX lib)
   ENDIF( APPLE )
ENDIF( WIN32 )

SET(SimTKLAPACK_MAJOR_VERSION 1)
SET(SimTKLAPACK_MINOR_VERSION 2)
SET(SimTKLAPACK_BUILD_VERSION 0)
SET(SimTKLAPACK_COPYRIGHT_YEARS "2005-8")
SET( ATLAS_VERSION      atlas3.8.2 )
SET (ATLAS_INCLUDE_DIR  ${CMAKE_BINARY_DIR}/atlas_build/include )
SET (ATLAS_LIB_DIR      ${CMAKE_BINARY_DIR}/atlas_build/lib )
#
# set default suffix for object files
#
SET( OBJ_SUFFIX o )
#
# list of authors 
# TODO don't know how to handle commnas in this list
#
SET(SimTKLAPACK_AUTHORS  "Jack Middleton  Vaibhav Nivargi")
#
# set svn version number in binary
#
EXEC_PROGRAM ( svnversion
               ARGS  ${PROJECT_SOURCE_DIR}
               OUTPUT_VARIABLE SimTKLAPACK_SVN_REVISION )

# It's possible that WIN32 installs use svnversion through cygwin
# so we'll try for both svnversion.exe and svnversion. Note that
# this will result in warnings if all you have is Tortoise without
# Cygwin, and your "about" string will say "unknown" rather than
# providing the SVN version of the source.


FIND_PROGRAM (SVNVERSION_EXE svnversion.exe)
IF (SVNVERSION_EXE)
    EXEC_PROGRAM (${SVNVERSION_EXE}
                  ARGS  \"${PROJECT_SOURCE_DIR}\"
                  OUTPUT_VARIABLE SimTKLAPACK_SVN_REVISION )
 ELSE (SVNVERSION_EXE) 
    FIND_PROGRAM (SVNVERSION svnversion) 
    IF (SVNVERSION)
        EXEC_PROGRAM (${SVNVERSION}
                      ARGS ${PROJECT_SOURCE_DIR}
                      OUTPUT_VARIABLE SimTKLAPACK_SVN_REVISION)
    ELSE (SVNVERSION)
        MESSAGE (STATUS 
          "Could not find 'svnversion' executable; 'about' will be wrong. (Cygwin provides one on Windows.)"
        )
        SET (SimTKLAPACK_SVN_REVISION unknown) 
    ENDIF (SVNVERSION)
ENDIF (SVNVERSION_EXE)
# Remove colon from build version, for easier placement in directory names
STRING(REPLACE ":" "_" SimTKLAPACK_SVN_REVISION ${SimTKLAPACK_SVN_REVISION})
# 
# do not use -fno-f2c becasue is causes failures in LAPACK tests (cause is unknown)
#
#SET( NO_F2C -fno-f2c )


#
# put libraries and test executables in same directory so that "make test" 
# will find the libraries on Windows
#
SET( LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}  )
SET( EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR} ) 

ENABLE_TESTING()

ADD_TEST( cgels_test  ${EXECUTABLE_OUTPUT_PATH}/cgels_test )
ADD_TEST( cgesv_test  ${EXECUTABLE_OUTPUT_PATH}/cgesv_test )
ADD_TEST( dgels_test  ${EXECUTABLE_OUTPUT_PATH}/dgels_test )
ADD_TEST( dgesdd_test ${EXECUTABLE_OUTPUT_PATH}/dgesdd_test )
ADD_TEST( sgels_test  ${EXECUTABLE_OUTPUT_PATH}/sgels_test )
ADD_TEST( sgesdd_test ${EXECUTABLE_OUTPUT_PATH}/sgesdd_test )
ADD_TEST( sgesv_test  ${EXECUTABLE_OUTPUT_PATH}/sgesv_test )
ADD_TEST( sgetrf_test ${EXECUTABLE_OUTPUT_PATH}/sgetrf_test )
ADD_TEST( zgels_test  ${EXECUTABLE_OUTPUT_PATH}/zgels_test )
ADD_TEST( cdotu_test  ${EXECUTABLE_OUTPUT_PATH}/cdotu_test )

SET( ATLAS_F77_BLAS libptf77blas )
SET( ATLAS_C_BLAS libptcblas )

IF( APPLE )
   EXEC_PROGRAM (sysctl ARGS hw.model OUTPUT_VARIABLE HWD_VER )
   #
   # Power PC does not support -mfpmath=387 flag
   #
   IF( ${HWD_VER} MATCHES "Power"  )
      SET( M387 )
   ELSE( ${HWD_VER} MATCHES "Power"  )
      SET( M387 -mfpmath=387 )
   ENDIF( ${HWD_VER} MATCHES "Power"  )

   SET( CMAKE_C_FLAGS "${M32} -mmacosx-version-min=10.4" )
   #
   # current g77 on Mac does not support -m32 or -m64
   #
   SET( M32 )
ELSE( APPLE )
   #
   # on x86 compile for 387 coprocessor because this is the most portable
   #
   SET( M387 -mfpmath=387 )
ENDIF( APPLE )


IF( WIN32 ) 
   SET( OS_CFLAGS -O3 -mno-cygwin ${M32} -fomit-frame-pointer ${M387})
   SET( OS_FFLAGS -O3 -mno-cygwin ${M32} -fomit-frame-pointer ${M387})
   SET( ATLAS_Fortran_FLAGS -F f ' ${OS_FFLAGS} ' )
   SET( WIN_TXT_SUFFIX .txt )
   SET( CMAKE_Fortran_FLAGS "-funroll-all-loops -O3  ${M32} -mno-cygwin" )
   SET( Fortran_FLAGS -funroll-all-loops -O3  ${M32} -mno-cygwin )
   SET( CMAKE_SHARED_LINKER_FLAGS "${M32} -mno-cygwin" )
   SET( CMAKE_EXE_LINKER_FLAGS    "${M32} -mno-cygwin" )
   SET( CMAKE_C_FLAGS             "${M32} -mno-cygwin" )
   SET( CMAKE_CXX_FLAGS           "${M32} -mno-cygwin" )
ELSE( WIN32 ) 
   SET( OS_CFLAGS -O3 -fPIC ${M32} -fomit-frame-pointer ${M387})
   SET( OS_FFLAGS -O3 -fPIC ${M32} -fomit-frame-pointer ${M387})
   SET( ATLAS_Fortran_FLAGS -f gfortran -F f ' ${OS_FFLAGS} ' )

   SET( CMAKE_SHARED_LINKER_FLAGS  ${M32} )
   SET( CMAKE_EXE_LINKER_FLAGS ${M32} )
   SET( CMAKE_C_FLAGS ${M32} )
   SET( CMAKE_CXX_FLAGS ${M32} )
   SET( CMAKE_Fortran_FLAGS "-fPIC -funroll-all-loops -O3  ${M32}"  )
   SET( Fortran_FLAGS -fPIC -funroll-all-loops -O3  -ff2c  ${M32} )
ENDIF( WIN32 )

SET( ATLAS_C_FLAGS ${LIB32}  -D c ' ${OS_CFLAGS}  ' -D m '${OS_CFLAGS} ')

SET( ATLAS_FLAGS ${ATLAS_C_FLAGS} ${ATLAS_Fortran_FLAGS} ${GENERIC_BUILD_FLAG} )

# Check if the ATLAS tar ball has needs to be untarred 
# Then replace the symlinks in ATLAS with cp commands because the nightly
# build system will fail when it tries to delete directories with sym links
# 
ADD_CUSTOM_COMMAND(
      DEPENDS ${CMAKE_SOURCE_DIR}/${ATLAS_VERSION}.tar.gz.Z
      OUTPUT ${CMAKE_BINARY_DIR}/ATLAS     
      COMMAND rm -rf ${CMAKE_BINARY_DIR}/ATLAS \;
              zcat ${CMAKE_SOURCE_DIR}/${ATLAS_VERSION}.tar.gz.Z | tar x \;
      ARGS     echo ${ATLAS_VERSION} >> ${CMAKE_BINARY_DIR}/ATLAS/version_${ATLAS_VERSION}
      COMMENT "untar ATLAS tar ball"
)

#
# The following custom command builds the ATLAS libraries in 4 steps:
# 1) removes any existing Make.${ATLAS_ARCH} because it's presense will 
#    interfere with   a new build
# 2) cd's to the ATLAS directory because ATLAS always assumes the build is 
#    being done from that directory
# 3) runs  a modified version of ATLAS's configure program 'xconfig' 
#    and sets compiler flags
# 4) executes a  'make install' in the ATLAS directory
#
IF (WIN32)
   ADD_CUSTOM_COMMAND(
      DEPENDS ${CMAKE_BINARY_DIR}/ATLAS/xconfig
      OUTPUT ${ATLAS_LIB_DIR}/${ATLAS_F77_BLAS}.a 
      COMMAND rm -rf  ${CMAKE_BINARY_DIR}/ATLAS/Make.${ATLAS_ARCH}\;
        cd ${CMAKE_BINARY_DIR}/ATLAS\; 
        cp ${CMAKE_SOURCE_DIR}/src/cblas/pthread.h ${CMAKE_BINARY_DIR}/ATLAS/include/pthread.h\; 
        bash --noprofile -c \"${CMAKE_BINARY_DIR}/ATLAS/xconfig -b ${PTRBITS} -t 0  \" \;
      ARGS    bash --noprofile -c \"make -C ${CMAKE_BINARY_DIR}/ATLAS install  MAKEFLAGS= arch=${ATLAS_ARCH} >& ${ATLAS_ARCH}_log\"
   )
ELSE(WIN32)
   ADD_CUSTOM_COMMAND(
      DEPENDS ${CMAKE_BINARY_DIR}/ATLAS
      OUTPUT ${CMAKE_BINARY_DIR}/atlas_build/lib/${ATLAS_F77_BLAS}.a 
      COMMAND mkdir atlas_build \;
        cd atlas_build \;
        ../ATLAS/configure ${ISA_OVERRIDE} -b ${PTRBITS} -t 2  \;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.sysinfo > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.sysinfo\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.l3tune > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.l3tune\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.l1tune > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.l1tune\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.mmtune > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.mmtune\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.mvtune > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.mvtune\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.r1tune > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/makes/Make.r1tune\;
        sed -e 's/ln -s/cp/g' ${CMAKE_BINARY_DIR}/ATLAS/Make.top > ${CMAKE_BINARY_DIR}/ATLAS/tmp \; 
        mv ${CMAKE_BINARY_DIR}/ATLAS/tmp ${CMAKE_BINARY_DIR}/ATLAS/Make.top \;
        cp ${PROJECT_SOURCE_DIR}/findNT.c ${CMAKE_BINARY_DIR}/ATLAS/tune/sysinfo/findNT.c  \;
        cp ${PROJECT_SOURCE_DIR}/ATL_ptflushcache.c ${CMAKE_BINARY_DIR}/ATLAS/src/auxil/ATL_ptflushcache.c  \;
      ARGS     make  build 
   )
ENDIF(WIN32)


# force ATLAS to build first
IF( BUILD_ATLAS )
    ADD_CUSTOM_TARGET ( build_atlas  ALL
    	DEPENDS ${ATLAS_LIB_DIR}/${ATLAS_F77_BLAS}.a
    )
ENDIF( BUILD_ATLAS )
#
# Installation
#
# CMake installs go into CMAKE_INSTALL_PREFIX, which is always
# set to something incorrect by CMake. If SimTK_INSTALL_PREFIX is set then
# it is a sandbox installation area, otherwise we want to install
# in /usr/local/SimTK or c:\program files\SimTK. 

IF(${CMAKE_C_COMPILER} MATCHES "gcc")

    IF(NOT SimTK_INSTALL_PREFIX)
        SET(SimTK_INSTALL_PREFIX "/usr/local/SimTK")
    ENDIF(NOT SimTK_INSTALL_PREFIX)

    IF(NOT SimTK_SDK)
        SET(SimTK_SDK "/usr/local/SimTK")
    ENDIF(NOT SimTK_SDK)

ELSE(${CMAKE_C_COMPILER} MATCHES "gcc")

    IF(NOT SimTK_INSTALL_PREFIX)
        SET(SimTK_INSTALL_PREFIX "C:/Program Files/SimTK")
    ENDIF(NOT SimTK_INSTALL_PREFIX)

    IF(NOT SimTK_SDK)
        SET(SimTK_SDK "C:/Program Files/SimTK")
    ENDIF(NOT SimTK_SDK)

ENDIF(${CMAKE_C_COMPILER} MATCHES "gcc")

SET(CMAKE_INSTALL_PREFIX ${SimTK_INSTALL_PREFIX} CACHE STRING "Install path prefix." FORCE)


# copy the project include file and README to the core directory
INSTALL( FILES ${PROJECT_SOURCE_DIR}/include/SimTKlapack.h    DESTINATION ${SimTK_INSTALL_PREFIX}/core/include  )
INSTALL( FILES ${PROJECT_SOURCE_DIR}/include/HardwareInfo.h   DESTINATION ${SimTK_INSTALL_PREFIX}/core/include  )
INSTALL( FILES ${PROJECT_SOURCE_DIR}/doc/README.txt           DESTINATION ${SimTK_INSTALL_PREFIX}/core/doc/lapack )