From a3bf0ee0e7f0c514ab3c9d6c37d2c386579465a6 Mon Sep 17 00:00:00 2001 From: Kolan Sh Date: Wed, 15 Oct 2014 17:32:46 +0400 Subject: [PATCH] Initial commit. --- CFlags.cmake | 6 + CPackCommon.cmake | 61 ++++++++++ CPackDetectArch.cmake | 20 ++++ FindVala.cmake | 69 +++++++++++ MacroOptionalAddSubdirectory.cmake | 31 +++++ README | 1 + UseVala.cmake | 180 +++++++++++++++++++++++++++++ ValaBinCommonRules.cmake | 18 +++ ValaLibCommonRules.cmake | 39 +++++++ ValaPluginCommonRules.cmake | 16 +++ 10 files changed, 441 insertions(+) create mode 100644 CFlags.cmake create mode 100644 CPackCommon.cmake create mode 100644 CPackDetectArch.cmake create mode 100644 FindVala.cmake create mode 100644 MacroOptionalAddSubdirectory.cmake create mode 100644 README create mode 100644 UseVala.cmake create mode 100644 ValaBinCommonRules.cmake create mode 100644 ValaLibCommonRules.cmake create mode 100644 ValaPluginCommonRules.cmake diff --git a/CFlags.cmake b/CFlags.cmake new file mode 100644 index 0000000..49c0dac --- /dev/null +++ b/CFlags.cmake @@ -0,0 +1,6 @@ +SET (CMAKE_C_FLAGS_DEBUG "-ggdb3 -O0 -ftest-coverage -Wcoverage-mismatch ${CMAKE_C_FLAGS_DEBUG}") +SET (CMAKE_C_FLAGS_RELEASE "-O2 ${CMAKE_C_FLAGS_RELEASE}") +IF (CMAKE_BUILD_TYPE STREQUAL "Debug") + SET (VALA_DEBUG "-g") +ENDIF () +SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") # supress Gcc warnings diff --git a/CPackCommon.cmake b/CPackCommon.cmake new file mode 100644 index 0000000..8a1de1e --- /dev/null +++ b/CPackCommon.cmake @@ -0,0 +1,61 @@ +INCLUDE (CPackDetectArch) + +## CPack configuration ## +SET (CPACK_PACKAGE_CONTACT "${CONTACT}") +SET (CPACK_PACKAGE_VENDOR "${CONTACT}") +SET (CPACK_NSIS_MODIFY_PATH ON) +SET (CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL ON) +INCLUDE (InstallRequiredSystemLibraries) +SET (CPACK_RESOURCE_FILE_LICENSE + "${CMAKE_SOURCE_DIR}/COPYING") +SET (CPACK_PACKAGE_DESCRIPTION_FILE + "${CMAKE_SOURCE_DIR}/README") +INSTALL (FILES "${PROJECT_BINARY_DIR}/pkg-config/${PROJECT_LOWERCASE_NAME}-${MAJOR}.pc" + DESTINATION lib/pkgconfig) +#SET (CPACK_NSIS_PACKAGE_NAME "${PROJECT_NAME}") +#SET (CPACK_NSIS_DISPLAY_NAME "${PROJECT_NAME}") +SET (CPACK_PACKAGE_VERSION_MAJOR "${MAJOR}") +SET (CPACK_PACKAGE_VERSION_MINOR "${MINOR}") +SET (CPACK_PACKAGE_VERSION_PATCH "${PATCH}") +SET (CPACK_PACKAGE_VERSION "${MAJOR}.${MINOR}.${PATCH}") + +IF (UNIX) + SET (CPACK_GENERATOR "DEB;RPM;STGZ;TBZ2;TGZ;TZ;ZIP") + SET (CPACK_SOURCE_GENERATOR "DEB;RPM;STGZ;TBZ2;TGZ;TZ;ZIP") + SET (CPACK_PACKAGE_NAME "${PROJECT_LOWERCASE_NAME}") + SET (CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_DESCRIPTION}") + SET (CPACK_PACKAGE_DESCRIPTION "${PROJECT_DESCRIPTION}") + + # Debian specific options + SET (CPACK_DEBIAN_PACKAGE_DEPENDS "${DEBIAN_DEPENDENCIES}") + SET (CPACK_DEBIAN_PACKAGE_SECTION "${DEBIAN_SECTION}") + # SET (CPACK_DEBIAN_PACKAGE_ARCHITECTURE "${ARCHITECTURE}") + # SET (CPACK_DEBIAN_PACKAGE_PRIORITY "optional") + SET (CPACK_DEBIAN_PACKAGE_RECOMMENDS "") + SET (CPACK_DEBIAN_PACKAGE_SUGGESTS "") + + # RPM specific options + # SET (CPACK_RPM_PACKAGE_ARCHITECTURE "${ARCHITECTURE}") + SET (CPACK_RPM_PACKAGE_LICENSE "${LICENSE}") + SET (CPACK_RPM_PACKAGE_GROUP "${REDHAT_SECTION}") + SET (CPACK_RPM_PACKAGE_REQUIRES "${REDHAT_DEPENDENCIES}") + SET (CPACK_RPM_PACKAGE_PROVIDES "${PROJECT_LOWERCASE_NAME}") + + # http://public.kitware.com/Bug/view.php?id=12997 + SET(CPACK_PACKAGE_FILE_NAME + "${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${ARCHITECTURE}") + +ELSEIF (WIN32) + SET (CPACK_GENERATOR "NSIS") + SET (CPACK_SOURCE_GENERATOR "NSIS") + SET (CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CMAKE_PROJECT_NAME}-${MAJOR}") + #SET (CPACK_NSIS_MENU_LINKS "${EWS_WEBSITE}" "Homepage for ${EWS_APP_NAME}") + #SET (CPACK_NSIS_INSTALLED_ICON_NAME bin\\\\${EXE_TARGET_NAME}.exe) + #SET (CPACK_NSIS_URL_INFO_ABOUT "${EWS_WEBSITE}") + #SET (CPACK_NSIS_HELP_LINK "${EWS_WEBSITE}") + SET (CPACK_PACKAGE_INSTALL_DIRECTORY "${CMAKE_PROJECT_NAME}-${MAJOR}") + SET (CPACK_UNINSTALL_NAME "${WIN32_UNINSTALL_NAME}-${MAJOR}") # <=10 symbols: https://redmine.backbone.ws/issues/83 +ENDIF () + +INCLUDE (CPack) + diff --git a/CPackDetectArch.cmake b/CPackDetectArch.cmake new file mode 100644 index 0000000..e878179 --- /dev/null +++ b/CPackDetectArch.cmake @@ -0,0 +1,20 @@ +# Kernel of Operation System +EXECUTE_PROCESS (COMMAND uname -s COMMAND tr -d '\n' OUTPUT_VARIABLE OSKERNEL) +MESSAGE ("OSKERNEL = ${OSKERNEL}") +STRING (TOLOWER "${OSKERNEL}" OSKERNEL) + +# CPU Architecture +SET (CUSTOM_ARCHITECTURE "" CACHE STRING "Specify custom target architecutre") +SET (ARCHITECTURE "${CUSTOM_ARCHITECTURE}") +IF (ARCHITECTURE STREQUAL "") + # SET (ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}") + # SET (ARCHITECTURE "${CMAKE_HOST_SYSTEM_PROCESSOR}") + EXECUTE_PROCESS(COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE) + + # Replacements + STRING (REGEX REPLACE "^x86_64$" "amd64" ARCHITECTURE "${ARCHITECTURE}") + STRING (REGEX REPLACE "^i.86$" "i386" ARCHITECTURE "${ARCHITECTURE}") + STRING (REGEX REPLACE "^armv7l$" "armel" ARCHITECTURE "${ARCHITECTURE}") + +ENDIF () +MESSAGE ("ARCHITECTURE = ${ARCHITECTURE}") diff --git a/FindVala.cmake b/FindVala.cmake new file mode 100644 index 0000000..c8854ce --- /dev/null +++ b/FindVala.cmake @@ -0,0 +1,69 @@ +## +# Find module for the Vala compiler (valac) +# +# This module determines wheter a Vala compiler is installed on the current +# system and where its executable is. +# +# Call the module using "find_package(Vala) from within your CMakeLists.txt. +# +# The following variables will be set after an invocation: +# +# VALA_FOUND Whether the vala compiler has been found or not +# VALA_EXECUTABLE Full path to the valac executable if it has been found +# VALA_VERSION Version number of the available valac +# VALA_USE_FILE Include this file to define the vala_precompile function +## + +## +# Copyright 2009-2010 Jakob Westhoff. All rights reserved. +# Copyright 2010-2011 Daniel Pfeifer +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +# EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# The views and conclusions contained in the software and documentation are those +# of the authors and should not be interpreted as representing official policies, +# either expressed or implied, of Jakob Westhoff +## + +# Search for the valac executable in the usual system paths. +find_program(VALA_EXECUTABLE valac) +mark_as_advanced(VALA_EXECUTABLE) + +# Determine the valac version +if(VALA_EXECUTABLE) + execute_process(COMMAND ${VALA_EXECUTABLE} "--version" + OUTPUT_VARIABLE VALA_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REPLACE "Vala " "" VALA_VERSION "${VALA_VERSION}") +endif(VALA_EXECUTABLE) + +# Handle the QUIETLY and REQUIRED arguments, which may be given to the find call. +# Furthermore set VALA_FOUND to TRUE if Vala has been found (aka. +# VALA_EXECUTABLE is set) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Vala + REQUIRED_VARS VALA_EXECUTABLE + VERSION_VAR VALA_VERSION) + +set(VALA_USE_FILE "${CMAKE_CURRENT_LIST_DIR}/UseVala.cmake") + diff --git a/MacroOptionalAddSubdirectory.cmake b/MacroOptionalAddSubdirectory.cmake new file mode 100644 index 0000000..545048b --- /dev/null +++ b/MacroOptionalAddSubdirectory.cmake @@ -0,0 +1,31 @@ +# - MACRO_OPTIONAL_ADD_SUBDIRECTORY() combines ADD_SUBDIRECTORY() with an OPTION() +# MACRO_OPTIONAL_ADD_SUBDIRECTORY( ) +# If you use MACRO_OPTIONAL_ADD_SUBDIRECTORY() instead of ADD_SUBDIRECTORY(), +# this will have two effects +# 1 - CMake will not complain if the directory doesn't exist +# This makes sense if you want to distribute just one of the subdirs +# in a source package, e.g. just one of the subdirs in kdeextragear. +# 2 - If the directory exists, it will offer an option to skip the +# subdirectory. +# This is useful if you want to compile only a subset of all +# directories. + +# Copyright (c) 2007, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY _dir ) + GET_FILENAME_COMPONENT(_fullPath ${_dir} ABSOLUTE) + IF(EXISTS ${_fullPath}) + IF(${ARGC} EQUAL 2) + OPTION(BUILD_${_dir} "Build directory ${_dir}" ${ARGV1}) + ELSE(${ARGC} EQUAL 2) + OPTION(BUILD_${_dir} "Build directory ${_dir}" TRUE) + ENDIF(${ARGC} EQUAL 2) + IF(BUILD_${_dir}) + ADD_SUBDIRECTORY(${_dir}) + ENDIF(BUILD_${_dir}) + ENDIF(EXISTS ${_fullPath}) +ENDMACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY) diff --git a/README b/README new file mode 100644 index 0000000..ddd7ab4 --- /dev/null +++ b/README @@ -0,0 +1 @@ +Backbone's CMake scripts. diff --git a/UseVala.cmake b/UseVala.cmake new file mode 100644 index 0000000..436d1d0 --- /dev/null +++ b/UseVala.cmake @@ -0,0 +1,180 @@ +## +# Compile vala files to their c equivalents for further processing. +# +# The "vala_precompile" function takes care of calling the valac executable on +# the given source to produce c files which can then be processed further using +# default cmake functions. +# +# The first parameter provided is a variable, which will be filled with a list +# of c files outputted by the vala compiler. This list can than be used in +# conjuction with functions like "add_executable" or others to create the +# neccessary compile rules with CMake. +# +# The following sections may be specified afterwards to provide certain options +# to the vala compiler: +# +# SOURCES +# A list of .vala files to be compiled. Please take care to add every vala +# file belonging to the currently compiled project or library as Vala will +# otherwise not be able to resolve all dependencies. +# +# PACKAGES +# A list of vala packages/libraries to be used during the compile cycle. The +# package names are exactly the same, as they would be passed to the valac +# "--pkg=" option. +# +# OPTIONS +# A list of optional options to be passed to the valac executable. This can be +# used to pass "--thread" for example to enable multi-threading support. +# +# CUSTOM_VAPIS +# A list of custom vapi files to be included for compilation. This can be +# useful to include freshly created vala libraries without having to install +# them in the system. +# +# GENERATE_VAPI +# Pass all the needed flags to the compiler to create an internal vapi for +# the compiled library. The provided name will be used for this and a +# .vapi file will be created. +# +# GENERATE_HEADER +# Let the compiler generate a header file for the compiled code. There will +# be a header file as well as an internal header file being generated called +# .h and _internal.h +# +# The following call is a simple example to the vala_precompile macro showing +# an example to every of the optional sections: +# +# find_package(Vala "0.12" REQUIRED) +# inlcude(${VALA_USE_FILE}) +# +# vala_precompile(VALA_C +# SOURCES +# source1.vala +# source2.vala +# source3.vala +# PACKAGES +# gtk+-2.0 +# gio-1.0 +# posix +# DIRECTORY +# gen +# OPTIONS +# --thread +# CUSTOM_VAPIS +# some_vapi.vapi +# GENERATE_VAPI +# myvapi +# GENERATE_HEADER +# myheader +# ) +# +# Most important is the variable VALA_C which will contain all the generated c +# file names after the call. +## + +## +# Copyright 2009-2010 Jakob Westhoff. All rights reserved. +# Copyright 2010-2011 Daniel Pfeifer +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +# EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# The views and conclusions contained in the software and documentation are those +# of the authors and should not be interpreted as representing official policies, +# either expressed or implied, of Jakob Westhoff +## + +include(CMakeParseArguments) + +function(vala_precompile output) + cmake_parse_arguments(ARGS "" "DIRECTORY;GENERATE_HEADER;GENERATE_VAPI" + "SOURCES;PACKAGES;OPTIONS;CUSTOM_VAPIS" ${ARGN}) + + if(ARGS_DIRECTORY) + set(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ARGS_DIRECTORY}) + else(ARGS_DIRECTORY) + set(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif(ARGS_DIRECTORY) + include_directories(${DIRECTORY}) + set(vala_pkg_opts "") + foreach(pkg ${ARGS_PACKAGES}) + list(APPEND vala_pkg_opts "--pkg=${pkg}") + endforeach(pkg ${ARGS_PACKAGES}) + set(in_files "") + set(out_files "") + foreach(src ${ARGS_SOURCES} ${ARGS_UNPARSED_ARGUMENTS}) + list(APPEND in_files "${CMAKE_CURRENT_SOURCE_DIR}/${src}") + string(REPLACE ".vala" ".c" src ${src}) + string(REPLACE ".gs" ".c" src ${src}) + set(out_file "${DIRECTORY}/${src}") + list(APPEND out_files "${DIRECTORY}/${src}") + endforeach(src ${ARGS_SOURCES} ${ARGS_UNPARSED_ARGUMENTS}) + + set(custom_vapi_arguments "") + if(ARGS_CUSTOM_VAPIS) + foreach(vapi ${ARGS_CUSTOM_VAPIS}) + if(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) + list(APPEND custom_vapi_arguments ${vapi}) + else (${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) + list(APPEND custom_vapi_arguments ${CMAKE_CURRENT_SOURCE_DIR}/${vapi}) + endif(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) + endforeach(vapi ${ARGS_CUSTOM_VAPIS}) + endif(ARGS_CUSTOM_VAPIS) + + set(vapi_arguments "") + if(ARGS_GENERATE_VAPI) + list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_VAPI}.vapi") + set(vapi_arguments "--internal-vapi=${ARGS_GENERATE_VAPI}.vapi") + + # Header and internal header is needed to generate internal vapi + if (NOT ARGS_GENERATE_HEADER) + set(ARGS_GENERATE_HEADER ${ARGS_GENERATE_VAPI}) + endif(NOT ARGS_GENERATE_HEADER) + endif(ARGS_GENERATE_VAPI) + + set(header_arguments "") + if(ARGS_GENERATE_HEADER) + list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_HEADER}.h") + list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_HEADER}_internal.h") + list(APPEND header_arguments "--header=${DIRECTORY}/${ARGS_GENERATE_HEADER}.h") + list(APPEND header_arguments "--internal-header=${DIRECTORY}/${ARGS_GENERATE_HEADER}_internal.h") + endif(ARGS_GENERATE_HEADER) + + add_custom_command(OUTPUT ${out_files} + COMMAND + ${VALA_EXECUTABLE} + ARGS + "-C" + ${header_arguments} + ${vapi_arguments} + "-b" ${CMAKE_CURRENT_SOURCE_DIR} + "-d" ${DIRECTORY} + ${vala_pkg_opts} + ${ARGS_OPTIONS} + ${in_files} + ${custom_vapi_arguments} + DEPENDS + ${in_files} + ${ARGS_CUSTOM_VAPIS} + ) + set(${output} ${out_files} PARENT_SCOPE) +endfunction(vala_precompile) diff --git a/ValaBinCommonRules.cmake b/ValaBinCommonRules.cmake new file mode 100644 index 0000000..45fedcd --- /dev/null +++ b/ValaBinCommonRules.cmake @@ -0,0 +1,18 @@ +INCLUDE (FindVala) +INCLUDE (UseVala) +INCLUDE (CFlags) +FIND_PACKAGE (PkgConfig REQUIRED) + +SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/run") # Avoid of "dll not found" messages + +VALA_PRECOMPILE (VALA_C ${BinSources} + PACKAGES ${BinPackages} + OPTIONS --thread ${VALA_DEBUG} + CUSTOM_VAPIS ${BinCustomVapis} + GENERATE_VAPI + GENERATE_HEADER + ) +PKG_CHECK_MODULES (PKGS REQUIRED ${BinPackages}) +INCLUDE_DIRECTORIES (${PKGS_INCLUDE_DIRS}) +ADD_EXECUTABLE (${BinName} ${VALA_C} ${BinExtraSources}) +TARGET_LINK_LIBRARIES (${BinName} ${PKGS_LIBRARIES} ${BinLinkLibs}) diff --git a/ValaLibCommonRules.cmake b/ValaLibCommonRules.cmake new file mode 100644 index 0000000..e67f499 --- /dev/null +++ b/ValaLibCommonRules.cmake @@ -0,0 +1,39 @@ +INCLUDE (FindVala) +INCLUDE (UseVala) +INCLUDE (CFlags) +FIND_PACKAGE (PkgConfig REQUIRED) + +IF (WIN32) + SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/run") # Avoid of "dll not found" messages +ENDIF (WIN32) + +VALA_PRECOMPILE (VALA_C ${LibSources} + PACKAGES ${LibPackages} + OPTIONS --thread ${VALA_DEBUG} --vapi=${LibName}-${MAJOR}.vapi + CUSTOM_VAPIS ${LibCustomVapis} + GENERATE_VAPI + GENERATE_HEADER ${LibName}-${MAJOR} + ) +PKG_CHECK_MODULES (PKGS REQUIRED ${LibPackages}) +INCLUDE_DIRECTORIES (${PKGS_INCLUDE_DIRS}) +ADD_LIBRARY (${LibName} SHARED ${VALA_C} ${LibExtraSources}) +TARGET_LINK_LIBRARIES (${LibName} ${PKGS_LIBRARIES} ${LibLinkLibs}) +SET_TARGET_PROPERTIES (${LibName} PROPERTIES VERSION ${MAJOR}.${MINOR}.${PATCH}) +SET_TARGET_PROPERTIES (${LibName} PROPERTIES SOVERSION ${MAJOR}) +IF (WIN32) + SET_TARGET_PROPERTIES (${LibName} PROPERTIES PREFIX "" IMPORT_PREFIX "" + SUFFIX "-${MAJOR}.dll" IMPORT_SUFFIX "-${MAJOR}.a") +ENDIF (WIN32) + +IF (LibInstall) + IF (UNIX) + INSTALL (TARGETS ${LibName} DESTINATION lib) + ELSEIF (WIN32) + INSTALL (TARGETS ${LibName} + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) + ENDIF (UNIX) + INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${LibName}-${MAJOR}.h DESTINATION include) + INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${LibName}-${MAJOR}.vapi DESTINATION share/vala/vapi) +ENDIF (LibInstall) diff --git a/ValaPluginCommonRules.cmake b/ValaPluginCommonRules.cmake new file mode 100644 index 0000000..1a71fa1 --- /dev/null +++ b/ValaPluginCommonRules.cmake @@ -0,0 +1,16 @@ +INCLUDE (FindVala) +INCLUDE (UseVala) +INCLUDE (CFlags) +FIND_PACKAGE (PkgConfig REQUIRED) + +VALA_PRECOMPILE (VALA_C ${PluginSources} + PACKAGES ${PluginPackages} + OPTIONS --thread ${VALA_DEBUG} + CUSTOM_VAPIS ${PluginCustomVapis} + GENERATE_VAPI + GENERATE_HEADER + ) +PKG_CHECK_MODULES (PKGS REQUIRED ${PluginPackages}) +INCLUDE_DIRECTORIES (${PKGS_INCLUDE_DIRS}) +ADD_LIBRARY (${PluginName} SHARED ${VALA_C} ${PluginExtraSources}) +TARGET_LINK_LIBRARIES (${PluginName} ${PKGS_LIBRARIES} ${PluginLinkLibs})