[Sdif-cvs] Easdif/cmModules ADD_EASDIF_FLAGS.cmake, NONE, 1.1 BuildTypeTargets.cmake, NONE, 1.1 CHE

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/sdif/Easdif/cmModules
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv32727/cmModules

Added Files:
	ADD_EASDIF_FLAGS.cmake BuildTypeTargets.cmake 
	CHECK_SIZEOF.cmake CLEAN_CMAKE.cmake 
	CREATE_CVSTAGS_MACRO.cmake cvsnew.sh CVS_Targets.cmake 
	GET_ARCH.cmake GET_GCC_VERSION.cmake OVERWRITE_COMPILER.cmake 
	REDIRECT_COMPILERS_TO_SYSROOT.cmake 
	RenameInstalledStaticLib.cmake.in 
	REPLACE_DEFAULT_VALUE_MACRO.cmake SET_INSTALL_NAME.cmake.in 
	SET_LOCAL_DEFAULTS.cmake STORE_FILES_LIST.cmake 
	trycompile.c.in update.sh 
Log Message:

--- NEW FILE: trycompile.c.in ---
@SOURCE@

--- NEW FILE: GET_ARCH.cmake ---
# determine architecture
IF( NOT ARCH )
#   EXEC_PROGRAM(arch OUTPUT_VARIABLE ARCH RETURN_VALUE RES)
#   IF( RES GREATER 0)
#      EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE ARCH RETURN_VALUE RES)
#   ENDIF( RES GREATER 0)
#
#   IF( RES EQUAL 0)
#       MESSAGE("configure for architecture  ${ARCH}")
#   ELSE( RES EQUAL 0)
#       MESSAGE("Cannot determine ARCH")
#       ERROR()
#   ENDIF(RES EQUAL 0)
  SET(ARCH ${CMAKE_SYSTEM_PROCESSOR})
ENDIF(NOT ARCH )
MESSAGE("-- ARCH system is ${ARCH}")

--- NEW FILE: STORE_FILES_LIST.cmake ---
# store the list of arguments
# in variable DOCFILES completing them with full path

MACRO (STORE_FILES_LIST STORE_VARIABLE INFILELIST )

SET(${STORE_VARIABLE})
FOREACH(FILE  ${INFILELIST} ${ARGN})
LIST(APPEND ${STORE_VARIABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${FILE})
ENDFOREACH(FILE  ${INFILELIST})

ENDMACRO(STORE_FILES_LIST STORE_VARIABLE INFILELIST  )

--- NEW FILE: SET_INSTALL_NAME.cmake.in ---
EXEC_PROGRAM(install_name_tool    ARGS -id "@INSTALLED_TARGET_NAME@"    "@INSTALLED_TARGET_NAME@")

--- NEW FILE: cvsnew.sh ---
#! /bin/sh

dir="$1";
shift
command="$1"
shift

cd "$dir"
"$command" status "$@"  2>/dev/null | perl -e '$num=0;while(<STDIN>) {if( m/.*Status:.*/ ) {$num=$num+1;
@stat=m/File:(.*)Status:\s*(.*)/} ; if($stat[1] !~ "Up-to-date" && m/ *Repository/ )
{@file=m/\s*Repository.*:\s*([-+.0-9]+)\s*(.+)/; print (@stat," -> ",$file[1],"\n");};};
print($num, " files checked \n");  '
--- NEW FILE: CVS_Targets.cmake ---
# Creat CVS/SVN related targets
#
#
FIND_PROGRAM(CVSCOMMAND cvs )
SET(CVS_UPDATE_OPTIONS "-d -A -P" CACHE STRING "Options passed to the cvs update command.")
FIND_PROGRAM(SVNCOMMAND svn)
#SET(SVN_UPDATE_OPTIONS "-d -A -P" CACHE STRING "Options passed to the svn update command.")

