[CMake] Re: premake build system

[Gonzalo Garramuño]

Alexander Neundorf wrote:
>> I have my own UnixPaths and modules to work around most of the above,
> 
> Can you please post it ?
> 

Sure.  It is really two pieces.  FindBuildDir.cmake which is called 
first and Platforms/UnixPaths.cmake.

FindBuildDir does the hard check of setting up a couple of variables. 
It sets CMAKE_NATIVE_ARCH to 32 or 64.

And sets the OS_32_BITS and OS_64_BITS variables to represent whether 
the machine can compile for that.

User calls (optionally) cmake with -DCMAKE_BUILD_ARCH=32 to build in 32 
bits.

Currently, I only have it working for Linux (tested) and Sun (not 
tested).  Windows and OSX are todo, as I don't have access to 64-bit 
versions of them.


UnixPaths.cmake is then set to search for 
/usr/local/lib${CMAKE_BUILD_ARCH} before it searches for any 
/usr/local/lib and other.

This is still kind of screwy now because try-compile will call 
UnixPaths.cmake without calling my FindBuildDir, which is a bug in how 
cmake deals with variables.


-- 
Gonzalo Garramuño
ggarra at advancedsl.com.ar

AMD4400 - ASUS48N-E
GeForce7300GT
Xubuntu Gutsy
-------------- next part --------------
#-*-cmake-*-
#
# This simple CMake extension makes sure that builds get
# created inside a BUILD/os-osversion-arch directory
# and that executables, obj files and lib files get placed
# correctly in subdirectories.
#
#
# Macro to check architecture
#
MACRO( CHECK_ARCHITECTURE )


  IF( NOT CMAKE_BUILD_ARCH )
    SET( CMAKE_BUILD_ARCH $ENV{CMAKE_BUILD_ARCH} )
    IF( NOT CMAKE_BUILD_ARCH )
      SET( CMAKE_BUILD_ARCH "Native" )
    ENDIF( NOT CMAKE_BUILD_ARCH )
  ENDIF( NOT CMAKE_BUILD_ARCH )

  IF( NOT CMAKE_BUILD_ARCH MATCHES "^(Native|64|32)$" )
    MESSAGE( FATAL_ERROR 
      "CMAKE_BUILD_ARCH set but invalid.  "
      "Only Native, 64 and 32 are valid settings" )
  ENDIF( NOT CMAKE_BUILD_ARCH MATCHES "^(Native|64|32)$" )

  #
  # Set Native architecture based on void* size
  #
  INCLUDE(CheckTypeSize)
  CHECK_TYPE_SIZE(void*  SIZEOF_VOID_PTR)

  IF( ${SIZEOF_VOID_PTR} MATCHES "^8$" )
    SET( OS_32_BITS 0 )
    SET( OS_64_BITS 1 )
    SET( CMAKE_NATIVE_ARCH 64 )
  ELSE( ${SIZEOF_VOID_PTR} MATCHES "^8$" )
    SET( OS_32_BITS 1 )
    SET( OS_64_BITS 0 )
    SET( CMAKE_NATIVE_ARCH 32 )
  ENDIF( ${SIZEOF_VOID_PTR} MATCHES "^8$" )

  MESSAGE( FATAL_ERROR "void size: ${SIZEOF_VOID_PTR}" )

  IF( UNIX )
    EXECUTE_PROCESS( 
      COMMAND uname -a
      OUTPUT_VARIABLE OS_ARCH 
      )

    #
    # For Linux
    #
    IF( OS_ARCH MATCHES ".*Linux.*" )
      IF( OS_ARCH MATCHES ".*x86_64.*" )
	SET( OS_32_BITS 1 )
      ELSEIF( OS_ARCH MATCHES ".*ia64.*" )
	SET( OS_32_BITS 0 )
      ELSEIF( OS_ARCH MATCHES ".*i686.*" )
	SET( OS_32_BITS 1 )
      ENDIF( OS_ARCH MATCHES ".*x86_64.*" )
    ENDIF( OS_ARCH MATCHES ".*Linux.*" )

    #
    # For SUN
    #
    IF( OS_ARCH MATCHES ".*SunOS.*" )
      EXECUTE_PROCESS( 
	COMMAND isainfo -v
	OUTPUT_VARIABLE SUNOS_ARCH 
	)

      IF ( SUNOS_ARCH MATCHES ".*64-bit.*" )
	SET( OS_32_BITS 1 )
      ENDIF(  SUNOS_ARCH MATCHES ".*64-bit.*" )

    ENDIF( OS_ARCH MATCHES ".*SunOS.*" )

    IF( APPLE )
      #
      # @todo: add Apple 64-bit OS detection here
      #
    ENDIF( APPLE )

  ELSE( UNIX )

    #
    # @todo: add windows 64-bit OS detection here
    #

  ENDIF( UNIX )


  IF ( CMAKE_BUILD_ARCH STREQUAL "Native" )
    SET( CMAKE_BUILD_ARCH ${CMAKE_NATIVE_ARCH} )
  ENDIF( CMAKE_BUILD_ARCH STREQUAL "Native" )

  IF( CMAKE_BUILD_ARCH EQUAL 32 )

    IF( NOT OS_32_BITS )
      MESSAGE( FATAL_ERROR 
	"Sorry, but this platform cannot compile 32-bit applications" )
    ENDIF( NOT OS_32_BITS )

    IF( NOT CMAKE_NATIVE_ARCH EQUAL 32 )

      IF( WIN32 )
      ELSE( WIN32 )

	IF( CMAKE_COMPILER_IS_GNUCXX )
	  ADD_DEFINITIONS( -m32 )
	  SET( LINK_FLAGS "-m32 ${LINK_FLAGS}" )
	ELSE( CMAKE_COMPILER_IS_GNUCXX )

	  #
	  # @todo: add 32-bit compile flags for non-GNU compilers here
	  #
	  
	ENDIF( CMAKE_COMPILER_IS_GNUCXX )
      ENDIF( WIN32 )

    ENDIF( NOT CMAKE_NATIVE_ARCH EQUAL 32 )

  ENDIF( CMAKE_BUILD_ARCH EQUAL 32 )

