# HG changeset patch
# User Louis Opter <louis@lse.epitech.net>
# Date 1327595207 -3600
# Node ID 0ca7946490286dad414b60f7ebd963cac4703a86
# Parent  b109c72d897bb47e9d98224b14579419a44e3df0
Wip on the build system patch, use a FindRathaxes CMake finder, fix some paths in the installed rathaxes binaries

diff -r b109c72d897b -r 0ca794649028 maintainers_refactor_the_build_system_to_allow_standalone_rathaxes_projects_with_cmake.patch
--- a/maintainers_refactor_the_build_system_to_allow_standalone_rathaxes_projects_with_cmake.patch	Sun Jan 22 18:31:23 2012 +0100
+++ b/maintainers_refactor_the_build_system_to_allow_standalone_rathaxes_projects_with_cmake.patch	Thu Jan 26 17:26:47 2012 +0100
@@ -1,11 +1,16 @@
 # HG changeset patch
-# Parent 656d49c6f011212578c0a29e49c4d1566b8ad16e
+# Parent 0861918d54e44cb25af0153bcac15647351ef6b1
 maintainers: make UseRathaxes.cmake usable in standalone projects
 
 - UseRathaxes now does more Rathaxes related things (like search for
   Codeworker);
+- UseRathaxes (as well as FindCodeWorker, FindRathaxes...) could be distributed
+  with Rathaxes (i.e installed when you install Rathaxes) but then you have the
+  problem of finding the CMakeLists files from your (separate) project. That's
+  why I think it's simpler to just copy the CMakeLists each time in each
+  project (for now);
 - Currently used by the examples;
-- Should make the first steps guide really usable now.
+- Should make the first steps guide really usable now;
 
 diff --git a/CMakeLists.txt b/CMakeLists.txt
 --- a/CMakeLists.txt
@@ -53,61 +58,159 @@
 diff --git a/maintainers/CMakeScripts/FindCodeWorker.cmake b/maintainers/CMakeScripts/FindCodeWorker.cmake
 --- a/maintainers/CMakeScripts/FindCodeWorker.cmake
 +++ b/maintainers/CMakeScripts/FindCodeWorker.cmake
