[cmake] Cosmetics: change project/cmake/scripts/* commands to lowercase

8 files changed, 272 insertions, 272 deletions

diff --git a/project/cmake/scripts/common/AddOptions.cmake b/project/cmake/scripts/common/AddOptions.cmake
index 0ebb823666..88a28faf8f 100644
--- a/project/cmake/scripts/common/AddOptions.cmake
+++ b/project/cmake/scripts/common/AddOptions.cmake
@@ -23,60 +23,60 @@
 #
 #	add_options (CXX RELEASE "-O3" "-DNDEBUG" "-Wall")
 
-function (add_options langs builds)
+function(add_options langs builds)
   # special handling of empty language specification
-  if ("${langs}" STREQUAL "ALL_LANGUAGES")
-	set (langs CXX C Fortran)
-  endif ("${langs}" STREQUAL "ALL_LANGUAGES")
-  foreach (lang IN LISTS langs)
+  if("${langs}" STREQUAL "ALL_LANGUAGES")
+	set(langs CXX C Fortran)
+  endif("${langs}" STREQUAL "ALL_LANGUAGES")
+  foreach(lang IN LISTS langs)
 	# prepend underscore if necessary
-	foreach (build IN LISTS builds)
-	  if (NOT ("${build}" STREQUAL "ALL_BUILDS"))
-		set (_bld "_${build}")
-		string (TOUPPER "${_bld}" _bld)
-	  else (NOT ("${build}" STREQUAL "ALL_BUILDS"))
-		set (_bld "")
-	  endif (NOT ("${build}" STREQUAL "ALL_BUILDS"))
-	  foreach (_opt IN LISTS ARGN)
-		set (_var "CMAKE_${lang}_FLAGS${_bld}")
-		#message (STATUS "Adding \"${_opt}\" to \${${_var}}")
+	foreach(build IN LISTS builds)
+	  if(NOT ("${build}" STREQUAL "ALL_BUILDS"))
+		set(_bld "_${build}")
+		string(TOUPPER "${_bld}" _bld)
+	  else(NOT ("${build}" STREQUAL "ALL_BUILDS"))
+		set(_bld "")
+	  endif(NOT ("${build}" STREQUAL "ALL_BUILDS"))
+	  foreach(_opt IN LISTS ARGN)
+		set(_var "CMAKE_${lang}_FLAGS${_bld}")
+		#message(STATUS "Adding \"${_opt}\" to \${${_var}}")
 		# remove it first
-		string (REPLACE "${_opt}" "" _without "${${_var}}")
-		string (STRIP "${_without}" _without)
+		string(REPLACE "${_opt}" "" _without "${${_var}}")
+		string(STRIP "${_without}" _without)
 		# we need to strip this one as well, so they are comparable
-		string (STRIP "${${_var}}" _stripped)
+		string(STRIP "${${_var}}" _stripped)
 		# if it wasn't there, then add it at the end
-		if ("${_without}" STREQUAL "${_stripped}")
+		if("${_without}" STREQUAL "${_stripped}")
 		  # don't add any extra spaces if no options yet are set
-		  if (NOT ${_stripped} STREQUAL "")
-			set (${_var} "${_stripped} ${_opt}")
-		  else (NOT ${_stripped} STREQUAL "")
-			set (${_var} "${_opt}")
-		  endif (NOT ${_stripped} STREQUAL "")
-		  set (${_var} "${${_var}}" PARENT_SCOPE)
-		endif ("${_without}" STREQUAL "${_stripped}")
-	  endforeach (_opt)
-	endforeach (build)
-  endforeach (lang)
-endfunction (add_options lang build)
+		  if(NOT ${_stripped} STREQUAL "")
+			set(${_var} "${_stripped} ${_opt}")
+		  else(NOT ${_stripped} STREQUAL "")
+			set(${_var} "${_opt}")
+		  endif(NOT ${_stripped} STREQUAL "")
+		  set(${_var} "${${_var}}" PARENT_SCOPE)
+		endif("${_without}" STREQUAL "${_stripped}")
+	  endforeach(_opt)
+	endforeach(build)
+  endforeach(lang)
+endfunction(add_options lang build)
 
 # set varname to flag unless user has specified something that matches regex
-function (set_default_option varname flag regex)
-  if (NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
+function(set_default_option varname flag regex)
+  if(NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
 	  AND NOT "${CMAKE_CXX_FLAGS}" MATCHES "${regex}"
 	  AND NOT "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}" MATCHES "${regex}")
-	set (${varname} ${flag} PARENT_SCOPE)
-  else (NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
+	set(${varname} ${flag} PARENT_SCOPE)
+  else(NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
 	  AND NOT "${CMAKE_CXX_FLAGS}" MATCHES "${regex}"
 	  AND NOT "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}" MATCHES "${regex}")
-	set (${varname} PARENT_SCOPE)
-  endif (NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
+	set(${varname} PARENT_SCOPE)
+  endif(NOT "$ENV{CXXFLAGS}" MATCHES "${regex}"
 	AND NOT "${CMAKE_CXX_FLAGS}" MATCHES "${regex}"
 	AND NOT "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}" MATCHES "${regex}")
-endfunction (set_default_option)
+endfunction(set_default_option)
 
 # note: this must be called before project()
-macro (no_default_options)
+macro(no_default_options)
   # prevent the platform probe to set options
-  set (CMAKE_NOT_USING_CONFIG_FLAGS TRUE)
-endmacro (no_default_options)
+  set(CMAKE_NOT_USING_CONFIG_FLAGS TRUE)
+endmacro(no_default_options)
diff --git a/project/cmake/scripts/common/AddonHelpers.cmake b/project/cmake/scripts/common/AddonHelpers.cmake
index e4d531d1d3..1941da5ddc 100644
--- a/project/cmake/scripts/common/AddonHelpers.cmake
+++ b/project/cmake/scripts/common/AddonHelpers.cmake
@@ -21,14 +21,14 @@ endmacro()
 
 # Grab the version from a given add-on's addon.xml
 macro (addon_version dir prefix)
-  IF(EXISTS ${PROJECT_SOURCE_DIR}/${dir}/addon.xml.in)
-    FILE(READ ${PROJECT_SOURCE_DIR}/${dir}/addon.xml.in ADDONXML)
-  ELSE()
-    FILE(READ ${dir}/addon.xml ADDONXML)
-  ENDIF()
-
-  STRING(REGEX MATCH "<addon[^>]*version.?=.?.[0-9\\.]+" VERSION_STRING ${ADDONXML}) 
-  STRING(REGEX REPLACE ".*version=.([0-9\\.]+).*" "\\1" ${prefix}_VERSION ${VERSION_STRING})
+  if(EXISTS ${PROJECT_SOURCE_DIR}/${dir}/addon.xml.in)
+    file(READ ${PROJECT_SOURCE_DIR}/${dir}/addon.xml.in ADDONXML)
+  else()
+    file(READ ${dir}/addon.xml ADDONXML)
+  endif()
+
+  string(REGEX MATCH "<addon[^>]*version.?=.?.[0-9\\.]+" VERSION_STRING ${ADDONXML}) 
+  string(REGEX REPLACE ".*version=.([0-9\\.]+).*" "\\1" ${prefix}_VERSION ${VERSION_STRING})
   message(STATUS ${prefix}_VERSION=${${prefix}_VERSION})
 endmacro()
 
@@ -36,14 +36,14 @@ endmacro()
 macro (build_addon target prefix libs)
   addon_version(${target} ${prefix})
   if(${prefix}_SOURCES)
-    ADD_LIBRARY(${target} ${${prefix}_SOURCES})
-    TARGET_LINK_LIBRARIES(${target} ${${libs}})
-    SET_TARGET_PROPERTIES(${target} PROPERTIES VERSION ${${prefix}_VERSION}
+    add_library(${target} ${${prefix}_SOURCES})
+    TARGET_link_libraries(${target} ${${libs}})
+    set_target_properties(${target} PROPERTIES VERSION ${${prefix}_VERSION}
                                                SOVERSION ${APP_VERSION_MAJOR}.${APP_VERSION_MINOR}
                                                PREFIX "")
-    IF(OS STREQUAL "android")
-      SET_TARGET_PROPERTIES(${target} PROPERTIES PREFIX "lib")
-    ENDIF(OS STREQUAL "android")
+    if(OS STREQUAL "android")
+      set_target_properties(${target} PROPERTIES PREFIX "lib")
+    endif(OS STREQUAL "android")
   elseif(${prefix}_CUSTOM_BINARY)
     add_custom_target(${target} ALL)
     list(GET ${prefix}_CUSTOM_BINARY 2 dependency)
@@ -55,47 +55,47 @@ macro (build_addon target prefix libs)
     list(GET ${prefix}_CUSTOM_BINARY 0 LIBRARY_LOCATION)
     list(GET ${prefix}_CUSTOM_BINARY 1 LIBRARY_FILENAME)
   else()
-    SET(LIBRARY_LOCATION $<TARGET_FILE:${target}>)
+    set(LIBRARY_LOCATION $<TARGET_FILE:${target}>)
     # get the library's filename
     if("${CORE_SYSTEM_NAME}" STREQUAL "android")
       # for android we need the filename without any version numbers
       set(LIBRARY_FILENAME $<TARGET_LINKER_FILE_NAME:${target}>)
     else()
-      SET(LIBRARY_FILENAME $<TARGET_FILE_NAME:${target}>)
+      set(LIBRARY_FILENAME $<TARGET_FILE_NAME:${target}>)
     endif()
   endif()
 
   # if there's an addon.xml.in we need to generate the addon.xml
-  IF(EXISTS ${PROJECT_SOURCE_DIR}/${target}/addon.xml.in)
-    SET(PLATFORM ${CORE_SYSTEM_NAME})
+  if(EXISTS ${PROJECT_SOURCE_DIR}/${target}/addon.xml.in)
+    set(PLATFORM ${CORE_SYSTEM_NAME})
 
-    FILE(READ ${PROJECT_SOURCE_DIR}/${target}/addon.xml.in addon_file)
-    STRING(CONFIGURE "${addon_file}" addon_file_conf @ONLY)
-    FILE(GENERATE OUTPUT ${PROJECT_SOURCE_DIR}/${target}/addon.xml CONTENT "${addon_file_conf}")
+    file(READ ${PROJECT_SOURCE_DIR}/${target}/addon.xml.in addon_file)
+    string(CONFIGURE "${addon_file}" addon_file_conf @ONLY)
+    file(GENERATE OUTPUT ${PROJECT_SOURCE_DIR}/${target}/addon.xml CONTENT "${addon_file_conf}")
     if(${APP_NAME_UC}_BUILD_DIR)
-      FILE(GENERATE OUTPUT ${${APP_NAME_UC}_BUILD_DIR}/addons/${target}/addon.xml CONTENT "${addon_file_conf}")
+      file(GENERATE OUTPUT ${${APP_NAME_UC}_BUILD_DIR}/addons/${target}/addon.xml CONTENT "${addon_file_conf}")
     endif()
-  ENDIF()
+  endif()
 
   # set zip as default if addon-package is called without PACKAGE_XXX
-  SET(CPACK_GENERATOR "ZIP")
-  SET(ext "zip")
-  IF(PACKAGE_ZIP OR PACKAGE_TGZ)
-    IF(PACKAGE_TGZ)
-      SET(CPACK_GENERATOR "TGZ")
-      SET(ext "tar.gz")
-    ENDIF(PACKAGE_TGZ)
-    SET(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
+  set(CPACK_GENERATOR "ZIP")
+  set(ext "zip")
+  if(PACKAGE_ZIP OR PACKAGE_TGZ)
+    if(PACKAGE_TGZ)
+      set(CPACK_GENERATOR "TGZ")
+      set(ext "tar.gz")
+    endif(PACKAGE_TGZ)
+    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
     set(CPACK_PACKAGE_FILE_NAME addon)
-    IF(CMAKE_BUILD_TYPE STREQUAL "Release")
-      SET(CPACK_STRIP_FILES TRUE)
-    ENDIF(CMAKE_BUILD_TYPE STREQUAL "Release")
+    if(CMAKE_BUILD_TYPE STREQUAL "Release")
+      set(CPACK_STRIP_FILES TRUE)
+    endif(CMAKE_BUILD_TYPE STREQUAL "Release")
     set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
     set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
     list(APPEND CPACK_COMPONENTS_ALL ${target}-${${prefix}_VERSION})
     # Pack files together to create an archive
-    INSTALL(DIRECTORY ${target} DESTINATION ./ COMPONENT ${target}-${${prefix}_VERSION} PATTERN "addon.xml.in" EXCLUDE)
-    IF(WIN32)
+    install(DIRECTORY ${target} DESTINATION ./ COMPONENT ${target}-${${prefix}_VERSION} PATTERN "addon.xml.in" EXCLUDE)
+    if(WIN32)
       if(NOT CPACK_PACKAGE_DIRECTORY)
         # determine the temporary path
         file(TO_CMAKE_PATH "$ENV{TEMP}" WIN32_TEMP_PATH)
@@ -116,15 +116,15 @@ macro (build_addon target prefix libs)
 
       if(${prefix}_SOURCES)
         # install the generated DLL file
-        INSTALL(PROGRAMS ${LIBRARY_LOCATION} DESTINATION ${target}
+        install(PROGRAMS ${LIBRARY_LOCATION} DESTINATION ${target}
                 COMPONENT ${target}-${${prefix}_VERSION})
 
-        IF(CMAKE_BUILD_TYPE MATCHES Debug)
+        if(CMAKE_BUILD_TYPE MATCHES Debug)
           # for debug builds also install the PDB file
           get_filename_component(LIBRARY_DIR ${LIBRARY_LOCATION} DIRECTORY)
-          INSTALL(FILES ${LIBRARY_DIR}/${target}.pdb DESTINATION ${target}
+          install(FILES ${LIBRARY_DIR}/${target}.pdb DESTINATION ${target}
                   COMPONENT ${target}-${${prefix}_VERSION})
-        ENDIF()
+        endif()
       endif()
       if (${prefix}_CUSTOM_BINARY)
         list(GET ${prefix}_CUSTOM_BINARY 0 FROM_BINARY)
@@ -134,12 +134,12 @@ macro (build_addon target prefix libs)
       if(${prefix}_CUSTOM_DATA)
         install(DIRECTORY ${${prefix}_CUSTOM_DATA} DESTINATION ${target}/resources)
       endif()
-    ELSE(WIN32)
+    else(WIN32)
       if(NOT CPACK_PACKAGE_DIRECTORY)
         set(CPACK_PACKAGE_DIRECTORY ${CMAKE_BINARY_DIR})
       endif()
       if(${prefix}_SOURCES)
-        INSTALL(TARGETS ${target} DESTINATION ${target}
+        install(TARGETS ${target} DESTINATION ${target}
                 COMPONENT ${target}-${${prefix}_VERSION})
       endif()
       if (${prefix}_CUSTOM_BINARY)
@@ -154,9 +154,9 @@ macro (build_addon target prefix libs)
       if(${prefix}_CUSTOM_DATA)
         install(DIRECTORY ${${prefix}_CUSTOM_DATA} DESTINATION ${target}/resources)
       endif()
-    ENDIF(WIN32)
+    endif(WIN32)
     add_cpack_workaround(${target} ${${prefix}_VERSION} ${ext})
-  ELSE(PACKAGE_ZIP OR PACKAGE_TGZ)
+  else(PACKAGE_ZIP OR PACKAGE_TGZ)
     if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
       if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT OR NOT CMAKE_INSTALL_PREFIX)
         message(STATUS "setting install paths to match ${APP_NAME}: CMAKE_INSTALL_PREFIX: ${${APP_NAME_UC}_PREFIX}")
@@ -173,7 +173,7 @@ macro (build_addon target prefix libs)
       set(CMAKE_INSTALL_LIBDIR "lib/${APP_NAME_LC}")
     endif()
     if(${prefix}_SOURCES)
-      INSTALL(TARGETS ${target} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target})
+      install(TARGETS ${target} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target})
     endif()
     if (${prefix}_CUSTOM_BINARY)
       list(GET ${prefix}_CUSTOM_BINARY 0 FROM_BINARY)
@@ -183,11 +183,11 @@ macro (build_addon target prefix libs)
       endif()
       install(FILES ${FROM_BINARY} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target} RENAME ${TO_BINARY})
     endif()
-    INSTALL(DIRECTORY ${target} DESTINATION share/${APP_NAME_LC}/addons PATTERN "addon.xml.in" EXCLUDE)
+    install(DIRECTORY ${target} DESTINATION share/${APP_NAME_LC}/addons PATTERN "addon.xml.in" EXCLUDE)
     if(${prefix}_CUSTOM_DATA)
       install(DIRECTORY ${${prefix}_CUSTOM_DATA} DESTINATION share/${APP_NAME_LC}/addons/${target}/resources)
     endif()
-  ENDIF(PACKAGE_ZIP OR PACKAGE_TGZ)
+  endif(PACKAGE_ZIP OR PACKAGE_TGZ)
   if(${APP_NAME_UC}_BUILD_DIR)
     file(GLOB_RECURSE files ${CMAKE_CURRENT_SOURCE_DIR}/${target}/*)
     if(${prefix}_CUSTOM_DATA)
@@ -222,23 +222,23 @@ endfunction()
 # Cmake build options
 include(AddOptions)
 include(TestCXXAcceptsFlag)
-OPTION(PACKAGE_ZIP "Package Zip file?" OFF)
-OPTION(PACKAGE_TGZ "Package TGZ file?" OFF)
-OPTION(BUILD_SHARED_LIBS "Build shared libs?" ON)
+option(PACKAGE_ZIP "Package Zip file?" OFF)
+option(PACKAGE_TGZ "Package TGZ file?" OFF)
+option(BUILD_SHARED_LIBS "Build shared libs?" ON)
 
 # LTO support?
 CHECK_CXX_ACCEPTS_FLAG("-flto" HAVE_LTO)
-IF(HAVE_LTO)
-  OPTION(USE_LTO "use link time optimization" OFF)
-  IF(USE_LTO)
+if(HAVE_LTO)
+  option(USE_LTO "use link time optimization" OFF)
+  if(USE_LTO)
     add_options(ALL_LANGUAGES ALL_BUILDS "-flto")
-  ENDIF(USE_LTO)
-ENDIF(HAVE_LTO) 
+  endif(USE_LTO)
+endif(HAVE_LTO) 
 
 # set this to try linking dependencies as static as possible
-IF(ADDONS_PREFER_STATIC_LIBS)
-  SET(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
-ENDIF(ADDONS_PREFER_STATIC_LIBS)
+if(ADDONS_PREFER_STATIC_LIBS)
+  set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+endif(ADDONS_PREFER_STATIC_LIBS)
 
 if(${APP_NAME_UC}_BUILD_DIR)
   list(APPEND CMAKE_PREFIX_PATH ${${APP_NAME_UC}_BUILD_DIR}/build)
diff --git a/project/cmake/scripts/common/CheckTargetPlatform.cmake b/project/cmake/scripts/common/CheckTargetPlatform.cmake
index fc8b4036df..199071d520 100644
--- a/project/cmake/scripts/common/CheckTargetPlatform.cmake
+++ b/project/cmake/scripts/common/CheckTargetPlatform.cmake
@@ -21,11 +21,11 @@ function(check_target_platform dir target_platform build)
         if(${platform_first} STREQUAL "!")
           # extract the platform
           string(LENGTH ${platform} platform_length)
-          MATH(EXPR platform_length "${platform_length} - 1")
+          math(EXPR platform_length "${platform_length} - 1")
           string(SUBSTRING ${platform} 1 ${platform_length} platform)
 
           # check if the current platform does not match the extracted platform
-          if (NOT ${platform} STREQUAL ${target_platform})
+          if(NOT ${platform} STREQUAL ${target_platform})
             set(${build} TRUE)
           endif()
         endif()
diff --git a/project/cmake/scripts/common/HandleDepends.cmake b/project/cmake/scripts/common/HandleDepends.cmake
index f44c87ac38..04da91a481 100644
--- a/project/cmake/scripts/common/HandleDepends.cmake
+++ b/project/cmake/scripts/common/HandleDepends.cmake
@@ -70,8 +70,8 @@ function(add_addon_depends addon searchpath)
 
         if(CMAKE_TOOLCHAIN_FILE)
           list(APPEND BUILD_ARGS -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
-          MESSAGE("toolchain specified")
-          MESSAGE(${BUILD_ARGS})
+          message("toolchain specified")
+          message(${BUILD_ARGS})
         endif()
 
         # if there's a CMakeLists.txt use it to prepare the build
@@ -141,7 +141,7 @@ function(add_addon_depends addon searchpath)
 
         # if the patch file exists we need to set the PATCH_COMMAND
         set(PATCH_COMMAND "")
-        if (EXISTS ${PATCH_FILE})
+        if(EXISTS ${PATCH_FILE})
           set(PATCH_COMMAND ${CMAKE_COMMAND} -P ${PATCH_FILE})
         endif()
 
diff --git a/project/cmake/scripts/common/Macros.cmake b/project/cmake/scripts/common/Macros.cmake
index de2a77cb15..055aaf223d 100644
--- a/project/cmake/scripts/common/Macros.cmake
+++ b/project/cmake/scripts/common/Macros.cmake
@@ -176,7 +176,7 @@ endfunction()
 # helper macro for optional deps
 macro(setup_enable_switch)
   string(TOUPPER ${dep} depup)
-  if (ARGV1)
+  if(ARGV1)
     set(enable_switch ${ARGV1})
   else()
     set(enable_switch ENABLE_${depup})
@@ -316,7 +316,7 @@ macro(core_add_optional_subdirs_from_filelist pattern)
 endmacro()
 
 macro(today RESULT)
-  if (WIN32)
+  if(WIN32)
     execute_process(COMMAND "cmd" " /C date /T" OUTPUT_VARIABLE ${RESULT})
     string(REGEX REPLACE "(..)/(..)/..(..).*" "\\1/\\2/\\3" ${RESULT} ${${RESULT}})
   elseif(UNIX)
@@ -336,12 +336,12 @@ function(core_find_git_rev)
     execute_process(COMMAND ${GIT_EXECUTABLE} diff-files --ignore-submodules --quiet --
                     RESULT_VARIABLE status_code
                     WORKING_DIRECTORY ${CORE_SOURCE_DIR})
-      if (NOT status_code)
+      if(NOT status_code)
         execute_process(COMMAND ${GIT_EXECUTABLE} diff-index --ignore-submodules --quiet HEAD --
                       RESULT_VARIABLE status_code
                       WORKING_DIRECTORY ${CORE_SOURCE_DIR})
       endif()
-      if (status_code)
+      if(status_code)
         execute_process(COMMAND ${GIT_EXECUTABLE} log -n 1 --pretty=format:"%h-dirty" HEAD
                         OUTPUT_VARIABLE HASH
                         WORKING_DIRECTORY ${CORE_SOURCE_DIR})
diff --git a/project/cmake/scripts/common/ManageString.cmake b/project/cmake/scripts/common/ManageString.cmake
index 7321f4cbe3..c9d5f041c3 100644
--- a/project/cmake/scripts/common/ManageString.cmake
+++ b/project/cmake/scripts/common/ManageString.cmake
@@ -2,8 +2,8 @@
 # Defines the following macros:
 #   STRING_TRIM(var str [NOUNQUOTE])
 #   - Trim a string by removing the leading and trailing spaces,
-#     just like STRING(STRIP ...) in CMake 2.6 and later.
-#     This macro is needed as CMake 2.4 does not support STRING(STRIP ..)
+#     just like string(STRIP ...) in CMake 2.6 and later.
+#     This macro is needed as CMake 2.4 does not support string(STRIP ..)
 #     This macro also remove quote and double quote marks around the string,
 #     unless NOUNQUOTE is defined.
 #     * Parameters:
@@ -35,201 +35,201 @@
 #       + NOESCAPE_SEMICOLON: (Optional) Do not escape semicolons.
 #
 
-IF(NOT DEFINED _MANAGE_STRING_CMAKE_)
-    SET(_MANAGE_STRING_CMAKE_ "DEFINED")
+if(NOT DEFINED _MANAGE_STRING_CMAKE_)
+    set(_MANAGE_STRING_CMAKE_ "DEFINED")
 
-    MACRO(STRING_TRIM var str)
-	SET(${var} "")
-	IF (NOT "${ARGN}" STREQUAL "NOUNQUOTE")
+    macro(STRING_TRIM var str)
+	set(${var} "")
+	if(NOT "${ARGN}" STREQUAL "NOUNQUOTE")
 	    # Need not trim a quoted string.
 	    STRING_UNQUOTE(_var "${str}")
-	    IF(NOT _var STREQUAL "")
+	    if(NOT _var STREQUAL "")
 		# String is quoted
-		SET(${var} "${_var}")
-	    ENDIF(NOT _var STREQUAL "")
-	ENDIF(NOT "${ARGN}" STREQUAL "NOUNQUOTE")
-
-	IF(${var} STREQUAL "")
-	    SET(_var_1 "${str}")
-	    STRING(REGEX REPLACE  "^[ \t\r\n]+" "" _var_2 "${str}" )
-	    STRING(REGEX REPLACE  "[ \t\r\n]+$" "" _var_3 "${_var_2}" )
-	    SET(${var} "${_var_3}")
-	ENDIF(${var} STREQUAL "")
-    ENDMACRO(STRING_TRIM var str)
+		set(${var} "${_var}")
+	    endif(NOT _var STREQUAL "")
+	endif(NOT "${ARGN}" STREQUAL "NOUNQUOTE")
+
+	if(${var} STREQUAL "")
+	    set(_var_1 "${str}")
+	    string(REGEX REPLACE  "^[ \t\r\n]+" "" _var_2 "${str}" )
+	    string(REGEX REPLACE  "[ \t\r\n]+$" "" _var_3 "${_var_2}" )
+	    set(${var} "${_var_3}")
+	endif(${var} STREQUAL "")
+    endmacro(STRING_TRIM var str)
 
     # Internal macro
     # Variable cannot be escaped here, as variable is already substituted
     # at the time it passes to this macro.
-    MACRO(STRING_ESCAPE var str)
+    macro(STRING_ESCAPE var str)
 	# ';' and '\' are tricky, need to be encoded.
 	# '#' => '#H'
 	# '\' => '#B'
 	# ';' => '#S'
-	SET(_NOESCAPE_SEMICOLON "")
-	SET(_NOESCAPE_HASH "")
-
-	FOREACH(_arg ${ARGN})
-	    IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-		SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
-	    ELSEIF(${_arg} STREQUAL "NOESCAPE_HASH")
-		SET(_NOESCAPE_HASH "NOESCAPE_HASH")
-	    ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-	ENDFOREACH(_arg)
-
-	IF(_NOESCAPE_HASH STREQUAL "")
-	    STRING(REGEX REPLACE "#" "#H" _ret "${str}")
-	ELSE(_NOESCAPE_HASH STREQUAL "")
-	    SET(_ret "${str}")
-	ENDIF(_NOESCAPE_HASH STREQUAL "")
-
-	STRING(REGEX REPLACE "\\\\" "#B" _ret "${_ret}")
-	IF(_NOESCAPE_SEMICOLON STREQUAL "")
-	    STRING(REGEX REPLACE ";" "#S" _ret "${_ret}")
-	ENDIF(_NOESCAPE_SEMICOLON STREQUAL "")
-	SET(${var} "${_ret}")
-    ENDMACRO(STRING_ESCAPE var str)
-
-    MACRO(STRING_UNESCAPE var str)
+	set(_NOESCAPE_SEMICOLON "")
+	set(_NOESCAPE_HASH "")
+
+	foreach(_arg ${ARGN})
+	    if(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+		set(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
+	    elseif(${_arg} STREQUAL "NOESCAPE_HASH")
+		set(_NOESCAPE_HASH "NOESCAPE_HASH")
+	    endif(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+	endforeach(_arg)
+
+	if(_NOESCAPE_HASH STREQUAL "")
+	    string(REGEX REPLACE "#" "#H" _ret "${str}")
+	else(_NOESCAPE_HASH STREQUAL "")
+	    set(_ret "${str}")
+	endif(_NOESCAPE_HASH STREQUAL "")
+
+	string(REGEX REPLACE "\\\\" "#B" _ret "${_ret}")
+	if(_NOESCAPE_SEMICOLON STREQUAL "")
+	    string(REGEX REPLACE ";" "#S" _ret "${_ret}")
+	endif(_NOESCAPE_SEMICOLON STREQUAL "")
+	set(${var} "${_ret}")
+    endmacro(STRING_ESCAPE var str)
+
+    macro(STRING_UNESCAPE var str)
 	# '#B' => '\'
 	# '#H' => '#'
 	# '#D' => '$'
 	# '#S' => ';'
-	SET(_ESCAPE_VARIABLE "")
-	SET(_NOESCAPE_SEMICOLON "")
-	SET(_ret "${str}")
-	FOREACH(_arg ${ARGN})
-	    IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-		SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
-	    ELSEIF(${_arg} STREQUAL "ESCAPE_VARIABLE")
-		SET(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
-		STRING(REGEX REPLACE "#D" "$" _ret "${_ret}")
-	    ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-	ENDFOREACH(_arg)
-
-	STRING(REGEX REPLACE "#B" "\\\\" _ret "${_ret}")
-	IF(_NOESCAPE_SEMICOLON STREQUAL "")
+	set(_ESCAPE_VARIABLE "")
+	set(_NOESCAPE_SEMICOLON "")
+	set(_ret "${str}")
+	foreach(_arg ${ARGN})
+	    if(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+		set(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
+	    elseif(${_arg} STREQUAL "ESCAPE_VARIABLE")
+		set(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
+		string(REGEX REPLACE "#D" "$" _ret "${_ret}")
+	    endif(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+	endforeach(_arg)
+
+	string(REGEX REPLACE "#B" "\\\\" _ret "${_ret}")
+	if(_NOESCAPE_SEMICOLON STREQUAL "")
 	    # ';' => '#S'
-	    STRING(REGEX REPLACE "#S" "\\\\;" _ret "${_ret}")
-	ELSE(_NOESCAPE_SEMICOLON STREQUAL "")
-	    STRING(REGEX REPLACE "#S" ";" _ret "${_ret}")
-	ENDIF(_NOESCAPE_SEMICOLON STREQUAL "")
+	    string(REGEX REPLACE "#S" "\\\\;" _ret "${_ret}")
+	else(_NOESCAPE_SEMICOLON STREQUAL "")
+	    string(REGEX REPLACE "#S" ";" _ret "${_ret}")
+	endif(_NOESCAPE_SEMICOLON STREQUAL "")
 
-	IF(NOT _ESCAPE_VARIABLE STREQUAL "")
+	if(NOT _ESCAPE_VARIABLE STREQUAL "")
 	    # '#D' => '$'
-	    STRING(REGEX REPLACE "#D" "$" _ret "${_ret}")
-	ENDIF(NOT _ESCAPE_VARIABLE STREQUAL "")
-	STRING(REGEX REPLACE "#H" "#" _ret "${_ret}")
-	SET(${var} "${_ret}")
-    ENDMACRO(STRING_UNESCAPE var str)
+	    string(REGEX REPLACE "#D" "$" _ret "${_ret}")
+	endif(NOT _ESCAPE_VARIABLE STREQUAL "")
+	string(REGEX REPLACE "#H" "#" _ret "${_ret}")
+	set(${var} "${_ret}")
+    endmacro(STRING_UNESCAPE var str)
 
 
-    MACRO(STRING_UNQUOTE var str)
+    macro(STRING_UNQUOTE var str)
 	STRING_ESCAPE(_ret "${str}" ${ARGN})
-	IF(_ret MATCHES "^[ \t\r\n]+")
-	    STRING(REGEX REPLACE "^[ \t\r\n]+" "" _ret "${_ret}")
-	ENDIF(_ret MATCHES "^[ \t\r\n]+")
-	IF(_ret MATCHES "^\"")
+	if(_ret MATCHES "^[ \t\r\n]+")
+	    string(REGEX REPLACE "^[ \t\r\n]+" "" _ret "${_ret}")
+	endif(_ret MATCHES "^[ \t\r\n]+")
+	if(_ret MATCHES "^\"")
 	    # Double quote
-	    STRING(REGEX REPLACE "\"\(.*\)\"[ \t\r\n]*$" "\\1" _ret "${_ret}")
-	ELSEIF(_ret MATCHES "^'")
+	    string(REGEX REPLACE "\"\(.*\)\"[ \t\r\n]*$" "\\1" _ret "${_ret}")
+	elseif(_ret MATCHES "^'")
 	    # Single quote
-	    STRING(REGEX REPLACE "'\(.*\)'[ \t\r\n]*$" "\\1" _ret "${_ret}")
-	ELSE(_ret MATCHES "^\"")
-	    SET(_ret "")
-	ENDIF(_ret MATCHES "^\"")
+	    string(REGEX REPLACE "'\(.*\)'[ \t\r\n]*$" "\\1" _ret "${_ret}")
+	else(_ret MATCHES "^\"")
+	    set(_ret "")
+	endif(_ret MATCHES "^\"")
 
 	# Unencoding
 	STRING_UNESCAPE(${var} "${_ret}" ${ARGN})
-    ENDMACRO(STRING_UNQUOTE var str)
-
-    MACRO(STRING_JOIN var delimiter str_list)
-	SET(_ret "")
-	FOREACH(_str ${str_list})
-	    IF(_ret STREQUAL "")
-		SET(_ret "${_str}")
-	    ELSE(_ret STREQUAL "")
-		SET(_ret "${_ret}${delimiter}${_str}")
-	    ENDIF(_ret STREQUAL "")
-	ENDFOREACH(_str ${str_list})
-
-	FOREACH(_str ${ARGN})
-	    IF(_ret STREQUAL "")
-		SET(_ret "${_str}")
-	    ELSE(_ret STREQUAL "")
-		SET(_ret "${_ret}${delimiter}${_str}")
-	    ENDIF(_ret STREQUAL "")
-	ENDFOREACH(_str ${str_list})
-	SET(${var} "${_ret}")
-    ENDMACRO(STRING_JOIN var delimiter str_list)
-
-    MACRO(STRING_SPLIT var delimiter str)
-	SET(_max_tokens "")
-	SET(_NOESCAPE_SEMICOLON "")
-	SET(_ESCAPE_VARIABLE "")
-	FOREACH(_arg ${ARGN})
-	    IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-		SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
-	    ELSEIF(${_arg} STREQUAL "ESCAPE_VARIABLE")
-		SET(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
-	    ELSE(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-		SET(_max_tokens ${_arg})
-	    ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
-	ENDFOREACH(_arg)
-
-	IF(NOT _max_tokens)
-	    SET(_max_tokens -1)
-	ENDIF(NOT _max_tokens)
+    endmacro(STRING_UNQUOTE var str)
+
+    macro(STRING_JOIN var delimiter str_list)
+	set(_ret "")
+	foreach(_str ${str_list})
+	    if(_ret STREQUAL "")
+		set(_ret "${_str}")
+	    else(_ret STREQUAL "")
+		set(_ret "${_ret}${delimiter}${_str}")
+	    endif(_ret STREQUAL "")
+	endforeach(_str ${str_list})
+
+	foreach(_str ${ARGN})
+	    if(_ret STREQUAL "")
+		set(_ret "${_str}")
+	    else(_ret STREQUAL "")
+		set(_ret "${_ret}${delimiter}${_str}")
+	    endif(_ret STREQUAL "")
+	endforeach(_str ${str_list})
+	set(${var} "${_ret}")
+    endmacro(STRING_JOIN var delimiter str_list)
+
+    macro(STRING_SPLIT var delimiter str)
+	set(_max_tokens "")
+	set(_NOESCAPE_SEMICOLON "")
+	set(_ESCAPE_VARIABLE "")
+	foreach(_arg ${ARGN})
+	    if(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+		set(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
+	    elseif(${_arg} STREQUAL "ESCAPE_VARIABLE")
+		set(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
+	    else(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+		set(_max_tokens ${_arg})
+	    endif(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
+	endforeach(_arg)
+
+	if(NOT _max_tokens)
+	    set(_max_tokens -1)
+	endif(NOT _max_tokens)
 
 	STRING_ESCAPE(_str "${str}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
 	STRING_ESCAPE(_delimiter "${delimiter}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
 
-	SET(_str_list "")
-	SET(_token_count 0)
-	STRING(LENGTH "${_delimiter}" _de_len)
+	set(_str_list "")
+	set(_token_count 0)
+	string(LENGTH "${_delimiter}" _de_len)
 
-	WHILE(NOT _token_count EQUAL _max_tokens)
-	    MATH(EXPR _token_count ${_token_count}+1)
-	    IF(_token_count EQUAL _max_tokens)
+	while(NOT _token_count EQUAL _max_tokens)
+	    math(EXPR _token_count ${_token_count}+1)
+	    if(_token_count EQUAL _max_tokens)
 		# Last token, no need splitting
-		SET(_str_list ${_str_list} "${_str}")
-	    ELSE(_token_count EQUAL _max_tokens)
+		set(_str_list ${_str_list} "${_str}")
+	    else(_token_count EQUAL _max_tokens)
 		# in case encoded characters are delimiters
-		STRING(LENGTH "${_str}" _str_len)
-		SET(_index 0)
-		SET(_token "")
-		SET(_str_remain "")
-		MATH(EXPR _str_end ${_str_len}-${_de_len}+1)
-		SET(_bound "k")
-		WHILE(_index LESS _str_end)
-		    STRING(SUBSTRING "${_str}" ${_index} ${_de_len} _str_cursor)
-		    IF(_str_cursor STREQUAL _delimiter)
+		string(LENGTH "${_str}" _str_len)
+		set(_index 0)
+		set(_token "")
+		set(_str_remain "")
+		math(EXPR _str_end ${_str_len}-${_de_len}+1)
+		set(_bound "k")
+		while(_index LESS _str_end)
+		    string(SUBSTRING "${_str}" ${_index} ${_de_len} _str_cursor)
+		    if(_str_cursor STREQUAL _delimiter)
 			# Get the token
-			STRING(SUBSTRING "${_str}" 0 ${_index} _token)
+			string(SUBSTRING "${_str}" 0 ${_index} _token)
 			# Get the rest
-			MATH(EXPR _rest_index ${_index}+${_de_len})
-			MATH(EXPR _rest_len ${_str_len}-${_index}-${_de_len})
-			STRING(SUBSTRING "${_str}" ${_rest_index} ${_rest_len} _str_remain)
-			SET(_index ${_str_end})
-		    ELSE(_str_cursor STREQUAL _delimiter)
-			MATH(EXPR _index ${_index}+1)
-		    ENDIF(_str_cursor STREQUAL _delimiter)
-		ENDWHILE(_index LESS _str_end)
-
-		IF(_str_remain STREQUAL "")
+			math(EXPR _rest_index ${_index}+${_de_len})
+			math(EXPR _rest_len ${_str_len}-${_index}-${_de_len})
+			string(SUBSTRING "${_str}" ${_rest_index} ${_rest_len} _str_remain)
+			set(_index ${_str_end})
+		    else(_str_cursor STREQUAL _delimiter)
+			math(EXPR _index ${_index}+1)
+		    endif(_str_cursor STREQUAL _delimiter)
+		endwhile(_index LESS _str_end)
+
+		if(_str_remain STREQUAL "")
 		    # Meaning: end of string
-		    LIST(APPEND _str_list "${_str}")
-		    SET(_max_tokens ${_token_count})
-		ELSE(_str_remain STREQUAL "")
-		    LIST(APPEND _str_list "${_token}")
-		    SET(_str "${_str_remain}")
-		ENDIF(_str_remain STREQUAL "")
-	    ENDIF(_token_count EQUAL _max_tokens)
-	ENDWHILE(NOT _token_count EQUAL _max_tokens)
+		    list(APPEND _str_list "${_str}")
+		    set(_max_tokens ${_token_count})
+		else(_str_remain STREQUAL "")
+		    list(APPEND _str_list "${_token}")
+		    set(_str "${_str_remain}")
+		endif(_str_remain STREQUAL "")
+	    endif(_token_count EQUAL _max_tokens)
+	endwhile(NOT _token_count EQUAL _max_tokens)
 
 
 	# Unencoding
 	STRING_UNESCAPE(${var} "${_str_list}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
-    ENDMACRO(STRING_SPLIT var delimiter str)
+    endmacro(STRING_SPLIT var delimiter str)
 
-ENDIF(NOT DEFINED _MANAGE_STRING_CMAKE_)
+endif(NOT DEFINED _MANAGE_STRING_CMAKE_)
 
diff --git a/project/cmake/scripts/common/PrepareEnv.cmake b/project/cmake/scripts/common/PrepareEnv.cmake
index fadca482d9..874d46bd86 100644
--- a/project/cmake/scripts/common/PrepareEnv.cmake
+++ b/project/cmake/scripts/common/PrepareEnv.cmake
@@ -1,7 +1,7 @@
 # parse version.txt to get the version info
 if(EXISTS "${CORE_SOURCE_DIR}/version.txt")
   file(STRINGS "${CORE_SOURCE_DIR}/version.txt" versions)
-  foreach (version ${versions})
+  foreach(version ${versions})
     if(version MATCHES "^VERSION_.*")
       string(REGEX MATCH "^[^ ]+" version_name ${version})
       string(REPLACE "${version_name} " "" version_value ${version})
@@ -81,7 +81,7 @@ foreach(binding ${bindings})
   # auto-generate header files for backwards compatibility to xbmc with deprecation warning
   # but only do it if the file doesn't already exist
   get_filename_component(headerfile ${header} NAME)
-  if (NOT EXISTS "${XBMC_INCLUDE_DIR}/${headerfile}")
+  if(NOT EXISTS "${XBMC_INCLUDE_DIR}/${headerfile}")
     file(WRITE ${XBMC_INCLUDE_DIR}/${headerfile}
 "#pragma once
 #define DEPRECATION_WARNING \"Including xbmc/${headerfile} has been deprecated, please use kodi/${headerfile}\"
diff --git a/project/cmake/scripts/linux/Install.cmake b/project/cmake/scripts/linux/Install.cmake
index a3267914fe..44fba34fcd 100644
--- a/project/cmake/scripts/linux/Install.cmake
+++ b/project/cmake/scripts/linux/Install.cmake
@@ -47,27 +47,27 @@ if(ENABLE_X11 AND XRANDR_FOUND)
 endif()
 
 if(NOT EXISTS ${libdir}/xbmc)
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${libdir})")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${libdir})")
 endif()
 install(FILES ${addon_bindings} DESTINATION ${includedir}/${APP_NAME_LC})
 if(NOT EXISTS ${includedir}/xbmc)
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${includedir})")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${includedir})")
 endif()
 
 install(PROGRAMS ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/scripts/${APP_NAME_LC}
                  ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/scripts/${APP_NAME_LC}-standalone
         DESTINATION ${bindir})
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC} xbmc WORKING_DIRECTORY ${bindir})")
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC}-standalone xbmc-standalone WORKING_DIRECTORY ${bindir})")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC} xbmc WORKING_DIRECTORY ${bindir})")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC}-standalone xbmc-standalone WORKING_DIRECTORY ${bindir})")
 
 configure_file(${CORE_SOURCE_DIR}/tools/Linux/kodi-xsession.desktop.in
                ${CORE_BUILD_DIR}/${APP_NAME_LC}.desktop)
 install(FILES ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/${APP_NAME_LC}.desktop
         DESTINATION ${datarootdir}/xsessions)
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC}.desktop xbmc.desktop WORKING_DIRECTORY ${datarootdir}/xsessions/)")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC}.desktop xbmc.desktop WORKING_DIRECTORY ${datarootdir}/xsessions/)")
 
 if(NOT EXISTS ${datarootdir}/xbmc)
-install(CODE "execute_process (COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${datarootdir})")
+install(CODE "execute_process(COMMAND ln -sf ${APP_NAME_LC}/ xbmc WORKING_DIRECTORY ${datarootdir})")
 endif()
 
 install(FILES ${CORE_SOURCE_DIR}/copying.txt