ENDMACRO( CHECK_ARCHITECTURE )


CHECK_ARCHITECTURE()

#
# Store build type
#
IF(NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE Release CACHE STRING
      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
      FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)

IF( CMAKE_BUILD_TYPE STREQUAL "Debug" )
  ADD_DEFINITIONS( -DDEBUG )
ENDIF( CMAKE_BUILD_TYPE STREQUAL "Debug" )

IF( NOT CMAKE_SYSTEM )
  MESSAGE( FATAL_ERROR "CMAKE_SYSTEM was not set" )
ENDIF( NOT CMAKE_SYSTEM )

#
# @bug in cmake2.5 in windows (workaround)
#
IF( NOT CMAKE_SYSTEM_VERSION )
  SET( CMAKE_SYSTEM_VERSION "5.1" )
  SET( CMAKE_SYSTEM "${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION}" )
ENDIF( NOT CMAKE_SYSTEM_VERSION )


IF( NOT CMAKE_BUILD_TYPE )
  MESSAGE( FATAL_ERROR "CMAKE_BUILD_TYPE was not set" )
ENDIF( NOT CMAKE_BUILD_TYPE )

IF( NOT CMAKE_BUILD_ARCH )
  MESSAGE( FATAL_ERROR "CMAKE_BUILD_ARCH was not set" )
ENDIF( NOT CMAKE_BUILD_ARCH )


SET( BUILD_DIR "${CMAKE_SOURCE_DIR}/BUILD/${CMAKE_SYSTEM}-${CMAKE_BUILD_ARCH}/${CMAKE_BUILD_TYPE}" )

