xavi
/
speed-dreams
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
speed-dreams/cmake/robot.cmake

314 lines
14 KiB
CMake
Raw Permalink Blame History

############################################################################
#
# file : robot.cmake
# copyright : (C) 2008 by Mart Kelder, 2010 by J.-P. Meuret
# web : www.speed-dreams.org
# version : $Id$
#
############################################################################
############################################################################
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
############################################################################
# @file Robots-related macros
# @author Mart Kelder
# @version $Id$
# Robot .def file generation for Windows builds with MSVC compilers
# ROBOTNAME : Name of the robot
# DEF_FILE : Target .def file path-name
# Other args : Robot DLL Interface description, as a list of names of exported symbols,
# but with keywords shortcuts :
# - if empty, assumed keyword "LEGACY_MIN"
# - if "LEGACY_MIN", means the smallest legacy scheme interface (TORCS style)
# with only "${NAME}" exported
# - if "LEGACY", means the complete legacy scheme interface,
# with "${NAME}" and "${NAME}Shut" exported
# - if "WELCOME", means the complete new scheme interface (Speed Dreams style),
# with "moduleWelcome", "moduleInitialize" and "moduleTerminate"
# exported
# - may be a list of above keywords for multi-scheme interface
# - may also be the raw list of symbols to export
MACRO(GENERATE_ROBOT_DEF_FILE ROBOTNAME DEF_FILE)
# Build the real list of exported symbols from the given one (that may include shortcuts)
#MESSAGE(STATUS "Generating ${DEF_FILE} for ${ROBOTNAME} robot")
SET(SYMBOLS) # Initialize the list
FOREACH(KEYSYM ${ARGN})
IF(KEYSYM STREQUAL "LEGACY_MIN")
LIST(APPEND SYMBOLS ${ROBOTNAME})
ELSEIF(KEYSYM STREQUAL "LEGACY")
LIST(APPEND SYMBOLS ${ROBOTNAME})
LIST(APPEND SYMBOLS "${ROBOTNAME}Shut")
ELSEIF(KEYSYM STREQUAL "WELCOME")
LIST(APPEND SYMBOLS moduleWelcome moduleInitialize moduleTerminate)
ELSE(KEYSYM STREQUAL "LEGACY_MIN")
LIST(APPEND SYMBOLS ${KEYSYM})
ENDIF(KEYSYM STREQUAL "LEGACY_MIN")
ENDFOREACH(KEYSYM ${ARGN})
# Clean duplicates
LIST(REMOVE_DUPLICATES SYMBOLS)
#MESSAGE(STATUS "Symbols: ${SYMBOLS}")
# Build an acceptable string for the .def file from this symbol list
SET(ROBOTSYMBOLS "")
FOREACH(SYMBOL ${SYMBOLS})
SET(ROBOTSYMBOLS "${ROBOTSYMBOLS}\n\t${SYMBOL}")
ENDFOREACH(SYMBOL ${SYMBOLS})
# Generate the .def file
SET(ROBOT_NAME "${ROBOTNAME}")
IF(IN_SOURCETREE)
CONFIGURE_FILE(${SOURCE_DIR}/cmake/robot.def.in.cmake ${DEF_FILE})
ELSE(IN_SOURCETREE)
CONFIGURE_FILE(${SD_DATADIR_ABS}/cmake/robot.def.in.cmake ${DEF_FILE})
ENDIF(IN_SOURCETREE)
ENDMACRO(GENERATE_ROBOT_DEF_FILE ROBOTNAME DEF_FILE)
# Robot project definition (module build and install, without associated data)
# Args:
# NAME : Name of the robot
# INTERFACE : Robot Windows DLL Interface description (tells about exported symbols)
# See GENERATE_ROBOT_DEF_FILE macro.
# If not specified, defaults to "LEGACY_MIN" ; not used if MODULE used
# SOURCES : List of files to use as build sources if any ; not needed if MODULE used
# CLONENAMES : The names of the clones to generate
# VERSION : The VERSION of the libraries to produce (robot and its clones) (def: $VERSION).
# SOVERSION : The SOVERSION of the libraries to produce (in the ldconfig meaning) (def: 0.0.0).
# WARNING: Not taken into account for the moment : might not work with GCC 4.5 or +.
#
# Example:
# ROBOT_MODULE(NAME simplix VERSION 3.0.5 SOVERSION 0.0.0
# INTERFACE LEGACY WELCOME simplix_trb1 simplix_ls1 simplix_36GP
# SOURCES simplix.cpp ...
# CLONENAMES simplix_trb1 simplix_ls1 simplix_36GP)
MACRO(ROBOT_MODULE)
SET(RBM_SYNTAX "NAME,1,1,RBM_HAS_NAME,RBM_NAME")
SET(RBM_SYNTAX ${RBM_SYNTAX} "VERSION,0,1,RBM_HAS_VERSION,RBM_VERSION")
SET(RBM_SYNTAX ${RBM_SYNTAX} "SOVERSION,0,1,RBM_HAS_SOVERSION,RBM_SOVERSION")
SET(RBM_SYNTAX ${RBM_SYNTAX} "INTERFACE,0,-1,RBM_HAS_INTERFACE,RBM_INTERFACE")
SET(RBM_SYNTAX ${RBM_SYNTAX} "SOURCES,0,-1,RBM_HAS_SOURCES,RBM_SOURCES")
SET(RBM_SYNTAX ${RBM_SYNTAX} "CLONENAMES,0,-1,RBM_HAS_CLONENAMES,RBM_CLONENAMES")
SPLIT_ARGN(${RBM_SYNTAX} ARGUMENTS ${ARGN})
IF(NOT RBM_HAS_NAME OR NOT RBM_NAME)
MESSAGE(FATAL_ERROR "Cannot build a robot module with no specified name")
ENDIF()
IF(NOT RBM_HAS_SOURCES OR NOT RBM_SOURCES)
MESSAGE(FATAL_ERROR "Cannot build a robot module without sources / module to copy")
ENDIF()
IF(NOT RBM_HAS_VERSION OR NOT RBM_VERSION)
SET(RBM_VERSION ${VERSION})
MESSAGE(STATUS "No version specified for robot module ${RBM_NAME} ; using ${RBM_VERSION}")
ENDIF()
IF(NOT RBM_HAS_SOVERSION OR NOT RBM_SOVERSION)
IF(UNIX)
SET(RBM_SOVERSION 0.0.0)
MESSAGE(STATUS "No so-version specified for robot module ${RBM_NAME} ; using ${RBM_SOVERSION}")
ENDIF()
ENDIF()
PROJECT("robot_${RBM_NAME}")
ADD_INTERFACE_INCLUDEDIR()
ADD_SDLIB_INCLUDEDIR(learning math portability robottools tgf)
ADD_PLIB_INCLUDEDIR()
# DLL export stuff under Windows (through a .def file or __declspec pragmas)
IF(WIN32)
# If an interface is specified, use the old way.
IF(RBM_HAS_INTERFACE AND RBM_INTERFACE)
IF(MSVC)
# For MSVC compilers, generate / add a .def file for legacy / welcome interface.
SET(ROBOT_DEF_FILE ${CMAKE_CURRENT_BINARY_DIR}/${RBM_NAME}_gen.def)
GENERATE_ROBOT_DEF_FILE(${RBM_NAME} ${ROBOT_DEF_FILE} ${RBM_INTERFACE})
SET(RBM_SOURCES ${RBM_SOURCES} ${ROBOT_DEF_FILE})
ENDIF()
# If no interface is specified, assume it's the new modern one.
ELSE()
# For any Windows compiler, use __declspec pragmas.
ADD_DEFINITIONS(-DROBOT_DLL)
ENDIF()
ENDIF(WIN32)
# Disable developer warning
IF (COMMAND cmake_policy)
CMAKE_POLICY(SET CMP0003 NEW)
ENDIF(COMMAND cmake_policy)
# Ignore some run-time libs to avoid MSVC link-time warnings and sometimes even crashes.
IF(MSVC)
SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:msvcrt.lib")
ENDIF(MSVC)
# The robot module is actually a module.
SD_ADD_LIBRARY(${RBM_NAME} ROBOT ${RBM_SOURCES})
# Customize shared library versions.
IF(UNIX) # Use ldconfig version naming scheme + no "lib" prefix under Linux
# Might not work with GCC 4.5 or + (non-robot modules crash at 1st reload = after 1 dlclose)
#SET_TARGET_PROPERTIES(${RBM_NAME} PROPERTIES VERSION ${RBM_VERSION})
#SET_TARGET_PROPERTIES(${RBM_NAME} PROPERTIES SOVERSION ${RBM_SOVERSION})
ELSE()
SET_TARGET_PROPERTIES(${RBM_NAME} PROPERTIES VERSION ${RBM_VERSION})
ENDIF()
# Link/Run-time dependencies
ADD_PLIB_LIBRARY(${RBM_NAME} sg)
ADD_SDLIB_LIBRARY(${RBM_NAME} portability tgf robottools)
# Install target robot module shared library
SD_INSTALL_FILES(LIB drivers/${RBM_NAME} TARGETS ${RBM_NAME})
# Install clone robot modules shared libraries (use ldconfig version naming scheme under Linux)
IF(RBM_HAS_CLONENAMES AND RBM_CLONENAMES)
GET_TARGET_PROPERTY(MODLOC ${RBM_NAME} RUNTIME_OUTPUT_DIRECTORY)
IF(NOT RUNTIME_OUTPUT_DIRECTORY)
GET_TARGET_PROPERTY(MODLOC ${RBM_NAME} LIBRARY_OUTPUT_DIRECTORY)
ENDIF()
SET(MODLOC "${MODLOC}/${RBM_NAME}${CMAKE_SHARED_MODULE_SUFFIX}")
FOREACH(CLONENAME ${RBM_CLONENAMES})
SET(CLONE_MODDIR "${CMAKE_BINARY_DIR}/${SD_LIBDIR}/drivers/${CLONENAME}")
SET(CLONE_MODLOC "${CLONE_MODDIR}/${CLONENAME}${CMAKE_SHARED_MODULE_SUFFIX}")
SET_PROPERTY(GLOBAL APPEND PROPERTY SD_ROBOT_LIST "${CLONENAME}")
IF(FALSE) #IF(UNIX)
# Might not work with GCC 4.5 or + (see above)
ADD_CUSTOM_COMMAND(TARGET ${RBM_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E echo "Cloning ${RBM_NAME}${CMAKE_SHARED_MODULE_SUFFIX} into ${CLONE_MODLOC}.${RBM_VERSION}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${CLONE_MODDIR}"
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODLOC} ${CLONE_MODLOC}.${RBM_VERSION})
ADD_CUSTOM_COMMAND(TARGET ${RBM_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E create_symlink ${CLONE_MODLOC}.${RBM_VERSION} ${CLONE_MODLOC}.${RBM_SOVERSION}
COMMAND ${CMAKE_COMMAND} -E create_symlink ${CLONE_MODLOC}.${RBM_SOVERSION} ${CLONE_MODLOC})
SD_INSTALL_FILES(LIB drivers/${CLONENAME}
FILES ${CLONE_MODLOC} ${CLONE_MODLOC}.${RBM_SOVERSION} ${CLONE_MODLOC}.${RBM_VERSION} )
ELSE()
ADD_CUSTOM_COMMAND(TARGET ${RBM_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E echo "Creating directory ${CLONE_MODDIR}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${CLONE_MODDIR}"
COMMAND ${CMAKE_COMMAND} -E echo "Cloning ${RBM_NAME}${CMAKE_SHARED_MODULE_SUFFIX}=${MODLOC} into ${CLONE_MODLOC}"
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODLOC} ${CLONE_MODLOC})
SD_INSTALL_FILES(LIB drivers/${CLONENAME}
FILES ${CLONE_MODLOC})
ENDIF()
ENDFOREACH(CLONENAME ${RBM_CLONENAMES})
ENDIF()
ENDMACRO(ROBOT_MODULE)
# Robot data installation
# Args:
# NAME : Name of the robot (may be a clone)
# PREFIX : Prefix to use to get source path for files/subdirs specified in FILES/SUBDIRS
# FILES : Files to install in the robot's data dir (see PREFIX)
# SUBDIRS : Sub-dirs to recusively install in the robot's data dir (see PREFIX)
# PATTERNS : Files to install from SUBDIRS in the robot's data dir,
# as glob patterns (defaults to *.*)
# USER : If this keyword is present, also mark _any_ above specified XML file
# as a user settings file (installed at run-time is the user settings folders).
#
MACRO(ROBOT_DATA)
SET(RBD_SYNTAX "NAME,1,1,RBD_HAS_NAME,RBD_NAME")
SET(RBD_SYNTAX ${RBD_SYNTAX} "PREFIX,0,1,RBD_HAS_PREFIX,RBD_PREFIX")
SET(RBD_SYNTAX ${RBD_SYNTAX} "FILES,0,-1,RBD_HAS_FILES,RBD_FILES")
SET(RBD_SYNTAX ${RBD_SYNTAX} "SUBDIRS,0,-1,RBD_HAS_SUBDIRS,RBD_SUBDIRS")
SET(RBD_SYNTAX ${RBD_SYNTAX} "PATTERNS,0,-1,RBD_HAS_PATTERNS,RBD_PATTERNS")
SET(RBD_SYNTAX ${RBD_SYNTAX} "USER,0,0,RBD_IS_USER,_")
SPLIT_ARGN(${RBD_SYNTAX} ARGUMENTS ${ARGN})
#MESSAGE(STATUS "ROBOT_DATA(${RBD_NAME}): PREFIX=${RBD_PREFIX} FILES=${RBD_FILES} PATTERNS=${RBD_PATTERNS} SUBDIRS=${RBD_SUBDIRS} USER=${RBD_IS_USER}")
# Check arguments syntax / values
IF(NOT RBD_HAS_NAME OR NOT RBD_NAME)
MESSAGE(FATAL_ERROR "Cannot install data for a robot module with no specified name")
ENDIF()
# Install specified files.
IF(RBD_HAS_FILES AND RBD_FILES)
IF(RBD_IS_USER)
SD_INSTALL_FILES(DATA drivers/${RBD_NAME} USER drivers/${RBD_NAME}
PREFIX ${RBD_PREFIX} FILES ${RBD_FILES})
ELSE()
SD_INSTALL_FILES(DATA drivers/${RBD_NAME}
PREFIX ${RBD_PREFIX} FILES ${RBD_FILES})
ENDIF()
ENDIF()
# Install subdirs if specified.
IF(RBD_HAS_SUBDIRS AND RBD_SUBDIRS)
# Install specified files.
IF(RBD_IS_USER)
SD_INSTALL_DIRECTORIES(DATA drivers/${RBD_NAME} USER drivers/${RBD_NAME}
PREFIX ${RBD_PREFIX} DIRECTORIES ${RBD_SUBDIRS}
PATTERNS ${RBD_PATTERNS})
ELSE()
SD_INSTALL_DIRECTORIES(DATA drivers/${RBD_NAME}
PREFIX ${RBD_PREFIX} DIRECTORIES ${RBD_SUBDIRS}
PATTERNS ${RBD_PATTERNS})
ENDIF()
ENDIF(RBD_HAS_SUBDIRS AND RBD_SUBDIRS)
ENDMACRO(ROBOT_DATA)
# Robot project definition (module build and install, with associated data)
# Args:
# NAME : Name of the robot
# INTERFACE : Robot Windows DLL Interface description (tells about exported symbols)
# See GENERATE_ROBOT_DEF_FILE macro.
# If not specified, defaults to "LEGACY_MIN" ; not used if MODULE used
# SOURCES : List of files to use as build sources if any ; not needed if MODULE used
# PREFIX : Dir. prefix for source files/subdirs to install in the robot's data dir
# FILES : Extra (non default) files to install in the robot's data dir
# SUBDIRS : Data subdirectories to install in the robot's data dir
MACRO(ROBOT)
SET(RB_SYNTAX "NAME,1,1,RB_HAS_NAME,RB_NAME")
SET(RB_SYNTAX ${RB_SYNTAX} "INTERFACE,0,-1,RB_HAS_INTERFACE,RB_INTERFACE")
SET(RB_SYNTAX ${RB_SYNTAX} "SOURCES,0,-1,RB_HAS_SOURCES,RB_SOURCES")
SET(RB_SYNTAX ${RB_SYNTAX} "PREFIX,0,-1,RB_HAS_PREFIX,RB_PREFIX")
SET(RB_SYNTAX ${RB_SYNTAX} "FILES,0,-1,RB_HAS_FILES,RB_FILES")
SET(RB_SYNTAX ${RB_SYNTAX} "SUBDIRS,0,-1,RB_HAS_SUBDIRS,RB_SUBDIRS")
#SET(__DEBUG__ TRUE)
SPLIT_ARGN(${RB_SYNTAX} ARGUMENTS ${ARGN})
#SET(__DEBUG__ FALSE)
#MESSAGE(STATUS "ROBOT(${RB_NAME}): INTERFACE=${RB_INTERFACE} (${RB_HAS_INTERFACE}) SOURCES=${RB_SOURCES} (${RB_HAS_SOURCES}) PREFIX=${RB_PREFIX} (${RB_HAS_PREFIX}) FILES=${RB_FILES} (${RB_HAS_FILES}) SUBDIRS=${RB_SUBDIRS} (${RB_HAS_SUBDIRS})")
IF(NOT RB_HAS_NAME OR NOT RB_NAME)
MESSAGE(FATAL_ERROR "Cannot build a robot with no specified name")
ENDIF()
IF(NOT RB_HAS_SOURCES OR NOT RB_SOURCES)
MESSAGE(FATAL_ERROR "Cannot build a robot without sources")
ENDIF()
ROBOT_MODULE(NAME ${RB_NAME} INTERFACE ${RB_INTERFACE} SOURCES ${RB_SOURCES})
ROBOT_DATA(NAME ${RB_NAME} PREFIX ${RB_PREFIX} FILES ${RB_FILES} SUBDIRS ${RB_SUBDIRS})
ENDMACRO(ROBOT)
Reference in New Issue View Git Blame Copy Permalink