kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/FindRuby.cmake

276 lines
10 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 22:01:08 +03:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#.rst:
# FindRuby
# --------
#
# Find Ruby
#
# This module finds if Ruby is installed and determines where the
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
# include files and libraries are. Ruby 1.8, 1.9, 2.0 and 2.1 are
# supported.
Improved version checking for FindRuby using the new mode of FPHSA() Alex
2010-08-08 00:08:51 +04:00
#
# The minimum required version of Ruby can be specified using the
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# standard syntax, e.g. find_package(Ruby 1.8)
#
# It also determines what the name of the library is. This code sets
# the following variables:
#
Modules: Format documentation to avoid over-long preformatted lines Convert several preformatted code block literals that enumerate lists of options or variables to use reST definition lists instead. Manually wrap other long lines in code blocks.
2014-10-22 23:52:31 +04:00
# ``RUBY_EXECUTABLE``
# full path to the ruby binary
# ``RUBY_INCLUDE_DIRS``
# include dirs to be used when using the ruby library
# ``RUBY_LIBRARY``
# full path to the ruby library
# ``RUBY_VERSION``
# the version of ruby which was found, e.g. "1.8.7"
# ``RUBY_FOUND``
# set to true if ruby ws found successfully
#
# Also:
#
# ``RUBY_INCLUDE_PATH``
# same as RUBY_INCLUDE_DIRS, only provided for compatibility reasons, don't use it
ENH: Initial import of swig. Start working towards Bug #749 - Add swig support module to cmake
2004-04-30 20:11:02 +04:00
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
# RUBY_ARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",Config::CONFIG@<:@"archdir"@:>@)'`
# RUBY_SITEARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",Config::CONFIG@<:@"sitearchdir"@:>@)'`
# RUBY_SITEDIR=`$RUBY -r rbconfig -e 'printf("%s",Config::CONFIG@<:@"sitelibdir"@:>@)'`
# RUBY_LIBDIR=`$RUBY -r rbconfig -e 'printf("%s",Config::CONFIG@<:@"libdir"@:>@)'`
# RUBY_LIBRUBYARG=`$RUBY -r rbconfig -e 'printf("%s",Config::CONFIG@<:@"LIBRUBYARG_SHARED"@:>@)'`
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# uncomment the following line to get debug output for this file
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
# set(_RUBY_DEBUG_OUTPUT TRUE)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# Determine the list of possible names of the ruby executable depending
# on which version of ruby is required
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(_RUBY_POSSIBLE_EXECUTABLE_NAMES ruby)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# if 1.9 is required, don't look for ruby18 and ruby1.8, default to version 1.8
FindRuby: fix selection of version x.0 (#15345) When "Ruby_FIND_VERSION_MINOR" is 0, the "if(Ruby_FIND_VERSION_MAJOR AND Ruby_FIND_VERSION_MINOR)" check evaluated to false.
2015-01-12 21:28:02 +03:00
if(DEFINED Ruby_FIND_VERSION_MAJOR AND DEFINED Ruby_FIND_VERSION_MINOR)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(Ruby_FIND_VERSION_SHORT_NODOT "${Ruby_FIND_VERSION_MAJOR}${RUBY_FIND_VERSION_MINOR}")
FindRuby: improve version selection This will stop e.g. looking for a ruby1.9 executable first if "1.8 EXACT" was given.
2013-03-18 23:17:08 +04:00
# we can't construct that if only major version is given
set(_RUBY_POSSIBLE_EXECUTABLE_NAMES
ruby${Ruby_FIND_VERSION_MAJOR}.${Ruby_FIND_VERSION_MINOR}
ruby${Ruby_FIND_VERSION_MAJOR}${Ruby_FIND_VERSION_MINOR}
${_RUBY_POSSIBLE_EXECUTABLE_NAMES})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(Ruby_FIND_VERSION_SHORT_NODOT "18")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
FindRuby: improve version selection This will stop e.g. looking for a ruby1.9 executable first if "1.8 EXACT" was given.
2013-03-18 23:17:08 +04:00
if(NOT Ruby_FIND_VERSION_EXACT)
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
list(APPEND _RUBY_POSSIBLE_EXECUTABLE_NAMES ruby2.1 ruby21)
list(APPEND _RUBY_POSSIBLE_EXECUTABLE_NAMES ruby2.0 ruby20)
FindRuby: improve version selection This will stop e.g. looking for a ruby1.9 executable first if "1.8 EXACT" was given.
2013-03-18 23:17:08 +04:00
list(APPEND _RUBY_POSSIBLE_EXECUTABLE_NAMES ruby1.9 ruby19)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
FindRuby: improve version selection This will stop e.g. looking for a ruby1.9 executable first if "1.8 EXACT" was given.
2013-03-18 23:17:08 +04:00
# if we want a version below 1.9, also look for ruby 1.8
if("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
list(APPEND _RUBY_POSSIBLE_EXECUTABLE_NAMES ruby1.8 ruby18)
endif()
list(REMOVE_DUPLICATES _RUBY_POSSIBLE_EXECUTABLE_NAMES)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(RUBY_EXECUTABLE NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES})
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(RUBY_EXECUTABLE AND NOT RUBY_VERSION_MAJOR)
function(_RUBY_CONFIG_VAR RBVAR OUTVAR)
execute_process(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['${RBVAR}']"
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
RESULT_VARIABLE _RUBY_SUCCESS
OUTPUT_VARIABLE _RUBY_OUTPUT
ERROR_QUIET)
FindRuby: Fix output check in _RUBY_CONFIG_VAR Since commit v2.8.8~173^2 (FindRuby: clean up querying variables from Ruby, 2012-02-17) we query RbConfig::CONFIG first and, if the command fails or its output equates to a false constant, then fall back to querying Config::CONFIG. Due to the above, an error condition exists with Ruby 2.2.0; when querying RbConfig::CONFIG['TEENY'], the output of '0' will be discarded since it matches the false constant '0'. In previous versions this wasn't a problem, but Ruby 2.2 has completely removed Config::CONFIG. This causes RUBY_VERSION_PATCH to be set to an empty string and the Ruby version to be detected as '2.2.' (instead of '2.2.0'). Fix the output check to explicitly look for an empty string before using the fallback query method. (Someone more familiar with Ruby might be able to deem the fallback as unnecessary and fully remove it.)
2014-12-29 20:02:04 +03:00
if(_RUBY_SUCCESS OR _RUBY_OUTPUT STREQUAL "")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
execute_process(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print Config::CONFIG['${RBVAR}']"
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
RESULT_VARIABLE _RUBY_SUCCESS
OUTPUT_VARIABLE _RUBY_OUTPUT
ERROR_QUIET)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(${OUTVAR} "${_RUBY_OUTPUT}" PARENT_SCOPE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endfunction()
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
# query the ruby version
_RUBY_CONFIG_VAR("MAJOR" RUBY_VERSION_MAJOR)
_RUBY_CONFIG_VAR("MINOR" RUBY_VERSION_MINOR)
_RUBY_CONFIG_VAR("TEENY" RUBY_VERSION_PATCH)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# query the different directories
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
_RUBY_CONFIG_VAR("archdir" RUBY_ARCH_DIR)
_RUBY_CONFIG_VAR("arch" RUBY_ARCH)
_RUBY_CONFIG_VAR("rubyhdrdir" RUBY_HDR_DIR)
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
_RUBY_CONFIG_VAR("rubyarchhdrdir" RUBY_ARCHHDR_DIR)
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
_RUBY_CONFIG_VAR("libdir" RUBY_POSSIBLE_LIB_DIR)
_RUBY_CONFIG_VAR("rubylibdir" RUBY_RUBY_LIB_DIR)
ENH: add more ruby paths: sitearch, sitelib, vendorarch, vendorlib (#5531) -make these variables cached and ADVANCED -remove unused QUIETLY code -document RUBY_LIBRARY Alex
2008-01-02 20:32:17 +03:00
# site_ruby
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
_RUBY_CONFIG_VAR("sitearchdir" RUBY_SITEARCH_DIR)
_RUBY_CONFIG_VAR("sitelibdir" RUBY_SITELIB_DIR)
ENH: add more ruby paths: sitearch, sitelib, vendorarch, vendorlib (#5531) -make these variables cached and ADVANCED -remove unused QUIETLY code -document RUBY_LIBRARY Alex
2008-01-02 20:32:17 +03:00
# vendor_ruby available ?
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
execute_process(COMMAND ${RUBY_EXECUTABLE} -r vendor-specific -e "print 'true'"
ENH: add more ruby paths: sitearch, sitelib, vendorarch, vendorlib (#5531) -make these variables cached and ADVANCED -remove unused QUIETLY code -document RUBY_LIBRARY Alex
2008-01-02 20:32:17 +03:00
OUTPUT_VARIABLE RUBY_HAS_VENDOR_RUBY ERROR_QUIET)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(RUBY_HAS_VENDOR_RUBY)
FindRuby: clean up querying variables from Ruby Newer Ruby versions (from 1.9 onward) seem to warn if you query Config::CONFIG and print a warning to use RbConfig instead. RbConfig seems to also work in older versions, at least in 1.8. Use a macro to query RbConfig first and only if that doesn't give anything fall back to Config.
2012-02-17 21:06:07 +04:00
_RUBY_CONFIG_VAR("vendorlibdir" RUBY_VENDORLIB_DIR)
_RUBY_CONFIG_VAR("vendorarchdir" RUBY_VENDORARCH_DIR)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
ENH: add more ruby paths: sitearch, sitelib, vendorarch, vendorlib (#5531) -make these variables cached and ADVANCED -remove unused QUIETLY code -document RUBY_LIBRARY Alex
2008-01-02 20:32:17 +03:00
# save the results in the cache so we don't have to run ruby the next time again
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_VERSION_MAJOR ${RUBY_VERSION_MAJOR} CACHE PATH "The Ruby major version" FORCE)
set(RUBY_VERSION_MINOR ${RUBY_VERSION_MINOR} CACHE PATH "The Ruby minor version" FORCE)
set(RUBY_VERSION_PATCH ${RUBY_VERSION_PATCH} CACHE PATH "The Ruby patch version" FORCE)
set(RUBY_ARCH_DIR ${RUBY_ARCH_DIR} CACHE PATH "The Ruby arch dir" FORCE)
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
set(RUBY_HDR_DIR ${RUBY_HDR_DIR} CACHE PATH "The Ruby header dir (1.9+)" FORCE)
set(RUBY_ARCHHDR_DIR ${RUBY_ARCHHDR_DIR} CACHE PATH "The Ruby arch header dir (2.0+)" FORCE)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_POSSIBLE_LIB_DIR ${RUBY_POSSIBLE_LIB_DIR} CACHE PATH "The Ruby lib dir" FORCE)
set(RUBY_RUBY_LIB_DIR ${RUBY_RUBY_LIB_DIR} CACHE PATH "The Ruby ruby-lib dir" FORCE)
set(RUBY_SITEARCH_DIR ${RUBY_SITEARCH_DIR} CACHE PATH "The Ruby site arch dir" FORCE)
set(RUBY_SITELIB_DIR ${RUBY_SITELIB_DIR} CACHE PATH "The Ruby site lib dir" FORCE)
set(RUBY_HAS_VENDOR_RUBY ${RUBY_HAS_VENDOR_RUBY} CACHE BOOL "Vendor Ruby is available" FORCE)
set(RUBY_VENDORARCH_DIR ${RUBY_VENDORARCH_DIR} CACHE PATH "The Ruby vendor arch dir" FORCE)
set(RUBY_VENDORLIB_DIR ${RUBY_VENDORLIB_DIR} CACHE PATH "The Ruby vendor lib dir" FORCE)
mark_as_advanced(
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
RUBY_ARCH_DIR
RUBY_ARCH
RUBY_HDR_DIR
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
RUBY_ARCHHDR_DIR
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
RUBY_POSSIBLE_LIB_DIR
RUBY_RUBY_LIB_DIR
RUBY_SITEARCH_DIR
RUBY_SITELIB_DIR
RUBY_HAS_VENDOR_RUBY
RUBY_VENDORARCH_DIR
RUBY_VENDORLIB_DIR
RUBY_VERSION_MAJOR
RUBY_VERSION_MINOR
RUBY_VERSION_PATCH
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
Remove trailing whitespace Alex
2011-10-13 01:05:30 +04:00
# In case RUBY_EXECUTABLE could not be executed (e.g. cross compiling)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# try to detect which version we found. This is not too good.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(RUBY_EXECUTABLE AND NOT RUBY_VERSION_MAJOR)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# by default assume 1.8.0
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_VERSION_MAJOR 1)
set(RUBY_VERSION_MINOR 8)
set(RUBY_VERSION_PATCH 0)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# check whether we found 1.9.x
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
if(${RUBY_EXECUTABLE} MATCHES "ruby1.?9")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_VERSION_MAJOR 1)
set(RUBY_VERSION_MINOR 9)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
# check whether we found 2.0.x
if(${RUBY_EXECUTABLE} MATCHES "ruby2.?0")
set(RUBY_VERSION_MAJOR 2)
set(RUBY_VERSION_MINOR 0)
endif()
# check whether we found 2.1.x
if(${RUBY_EXECUTABLE} MATCHES "ruby2.?1")
set(RUBY_VERSION_MAJOR 2)
set(RUBY_VERSION_MINOR 1)
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(RUBY_VERSION_MAJOR)
set(RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}")
set(_RUBY_VERSION_SHORT "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}")
set(_RUBY_VERSION_SHORT_NODOT "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}")
set(_RUBY_NODOT_VERSION "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_path(RUBY_INCLUDE_DIR
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
NAMES ruby.h
use HINTS instead of PATHS and also look for libruby-static.a (which is built by default) Alex
2009-09-12 12:38:11 +04:00
HINTS
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
${RUBY_HDR_DIR}
ENH: apply patch so that the config values from ruby are used to determine the additional locations (see #3297) Alex
2006-10-04 23:54:25 +04:00
${RUBY_ARCH_DIR}
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
/usr/lib/ruby/${_RUBY_VERSION_SHORT}/i586-linux-gnu/ )
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR} )
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( "${Ruby_FIND_VERSION_SHORT_NODOT}" GREATER 18 OR "${_RUBY_VERSION_SHORT_NODOT}" GREATER 18 OR RUBY_HDR_DIR)
find_path(RUBY_CONFIG_INCLUDE_DIR
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
NAMES ruby/config.h config.h
Remove trailing whitespace Alex
2011-10-13 01:05:30 +04:00
HINTS
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
${RUBY_HDR_DIR}/${RUBY_ARCH}
Remove trailing whitespace Alex
2011-10-13 01:05:30 +04:00
${RUBY_ARCH_DIR}
FindRuby: Add support for Ruby 2.0 and 2.1 The most significant change since Ruby 1.9 is the changed path of config.h, from RbConfig::CONFIG['rubyhdrdir'] to RbConfig::CONFIG['rubyarchhdrdir'].
2014-02-28 17:12:18 +04:00
${RUBY_ARCHHDR_DIR}
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR} )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# Determine the list of possible names for the ruby library
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(_RUBY_POSSIBLE_LIB_NAMES ruby ruby-static ruby${_RUBY_VERSION_SHORT} ruby${_RUBY_VERSION_SHORT_NODOT} ruby-${_RUBY_VERSION_SHORT} ruby-${RUBY_VERSION})
if(WIN32)
set( _RUBY_MSVC_RUNTIME "" )
if( MSVC60 )
set( _RUBY_MSVC_RUNTIME "60" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( MSVC70 )
set( _RUBY_MSVC_RUNTIME "70" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( MSVC71 )
set( _RUBY_MSVC_RUNTIME "71" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( MSVC80 )
set( _RUBY_MSVC_RUNTIME "80" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( MSVC90 )
set( _RUBY_MSVC_RUNTIME "90" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
FindRuby: Fix finding 64-bit Ruby on Windows Ruby 2.0.0 and 2.1.5 have 64-bit binaries for Windows, with "x64-" prefix.
2015-02-06 23:21:51 +03:00
set(_RUBY_ARCH_PREFIX "")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(_RUBY_ARCH_PREFIX "x64-")
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND _RUBY_POSSIBLE_LIB_NAMES
FindRuby: Fix finding 64-bit Ruby on Windows Ruby 2.0.0 and 2.1.5 have 64-bit binaries for Windows, with "x64-" prefix.
2015-02-06 23:21:51 +03:00
"${_RUBY_ARCH_PREFIX}msvcr${_RUBY_MSVC_RUNTIME}-ruby${_RUBY_NODOT_VERSION}"
"${_RUBY_ARCH_PREFIX}msvcr${_RUBY_MSVC_RUNTIME}-ruby${_RUBY_NODOT_VERSION}-static"
"${_RUBY_ARCH_PREFIX}msvcrt-ruby${_RUBY_NODOT_VERSION}"
"${_RUBY_ARCH_PREFIX}msvcrt-ruby${_RUBY_NODOT_VERSION}-static" )
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_library(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR} )
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
set(_RUBY_REQUIRED_VARS RUBY_EXECUTABLE RUBY_INCLUDE_DIR RUBY_LIBRARY)
if(_RUBY_VERSION_SHORT_NODOT GREATER 18)
list(APPEND _RUBY_REQUIRED_VARS RUBY_CONFIG_INCLUDE_DIR)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(_RUBY_DEBUG_OUTPUT)
message(STATUS "--------FindRuby.cmake debug------------")
message(STATUS "_RUBY_POSSIBLE_EXECUTABLE_NAMES: ${_RUBY_POSSIBLE_EXECUTABLE_NAMES}")
message(STATUS "_RUBY_POSSIBLE_LIB_NAMES: ${_RUBY_POSSIBLE_LIB_NAMES}")
message(STATUS "RUBY_ARCH_DIR: ${RUBY_ARCH_DIR}")
message(STATUS "RUBY_HDR_DIR: ${RUBY_HDR_DIR}")
message(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")
message(STATUS "Found RUBY_VERSION: \"${RUBY_VERSION}\" , short: \"${_RUBY_VERSION_SHORT}\", nodot: \"${_RUBY_VERSION_SHORT_NODOT}\"")
message(STATUS "_RUBY_REQUIRED_VARS: ${_RUBY_REQUIRED_VARS}")
message(STATUS "RUBY_EXECUTABLE: ${RUBY_EXECUTABLE}")
message(STATUS "RUBY_LIBRARY: ${RUBY_LIBRARY}")
message(STATUS "RUBY_INCLUDE_DIR: ${RUBY_INCLUDE_DIR}")
message(STATUS "RUBY_CONFIG_INCLUDE_DIR: ${RUBY_CONFIG_INCLUDE_DIR}")
message(STATUS "--------------------")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
Improved version checking for FindRuby using the new mode of FPHSA() Alex
2010-08-08 00:08:51 +04:00
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Ruby REQUIRED_VARS ${_RUBY_REQUIRED_VARS}
VERSION_VAR RUBY_VERSION )
ENH: Initial import of swig. Start working towards Bug #749 - Add swig support module to cmake
2004-04-30 20:11:02 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(
ENH: Initial import of swig. Start working towards Bug #749 - Add swig support module to cmake
2004-04-30 20:11:02 +04:00
RUBY_EXECUTABLE
RUBY_LIBRARY
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
RUBY_INCLUDE_DIR
RUBY_CONFIG_INCLUDE_DIR
ENH: Initial import of swig. Start working towards Bug #749 - Add swig support module to cmake
2004-04-30 20:11:02 +04:00
)
major improvement of FindRuby.cmake -now supports specifying minimum required version -now supports ruby 1.8 and 1.9 -uses find_package_handle_standard_args() now -fix #6212 and using a lot of ideas from the file attached there Alex
2009-09-12 14:25:58 +04:00
# Set some variables for compatibility with previous version of this file
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(RUBY_POSSIBLE_LIB_PATH ${RUBY_POSSIBLE_LIB_DIR})
set(RUBY_RUBY_LIB_PATH ${RUBY_RUBY_LIB_DIR})
set(RUBY_INCLUDE_PATH ${RUBY_INCLUDE_DIRS})