SET( PROJECT_BINARY_DIR "${BUILD_DIR}" )
SET( EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/bin" )
# SET( CMAKE_BINARY_DIR "${BUILD_DIR}/obj" )
SET( LIBRARY_OUTPUT_PATH "${BUILD_DIR}/lib" )
SET( CMAKE_LIBRARY_PATH ${LIBRARY_OUTPUT_PATH} ${CMAKE_LIBRARY_PATH} )

FILE( MAKE_DIRECTORY "${BUILD_DIR}" )
FILE( MAKE_DIRECTORY "${PROJECT_BINARY_DIR}" )
FILE( MAKE_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}" )
FILE( MAKE_DIRECTORY "${LIBRARY_OUTPUT_PATH}" )


#
# Turn off crappy cmake's use of RPATH, which prevents the proper use
# of LD_LIBRARY_PATH
#
SET( CMAKE_SKIP_RPATH "ON" )


#
# If compiling in 32-bits mode on a 64-bits machine, place 32-bits
# libraries first
#
IF( ${CMAKE_CXX_FLAGS} MATCHES "-m32" )

  #
  # Remove 64-bits paths
  #
  LIST( REMOVE_ITEM CMAKE_SYSTEM_LIBRARY_PATH 
    /usr/local/lib /opt/local/lib /usr/X11R6/lib /usr/lib/X11 
    /usr/lib64 /lib64 /lib /usr/lib )


ENDIF( ${CMAKE_CXX_FLAGS} MATCHES "-m32" )


#
# Macro used to easily add linker flags to a target
#
MACRO( TARGET_LINK_FLAGS TARGET FLAGS )
  GET_TARGET_PROPERTY( OLD_FLAGS ${TARGET} LINK_FLAGS )
  SET_TARGET_PROPERTIES( 
    ${TARGET}
    PROPERTIES 
    LINK_FLAGS "${FLAGS} ${OLD_FLAGS}"
    )
ENDMACRO( TARGET_LINK_FLAGS )

-------------- next part --------------
SET(UNIX 1)

# also add the install directory of the running cmake to the search directories
# CMAKE_ROOT is CMAKE_INSTALL_PREFIX/share/cmake, so we need to go two levels up
GET_FILENAME_COMPONENT(_CMAKE_INSTALL_DIR "${CMAKE_ROOT}" PATH)
GET_FILENAME_COMPONENT(_CMAKE_INSTALL_DIR "${_CMAKE_INSTALL_DIR}" PATH)

SET(CMAKE_SYSTEM_INCLUDE_PATH ${CMAKE_SYSTEM_INCLUDE_PATH}
  # Locals first
  /usr/local/include /opt/local/include 
 
  # Windows API on Cygwin
  /usr/include/w32api

  # X11
  /usr/X11R6/include /usr/include/X11

  # Other
  /opt/local/include /usr/pkg/include
  /opt/csw/include /opt/include  
  /usr/openwin/include
  "${_CMAKE_INSTALL_DIR}/include"
  "${CMAKE_INSTALL_PREFIX}/include"

  # Standard
  /usr/include /include 
  )

SET(CMAKE_SYSTEM_LIBRARY_PATH ${CMAKE_SYSTEM_LIBRARY_PATH}

  # Platforms first
  /usr/local/lib${CMAKE_BUILD_ARCH}
  /opt/local/lib${CMAKE_BUILD_ARCH}
  /opt/lib${CMAKE_BUILD_ARCH}
  /usr/lib${CMAKE_BUILD_ARCH}
  /lib${CMAKE_BUILD_ARCH}

  # Locals first
  /usr/local/lib /opt/local/lib 

  # Windows API on Cygwin
  /usr/lib/w32api

  # X11
  /usr/X11R6/lib /usr/lib/X11

  # Other
  /opt/local/lib /usr/pkg/lib
  /opt/csw/lib /opt/lib 
  /usr/openwin/lib
  "${_CMAKE_INSTALL_DIR}/lib"
  "${CMAKE_INSTALL_PREFIX}/lib"

  # Standard
  /usr/lib /lib
  )

SET(CMAKE_SYSTEM_PROGRAM_PATH ${CMAKE_SYSTEM_PROGRAM_PATH}
  /usr/local/bin /usr/pkg/bin /usr/bin /sbin /bin
  "${_CMAKE_INSTALL_DIR}/bin"
  "${CMAKE_INSTALL_PREFIX}/bin"
  )

SET(CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES
  ${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}
  /usr/lib64 /usr/lib32 /usr/lib /lib 
  )

# Enable use of lib64 search path variants by default.
SET_PROPERTIES(GLOBAL PROPERTIES FIND_LIBRARY_USE_LIB64_PATHS TRUE)