-@@ -18,7 +18,11 @@
-                  NAMES
-                  codeworker
-                  PATHS
--                 $ENV{CODEWORKER_DIR})
-+                 $ENV{CODEWORKER_DIR}
-+                 $ENV{RATHAXES_PATH}/lib/
-+                 ${CMAKE_SYSTEM_LIBRARY_PATH}
-+                 PATH_SUFFIXES
+@@ -50,7 +50,7 @@
+                 IF (UNIX)
+                     EXECUTE_PROCESS(COMMAND "chmod" "+x" "${CODEWORKER_BINARY_PATH}")
+                     IF (CMAKE_SYSTEM_NAME MATCHES "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
+-                        MESSAGE(STATUS "CodeWorker needs the 32bit compatability libraries (ia32-libs), make sure you have them!")
++                        MESSAGE(STATUS "CodeWorker needs the 32bit compatibility libraries (ia32-libs), make sure you have them!")
+                     ENDIF (CMAKE_SYSTEM_NAME MATCHES "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
+                 ENDIF (UNIX)
+             ELSE (${CODEWORKER_DL_RETURN} EQUAL 0)
+diff --git a/maintainers/CMakeScripts/FindRathaxes.cmake b/maintainers/CMakeScripts/FindRathaxes.cmake
+new file mode 100644
+--- /dev/null
++++ b/maintainers/CMakeScripts/FindRathaxes.cmake
+@@ -0,0 +1,18 @@
++# Package Finder for Rathaxes and CMake.
++#
++# This finder simply seek for the rathaxes compiler and stores its path in the
++# variable RATHAXES_BINARY_PATH, if rathaxes is found.
++#
++# This finder is used internally by UseRathaxes.
++
++IF (NOT RATHAXES_BINARY_PATH)
++    FIND_PROGRAM(RATHAXES_BINARY_PATH
++                 NAMES
 +                 rathaxes)
- 
-     # Else try to download it:
-     IF (NOT CODEWORKER_BINARY_PATH)
++ELSE (NOT RATHAXES_BINARY_PATH)
++    SET(RATHAXES_FIND_QUIETLY TRUE)
++ENDIF (NOT RATHAXES_BINARY_PATH)
++
++INCLUDE(FindPackageHandleStandardArgs)
++
++FIND_PACKAGE_HANDLE_STANDARD_ARGS(Rathaxes DEFAULT_MSG RATHAXES_BINARY_PATH)
 diff --git a/maintainers/CMakeScripts/UseRathaxes.cmake b/maintainers/CMakeScripts/UseRathaxes.cmake
 --- a/maintainers/CMakeScripts/UseRathaxes.cmake
 +++ b/maintainers/CMakeScripts/UseRathaxes.cmake
-@@ -1,3 +1,5 @@
+@@ -1,3 +1,12 @@
++# CMake library to easily make Rathaxes projects.
++#
++# This library depends on:
++# - FindCodeWorker.cmake;
++# - FindRathaxes.cmake;
++# - FindLinuxKBuildDir.cmake (could be made optional).
++
 +# Functions ####################################################################
 +
  FUNCTION(_RTX_PARSE_OPTIONS ARGS RTI_OUT BLT_OUT SYSTEM_OUT)
      SET(OPTIONS "RTI" "BLT" "SYSTEM")
      SET(FILE_LISTS ${RTI_OUT} ${BLT_OUT} ${SYSTEM_OUT})
-@@ -188,7 +190,7 @@
+@@ -38,13 +47,13 @@
+          SYSTEMS)               # [in] name of each target system
+     FOREACH(RTI ${RTI_FILES})
+         LIST(APPEND ${REGISTER_COMMANDS_OUT}
+-             "COMMAND" ${_RTX_CODEWORKER_COMMAND}
++             "COMMAND" ${_USE_RATHAXES_CODEWORKER_COMMAND}
+              "rti-register" "${CMAKE_CURRENT_SOURCE_DIR}/${RTI}")
+     ENDFOREACH(RTI ${RTI_FILES})
+ 
+     FOREACH(BLT ${BLT_FILES})
+         LIST(APPEND ${REGISTER_COMMANDS_OUT}
+-            "COMMAND" ${_RTX_CODEWORKER_COMMAND}
++            "COMMAND" ${_USE_RATHAXES_CODEWORKER_COMMAND}
+             "blt-register" "${CMAKE_CURRENT_SOURCE_DIR}/${BLT}")
+     ENDFOREACH(BLT ${BLT_FILES})
+ 
+@@ -53,7 +62,7 @@
+         # At some point I guess we will use different directories instead of
+         # different file names.
+         LIST(APPEND ${GENERATE_COMMANDS_OUT}
+-             COMMAND ${_RTX_CODEWORKER_COMMAND}
++             COMMAND ${_USE_RATHAXES_CODEWORKER_COMMAND}
+              "generate" "/o" "${OUT_NAME}_${OS}.c" "${OS}"
+              "${CMAKE_CURRENT_SOURCE_DIR}/${RTX_FILE}")
+     ENDFOREACH(OS ${SYSTEMS})
+@@ -85,13 +94,6 @@
+ # At some point we will certainly have our own language definition for CMake
+ # but let's start with simpler things.
+ FUNCTION(ADD_RATHAXES_SOURCES OUT_NAME RTX_FILE)
+-    SET(_RTX_CODEWORKER_COMMAND
+-        ${CODEWORKER_BINARY_PATH} "-nologo"
+-        "-I" "${RATHAXES_SOURCE_DIR}/maintainers/cnorm/src"
+-        "-I" "${RATHAXES_SOURCE_DIR}/rathaxes/compiler/"
+-        "-script" "${CMAKE_SOURCE_DIR}/rathaxes/compiler/rathaxes.cws"
+-        "-args" "${CMAKE_SOURCE_DIR}/rathaxes/" "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/RathaxesCache/")
+-
+     LIST(REMOVE_ITEM ARGV ${OUT_NAME} ${RTX_FILE})
+ 
+     # We have to expand ARGV inside quotes, so it expand as a single LIST
+@@ -118,7 +120,7 @@
+     # that should be rebuilt automatically when its sources change.
+     STRING(REPLACE ";" ", " SYSTEMS "${SYSTEMS}")
+     ADD_CUSTOM_COMMAND(OUTPUT ${OUTPUTS}
+-                       COMMAND ${_RTX_CODEWORKER_COMMAND} "cache" "clear"
++                       COMMAND ${_USE_RATHAXES_CODEWORKER_COMMAND} "cache" "clear"
+                        ${REGISTER_COMMANDS}
+                        ${GENERATE_COMMANDS}
+                        COMMENT "Building Rathaxes target ${OUT_NAME} for ${SYSTEMS}"
+@@ -188,8 +190,7 @@
          # Generate the Linux Makefile to build a Linux kernel module
          SET(MODULE_MAKEFILE "${MODULE_BUILD_DIR}/Makefile")
          SET(LKM_OBJECTS "${RATHAXES_SOURCE}_${SYSTEM}.o")
 -        CONFIGURE_FILE("${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/Templates/MakefileLKM.in"
-+        CONFIGURE_FILE("${CMAKE_CURRENT_LIST_DIR}/Templates/MakefileLKM.in"
-                        "${MODULE_MAKEFILE}")
+-                       "${MODULE_MAKEFILE}")
++        CONFIGURE_FILE("${_USE_RATHAXES_LIST_DIR}/Templates/MakefileLKM.in" "${MODULE_MAKEFILE}")
  
          SET(KERNEL_OBJECT_NAME "${RATHAXES_SOURCE}_${SYSTEM}.ko")
-@@ -216,11 +218,11 @@
+         ADD_CUSTOM_COMMAND(OUTPUT "${KERNEL_OBJECT_NAME}"
+@@ -216,11 +217,9 @@
          # Generate the Windows Makefile to build a Windows kernel module
          SET(MODULE_SOURCES "${MODULE_BUILD_DIR}/sources")
          SET(LKM_SOURCES "${RATHAXES_SOURCE}_${SYSTEM}.c")
 -        CONFIGURE_FILE("${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/Templates/sources.in"
-+        CONFIGURE_FILE("${CMAKE_CURRENT_LIST_DIR}/Templates/sources.in"
-                        "${MODULE_SOURCES}")
+-                       "${MODULE_SOURCES}")
++        CONFIGURE_FILE("${_USE_RATHAXES_LIST_DIR}/Templates/sources.in" "${MODULE_SOURCES}")
  
-        SET(WINDOWS_MAKEFILE
+-       SET(WINDOWS_MAKEFILE
 -           "${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/Templates/Windows_Makefile")
-+           "${CMAKE_CURRENT_LIST_DIR}/Templates/Windows_Makefile")
++       SET(WINDOWS_MAKEFILE "${_USE_RATHAXES_LIST_DIR}/Templates/Windows_Makefile")
  
          SET(KERNEL_OBJECT_NAME "${RATHAXES_SOURCE}_${SYSTEM}.sys")
          ADD_CUSTOM_COMMAND(OUTPUT "${KERNEL_OBJECT_NAME}"
-@@ -237,3 +239,24 @@
+@@ -237,3 +236,47 @@
  	MESSAGE(STATUS "Don't know how to build kernel modules for ${SYSTEM} (yet)")
  ENDIF (${SYSTEM} MATCHES "Linux")
  ENDFUNCTION(ADD_RATHAXES_LKM NAME RATHAXES_SOURCE)
 +
 +# Code #########################################################################
 +
++# Inside a FUNCTION OR MACRO CMAKE_CURRENT_LIST_{DIR,FILE} return the path of
++# the caller CMakeLists.txt. Additionaly, CMAKE_CURRENT_LIST_DIR is a feature
++# of CMake >= 2.8.3.
++GET_FILENAME_COMPONENT(_USE_RATHAXES_LIST_DIR ${CMAKE_CURRENT_LIST_FILE} PATH CACHE)
++MARK_AS_ADVANCED(_USE_RATHAXES_LIST_DIR)
++
 +# Find additional dependencies:
 +
-+FIND_PACKAGE(CodeWorker REQUIRED)
++# If we are within the Rathaxes project directly use CodeWorker and directly
++# point to the compiler files within the repository.
++# Else use the "system" rathaxes binary.
++IF (${PROJECT_NAME} STREQUAL RATHAXES)
++    FIND_PACKAGE(CodeWorker REQUIRED)
++
++    SET(_USE_RATHAXES_CODEWORKER_COMMAND
++        ${CODEWORKER_BINARY_PATH} "-nologo"
++        "-I" "${RATHAXES_SOURCE_DIR}/maintainers/cnorm/src"
++        "-I" "${RATHAXES_SOURCE_DIR}/rathaxes/compiler/"
++        "-script" "${CMAKE_SOURCE_DIR}/rathaxes/compiler/rathaxes.cws"
++        "-args" "${CMAKE_SOURCE_DIR}/rathaxes/" "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/RathaxesCache/"
++        CACHE INTERNAL "CodeWorker command to -manually- invoke the Rathaxes compiler")
++ELSE (${PROJECT_NAME} STREQUAL RATHAXES)
++    FIND_PACKAGE(Rathaxes REQUIRED)
++
++    SET(_USE_RATHAXES_CODEWORKER_COMMAND ${RATHAXES_BINARY_PATH} CACHE INTERNAL "Rathaxes command")
++ENDIF (${PROJECT_NAME} STREQUAL RATHAXES)
 +
 +# Only do this on Linux, as far as I know nobody compiles Linux from another OS.
 +IF (CMAKE_SYSTEM_NAME MATCHES "Linux")
@@ -123,6 +226,18 @@
 +IF (CMAKE_COMPILER_IS_GNUCC)
 +    SET(CMAKE_C_FLAGS "-pipe -Wextra -Wall -std=c99")
 +ENDIF (CMAKE_COMPILER_IS_GNUCC)
+diff --git a/maintainers/bin/CMakeLists.txt b/maintainers/bin/CMakeLists.txt
+--- a/maintainers/bin/CMakeLists.txt
++++ b/maintainers/bin/CMakeLists.txt
+@@ -19,7 +19,7 @@
+ ENDIF (WIN32)
+ 
+ SET(CNORM_PATH "${PATH_PREFIX}/lib/rathaxes/cnorm/")
+-SET(COMPILER_PATH "${PATH_PREFIX}/lib/rathaxes/compiler/")
++SET(RATHAXES_LIB "${PATH_PREFIX}/lib/rathaxes")
+ SET(CODEWORKER_PATH "${PATH_PREFIX}/lib/rathaxes/codeworker${CMAKE_EXECUTABLE_SUFFIX}")
+ 
+ CONFIGURE_FILE("${RATHAXES_SCRIPT_NAME}.in" "${RATHAXES_SCRIPT_NAME}" @ONLY)
 diff --git a/maintainers/bin/rathaxes.bat b/maintainers/bin/rathaxes.bat
 --- a/maintainers/bin/rathaxes.bat
 +++ b/maintainers/bin/rathaxes.bat
@@ -132,11 +247,29 @@
 -rem We have to explicitely give the path of the script as the first argument on
 -rem Windows.
 -
- %CODEWORKER% --quiet %INCLUDE_PATHS% -script %COMPILER_PATH%/rathaxes.cws -args %COMPILER_PATH%/rathaxes.cws %LOCAL_CACHE_PATH% %*
+-%CODEWORKER% --quiet %INCLUDE_PATHS% -script %COMPILER_PATH%/rathaxes.cws -args %COMPILER_PATH%/rathaxes.cws %LOCAL_CACHE_PATH% %*
++%CODEWORKER% --quiet %INCLUDE_PATHS% -script %COMPILER_PATH%/rathaxes.cws -args %RATHAXES_LIB% %LOCAL_CACHE_PATH% %*
+diff --git a/maintainers/bin/rathaxes.in b/maintainers/bin/rathaxes.in
+--- a/maintainers/bin/rathaxes.in
++++ b/maintainers/bin/rathaxes.in
+@@ -1,10 +1,11 @@
+ #!/bin/sh
+ 
+ CNORM_PATH="@CNORM_PATH@"
+-COMPILER_PATH="@COMPILER_PATH@"
++RATHAXES_LIB="@RATHAXES_LIB@"
++COMPILER_PATH="$RATHAXES_LIB/compiler"
+ LOCAL_CACHE_PATH=${LOCAL_CACHE_PATH:-~/.rathaxes/cache}
+ 
+ INCLUDE_PATHS="-I $CNORM_PATH -I $COMPILER_PATH"
+ 
+ exec @CODEWORKER_PATH@ --quiet $INCLUDE_PATHS \
+-         -script $COMPILER_PATH/rathaxes.cws -args $COMPILER_PATH $LOCAL_CACHE_PATH $*
++         -script $COMPILER_PATH/rathaxes.cws -args $RATHAXES_LIB $LOCAL_CACHE_PATH $*
 diff --git a/maintainers/bin/rathaxesvars.bat.in b/maintainers/bin/rathaxesvars.bat.in
 --- a/maintainers/bin/rathaxesvars.bat.in
 +++ b/maintainers/bin/rathaxesvars.bat.in
-@@ -2,6 +2,11 @@
+@@ -2,8 +2,14 @@
  
  echo -- Setting up the Rathaxes environment
  
@@ -146,12 +279,16 @@
 +rem FindCodeWorker CMake finder.
 +set RATHAXES_PATH="%CD%"
  set CNORM_PATH="%CD%@CNORM_PATH@"
- set COMPILER_PATH="%CD%@COMPILER_PATH@"
+-set COMPILER_PATH="%CD%@COMPILER_PATH@"
++set RATHAXES_LIB="%CD%@RATHAXES_LIB@"
++set COMPILER_PATH="%CD%%RATHAXES_LIB%/compiler"
  set LOCAL_CACHE_PATH="%LOCALAPPDATA%\\Rathaxes\\cache\\"
+ 
+ set INCLUDE_PATHS=-I %CNORM_PATH% -I %COMPILER_PATH%
 diff --git a/rathaxes/CMakeLists.txt b/rathaxes/CMakeLists.txt
 --- a/rathaxes/CMakeLists.txt
 +++ b/rathaxes/CMakeLists.txt
-@@ -26,4 +26,21 @@
+@@ -26,4 +26,22 @@
  
  INSTALL(DIRECTORY compiler DESTINATION lib/rathaxes
          PATTERN compiler/tests EXCLUDE)
@@ -169,6 +306,7 @@
 +INSTALL(FILES
 +        ${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/UseRathaxes.cmake
 +        ${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/FindCodeWorker.cmake
++        ${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/FindRathaxes.cmake
 +        ${RATHAXES_SOURCE_DIR}/maintainers/CMakeScripts/FindLinuxKBuildDir.cmake
 +        DESTINATION share/doc/rathaxes/samples/CMakeScripts/)
 +# Templates used by the CMakeScripts
@@ -178,12 +316,14 @@
 new file mode 100644
 --- /dev/null
 +++ b/rathaxes/samples/SamplesCMakeLists.txt
-@@ -0,0 +1,12 @@
+@@ -0,0 +1,14 @@
 +PROJECT(RTX_SAMPLES C)
 +
 +CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 +
-+INCLUDE(CMakeScripts/UseRathaxes)
++LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMakeScripts)
++
++INCLUDE(UseRathaxes)
 +
 +ENABLE_TESTING()
 +