IF(NOT UPDATE_TYPE)
  IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
    SET(UPDATE_TYPE cvs)
  ELSE(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
    IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.svn")
      SET(UPDATE_TYPE svn)
    ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.svn")
  ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CVS")
ENDIF(NOT UPDATE_TYPE)

#IF(NOT UPDATE_TYPE)
#  MESSAGE(STATUS "Cannot determine repository type. Please set UPDATE_TYPE to 'cvs' or 'svn'. CTest update will not work.")
#ENDIF(NOT UPDATE_TYPE)

IF(UPDATE_TYPE MATCHES "[Cc][Vv][Ss]")
  MESSAGE(STATUS "This is a CVS repository")
  SET(UPDATE_COMMAND "${CVSCOMMAND}")
  SET(UPDATE_OPTIONS "${CVS_UPDATE_OPTIONS}")
ELSE(UPDATE_TYPE MATCHES "[Cc][Vv][Ss]")
  IF(UPDATE_TYPE MATCHES "[Ss][Vv][Nn]")
    MESSAGE(STATUS "This is a SVN repository")
    SET(UPDATE_COMMAND "${SVNCOMMAND}")
    SET(UPDATE_OPTIONS "${SVN_UPDATE_OPTIONS}")
  ENDIF(UPDATE_TYPE MATCHES "[Ss][Vv][Nn]")
ENDIF(UPDATE_TYPE MATCHES "[Cc][Vv][Ss]")

MARK_AS_ADVANCED(
  CVSCOMMAND
  SVNCOMMAND
  CVS_UPDATE_OPTIONS
  SVN_UPDATE_OPTIONS
  )

IF(NOT CVSUPDATE_INIT)
  ADD_CUSTOM_TARGET(cvsupdate  cd ${CMAKE_CURRENT_SOURCE_DIR} \; ${UPDATE_COMMAND} up -P )
  SET(CVSUPDATE_INIT 1)
ENDIF(NOT CVSUPDATE_INIT)

IF(UPDATE_TYPE MATCHES "[Cc][Vv][Ss]")
IF(NOT CVSNEW_INIT)
  ADD_CUSTOM_TARGET(cvsnew ${CMAKE_SOURCE_DIR}/cmModules/cvsnew.sh ${CMAKE_CURRENT_SOURCE_DIR} ${UPDATE_COMMAND} )
  SET(CVSNEW_INIT 1)
ENDIF(NOT CVSNEW_INIT)
ENDIF(UPDATE_TYPE MATCHES "[Cc][Vv][Ss]")

--- NEW FILE: RenameInstalledStaticLib.cmake.in ---
FILE(GLOB INSTALLED_LIBNAME $ENV{DESTDIR}@CMAKE_INSTALL_PREFIX@@INSTALL_LIB_DIR@/*@BEFORE_RENAME@*)
MESSAGE("INSTALLED_LIBNAME  $ENV{DESTDIR}@CMAKE_INSTALL_PREFIX@@INSTALL_LIB_DIR@/*@BEFORE_RENAME@*")
MESSAGE("INSTALLED_LIBNAME  ${INSTALLED_LIBNAME}")
STRING(REPLACE "@BEFORE_RENAME@" "@AFTER_RENAME@" INSTALLED_NAME_AFTER_RENAME ${INSTALLED_LIBNAME})
EXEC_PROGRAM(@CMAKE_COMMAND@ ARGS -E copy "${INSTALLED_LIBNAME}" "${INSTALLED_NAME_AFTER_RENAME}")
EXEC_PROGRAM(@CMAKE_COMMAND@ ARGS -E remove "${INSTALLED_LIBNAME}")

--- NEW FILE: REPLACE_DEFAULT_VALUE_MACRO.cmake ---
# Replace default values of variable given in VARIABLE
# default will be replaced by value given in INIT and put in chache as type given as type
# value will be replaced if the cache does not yet exist and the variable given in
# USE_CMAKE_DEFAULTS is not true or if the varibale VARIABLE has the value default

MACRO (REPLACE_DEFAULT_VALUE VARIABLE TYPE INIT USE_CMAKE_DEFAULTS DOCSTRING )
  IF ( "${VARIABLE}"  STREQUAL "default")
     SET(${VARIABLE}  ${INIT}  CACHE ${TYPE} ${DOCSTRING}  FORCE)
  ELSE  ( "${VARIABLE}"  STREQUAL "default")
    IF (NOT ${USE_CMAKE_DEFAULTS})
      IF (NOT ${VARIABLE}_DEFAULTS_INIT)
        SET(${VARIABLE}  ${INIT}  CACHE ${TYPE} ${DOCSTRING}  FORCE)
        SET(${VARIABLE}_DEFAULTS_INIT  1  CACHE INTERNAL "Variable ${VARIABLE} has been initialized with default value")
      ENDIF(NOT ${VARIABLE}_DEFAULTS_INIT)
    ENDIF(NOT ${USE_CMAKE_DEFAULTS})
  ENDIF ( "${VARIABLE}"  STREQUAL "default")
ENDMACRO (REPLACE_DEFAULT_VALUE)

--- NEW FILE: CREATE_CVSTAGS_MACRO.cmake ---
MACRO(CREATE_CVSTAG_TARGET VERSION_TAG)
IF(NOT CREATE_CVSTAG_TARGET_INIT)
  # create cvstags for current version
  ADD_CUSTOM_TARGET(cvstags 
    COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR}\; cvs tag  -F ${VERSION_TAG}\; echo "tag ${VERSION_TAG} set")
  SET(CREATE_CVSTAG_TARGET_INIT 1)
ENDIF(NOT CREATE_CVSTAG_TARGET_INIT)
ENDMACRO(CREATE_CVSTAG_TARGET VERSION_TAG)

--- NEW FILE: OVERWRITE_COMPILER.cmake ---
# Set default compiler 
MACRO(OVERWRITE_COMPILER TAG COMP)

  REPLACE_DEFAULT_VALUE(CMAKE_${TAG}_COMPILER STRING ${COMP} 0 "${TAG} compiler" )

  IF(EXISTS "${CMAKE_BINARY_DIR}/CMakeFiles/CMake${TAG}Compiler.cmake")
    FILE(READ ${CMAKE_BINARY_DIR}/CMakeFiles/CMake${TAG}Compiler.cmake TMP)
    SET(TMP2 "SET[(]CMAKE_${TAG}_COMPILER ${CMAKE_${TAG}_COMPILER}[)]")
    STRING(REPLACE "+" "[+]" TMP2 ${TMP2})

    IF(NOT "${TMP}" MATCHES ".*${TMP2}[ \n\r\t]*$")
      MESSAGE("APPENDING compiler info")
      EXEC_PROGRAM(echo ARGS "SET\\(CMAKE_${TAG}_COMPILER ${CMAKE_${TAG}_COMPILER}\\)"  >> ${CMAKE_BINARY_DIR}/CMakeFiles/CMake${TAG}Compiler.cmake OUTPUT_VARIABLE TMPOUT)
    ENDIF(NOT  "${TMP}" MATCHES ".*${TMP2}[ \n\r\t]*$")
  ENDIF(EXISTS "${CMAKE_BINARY_DIR}/CMakeFiles/CMake${TAG}Compiler.cmake")

ENDMACRO(OVERWRITE_COMPILER TAG COMP)

--- NEW FILE: ADD_EASDIF_FLAGS.cmake ---

# Add  switches for Easdif
INCLUDE(UsePkgConfig)
PKGCONFIG(libEasdif${DEBUGEXT}     EASDIF_INC_DIR LIBEASDIF${DEBUGEXT}_LINK_DIR LIBEASDIF_LINK_FLAGS LIBEASDIF_CFLAGS)

IF(NOT EASDIF_LIB${DEBUGEXT})
  FIND_LIBRARY(EASDIF_LIB${DEBUGEXT} Names Easdif${DEBUGEXT}  PATHS  ${LIBRARY_OUTPUT_PATH} ${CMAKE_INSTALL_PREFIX}${INSTALL_LIB_DIR} ${LIBEASDIF${DEBUGEXT}_LINK_DIR} /u/formes/share/lib/$ENV{SYS}   /usr/local/lib /usr/lib  DOC "Path to EaSDIF library")
ENDIF(NOT EASDIF_LIB${DEBUGEXT})

IF(NOT EASDIF_INC_DIR)
  FIND_PATH(EASDIF_INC_DIR easdif/easdif.h  ${CMAKE_BINARY_DIR}${include} ${CMAKE_INSTALL_PREFIX}${INSTALL_INC_DIR} /u/formes/share/include   /usr/local/include /usr/include  DOC "Path to EaSDIF includes")
ENDIF(NOT EASDIF_INC_DIR)

INCLUDE_DIRECTORIES(${EASDIF_INC_DIR})

--- NEW FILE: CLEAN_CMAKE.cmake ---
# include special targets
# cmclean to remove cache, system and compiler info
# reinit  to reinit the cache to the default values either given in CMakeLists.txt
#         or if available in ${CMAKE_SOURCE_DIR}/Modules/CMAKE_INIT_CACHE.cmake

IF(NOT CLEAN_CMAKE_INIT)

  ADD_CUSTOM_TARGET(cmclean ${CMAKE_COMMAND} -E remove ${CMAKE_CACHEFILE_DIR}/CMakeCache.txt ${CMAKE_CACHEFILE_DIR}/CMakeFiles/CMakeSystem.cmake ${CMAKE_CACHEFILE_DIR}/CMakeFiles/CMakeCXXCompiler.cmake ${CMAKE_CACHEFILE_DIR}/CMakeFiles/CMakeCCompiler.cmake)

  #IF  (EXISTS ${CMAKE_SOURCE_DIR}/Modules/CMAKE_CACHE_INIT.cmake)
  #ADD_CUSTOM_TARGET(reinit ${CMAKE_COMMAND} -C${CMAKE_SOURCE_DIR}/Modules/CMAKE_CACHE_INIT.cmake ${CMAKE_SOURCE_DIR})
  #ELSE(EXISTS ${CMAKE_SOURCE_DIR}/Modules/CMAKE_CACHE_INIT.cmake)
  ADD_CUSTOM_TARGET(reinit ${CMAKE_COMMAND} ${CMAKE_SOURCE_DIR})
  #ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/Modules/CMAKE_CACHE_INIT.cmake)
  ADD_DEPENDENCIES(reinit cmclean)
  SET(CLEAN_CMAKE_INIT 1)
ENDIF(NOT CLEAN_CMAKE_INIT)

--- NEW FILE: GET_GCC_VERSION.cmake ---
# Determine gcc version
IF("${GCCVERSIONMAJ}" STREQUAL "" OR "${GCCVERSIONMIN}" STREQUAL "")

EXEC_PROGRAM(${CMAKE_C_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE TMP)
MESSAGE("Compiler version: ${TMP}")
STRING(REGEX REPLACE "^\([0-9]*\)[.][0-9]*[.][0-9]*" "\\1" TMP1 ${TMP} )
STRING(REGEX REPLACE "^[0-9]*[.]\([0-9]*\)[.][0-9]*" "\\1" TMP2 ${TMP} )
SET(GCCVERSIONMAJ ${TMP1} CACHE INTERNAL "gcc major version")
SET(GCCVERSIONMIN ${TMP2} CACHE INTERNAL "gcc minor version")

ENDIF("${GCCVERSIONMAJ}" STREQUAL "" OR  "${GCCVERSIONMIN}" STREQUAL "")

--- NEW FILE: CHECK_SIZEOF.cmake ---

MACRO(CHECK_SIZEOF TYPE DEFAULT)

INCLUDE(CheckTypeSize)
INCLUDE(CheckIncludeFile)

STRING(REPLACE " " "_" VARTYPE "${TYPE}" )
STRING(REPLACE "*" "p" TMP "${VARTYPE}" )
STRING(TOUPPER   "${TMP}" VARTYPE )

IF("${SIZEOF_${VARTYPE}}" STREQUAL "")
CHECK_INCLUDE_FILE(sys/types.h HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILE(stdint.h HAVE_STDINT_H)
CHECK_INCLUDE_FILE(stddef.h HAVE_STDDEF_H)

#MESSAGE("var name SIZEOF_${VARTYPE}")
CHECK_TYPE_SIZE("${TYPE}" SIZEOF_${VARTYPE})
ENDIF("${SIZEOF_${VARTYPE}}" STREQUAL "")

IF(NOT SIZEOF_${VARTYPE})
SET(HAVE_${VARTYPE} 0)
SET(SIZEOF_${VARTYPE} ${DEFAULT})
ELSE(NOT  SIZEOF_${VARTYPE})
SET(HAVE_${VARTYPE} 1)
ENDIF(NOT SIZEOF_${VARTYPE})

MESSAGE("-- Sizeof type ${TYPE} is  ${SIZEOF_${VARTYPE}}!")

ENDMACRO(CHECK_SIZEOF TYPE DEFAULT)

--- NEW FILE: SET_LOCAL_DEFAULTS.cmake ---
# set defaults for install prefix and build type
INCLUDE(REPLACE_DEFAULT_VALUE_MACRO)
REPLACE_DEFAULT_VALUE(CMAKE_BUILD_TYPE  STRING release 0 "set build type, debug or release" )
REPLACE_DEFAULT_VALUE(CMAKE_INSTALL_PREFIX PATH /u/formes/share 0 "install prefix" )
MESSAGE("Configure for mode = ${CMAKE_BUILD_TYPE}")

--- NEW FILE: REDIRECT_COMPILERS_TO_SYSROOT.cmake ---
IF(NOT COMPILER_REDIRECT_INIT)
  INCLUDE(REPLACE_DEFAULT_VALUE_MACRO)
  INCLUDE(OVERWRITE_COMPILER)
  MACRO( REDIRECT_COMP DEPTARGET)
    IF (CMAKE_CXX_COMPILER)
     GET_FILENAME_COMPONENT(BASENAME ${CMAKE_CXX_COMPILER} NAME_WE )
     SET(COMP ${CMAKE_BINARY_DIR}/Modules/${BASENAME}.sh )
     FILE(WRITE ${COMP}  "#! /bin/bash\n")
     FILE(APPEND ${COMP} "MACOSX_DEPLOYMENT_TARGET=${DEPTARGET} ${CMAKE_CXX_COMPILER} \"$@\"\n")

     OVERWRITE_COMPILER(CXX ${COMP})
     SET(CMAKE_CXX_COMPILER_FULLPATH ${COMP} CACHE INTERNAL "Full path to cxx compiler" )
     EXEC_PROGRAM(chmod ARGS u+x ${COMP} )
    ENDIF (CMAKE_CXX_COMPILER)
    IF(CMAKE_C_COMPILER)
    GET_FILENAME_COMPONENT(BASENAME ${CMAKE_C_COMPILER} NAME_WE )
    SET(COMP ${CMAKE_BINARY_DIR}/Modules/${BASENAME}.sh )
    FILE(WRITE ${COMP}  "#! /bin/bash\n")
    FILE(APPEND ${COMP} "MACOSX_DEPLOYMENT_TARGET=${DEPTARGET} ${CMAKE_C_COMPILER} \"$@\"\n")

    OVERWRITE_COMPILER(C ${COMP})
    SET(CMAKE_C_COMPILER_FULLPATH ${COMP} CACHE INTERNAL "Full path to c compiler")
    EXEC_PROGRAM(chmod ARGS u+x ${COMP} )
    ENDIF(CMAKE_C_COMPILER)
  ENDMACRO( REDIRECT_COMP)

  IF ("${ARCH}" MATCHES "^p.*pc.*")
    FIND_PATH (SDK MacOSX10.3.9.sdk /Developer/SDKs DOC "Path to 10.3.9 SDK") 
    IF ("${SDK}" MATCHES "/Developer/SDKs")
      ADD_DEFINITIONS ( -isysroot ${SDK}/MacOSX10.3.9.sdk )
      REDIRECT_COMP(10.3)
    ENDIF ("${SDK}" MATCHES "/Developer/SDKs")
  ELSE ("${ARCH}" MATCHES "^p.*pc.*" )
    FIND_PATH (SDK MacOSX10.4u.sdk /Developer/SDKs DOC "Path to 10.4 SDK") 
    IF ("${SDK}" MATCHES "/Developer/SDKs")
      # does not work due to space escaping of cmake
      #SET(CMAKE_CXX_COMPILER "MACOSX_DEPLOYMENT_TARGET=10.4 ${CMAKE_CXX_COMPILER}" )
      REDIRECT_COMP(10.4)
      ADD_DEFINITIONS (-isysroot ${SDK}/MacOSX10.4u.sdk )
    ENDIF ("${SDK}" MATCHES "/Developer/SDKs")
  ENDIF("${ARCH}" MATCHES "^p.*pc.*" )
  SET(COMPILER_REDIRECT_INIT 1 CACHE INTERNAL "Compiler has been redirected to shell script to use deploment target enviroment")
ENDIF(NOT COMPILER_REDIRECT_INIT)

--- NEW FILE: update.sh ---
#! /bin/sh

echo "$@"

dir="$1";
shift
command="$1"
shift
cd "$dir"
"$command" "$@"  

--- NEW FILE: BuildTypeTargets.cmake ---
IF(NOT BUILD_TYPE_TARGETS_INIT)
  ADD_CUSTOM_TARGET(set_debug ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE:STRING=debug ${CMAKE_CURRENT_SOURCE_DIR})
  ADD_CUSTOM_TARGET(set_release ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE:STRING=release ${CMAKE_CURRENT_SOURCE_DIR})
  ADD_CUSTOM_TARGET(show_build echo ${CMAKE_BUILD_TYPE})
  SET(BUILD_TYPE_TARGETS_INIT 1)
ENDIF(NOT BUILD_TYPE_TARGETS_INIT)