merge from default

code/CMakeLists.txt

@@ -48,9 +48,6 @@ SET(NL_VERSION_MINOR 8)
 SET(NL_VERSION_PATCH 0)
 SET(NL_VERSION "${NL_VERSION_MAJOR}.${NL_VERSION_MINOR}.${NL_VERSION_PATCH}")
 
-NL_SETUP_BUILD()
-NL_SETUP_BUILD_FLAGS()
-
 #-----------------------------------------------------------------------------
 # Redirect output files
 SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
@@ -87,6 +84,9 @@ RYZOM_SETUP_PREFIX_PATHS()
 
 NL_CONFIGURE_CHECKS()
 
+NL_SETUP_BUILD()
+NL_SETUP_BUILD_FLAGS()
+
 #-----------------------------------------------------------------------------
 #Platform specifics
 
@@ -111,10 +111,11 @@ IF(WITH_STATIC)
   SET(LIBXML2_DEFINITIONS ${LIBXML2_DEFINITIONS} -DLIBXML_STATIC)
   SET(LIBXML2_LIBRARIES ${LIBXML2_LIBRARIES} ${WINSOCK2_LIB})
 
-  # on Mac OS X libxml2 requieres iconv
+  # on Mac OS X libxml2 requires iconv and liblzma
   IF(APPLE)
     FIND_PACKAGE(Iconv REQUIRED)
-    SET(LIBXML2_LIBRARIES ${LIBXML2_LIBRARIES} ${ICONV_LIBRARIES})
+    FIND_PACKAGE(LibLZMA REQUIRED)
+    SET(LIBXML2_LIBRARIES ${LIBXML2_LIBRARIES} ${ICONV_LIBRARIES} ${LIBLZMA_LIBRARIES})
     INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
   ENDIF(APPLE)
 ENDIF(WITH_STATIC)
@@ -230,7 +231,7 @@ IF(WIN32)
         "${QT_LIBRARY_DIR}/../bin/QtGuid4.dll"
         "${QT_LIBRARY_DIR}/../bin/QtXmld4.dll"
         "${QT_LIBRARY_DIR}/../bin/QtCored4.dll"
-        DESTINATION bin)
+        DESTINATION ${NL_BIN_PREFIX})
     ENDIF(WITH_QT)
   ELSE(NOT CMAKE_BUILD_TYPE STREQUAL "Release")
     IF(WITH_QT)
@@ -239,18 +240,18 @@ IF(WIN32)
         "${QT_LIBRARY_DIR}/../bin/QtGui4.dll"
         "${QT_LIBRARY_DIR}/../bin/QtXml4.dll"
         "${QT_LIBRARY_DIR}/../bin/QtCore4.dll"
-        DESTINATION bin)
+        DESTINATION ${NL_BIN_PREFIX})
     ENDIF(WITH_QT)
   ENDIF(NOT CMAKE_BUILD_TYPE STREQUAL "Release")
 
   # Install CEGUI and its dependencies.
   IF(WITH_NEL_CEGUI)
-    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIBase.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIBase.dll" DESTINATION ${NL_BIN_PREFIX})
-    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIDevilImageCodec.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIDevilImageCodec.dll" DESTINATION ${NL_BIN_PREFIX})
-    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIExpatParser.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIExpatParser.dll" DESTINATION ${NL_BIN_PREFIX})
-    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIFalagardWRBase.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/CEGUIFalagardWRBase.dll" DESTINATION ${NL_BIN_PREFIX})
-    INSTALL(FILES "${CEGUI_LIB_DIR}/Devil.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/Devil.dll" DESTINATION ${NL_BIN_PREFIX})
-    INSTALL(FILES "${CEGUI_LIB_DIR}/ILU.dll" DESTINATION bin)
+    INSTALL(FILES "${CEGUI_LIB_DIR}/ILU.dll" DESTINATION ${NL_BIN_PREFIX})
   ENDIF(WITH_NEL_CEGUI)
 
   # Only the tools require MFC.

code/CMakeModules/FindMercurial.cmake

@@ -60,7 +60,7 @@ IF(Mercurial_HG_EXECUTABLE)
     "\\1" Mercurial_VERSION_HG "${Mercurial_VERSION_HG}")
 	
   MACRO(Mercurial_WC_INFO dir prefix)
-    EXECUTE_PROCESS(COMMAND ${Mercurial_HG_EXECUTABLE} tip
+    EXECUTE_PROCESS(COMMAND ${Mercurial_HG_EXECUTABLE} tip --template "{rev};{node};{tags};{author}"
       WORKING_DIRECTORY ${dir}
       OUTPUT_VARIABLE ${prefix}_WC_INFO
       ERROR_VARIABLE Mercurial_hg_info_error
@@ -70,18 +70,18 @@ IF(Mercurial_HG_EXECUTABLE)
     IF(NOT ${Mercurial_hg_info_result} EQUAL 0)
       MESSAGE(SEND_ERROR "Command \"${Mercurial_HG_EXECUTABLE} tip\" failed with output:\n${Mercurial_hg_info_error}")
     ELSE(NOT ${Mercurial_hg_info_result} EQUAL 0)
-
+      LIST(LENGTH ${prefix}_WC_INFO _COUNT)
-      STRING(REGEX REPLACE "^(.*\n)?Repository Root: ([^\n]+).*"
+      IF(_COUNT EQUAL 4)
-        "\\2" ${prefix}_WC_ROOT "${${prefix}_WC_INFO}")
+        LIST(GET ${prefix}_WC_INFO 0 ${prefix}_WC_REVISION)
-      STRING(REGEX REPLACE "^(.*\n)?changeset: *([0-9]+).*"
+        LIST(GET ${prefix}_WC_INFO 1 ${prefix}_WC_CHANGESET)
-        "\\2" ${prefix}_WC_REVISION "${${prefix}_WC_INFO}")
+        LIST(GET ${prefix}_WC_INFO 2 ${prefix}_WC_BRANCH)
-      STRING(REGEX REPLACE "^(.*\n)?Last Changed Author: ([^\n]+).*"
+        LIST(GET ${prefix}_WC_INFO 3 ${prefix}_WC_LAST_CHANGED_AUTHOR)
-        "\\2" ${prefix}_WC_LAST_CHANGED_AUTHOR "${${prefix}_WC_INFO}")
+      ELSE(_COUNT EQUAL 4)
-      STRING(REGEX REPLACE "^(.*\n)?Last Changed Rev: ([^\n]+).*"
+        MESSAGE(STATUS "Bad output from HG")
-        "\\2" ${prefix}_WC_LAST_CHANGED_REV "${${prefix}_WC_INFO}")
+        SET(${prefix}_WC_REVISION "unknown")
-      STRING(REGEX REPLACE "^(.*\n)?Last Changed Date: ([^\n]+).*"
+        SET(${prefix}_WC_CHANGESET "unknown")
-        "\\2" ${prefix}_WC_LAST_CHANGED_DATE "${${prefix}_WC_INFO}")
+        SET(${prefix}_WC_BRANCH "unknown")
-
+      ENDIF(_COUNT EQUAL 4)
     ENDIF(NOT ${Mercurial_hg_info_result} EQUAL 0)
 
   ENDMACRO(Mercurial_WC_INFO)

code/CMakeModules/FindSquish.cmake

@@ -67,6 +67,11 @@ IF(SQUISH_FOUND)
   IF(NOT SQUISH_FIND_QUIETLY)
     MESSAGE(STATUS "Found Squish: ${SQUISH_LIBRARIES}")
   ENDIF(NOT SQUISH_FIND_QUIETLY)
+  FILE(STRINGS ${SQUISH_INCLUDE_DIR}/squish.h METRIC REGEX "metric = 0")
+  IF(METRIC)
+    SET(SQUISH_COMPRESS_HAS_METRIC ON)
+    SET(SQUISH_DEFINITIONS -DSQUISH_COMPRESS_HAS_METRIC)
+  ENDIF(METRIC)
 ELSE(SQUISH_FOUND)
   IF(NOT SQUISH_FIND_QUIETLY)
     MESSAGE(STATUS "Warning: Unable to find Squish!")

code/CMakeModules/FindWindowsSDK.cmake

@@ -2,47 +2,86 @@
 # Find the Windows includes
 #
 #  WINSDK_INCLUDE_DIR - where to find Windows.h
+#  WINSDK_INCLUDE_DIRS - where to find all Windows headers
+#  WINSDK_LIBRARY_DIR - where to find libraries
 #  WINSDK_FOUND       - True if Windows SDK found.
 
 IF(WINSDK_INCLUDE_DIR)
     # Already in cache, be silent
-    SET(WINSDK_FIND_QUIETLY TRUE)
+    SET(WindowsSDK_FIND_QUIETLY TRUE)
 ENDIF(WINSDK_INCLUDE_DIR)
 
+# TODO: add the possibility to use a specific Windows SDK
+
+IF(MSVC11)
+  GET_FILENAME_COMPONENT(WINSDK8_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;InstallationFolder]" ABSOLUTE CACHE)
+  GET_FILENAME_COMPONENT(WINSDK8_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;ProductVersion]" NAME)
+
+  IF(WINSDK8_DIR)
+    IF(NOT WindowsSDK_FIND_QUIETLY)
+      MESSAGE(STATUS "Found Windows SDK ${WINSDK8_VERSION} in ${WINSDK8_DIR}")
+    ENDIF(NOT WindowsSDK_FIND_QUIETLY)
+    IF(TARGET_ARM)
+      SET(WINSDK8_SUFFIX "arm")
+    ELSEIF(TARGET_X64)
+      SET(WINSDK8_SUFFIX "x64")
+    ELSEIF(TARGET_X86)
+      SET(WINSDK8_SUFFIX "x86")
+    ENDIF(TARGET_ARM)
+  ENDIF(WINSDK8_DIR)
+ENDIF(MSVC11)
+
 GET_FILENAME_COMPONENT(WINSDK71_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1;InstallationFolder]" ABSOLUTE CACHE)
 GET_FILENAME_COMPONENT(WINSDK71_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v7.1;ProductVersion]" NAME)
 
 IF(WINSDK71_DIR)
-  IF(NOT WINSDK_FIND_QUIETLY)
+  IF(NOT WindowsSDK_FIND_QUIETLY)
     MESSAGE(STATUS "Found Windows SDK ${WINSDK71_VERSION} in ${WINSDK71_DIR}")
-  ENDIF(NOT WINSDK_FIND_QUIETLY)
+  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
 ENDIF(WINSDK71_DIR)
 
 GET_FILENAME_COMPONENT(WINSDKCURRENT_DIR  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]" ABSOLUTE CACHE)
 GET_FILENAME_COMPONENT(WINSDKCURRENT_VERSION "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentVersion]" NAME)
 
 IF(WINSDKCURRENT_DIR)
-  IF(NOT WINSDK_FIND_QUIETLY)
+  IF(NOT WindowsSDK_FIND_QUIETLY)
     MESSAGE(STATUS "Found Windows SDK ${WINSDKCURRENT_VERSION} in ${WINSDKCURRENT_DIR}")
-  ENDIF(NOT WINSDK_FIND_QUIETLY)
+  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
 ENDIF(WINSDKCURRENT_DIR)
 
 FIND_PATH(WINSDK_INCLUDE_DIR Windows.h
-  PATHS
+  HINTS
+  ${WINSDK8_DIR}/Include/um
   ${WINSDK71_DIR}/Include
   ${WINSDKCURRENT_DIR}/Include
 )
 
+FIND_PATH(WINSDK_SHARED_INCLUDE_DIR d3d9.h
+  HINTS
+  ${WINSDK8_DIR}/Include/shared
+  ${WINSDK71_DIR}/Include
+  ${WINSDKCURRENT_DIR}/Include
+)
+
+FIND_PATH(WINSDK_LIBRARY_DIR ComCtl32.lib
+  HINTS
+  ${WINSDK8_DIR}/Lib/win8/um/${WINSDK8_SUFFIX}
+  ${WINSDK71_DIR}/Lib
+  ${WINSDKCURRENT_DIR}/Lib
+)
+
 FIND_PROGRAM(WINSDK_SIGNTOOL signtool
-  PATHS
+  HINTS
+  ${WINSDK8_DIR}/Bin/x86
   ${WINSDK71_DIR}/Bin
   ${WINSDKCURRENT_DIR}/Bin
 )
 
 IF(WINSDK_INCLUDE_DIR)
   SET(WINSDK_FOUND TRUE)
+  SET(WINSDK_INCLUDE_DIRS ${WINSDK_INCLUDE_DIR} ${WINSDK_SHARED_INCLUDE_DIR})
 ELSE(WINSDK_INCLUDE_DIR)
-  IF(NOT WINSDK_FIND_QUIETLY)
+  IF(NOT WindowsSDK_FIND_QUIETLY)
     MESSAGE(STATUS "Warning: Unable to find Windows SDK!")
-  ENDIF(NOT WINSDK_FIND_QUIETLY)
+  ENDIF(NOT WindowsSDK_FIND_QUIETLY)
 ENDIF(WINSDK_INCLUDE_DIR)

code/CMakeModules/GetRevision.cmake

@@ -3,20 +3,24 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3)
 # ROOT_DIR should be set to root of the repository (where to find the .svn or .hg directory)
 # SOURCE_DIR should be set to root of your code (where to find CMakeLists.txt)
 
-# Replace spaces by semi-columns
+IF(SOURCE_DIR)
-IF(CMAKE_MODULE_PATH)
+  # Replace spaces by semi-columns
+  IF(CMAKE_MODULE_PATH)
     STRING(REPLACE " " ";" CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH})
-ENDIF(CMAKE_MODULE_PATH)
+  ENDIF(CMAKE_MODULE_PATH)
 
-SET(CMAKE_MODULE_PATH ${SOURCE_DIR}/CMakeModules ${CMAKE_MODULE_PATH})
+  SET(CMAKE_MODULE_PATH ${SOURCE_DIR}/CMakeModules ${CMAKE_MODULE_PATH})
 
-IF(NOT ROOT_DIR AND SOURCE_DIR)
+  IF(NOT ROOT_DIR AND SOURCE_DIR)
     SET(ROOT_DIR ${SOURCE_DIR})
-ENDIF(NOT ROOT_DIR AND SOURCE_DIR)
+  ENDIF(NOT ROOT_DIR AND SOURCE_DIR)
 
-IF(NOT SOURCE_DIR AND ROOT_DIR)
+  IF(NOT SOURCE_DIR AND ROOT_DIR)
     SET(SOURCE_DIR ${ROOT_DIR})
-ENDIF(NOT SOURCE_DIR AND ROOT_DIR)
+  ENDIF(NOT SOURCE_DIR AND ROOT_DIR)
+ELSE(SOURCE_DIR)
+  SET(ROOT_DIR ${CMAKE_SOURCE_DIR})
+ENDIF(SOURCE_DIR)
 
 MACRO(NOW RESULT)
   IF (WIN32)
@@ -53,10 +57,11 @@ IF(EXISTS "${ROOT_DIR}/.hg/")
   ENDIF(MERCURIAL_FOUND)
 ENDIF(EXISTS "${ROOT_DIR}/.hg/")
 
-IF(DEFINED REVISION)
+IF(SOURCE_DIR AND DEFINED REVISION)
   IF(EXISTS ${SOURCE_DIR}/revision.h.in)
+    MESSAGE(STATUS "Revision: ${REVISION}")
     NOW(BUILD_DATE)
     CONFIGURE_FILE(${SOURCE_DIR}/revision.h.in revision.h.txt)
     EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E copy revision.h.txt revision.h) # copy_if_different
   ENDIF(EXISTS ${SOURCE_DIR}/revision.h.in)
-ENDIF(DEFINED REVISION)
+ENDIF(SOURCE_DIR AND DEFINED REVISION)

code/CMakeModules/PCHSupport.cmake

@@ -17,13 +17,11 @@ ELSE(MSVC)
       ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
       OUTPUT_VARIABLE gcc_compiler_version)
 
-		IF(gcc_compiler_version MATCHES "4\\.[0-9]\\.[0-9]")
+    IF(gcc_compiler_version MATCHES "^4\\.1(\\.[0-9]+)?")
+      SET(PCHSupport_FOUND FALSE)
+    ELSEIF(gcc_compiler_version MATCHES "^4\\.[0-9]+(\\.[0-9]+)?")
       SET(PCHSupport_FOUND TRUE)
-		ELSE(gcc_compiler_version MATCHES "4\\.[0-9]\\.[0-9]")
+    ENDIF(gcc_compiler_version MATCHES "^4\\.1(\\.[0-9]+)?")
-			IF(gcc_compiler_version MATCHES "3\\.4\\.[0-9]")
-				SET(PCHSupport_FOUND TRUE)
-			ENDIF(gcc_compiler_version MATCHES "3\\.4\\.[0-9]")
-		ENDIF(gcc_compiler_version MATCHES "4\\.[0-9]\\.[0-9]")
   ELSE(CMAKE_COMPILER_IS_GNUCXX)
     # TODO: make tests for other compilers than GCC
     SET(PCHSupport_FOUND TRUE)
@@ -32,41 +30,123 @@ ELSE(MSVC)
   SET(_PCH_include_prefix "-I")
 ENDIF(MSVC)
 
-MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
+# Set PCH_FLAGS for common flags, PCH_ARCH_XXX_FLAGS for specific archs flags and PCH_ARCHS for archs
-	STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _flags_var_name)
+MACRO(PCH_SET_COMPILE_FLAGS _target)
-	SET(${_out_compile_flags} ${${_flags_var_name}} )
+  SET(PCH_FLAGS)
+  SET(PCH_ARCHS)
+
+  SET(FLAGS)
+  LIST(APPEND _FLAGS ${CMAKE_CXX_FLAGS})
+
+  STRING(TOUPPER "${CMAKE_BUILD_TYPE}" _UPPER_BUILD)
+  LIST(APPEND _FLAGS " ${CMAKE_CXX_FLAGS_${_UPPER_BUILD}}")
 
   IF(NOT MSVC)
-		GET_TARGET_PROPERTY(_targetType ${_PCH_current_target} TYPE)
+    GET_TARGET_PROPERTY(_targetType ${_target} TYPE)
     IF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
-			LIST(APPEND ${_out_compile_flags} "-fPIC")
+      LIST(APPEND _FLAGS " -fPIC")
     ENDIF(${_targetType} STREQUAL SHARED_LIBRARY OR ${_targetType} STREQUAL MODULE_LIBRARY)
   ENDIF(NOT MSVC)
 
-	GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )
+  GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES)
   FOREACH(item ${DIRINC})
-		LIST(APPEND ${_out_compile_flags} " ${_PCH_include_prefix}\"${item}\"")
+    LIST(APPEND _FLAGS " ${_PCH_include_prefix}\"${item}\"")
   ENDFOREACH(item)
 
   # Required for CMake 2.6
-	SET(GLOBAL_DEFINITIONS "")
+  SET(GLOBAL_DEFINITIONS)
   GET_DIRECTORY_PROPERTY(DEFINITIONS COMPILE_DEFINITIONS)
   FOREACH(item ${DEFINITIONS})
-		LIST(APPEND GLOBAL_DEFINITIONS -D${item})
+    LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
   ENDFOREACH(item)
 
+  GET_DIRECTORY_PROPERTY(DEFINITIONS COMPILE_DEFINITIONS_${_UPPER_BUILD})
+  FOREACH(item ${DEFINITIONS})
+    LIST(APPEND GLOBAL_DEFINITIONS " -D${item}")
+  ENDFOREACH(item)
+
+  GET_TARGET_PROPERTY(oldProps ${_target} COMPILE_FLAGS)
+  IF(oldProps)
+    LIST(APPEND _FLAGS " ${oldProps}")
+  ENDIF(oldProps)
+
+  GET_TARGET_PROPERTY(oldPropsBuild ${_target} COMPILE_FLAGS_${_UPPER_BUILD})
+  IF(oldPropsBuild)
+    LIST(APPEND _FLAGS " ${oldPropsBuild}")
+  ENDIF(oldPropsBuild)
+
   GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
   GET_DIRECTORY_PROPERTY(_directory_definitions DIRECTORY ${CMAKE_SOURCE_DIR} DEFINITIONS)
-	LIST(APPEND ${_out_compile_flags} ${GLOBAL_DEFINITIONS})
+  LIST(APPEND _FLAGS " ${GLOBAL_DEFINITIONS}")
-	LIST(APPEND ${_out_compile_flags} ${_directory_flags})
+  LIST(APPEND _FLAGS " ${_directory_flags}")
-	LIST(APPEND ${_out_compile_flags} ${_directory_definitions})
+  LIST(APPEND _FLAGS " ${_directory_definitions}")
-	LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS})
+
+  STRING(REGEX REPLACE " +" " " _FLAGS ${_FLAGS})
 
   # Format definitions
-	SEPARATE_ARGUMENTS(${_out_compile_flags})
+  SEPARATE_ARGUMENTS(_FLAGS)
-ENDMACRO(_PCH_GET_COMPILE_FLAGS)
 
-MACRO(_PCH_GET_PDB_FILENAME out_filename _target)
+  IF(CLANG)
+    # Determining all architectures and get common flags
+    SET(_ARCH_NEXT)
+    SET(_XARCH_NEXT)
+    FOREACH(item ${_FLAGS})
+      IF(_ARCH_NEXT)
+        LIST(FIND PCH_ARCHS ${item} ITEM_FOUND)
+        IF(ITEM_FOUND EQUAL -1)
+          LIST(APPEND PCH_ARCHS ${item})
+          STRING(TOUPPER "${item}" _UPPER_ARCH)
+          SET(PCH_ARCH_${_UPPER_ARCH}_FLAGS "-arch" ${item})
+        ENDIF(ITEM_FOUND EQUAL -1)
+        SET(_ARCH_NEXT OFF)
+      ELSEIF(_XARCH_NEXT)
+        SET(_XARCH_NEXT OFF)
+      ELSE(_ARCH_NEXT)
+        IF(item MATCHES "^-arch")
+          SET(_ARCH_NEXT ON)
+        ELSEIF(item MATCHES "^-Xarch_")
+          STRING(REGEX REPLACE "-Xarch_([a-z0-9_]+)" "\\1" item ${item})
+          LIST(FIND PCH_ARCHS ${item} ITEM_FOUND)
+          IF(ITEM_FOUND EQUAL -1)
+            LIST(APPEND PCH_ARCHS ${item})
+            STRING(TOUPPER "${item}" _UPPER_ARCH)
+            SET(PCH_ARCH_${_UPPER_ARCH}_FLAGS "-arch" ${item})
+          ENDIF(ITEM_FOUND EQUAL -1)
+          SET(_XARCH_NEXT ON)
+        ELSE(item MATCHES "^-arch")
+          LIST(APPEND PCH_FLAGS ${item})
+        ENDIF(item MATCHES "^-arch")
+      ENDIF(_ARCH_NEXT)
+    ENDFOREACH(item)
+
+    # Get architcture specific flags
+    SET(_XARCH_NEXT)
+    FOREACH(item ${_FLAGS})
+      IF(_XARCH_NEXT)
+        STRING(TOUPPER "${_XARCH_NEXT}" _UPPER_XARCH)
+        LIST(APPEND PCH_ARCH_${_UPPER_XARCH}_FLAGS ${item})
+        SET(_XARCH_NEXT OFF)
+      ELSE(_XARCH_NEXT)
+        IF(item MATCHES "^-Xarch_")
+          STRING(SUBSTRING "${item}" 7 -1 _XARCH_NEXT)
+        ENDIF(item MATCHES "^-Xarch_")
+      ENDIF(_XARCH_NEXT)
+    ENDFOREACH(item)
+
+    # Remove duplicated architectures
+    IF(_ARCHS AND PCH_ARCHS)
+      LIST(REMOVE_DUPLICATES PCH_ARCHS)
+    ENDIF(_ARCHS AND PCH_ARCHS)
+  ELSE(CLANG)
+    SET(PCH_FLAGS ${_FLAGS})
+  ENDIF(CLANG)
+
+  IF(PCH_FLAGS)
+    LIST(REMOVE_DUPLICATES PCH_FLAGS)
+  ENDIF(PCH_FLAGS)
+ENDMACRO(PCH_SET_COMPILE_FLAGS)
+
+MACRO(GET_PDB_FILENAME _out_filename _target)
   # determine output directory based on target type
   GET_TARGET_PROPERTY(_targetType ${_target} TYPE)
   IF(${_targetType} STREQUAL EXECUTABLE)
@@ -84,10 +164,10 @@ MACRO(_PCH_GET_PDB_FILENAME out_filename _target)
     SET(_targetPostfix "")
   ENDIF(${_targetPostfix} MATCHES NOTFOUND)
 
-	SET(${out_filename} "${_targetOutput}/${_target}${_targetPostfix}.pdb")
+  SET(${_out_filename} "${_targetOutput}/${_target}${_targetPostfix}.pdb")
-ENDMACRO(_PCH_GET_PDB_FILENAME)
+ENDMACRO(GET_PDB_FILENAME)
 
-MACRO(_PCH_GET_COMPILE_COMMAND out_command _input _inputcpp _output)
+MACRO(PCH_SET_COMPILE_COMMAND _inputcpp _compile_FLAGS)
   IF(CMAKE_CXX_COMPILER_ARG1)
     # remove leading space in compiler argument
     STRING(REGEX REPLACE "^ +" "" pchsupport_compiler_cxx_arg1 ${CMAKE_CXX_COMPILER_ARG1})
@@ -96,56 +176,117 @@ MACRO(_PCH_GET_COMPILE_COMMAND out_command _input _inputcpp _output)
   ENDIF(CMAKE_CXX_COMPILER_ARG1)
 
   IF(MSVC)
-		_PCH_GET_PDB_FILENAME(PDB_FILE ${_PCH_current_target})
+    GET_PDB_FILENAME(PDB_FILE ${_PCH_current_target})
-		SET(${out_command} ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} /Yc /Fp\"${_output}\" ${_inputcpp} /c /Fd\"${PDB_FILE}\")
+    SET(PCH_COMMAND ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} /Yc /Fp"${PCH_OUTPUT}" ${_inputcpp} /Fd"${PDB_FILE}" /c /Fo"${PCH_OUTPUT}.obj")
   ELSE(MSVC)
     SET(HEADER_FORMAT "c++-header")
+    SET(_FLAGS "")
     IF(APPLE)
       SET(HEADER_FORMAT "objective-${HEADER_FORMAT}")
+      SET(_FLAGS -fobjc-abi-version=2 -fobjc-legacy-dispatch)
     ENDIF(APPLE)
-		SET(${out_command} ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} -x ${HEADER_FORMAT} -o ${_output} -c ${_input})
+    SET(PCH_COMMAND ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} ${_FLAGS} -x ${HEADER_FORMAT} -o ${PCH_OUTPUT} -c ${PCH_INPUT})
   ENDIF(MSVC)
-ENDMACRO(_PCH_GET_COMPILE_COMMAND)
+ENDMACRO(PCH_SET_COMPILE_COMMAND)
+
+MACRO(PCH_SET_PRECOMPILED_HEADER_OUTPUT _targetName _input _arch _language)
+  SET(_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${_targetName}_pch")
 
-MACRO(GET_PRECOMPILED_HEADER_OUTPUT _targetName _input _output)
   IF(MSVC)
+    FILE(MAKE_DIRECTORY ${_OUTPUT_DIR})
     GET_FILENAME_COMPONENT(_name ${_input} NAME_WE)
-		SET(_output "${CMAKE_CURRENT_BINARY_DIR}/${_name}.pch")
+    SET(PCH_INPUT ${_input})
+    SET(PCH_OUTPUT "${_OUTPUT_DIR}/${_name}.pch")
   ELSE(MSVC)
-		GET_FILENAME_COMPONENT(_name ${_input} NAME)
+    IF(NOT "${_arch}" STREQUAL "")
-		SET(_output "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gch")
+      SET(_OUTPUT_DIR "${_OUTPUT_DIR}_${_arch}")
-	ENDIF(MSVC)
+    ENDIF(NOT "${_arch}" STREQUAL "")
-ENDMACRO(GET_PRECOMPILED_HEADER_OUTPUT _targetName _input)
 
-MACRO(ADD_PRECOMPILED_HEADER_TO_TARGET _targetName _input _pch_output_to_use )
+    IF(NOT "${_language}" STREQUAL "")
+      SET(_OUTPUT_DIR "${_OUTPUT_DIR}_${_language}")
+    ENDIF(NOT "${_language}" STREQUAL "")
+
+    GET_FILENAME_COMPONENT(_name ${_input} NAME)
+
+    # Copy .h to output dir
+    SET(PCH_INPUT "${_OUTPUT_DIR}/${_name}")
+    ADD_CUSTOM_COMMAND(OUTPUT ${PCH_INPUT}
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${_input} ${PCH_INPUT}
+        DEPENDS ${_input}
+        COMMENT "[${_targetName}] Update precompiled header - done"
+    )
+
+    IF(CLANG)
+      SET(PCH_EXT "pth")
+    ELSE(CLANG)
+      SET(PCH_EXT "gch")
+    ENDIF(CLANG)
+
+    # For GCC and Clang, PCH needs to be in the same directory as .h
+    SET(PCH_OUTPUT "${_OUTPUT_DIR}/${_name}.${PCH_EXT}")
+  ENDIF(MSVC)
+ENDMACRO(PCH_SET_PRECOMPILED_HEADER_OUTPUT)
+
+# Add common flags
+MACRO(ADD_PRECOMPILED_HEADER_TO_TARGET _targetName)
   GET_TARGET_PROPERTY(oldProps ${_targetName} COMPILE_FLAGS)
+
   IF(${oldProps} MATCHES NOTFOUND)
     SET(oldProps "")
   ENDIF(${oldProps} MATCHES NOTFOUND)
 
   IF(MSVC)
-		SET(_target_cflags "${oldProps} /Yu\"${_input}\" /FI\"${_input}\" /Fp\"${_pch_output_to_use}\"")
+    SET(_target_cflags "${oldProps} /Yu\"${PCH_INPUT}\" /FI\"${PCH_INPUT}\" /Fp\"${PCH_OUTPUT}\"")
   ELSE(MSVC)
-		# to do: test whether compiler flags match between target  _targetName
-		# and _pch_output_to_use
-		FILE(TO_NATIVE_PATH ${_pch_output_to_use} _native_pch_path)
-
     # for use with distcc and gcc >4.0.1 if preprocessed files are accessible
     # on all remote machines set
     # PCH_ADDITIONAL_COMPILER_FLAGS to -fpch-preprocess
-		SET(_target_cflags "${oldProps} ${PCH_ADDITIONAL_COMPILER_FLAGS}-include ${_input} -Winvalid-pch")
+    SET(PCH_ADDITIONAL_COMPILER_FLAGS)
+    LIST(LENGTH PCH_ARCHS PCH_ARCHS_COUNT)
+
+    # If no arch is specified, create common flags
+    IF(PCH_ARCHS_COUNT LESS 2)
+      SET(PCH_ADDITIONAL_COMPILER_FLAGS "-include ${PCH_INPUT} ${PCH_ADDITIONAL_COMPILER_FLAGS}")
+    ENDIF(PCH_ARCHS_COUNT LESS 2)
+
+    IF(APPLE)
+      SET(PCH_ADDITIONAL_COMPILER_FLAGS "-fobjc-abi-version=2 -fobjc-legacy-dispatch -x objective-c++ ${PCH_ADDITIONAL_COMPILER_FLAGS}")
+    ENDIF(APPLE)
+    
+    IF(WITH_PCH_DEBUG)
+      SET(PCH_ADDITIONAL_COMPILER_FLAGS "-H ${PCH_ADDITIONAL_COMPILER_FLAGS}")
+    ENDIF(WITH_PCH_DEBUG)
+
+    SET(_target_cflags "${oldProps} ${PCH_ADDITIONAL_COMPILER_FLAGS} -Winvalid-pch")
   ENDIF(MSVC)
 
   SET_TARGET_PROPERTIES(${_targetName} PROPERTIES COMPILE_FLAGS ${_target_cflags})
-	IF(oldProps)
-		SET_TARGET_PROPERTIES(${_targetName}_pch_dephelp PROPERTIES COMPILE_FLAGS ${oldProps})
-	ENDIF(oldProps)
-	ADD_CUSTOM_TARGET(pch_Generate_${_targetName} DEPENDS ${_pch_output_to_use})
-	ADD_DEPENDENCIES(${_targetName} pch_Generate_${_targetName})
 ENDMACRO(ADD_PRECOMPILED_HEADER_TO_TARGET)
 
-MACRO(ADD_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
+# Add specific flags for an arch
+MACRO(ADD_PRECOMPILED_HEADER_TO_TARGET_ARCH _targetName _arch)
+  LIST(LENGTH PCH_ARCHS PCH_ARCHS_COUNT)
 
+  IF(PCH_ARCHS_COUNT GREATER 1)
+    GET_TARGET_PROPERTY(_FLAGS ${_targetName} COMPILE_FLAGS)
+
+    IF(${_FLAGS} MATCHES NOTFOUND)
+      SET(_FLAGS "")
+    ENDIF(${_FLAGS} MATCHES NOTFOUND)
+
+    SET(_FLAGS "${_FLAGS} -Xarch_${_arch} -include${PCH_INPUT}")
+
+    SET_TARGET_PROPERTIES(${_targetName} PROPERTIES COMPILE_FLAGS ${_FLAGS})
+  ENDIF(PCH_ARCHS_COUNT GREATER 1)
+ENDMACRO(ADD_PRECOMPILED_HEADER_TO_TARGET_ARCH)
+
+MACRO(PCH_CREATE_TARGET _targetName _targetNamePCH)
+  ADD_CUSTOM_COMMAND(OUTPUT ${PCH_OUTPUT} COMMAND ${PCH_COMMAND} COMMENT "Generating ${_targetNamePCH}" DEPENDS ${PCH_INPUT})
+  ADD_CUSTOM_TARGET(${_targetNamePCH} DEPENDS ${PCH_INPUT} ${PCH_OUTPUT})
+  ADD_DEPENDENCIES(${_targetName} ${_targetNamePCH})
+ENDMACRO(PCH_CREATE_TARGET _targetName _inputh _inputcpp)
+
+MACRO(ADD_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
   SET(_PCH_current_target ${_targetName})
 
   IF(NOT CMAKE_BUILD_TYPE)
@@ -155,38 +296,50 @@ MACRO(ADD_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
     )
   ENDIF(NOT CMAKE_BUILD_TYPE)
 
-	GET_PRECOMPILED_HEADER_OUTPUT( ${_targetName} ${_inputh} _output)
+  PCH_SET_COMPILE_FLAGS(${_targetName})
 
-	GET_TARGET_PROPERTY(_targetType ${_PCH_current_target} TYPE)
+  IF(PCH_ARCHS)
+    SET(PCH_OUTPUTS)
+    FOREACH(_ARCH ${PCH_ARCHS})
+      STRING(TOUPPER "${_ARCH}" _UPPER_ARCH)
 
-	# always build static library because it doesn't need linking
+      PCH_SET_PRECOMPILED_HEADER_OUTPUT(${_targetName} ${_inputh} ${_ARCH} "")
-	ADD_LIBRARY(${_targetName}_pch_dephelp STATIC ${_inputcpp})
+      LIST(APPEND PCH_OUTPUTS ${PCH_OUTPUT})
 
-	_PCH_GET_COMPILE_FLAGS(_compile_FLAGS)
+      PCH_SET_COMPILE_COMMAND(${_inputcpp} "${PCH_ARCH_${_UPPER_ARCH}_FLAGS};${PCH_FLAGS}")
+      PCH_CREATE_TARGET(${_targetName} ${_targetName}_pch_${_ARCH})
 
-	SET_SOURCE_FILES_PROPERTIES(${_inputh} PROPERTIES GENERATED 1)
+      ADD_PRECOMPILED_HEADER_TO_TARGET_ARCH(${_targetName} ${_ARCH})
+    ENDFOREACH(_ARCH)
+  ELSE(PCH_ARCHS)
+    PCH_SET_PRECOMPILED_HEADER_OUTPUT(${_targetName} ${_inputh} "" "")
+    LIST(APPEND PCH_OUTPUTS ${PCH_OUTPUT})
 
-	_PCH_GET_COMPILE_COMMAND(_command  ${_inputh} ${_inputcpp} ${_output})
+    PCH_SET_COMPILE_COMMAND(${_inputcpp} "${PCH_FLAGS}")
+    PCH_CREATE_TARGET(${_targetName} ${_targetName}_pch)
+  ENDIF(PCH_ARCHS)
 
-	ADD_CUSTOM_COMMAND(
+  ADD_PRECOMPILED_HEADER_TO_TARGET(${_targetName})
-		OUTPUT ${_output}
-		COMMAND ${_command}
-		DEPENDS ${_inputh} ${_targetName}_pch_dephelp
-	)
 
-	ADD_PRECOMPILED_HEADER_TO_TARGET(${_targetName} ${_inputh} ${_output})
+  SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${PCH_OUTPUTS}")
 ENDMACRO(ADD_PRECOMPILED_HEADER)
 
 # Macro to move PCH creation file to the front of files list
+# or remove .cpp from library/executable to avoid warning
 MACRO(FIX_PRECOMPILED_HEADER _files _pch)
   # Remove .cpp creating PCH from the list
   LIST(REMOVE_ITEM ${_files} ${_pch})
+  IF(MSVC)
     # Prepend .cpp creating PCH to the list
     LIST(INSERT ${_files} 0 ${_pch})
+  ENDIF(MSVC)
 ENDMACRO(FIX_PRECOMPILED_HEADER)
 
 MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
-	SET(PCH_METHOD 0)
+  IF(NOT PCHSupport_FOUND)
+    MESSAGE(STATUS "PCH disabled because compiler doesn't support them")
+    RETURN()
+  ENDIF(NOT PCHSupport_FOUND)
 
   # 0 => creating a new target for PCH, works for all makefiles
   # 1 => setting PCH for VC++ project, works for VC++ projects
@@ -199,6 +352,8 @@ MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
 #    SET(PCH_METHOD 1)
   ELSEIF(CMAKE_GENERATOR MATCHES "Xcode")
     SET(PCH_METHOD 2)
+  ELSE(CMAKE_GENERATOR MATCHES "Visual Studio")
+    SET(PCH_METHOD 0)
   ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio")
 
   IF(PCH_METHOD EQUAL 1)
@@ -220,11 +375,6 @@ MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
     # For Xcode, cmake needs my patch to process
     # GCC_PREFIX_HEADER and GCC_PRECOMPILE_PREFIX_HEADER as target properties
 
-		GET_TARGET_PROPERTY(oldProps ${_targetName} COMPILE_FLAGS)
-		IF(${oldProps} MATCHES NOTFOUND)
-			SET(oldProps "")
-		ENDIF(${oldProps} MATCHES NOTFOUND)
-
     # When buiding out of the tree, precompiled may not be located
     # Use full path instead.
     GET_FILENAME_COMPONENT(fullPath ${_inputh} ABSOLUTE)
@@ -236,4 +386,7 @@ MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _inputh _inputcpp)
     ADD_PRECOMPILED_HEADER(${_targetName} ${_inputh} ${_inputcpp})
   ENDIF(PCH_METHOD EQUAL 1)
 
+  IF(TARGET ${_targetName}_static)
+    ADD_NATIVE_PRECOMPILED_HEADER(${_targetName}_static ${_inputh} ${_inputcpp})
+  ENDIF(TARGET ${_targetName}_static)
 ENDMACRO(ADD_NATIVE_PRECOMPILED_HEADER)

code/CMakeModules/nel.cmake

@@ -13,11 +13,7 @@ ENDIF(NOT CMAKE_BUILD_TYPE)
 MACRO(NL_GEN_PC name)
   IF(NOT WIN32 AND WITH_INSTALL_LIBRARIES)
     CONFIGURE_FILE(${name}.in "${CMAKE_CURRENT_BINARY_DIR}/${name}")
-    IF(CMAKE_LIBRARY_ARCHITECTURE)
+    INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/${name}" DESTINATION ${NL_LIB_PREFIX}/pkgconfig)
-      INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/${name}" DESTINATION lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig)
-    ELSE(CMAKE_LIBRARY_ARCHITECTURE)
-      INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/${name}" DESTINATION lib/pkgconfig)
-    ENDIF(CMAKE_LIBRARY_ARCHITECTURE)
   ENDIF(NOT WIN32 AND WITH_INSTALL_LIBRARIES)
 ENDMACRO(NL_GEN_PC)
 
@@ -26,25 +22,52 @@ ENDMACRO(NL_GEN_PC)
 ###
 MACRO(NL_GEN_REVISION_H)
   IF(EXISTS ${CMAKE_SOURCE_DIR}/revision.h.in)
-    INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})
+    SET(TOOL_FOUND OFF)
-    ADD_DEFINITIONS(-DHAVE_REVISION_H)
-    SET(HAVE_REVISION_H ON)
 
+    IF(EXISTS "${CMAKE_SOURCE_DIR}/../.svn/")
+      FIND_PACKAGE(Subversion)
+
+      IF(SUBVERSION_FOUND)
+        SET(TOOL_FOUND ON)
+      ENDIF(SUBVERSION_FOUND)
+    ENDIF(EXISTS "${CMAKE_SOURCE_DIR}/../.svn/")
+
+    IF(EXISTS "${CMAKE_SOURCE_DIR}/../.hg/")
+      FIND_PACKAGE(Mercurial)
+
+      IF(MERCURIAL_FOUND)
+        SET(TOOL_FOUND ON)
+      ENDIF(MERCURIAL_FOUND)
+    ENDIF(EXISTS "${CMAKE_SOURCE_DIR}/../.hg/")
+
+    # if already generated
+    IF(EXISTS ${CMAKE_SOURCE_DIR}/revision.h)
+      # copy it
+      MESSAGE(STATUS "Copying provided revision.h...")
+      FILE(COPY ${CMAKE_SOURCE_DIR}/revision.h DESTINATION ${CMAKE_BINARY_DIR})
+      SET(HAVE_REVISION_H ON)
+    ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/revision.h)
+
+    IF(TOOL_FOUND)
       # a custom target that is always built
       ADD_CUSTOM_TARGET(revision ALL
-      DEPENDS ${CMAKE_BINARY_DIR}/revision.h)
-
-    # creates revision.h using cmake script
-    ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_BINARY_DIR}/revision.h
         COMMAND ${CMAKE_COMMAND}
         -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
         -DROOT_DIR=${CMAKE_SOURCE_DIR}/..
+        -DCMAKE_MODULE_PATH=${CMAKE_SOURCE_DIR}/CMakeModules
         -P ${CMAKE_SOURCE_DIR}/CMakeModules/GetRevision.cmake)
 
       # revision.h is a generated file
       SET_SOURCE_FILES_PROPERTIES(${CMAKE_BINARY_DIR}/revision.h
         PROPERTIES GENERATED TRUE
         HEADER_FILE_ONLY TRUE)
+      SET(HAVE_REVISION_H ON)
+    ENDIF(TOOL_FOUND)
+
+    IF(HAVE_REVISION_H)
+      INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})
+      ADD_DEFINITIONS(-DHAVE_REVISION_H)
+    ENDIF(HAVE_REVISION_H)
   ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/revision.h.in)
 ENDMACRO(NL_GEN_REVISION_H)
 
@@ -76,6 +99,11 @@ ENDMACRO(NL_TARGET_DRIVER)
 # Argument:
 ###
 MACRO(NL_DEFAULT_PROPS name label)
+  IF(HAVE_REVISION_H)
+    # explicitly say that the target depends on revision.h
+    ADD_DEPENDENCIES(${name} revision)
+  ENDIF(HAVE_REVISION_H)
+
   # Note: This is just a workaround for a CMake bug generating VS10 files with a colon in the project name.
   # CMake Bug ID: http://www.cmake.org/Bug/view.php?id=11819
   STRING(REGEX REPLACE "\\:" " -" proj_label ${label})
@@ -243,16 +271,7 @@ MACRO(NL_SETUP_DEFAULT_OPTIONS)
   ###
   # Optional support
   ###
-
-  # Check if CMake is launched from a Debian packaging script
-  SET(DEB_HOST_GNU_CPU $ENV{DEB_HOST_GNU_CPU})
-
-  # Don't strip if generating a .deb
-  IF(DEB_HOST_GNU_CPU)
-    OPTION(WITH_SYMBOLS           "Keep debug symbols in binaries"                 ON )
-  ELSE(DEB_HOST_GNU_CPU)
   OPTION(WITH_SYMBOLS             "Keep debug symbols in binaries"                OFF)
-  ENDIF(DEB_HOST_GNU_CPU)
 
   IF(WIN32)
     OPTION(WITH_STLPORT           "With STLport support."                         ON )
@@ -332,6 +351,11 @@ MACRO(NL_SETUP_SNOWBALLS_DEFAULT_OPTIONS)
   OPTION(WITH_SNOWBALLS_SERVER    "Build Snowballs Services"                      ON )
 ENDMACRO(NL_SETUP_SNOWBALLS_DEFAULT_OPTIONS)
 
+MACRO(ADD_PLATFORM_FLAGS _FLAGS)
+  SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} ${_FLAGS}")
+  SET(PLATFORM_CXXFLAGS "${PLATFORM_CXXFLAGS} ${_FLAGS}")
+ENDMACRO(ADD_PLATFORM_FLAGS)
+
 MACRO(NL_SETUP_BUILD)
 
   #-----------------------------------------------------------------------------
@@ -364,9 +388,6 @@ MACRO(NL_SETUP_BUILD)
   ENDIF(HOST_CPU MATCHES "amd64")
   
   # Determine target CPU
-  IF(NOT TARGET_CPU)
-    SET(TARGET_CPU $ENV{DEB_HOST_GNU_CPU})
-  ENDIF(NOT TARGET_CPU)
 
   # If not specified, use the same CPU as host
   IF(NOT TARGET_CPU)
@@ -379,9 +400,6 @@ MACRO(NL_SETUP_BUILD)
     SET(TARGET_CPU "x86")
   ENDIF(TARGET_CPU MATCHES "amd64")
 
-  # DEB_HOST_ARCH_ENDIAN is 'little' or 'big'
-  # DEB_HOST_ARCH_BITS is '32' or '64'
-
   IF(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
     SET(CLANG ON)
     MESSAGE(STATUS "Using Clang compiler")
@@ -393,7 +411,7 @@ MACRO(NL_SETUP_BUILD)
   ENDIF(CMAKE_GENERATOR MATCHES "Xcode")
 
   # If target and host CPU are the same
-  IF("${HOST_CPU}" STREQUAL "${TARGET_CPU}")
+  IF("${HOST_CPU}" STREQUAL "${TARGET_CPU}" AND NOT CMAKE_CROSSCOMPILING)
     # x86-compatible CPU
     IF(HOST_CPU MATCHES "x86")
       IF(NOT CMAKE_SIZEOF_VOID_P)
@@ -414,75 +432,145 @@ MACRO(NL_SETUP_BUILD)
       MESSAGE(STATUS "Unknown architecture: ${HOST_CPU}")
     ENDIF(HOST_CPU MATCHES "x86")
     # TODO: add checks for PPC
-  ELSE("${HOST_CPU}" STREQUAL "${TARGET_CPU}")
+  ELSE("${HOST_CPU}" STREQUAL "${TARGET_CPU}" AND NOT CMAKE_CROSSCOMPILING)
     MESSAGE(STATUS "Compiling on ${HOST_CPU} for ${TARGET_CPU}")
-  ENDIF("${HOST_CPU}" STREQUAL "${TARGET_CPU}")
+  ENDIF("${HOST_CPU}" STREQUAL "${TARGET_CPU}" AND NOT CMAKE_CROSSCOMPILING)
 
+  # Use values from environment variables
+  SET(PLATFORM_CFLAGS "$ENV{CFLAGS} $ENV{CPPFLAGS} ${PLATFORM_CFLAGS}")
+  SET(PLATFORM_CXXFLAGS "$ENV{CXXFLAGS} $ENV{CPPFLAGS} ${PLATFORM_CXXFLAGS}")
+  SET(PLATFORM_LINKFLAGS "$ENV{LDFLAGS} ${PLATFORM_LINKFLAGS}")
+
+  # Remove -g and -O flag because we are managing them ourself
+  STRING(REPLACE "-g" "" PLATFORM_CFLAGS ${PLATFORM_CFLAGS})
+  STRING(REPLACE "-g" "" PLATFORM_CXXFLAGS ${PLATFORM_CXXFLAGS})
+  STRING(REGEX REPLACE "-O[0-9s]" "" PLATFORM_CFLAGS ${PLATFORM_CFLAGS})
+  STRING(REGEX REPLACE "-O[0-9s]" "" PLATFORM_CXXFLAGS ${PLATFORM_CXXFLAGS})
+
+  # Strip spaces
+  STRING(STRIP ${PLATFORM_CFLAGS} PLATFORM_CFLAGS)
+  STRING(STRIP ${PLATFORM_CXXFLAGS} PLATFORM_CXXFLAGS)
+  STRING(STRIP ${PLATFORM_LINKFLAGS} PLATFORM_LINKFLAGS)
+
+  IF(NOT CMAKE_OSX_ARCHITECTURES)
     IF(TARGET_CPU STREQUAL "x86_64")
       SET(TARGET_X64 1)
-    SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -DHAVE_X86_64")
+      SET(TARGET_X86 1)
     ELSEIF(TARGET_CPU STREQUAL "x86")
       SET(TARGET_X86 1)
-    SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -DHAVE_X86")
+    ELSEIF(TARGET_CPU STREQUAL "armv7s")
+      SET(TARGET_ARM 1)
+      SET(TARGET_ARMV7S 1)
+    ELSEIF(TARGET_CPU STREQUAL "armv7")
+      SET(TARGET_ARM 1)
+      SET(TARGET_ARMV7 1)
+    ELSEIF(TARGET_CPU STREQUAL "armv6")
+      SET(TARGET_ARM 1)
+      SET(TARGET_ARMV6 1)
+    ELSEIF(TARGET_CPU STREQUAL "armv5")
+      SET(TARGET_ARM 1)
+      SET(TARGET_ARMV5 1)
     ELSEIF(TARGET_CPU STREQUAL "arm")
       SET(TARGET_ARM 1)
-    SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -DHAVE_ARM")
+    ELSEIF(TARGET_CPU STREQUAL "mips")
+      SET(TARGET_MIPS 1)
     ENDIF(TARGET_CPU STREQUAL "x86_64")
 
+    IF(TARGET_ARM)
+      IF(TARGET_ARMV7S)
+        ADD_PLATFORM_FLAGS("-DHAVE_ARMV7S")
+      ENDIF(TARGET_ARMV7S)
+
+      IF(TARGET_ARMV7)
+        ADD_PLATFORM_FLAGS("-DHAVE_ARMV7")
+      ENDIF(TARGET_ARMV7)
+
+      IF(TARGET_ARMV6)
+        ADD_PLATFORM_FLAGS("-HAVE_ARMV6")
+      ENDIF(TARGET_ARMV6)
+
+      ADD_PLATFORM_FLAGS("-DHAVE_ARM")
+    ENDIF(TARGET_ARM)
+
+    IF(TARGET_X86)
+      ADD_PLATFORM_FLAGS("-DHAVE_X86")
+    ENDIF(TARGET_X86)
+
+    IF(TARGET_X64)
+      ADD_PLATFORM_FLAGS("-DHAVE_X64 -DHAVE_X86_64")
+    ENDIF(TARGET_X64)
+
+    IF(TARGET_MIPS)
+      ADD_PLATFORM_FLAGS("-DHAVE_MIPS")
+    ENDIF(TARGET_MIPS)
+  ENDIF(NOT CMAKE_OSX_ARCHITECTURES)
+
   # Fix library paths suffixes for Debian MultiArch
-  SET(DEBIAN_MULTIARCH $ENV{DEB_HOST_MULTIARCH})
+  IF(LIBRARY_ARCHITECTURE)
-
+    SET(CMAKE_LIBRARY_PATH /lib/${LIBRARY_ARCHITECTURE} /usr/lib/${LIBRARY_ARCHITECTURE} ${CMAKE_LIBRARY_PATH})
-  IF(DEBIAN_MULTIARCH)
-    SET(CMAKE_LIBRARY_ARCHITECTURE ${DEBIAN_MULTIARCH})
-  ENDIF(DEBIAN_MULTIARCH)
-
-  IF(CMAKE_LIBRARY_ARCHITECTURE)
-    SET(CMAKE_LIBRARY_PATH /lib/${CMAKE_LIBRARY_ARCHITECTURE} /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE} ${CMAKE_LIBRARY_PATH})
     IF(TARGET_X64)
       SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /lib64 /usr/lib64)
-    ENDIF(TARGET_X64)
+    ELSEIF(TARGET_X86)
-    IF(TARGET_X86)
       SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /lib32 /usr/lib32)
-    ENDIF(TARGET_X86)
+    ENDIF(TARGET_X64)
-  ENDIF(CMAKE_LIBRARY_ARCHITECTURE)
+  ENDIF(LIBRARY_ARCHITECTURE)
+
+  IF(APPLE AND NOT IOS)
+    SET(CMAKE_INCLUDE_PATH /opt/local/include ${CMAKE_INCLUDE_PATH})
+    SET(CMAKE_LIBRARY_PATH /opt/local/lib ${CMAKE_LIBRARY_PATH})
+  ENDIF(APPLE AND NOT IOS)
+
+  IF(WITH_LOGGING)
+    ADD_PLATFORM_FLAGS("-DENABLE_LOGS")
+  ENDIF(WITH_LOGGING)
 
   IF(MSVC)
-    IF(MSVC10)
+    IF(MSVC_VERSION EQUAL "1700" AND NOT MSVC11)
+      SET(MSVC11 ON)
+    ENDIF(MSVC_VERSION EQUAL "1700" AND NOT MSVC11)
+
+    IF(MSVC11)
+      ADD_PLATFORM_FLAGS("/Gy- /MP")
       # /Ox is working with VC++ 2010, but custom optimizations don't exist
-      SET(SPEED_OPTIMIZATIONS "/Ox /GF /GS-")
+      SET(RELEASE_CFLAGS "/Ox /GF /GS- ${RELEASE_CFLAGS}")
       # without inlining it's unusable, use custom optimizations again
-      SET(MIN_OPTIMIZATIONS "/Od /Ob1")
+      SET(DEBUG_CFLAGS "/Od /Ob1 /GF- ${DEBUG_CFLAGS}")
+    ELSEIF(MSVC10)
+      ADD_PLATFORM_FLAGS("/Gy- /MP")
+      # /Ox is working with VC++ 2010, but custom optimizations don't exist
+      SET(RELEASE_CFLAGS "/Ox /GF /GS- ${RELEASE_CFLAGS}")
+      # without inlining it's unusable, use custom optimizations again
+      SET(DEBUG_CFLAGS "/Od /Ob1 /GF- ${DEBUG_CFLAGS}")
     ELSEIF(MSVC90)
+      ADD_PLATFORM_FLAGS("/Gy- /MP")
       # don't use a /O[012x] flag if you want custom optimizations
-      SET(SPEED_OPTIMIZATIONS "/Ob2 /Oi /Ot /Oy /GT /GF /GS-")
+      SET(RELEASE_CFLAGS "/Ob2 /Oi /Ot /Oy /GT /GF /GS- ${RELEASE_CFLAGS}")
       # without inlining it's unusable, use custom optimizations again
-      SET(MIN_OPTIMIZATIONS "/Ob1")
+      SET(DEBUG_CFLAGS "/Ob1 /GF- ${DEBUG_CFLAGS}")
     ELSEIF(MSVC80)
+      ADD_PLATFORM_FLAGS("/Gy- /Wp64")
       # don't use a /O[012x] flag if you want custom optimizations
-      SET(SPEED_OPTIMIZATIONS "/Ox /GF /GS-")
+      SET(RELEASE_CFLAGS "/Ox /GF /GS- ${RELEASE_CFLAGS}")
       # without inlining it's unusable, use custom optimizations again
-      SET(MIN_OPTIMIZATIONS "/Od /Ob1")
+      SET(DEBUG_CFLAGS "/Od /Ob1 ${DEBUG_CFLAGS}")
-    ELSE(MSVC10)
+    ELSE(MSVC11)
       MESSAGE(FATAL_ERROR "Can't determine compiler version ${MSVC_VERSION}")
-    ENDIF(MSVC10)
+    ENDIF(MSVC11)
 
-    SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} /D_CRT_SECURE_NO_WARNINGS /D_CRT_NONSTDC_NO_WARNINGS /DWIN32 /D_WINDOWS /W3 /Zm1000 /MP /Gy-")
+    ADD_PLATFORM_FLAGS("/D_CRT_SECURE_NO_DEPRECATE /D_CRT_SECURE_NO_WARNINGS /D_CRT_NONSTDC_NO_WARNINGS /DWIN32 /D_WINDOWS /Zm1000 /wd4250")
-
-    # Common link flags
-    SET(PLATFORM_LINKFLAGS "")
 
     IF(TARGET_X64)
       # Fix a bug with Intellisense
-      SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} /D_WIN64")
+      ADD_PLATFORM_FLAGS("/D_WIN64")
       # Fix a compilation error for some big C++ files
-      SET(MIN_OPTIMIZATIONS "${MIN_OPTIMIZATIONS} /bigobj")
+      SET(RELEASE_CFLAGS "${RELEASE_CFLAGS} /bigobj")
     ELSE(TARGET_X64)
       # Allows 32 bits applications to use 3 GB of RAM
       SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /LARGEADDRESSAWARE")
     ENDIF(TARGET_X64)
 
     # Exceptions are only set for C++
-    SET(PLATFORM_CXXFLAGS "${PLATFORM_CFLAGS} /EHa")
+    SET(PLATFORM_CXXFLAGS "${PLATFORM_CXXFLAGS} /EHa")
 
     IF(WITH_SYMBOLS)
       SET(NL_RELEASE_CFLAGS "/Zi ${NL_RELEASE_CFLAGS}")
@@ -491,54 +579,217 @@ MACRO(NL_SETUP_BUILD)
       SET(NL_RELEASE_LINKFLAGS "/RELEASE ${NL_RELEASE_LINKFLAGS}")
     ENDIF(WITH_SYMBOLS)
 
-    SET(NL_DEBUG_CFLAGS "/Zi /MDd /RTC1 /D_DEBUG ${MIN_OPTIMIZATIONS} ${NL_DEBUG_CFLAGS}")
+    SET(NL_DEBUG_CFLAGS "/Zi /MDd /RTC1 /D_DEBUG ${DEBUG_CFLAGS} ${NL_DEBUG_CFLAGS}")
-    SET(NL_RELEASE_CFLAGS "/MD /DNDEBUG ${SPEED_OPTIMIZATIONS} ${NL_RELEASE_CFLAGS}")
+    SET(NL_RELEASE_CFLAGS "/MD /DNDEBUG ${RELEASE_CFLAGS} ${NL_RELEASE_CFLAGS}")
     SET(NL_DEBUG_LINKFLAGS "/DEBUG /OPT:NOREF /OPT:NOICF /NODEFAULTLIB:msvcrt /INCREMENTAL:YES ${NL_DEBUG_LINKFLAGS}")
     SET(NL_RELEASE_LINKFLAGS "/OPT:REF /OPT:ICF /INCREMENTAL:NO ${NL_RELEASE_LINKFLAGS}")
+
+    IF(WITH_WARNINGS)
+      SET(DEBUG_CFLAGS "/W4 ${DEBUG_CFLAGS}")
+    ELSE(WITH_WARNINGS)
+      SET(DEBUG_CFLAGS "/W3 ${DEBUG_CFLAGS}")
+    ENDIF(WITH_WARNINGS)
   ELSE(MSVC)
     IF(WIN32)
-      SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -DWIN32 -D_WIN32")
+      ADD_PLATFORM_FLAGS("-DWIN32 -D_WIN32")
+
+      IF(CLANG)
+        ADD_PLATFORM_FLAGS("-nobuiltininc")
+      ENDIF(CLANG)
     ENDIF(WIN32)
 
     IF(APPLE)
-      IF(TARGET_CPU STREQUAL "x86")
+      IF(IOS)
-        SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -arch i386")
+        # Disable CMAKE_OSX_DEPLOYMENT_TARGET for iOS
-      ENDIF(TARGET_CPU STREQUAL "x86")
+        SET(CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE PATH "" FORCE)
-
+      ELSE(IOS)
-      IF(TARGET_CPU STREQUAL "x86_64")
-        SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -arch x86_64")
-      ENDIF(TARGET_CPU STREQUAL "x86_64")
-    ELSE(APPLE)
-      IF(HOST_CPU STREQUAL "x86_64" AND TARGET_CPU STREQUAL "x86")
-        SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -m32 -march=i686")
-      ENDIF(HOST_CPU STREQUAL "x86_64" AND TARGET_CPU STREQUAL "x86")
-
-      IF(HOST_CPU STREQUAL "x86" AND TARGET_CPU STREQUAL "x86_64")
-        SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -m64")
-      ENDIF(HOST_CPU STREQUAL "x86" AND TARGET_CPU STREQUAL "x86_64")
-    ENDIF(APPLE)
-
-    SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -D_REENTRANT -pipe -ftemplate-depth-48 -Wall -W -Wpointer-arith -Wsign-compare -Wno-deprecated-declarations -Wno-multichar -Wno-unused -fno-strict-aliasing")
-
-    IF(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-      SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -ansi")
-    ENDIF(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-
-    IF(WITH_COVERAGE)
-      SET(PLATFORM_CFLAGS "-fprofile-arcs -ftest-coverage ${PLATFORM_CFLAGS}")
-    ENDIF(WITH_COVERAGE)
-
-    IF(APPLE)
-      SET(PLATFORM_CFLAGS "-gdwarf-2 ${PLATFORM_CFLAGS}")
-    ENDIF(APPLE)
-
-    IF(APPLE AND XCODE)
-#      SET(CMAKE_OSX_SYSROOT "macosx" CACHE PATH "" FORCE)
-    ELSEIF(APPLE AND NOT XCODE)
         IF(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
-        SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.6")
+          SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.6" CACHE PATH "" FORCE)
         ENDIF(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
+      ENDIF(IOS)
 
+      IF(XCODE)
+        IF(IOS)
+          SET(CMAKE_OSX_SYSROOT "iphoneos" CACHE PATH "" FORCE)
+        ELSE(IOS)
+#          SET(CMAKE_OSX_SYSROOT "macosx" CACHE PATH "" FORCE)
+        ENDIF(IOS)
+      ELSE(XCODE)
+        IF(CMAKE_OSX_ARCHITECTURES)
+          SET(TARGETS_COUNT 0)
+          SET(_ARCHS)
+          FOREACH(_ARCH ${CMAKE_OSX_ARCHITECTURES})
+            IF(_ARCH STREQUAL "i386")
+              SET(_ARCHS "${_ARCHS} i386")
+              SET(TARGET_X86 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSEIF(_ARCH STREQUAL "x86_64")
+              SET(_ARCHS "${_ARCHS} x86_64")
+              SET(TARGET_X64 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSEIF(_ARCH STREQUAL "armv7s")
+              SET(_ARCHS "${_ARCHS} armv7s")
+              SET(TARGET_ARMV7S 1)
+              SET(TARGET_ARM 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSEIF(_ARCH STREQUAL "armv7")
+              SET(_ARCHS "${_ARCHS} armv7")
+              SET(TARGET_ARMV7 1)
+              SET(TARGET_ARM 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSEIF(_ARCH STREQUAL "armv6")
+              SET(_ARCHS "${_ARCHS} armv6")
+              SET(TARGET_ARMV6 1)
+              SET(TARGET_ARM 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSEIF(_ARCH STREQUAL "mips")
+              SET(_ARCHS "${_ARCHS} mips")
+              SET(TARGET_MIPS 1)
+              MATH(EXPR TARGETS_COUNT "${TARGETS_COUNT}+1")
+            ELSE(_ARCH STREQUAL "i386")
+              SET(_ARCHS "${_ARCHS} unknwon(${_ARCH})")
+            ENDIF(_ARCH STREQUAL "i386")
+          ENDFOREACH(_ARCH)
+          MESSAGE(STATUS "Compiling under Mac OS X for ${TARGETS_COUNT} architectures: ${_ARCHS}")
+        ELSE(CMAKE_OSX_ARCHITECTURES)
+          SET(TARGETS_COUNT 0)
+        ENDIF(CMAKE_OSX_ARCHITECTURES)
+
+        IF(TARGETS_COUNT EQUAL 1)
+          IF(TARGET_ARM)
+            IF(TARGET_ARMV7S)
+              ADD_PLATFORM_FLAGS("-arch armv7s -DHAVE_ARMV7S")
+            ENDIF(TARGET_ARMV7S)
+
+            IF(TARGET_ARMV7)
+              ADD_PLATFORM_FLAGS("-arch armv7 -DHAVE_ARMV7")
+            ENDIF(TARGET_ARMV7)
+
+            IF(TARGET_ARMV6)
+              ADD_PLATFORM_FLAGS("-arch armv6 -DHAVE_ARMV6")
+            ENDIF(TARGET_ARMV6)
+
+            IF(TARGET_ARMV5)
+              ADD_PLATFORM_FLAGS("-arch armv5 -DHAVE_ARMV5")
+            ENDIF(TARGET_ARMV5)
+
+            ADD_PLATFORM_FLAGS("-mthumb -DHAVE_ARM")
+          ENDIF(TARGET_ARM)
+
+          IF(TARGET_X64)
+            ADD_PLATFORM_FLAGS("-arch x86_64 -DHAVE_X64 -DHAVE_X86_64 -DHAVE_X86")
+          ELSEIF(TARGET_X86)
+            ADD_PLATFORM_FLAGS("-arch i386 -DHAVE_X86")
+          ENDIF(TARGET_X64)
+
+          IF(TARGET_MIPS)
+            ADD_PLATFORM_FLAGS("-arch mips -DHAVE_MIPS")
+          ENDIF(TARGET_MIPS)
+        ELSEIF(TARGETS_COUNT EQUAL 0)
+          # Not using CMAKE_OSX_ARCHITECTURES, HAVE_XXX already defined before
+          IF(TARGET_ARM)
+            IF(TARGET_ARMV7S)
+              ADD_PLATFORM_FLAGS("-arch armv7s")
+            ENDIF(TARGET_ARMV7S)
+
+            IF(TARGET_ARMV7)
+              ADD_PLATFORM_FLAGS("-arch armv7")
+            ENDIF(TARGET_ARMV7)
+
+            IF(TARGET_ARMV6)
+              ADD_PLATFORM_FLAGS("-arch armv6")
+            ENDIF(TARGET_ARMV6)
+
+            IF(TARGET_ARMV5)
+              ADD_PLATFORM_FLAGS("-arch armv5")
+            ENDIF(TARGET_ARMV5)
+
+            ADD_PLATFORM_FLAGS("-mthumb")
+          ENDIF(TARGET_ARM)
+
+          IF(TARGET_X64)
+            ADD_PLATFORM_FLAGS("-arch x86_64")
+          ELSEIF(TARGET_X86)
+            ADD_PLATFORM_FLAGS("-arch i386")
+          ENDIF(TARGET_X64)
+
+          IF(TARGET_MIPS)
+            ADD_PLATFORM_FLAGS("-arch mips")
+          ENDIF(TARGET_MIPS)
+        ELSE(TARGETS_COUNT EQUAL 1)
+          IF(TARGET_ARMV6)
+            ADD_PLATFORM_FLAGS("-Xarch_armv6 -mthumb -Xarch_armv6 -DHAVE_ARM -Xarch_armv6 -DHAVE_ARMV6")
+          ENDIF(TARGET_ARMV6)
+
+          IF(TARGET_ARMV7)
+            ADD_PLATFORM_FLAGS("-Xarch_armv7 -mthumb -Xarch_armv7 -DHAVE_ARM -Xarch_armv7 -DHAVE_ARMV7")
+          ENDIF(TARGET_ARMV7)
+
+          IF(TARGET_X86)
+            ADD_PLATFORM_FLAGS("-Xarch_i386 -DHAVE_X86")
+          ENDIF(TARGET_X86)
+
+          IF(TARGET_X64)
+            ADD_PLATFORM_FLAGS("-Xarch_x86_64 -DHAVE_X64 -Xarch_x86_64 -DHAVE_X86_64")
+          ENDIF(TARGET_X64)
+
+          IF(TARGET_MIPS)
+            ADD_PLATFORM_FLAGS("-Xarch_mips -DHAVE_MIPS")
+          ENDIF(TARGET_MIPS)
+        ENDIF(TARGETS_COUNT EQUAL 1)
+
+        IF(IOS)
+          SET(CMAKE_OSX_SYSROOT "" CACHE PATH "" FORCE)
+
+          IF(IOS_VERSION)
+            PARSE_VERSION_STRING(${IOS_VERSION} IOS_VERSION_MAJOR IOS_VERSION_MINOR IOS_VERSION_PATCH)
+            CONVERT_VERSION_NUMBER(${IOS_VERSION_MAJOR} ${IOS_VERSION_MINOR} ${IOS_VERSION_PATCH} IOS_VERSION_NUMBER)
+
+            ADD_PLATFORM_FLAGS("-D__IPHONE_OS_VERSION_MIN_REQUIRED=${IOS_VERSION_NUMBER}")
+          ENDIF(IOS_VERSION)
+
+          IF(CMAKE_IOS_SYSROOT)
+            IF(TARGET_ARMV7S)
+              IF(TARGETS_COUNT GREATER 1)
+                SET(XARCH "-Xarch_armv7s ")
+              ENDIF(TARGETS_COUNT GREATER 1)
+
+              ADD_PLATFORM_FLAGS("${XARCH}-isysroot${CMAKE_IOS_SYSROOT}")
+              ADD_PLATFORM_FLAGS("${XARCH}-miphoneos-version-min=${IOS_VERSION}")
+              SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${XARCH}-Wl,-iphoneos_version_min,${IOS_VERSION}")
+            ENDIF(TARGET_ARMV7S)
+
+            IF(TARGET_ARMV7)
+              IF(TARGETS_COUNT GREATER 1)
+                SET(XARCH "-Xarch_armv7 ")
+              ENDIF(TARGETS_COUNT GREATER 1)
+
+              ADD_PLATFORM_FLAGS("${XARCH}-isysroot${CMAKE_IOS_SYSROOT}")
+              ADD_PLATFORM_FLAGS("${XARCH}-miphoneos-version-min=${IOS_VERSION}")
+              SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${XARCH}-Wl,-iphoneos_version_min,${IOS_VERSION}")
+            ENDIF(TARGET_ARMV7)
+
+            IF(TARGET_ARMV6)
+              IF(TARGETS_COUNT GREATER 1)
+                SET(XARCH "-Xarch_armv6 ")
+              ENDIF(TARGETS_COUNT GREATER 1)
+
+              ADD_PLATFORM_FLAGS("${XARCH}-isysroot${CMAKE_IOS_SYSROOT}")
+              ADD_PLATFORM_FLAGS("${XARCH}-miphoneos-version-min=${IOS_VERSION}")
+              SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${XARCH}-Wl,-iphoneos_version_min,${IOS_VERSION}")
+            ENDIF(TARGET_ARMV6)
+          ENDIF(CMAKE_IOS_SYSROOT)
+
+          IF(CMAKE_IOS_SIMULATOR_SYSROOT AND TARGET_X86)
+            IF(TARGETS_COUNT GREATER 1)
+              SET(XARCH "-Xarch_i386 ")
+            ENDIF(TARGETS_COUNT GREATER 1)
+
+            ADD_PLATFORM_FLAGS("${XARCH}-isysroot${CMAKE_IOS_SIMULATOR_SYSROOT}")
+            ADD_PLATFORM_FLAGS("${XARCH}-mios-simulator-version-min=${IOS_VERSION}")
+            SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} ${XARCH}-Wl,-macosx_version_min,${CMAKE_OSX_DEPLOYMENT_TARGET}")
+          ENDIF(CMAKE_IOS_SIMULATOR_SYSROOT AND TARGET_X86)
+        ELSE(IOS)
           FOREACH(_SDK ${_CMAKE_OSX_SDKS})
             IF(${_SDK} MATCHES "MacOSX${CMAKE_OSX_DEPLOYMENT_TARGET}\\.sdk")
               SET(CMAKE_OSX_SYSROOT ${_SDK} CACHE PATH "" FORCE)
@@ -546,33 +797,97 @@ MACRO(NL_SETUP_BUILD)
           ENDFOREACH(_SDK)
 
           IF(CMAKE_OSX_SYSROOT)
-        SET(PLATFORM_CFLAGS "-isysroot ${CMAKE_OSX_SYSROOT} ${PLATFORM_CFLAGS}")
+            ADD_PLATFORM_FLAGS("-isysroot ${CMAKE_OSX_SYSROOT}")
           ELSE(CMAKE_OSX_SYSROOT)
             MESSAGE(FATAL_ERROR "CMAKE_OSX_SYSROOT can't be determinated")
           ENDIF(CMAKE_OSX_SYSROOT)
 
-      IF(CMAKE_OSX_ARCHITECTURES)
+          # Always force -mmacosx-version-min to override environement variable
-        FOREACH(_ARCH ${CMAKE_OSX_ARCHITECTURES})
+          ADD_PLATFORM_FLAGS("-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-          SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -arch ${_ARCH}")
+          SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,-macosx_version_min,${CMAKE_OSX_DEPLOYMENT_TARGET}")
-        ENDFOREACH(_ARCH)
+        ENDIF(IOS)
-      ENDIF(CMAKE_OSX_ARCHITECTURES)
-      IF(CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG)
-        SET(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-      ENDIF(CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG)
 
         SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,-headerpad_max_install_names")
 
         IF(HAVE_FLAG_SEARCH_PATHS_FIRST)
-        SET(PLATFORM_LINKFLAGS "-Wl,-search_paths_first ${PLATFORM_LINKFLAGS}")
+          SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,-search_paths_first")
         ENDIF(HAVE_FLAG_SEARCH_PATHS_FIRST)
-    ENDIF(APPLE AND XCODE)
+      ENDIF(XCODE)
+    ELSE(APPLE)
+      IF(HOST_CPU STREQUAL "x86_64" AND TARGET_CPU STREQUAL "x86")
+        ADD_PLATFORM_FLAGS("-m32 -march=i686")
+      ENDIF(HOST_CPU STREQUAL "x86_64" AND TARGET_CPU STREQUAL "x86")
+
+      IF(HOST_CPU STREQUAL "x86" AND TARGET_CPU STREQUAL "x86_64")
+        ADD_PLATFORM_FLAGS("-m64")
+      ENDIF(HOST_CPU STREQUAL "x86" AND TARGET_CPU STREQUAL "x86_64")
+    ENDIF(APPLE)
+
+    ADD_PLATFORM_FLAGS("-D_REENTRANT -pipe -fno-strict-aliasing")
+
+    IF(WITH_COVERAGE)
+      ADD_PLATFORM_FLAGS("-fprofile-arcs -ftest-coverage")
+    ENDIF(WITH_COVERAGE)
+
+    IF(WITH_WARNINGS)
+      ADD_PLATFORM_FLAGS("-Wall -W -Wpointer-arith -Wsign-compare -Wno-deprecated-declarations -Wno-multichar -Wno-unused")
+      IF(CLANG)
+        ADD_PLATFORM_FLAGS("-std=gnu99")
+      ELSE(CLANG)
+        ADD_PLATFORM_FLAGS("-ansi")
+      ENDIF(CLANG)
+    ENDIF(WITH_WARNINGS)
+
+    IF(ANDROID)
+      ADD_PLATFORM_FLAGS("--sysroot=${PLATFORM_ROOT}")
+      ADD_PLATFORM_FLAGS("-ffunction-sections -funwind-tables")
+      ADD_PLATFORM_FLAGS("-DANDROID")
+      ADD_PLATFORM_FLAGS("-Wa,--noexecstack")
+
+      IF(TARGET_ARM)
+        ADD_PLATFORM_FLAGS("-fpic -fstack-protector")
+        ADD_PLATFORM_FLAGS("-D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__")
+
+        IF(TARGET_ARMV7)
+          ADD_PLATFORM_FLAGS("-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16")
+          SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -march=armv7-a -Wl,--fix-cortex-a8")
+        ELSEIF(TARGET_ARMV5)
+          ADD_PLATFORM_FLAGS("-march=armv5te -mtune=xscale -msoft-float")
+        ENDIF(TARGET_ARMV7)
+
+        SET(TARGET_THUMB ON)
+        IF(TARGET_THUMB)
+          ADD_PLATFORM_FLAGS("-mthumb -fno-strict-aliasing -finline-limit=64")
+          SET(DEBUG_CFLAGS "${DEBUG_CFLAGS} -marm")
+        ELSE(TARGET_THUMB)
+          ADD_PLATFORM_FLAGS("-funswitch-loops -finline-limit=300")
+          SET(DEBUG_CFLAGS "${DEBUG_CFLAGS} -fno-strict-aliasing")
+          SET(RELEASE_CFLAGS "${RELEASE_CFLAGS} -fstrict-aliasing")
+        ENDIF(TARGET_THUMB)
+      ELSEIF(TARGET_X86)
+        # Optimizations for Intel Atom
+        ADD_PLATFORM_FLAGS("-march=i686 -mtune=atom -mstackrealign -msse3 -mfpmath=sse -m32 -flto -ffast-math -funroll-loops")
+        ADD_PLATFORM_FLAGS("-fstack-protector -funswitch-loops -finline-limit=300")
+        SET(RELEASE_CFLAGS "${RELEASE_CFLAGS} -fstrict-aliasing")
+        SET(DEBUG_CFLAGS "${DEBUG_CFLAGS} -fno-strict-aliasing")
+      ELSEIF(TARGET_MIPS)
+        ADD_PLATFORM_FLAGS("-fpic -finline-functions -fmessage-length=0 -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers -fno-strict-aliasing")
+        SET(RELEASE_CFLAGS "${RELEASE_CFLAGS} -funswitch-loops -finline-limit=300")
+      ENDIF(TARGET_ARM)
+      SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now")
+      SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -L${PLATFORM_ROOT}/usr/lib")
+    ENDIF(ANDROID)
+
+    IF(APPLE)
+      ADD_PLATFORM_FLAGS("-gdwarf-2")
+    ENDIF(APPLE)
 
     # Fix "relocation R_X86_64_32 against.." error on x64 platforms
     IF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS)
-      SET(PLATFORM_CFLAGS "-fPIC ${PLATFORM_CFLAGS}")
+      ADD_PLATFORM_FLAGS("-fPIC")
     ENDIF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS)
 
-    SET(PLATFORM_CXXFLAGS ${PLATFORM_CFLAGS})
+    SET(PLATFORM_CXXFLAGS "${PLATFORM_CXXFLAGS} -ftemplate-depth-48")
 
     IF(NOT APPLE)
       SET(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,--no-undefined -Wl,--as-needed")
@@ -612,125 +927,146 @@ MACRO(NL_SETUP_BUILD_FLAGS)
   SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${PLATFORM_LINKFLAGS} ${NL_RELEASE_LINKFLAGS}" CACHE STRING "" FORCE)
 ENDMACRO(NL_SETUP_BUILD_FLAGS)
 
+# Macro to create x_ABSOLUTE_PREFIX from x_PREFIX
+MACRO(NL_MAKE_ABSOLUTE_PREFIX NAME_RELATIVE NAME_ABSOLUTE)
+  IF(IS_ABSOLUTE "${${NAME_RELATIVE}}")
+    SET(${NAME_ABSOLUTE} ${${NAME_RELATIVE}})
+  ELSE(IS_ABSOLUTE "${${NAME_RELATIVE}}")
+    IF(WIN32)
+      SET(${NAME_ABSOLUTE} ${${NAME_RELATIVE}})
+    ELSE(WIN32)
+      SET(${NAME_ABSOLUTE} ${CMAKE_INSTALL_PREFIX}/${${NAME_RELATIVE}})
+    ENDIF(WIN32)
+  ENDIF(IS_ABSOLUTE "${${NAME_RELATIVE}}")
+ENDMACRO(NL_MAKE_ABSOLUTE_PREFIX)
+
 MACRO(NL_SETUP_PREFIX_PATHS)
   ## Allow override of install_prefix/etc path.
   IF(NOT NL_ETC_PREFIX)
     IF(WIN32)
-      SET(NL_ETC_PREFIX "../etc/nel" CACHE PATH "Installation path for configurations")
+      SET(NL_ETC_PREFIX "." CACHE PATH "Installation path for configurations")
     ELSE(WIN32)
-      SET(NL_ETC_PREFIX "${CMAKE_INSTALL_PREFIX}/etc/nel" CACHE PATH "Installation path for configurations")
+      SET(NL_ETC_PREFIX "etc/nel" CACHE PATH "Installation path for configurations")
     ENDIF(WIN32)
   ENDIF(NOT NL_ETC_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_ETC_PREFIX NL_ETC_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/share path.
   IF(NOT NL_SHARE_PREFIX)
     IF(WIN32)
-      SET(NL_SHARE_PREFIX "../share/nel" CACHE PATH "Installation path for data.")
+      SET(NL_SHARE_PREFIX "." CACHE PATH "Installation path for data.")
     ELSE(WIN32)
-      SET(NL_SHARE_PREFIX "${CMAKE_INSTALL_PREFIX}/share/nel" CACHE PATH "Installation path for data.")
+      SET(NL_SHARE_PREFIX "share/nel" CACHE PATH "Installation path for data.")
     ENDIF(WIN32)
   ENDIF(NOT NL_SHARE_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_SHARE_PREFIX NL_SHARE_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/sbin path.
   IF(NOT NL_SBIN_PREFIX)
     IF(WIN32)
-      SET(NL_SBIN_PREFIX "../sbin" CACHE PATH "Installation path for admin tools and services.")
+      SET(NL_SBIN_PREFIX "." CACHE PATH "Installation path for admin tools and services.")
     ELSE(WIN32)
-      SET(NL_SBIN_PREFIX "${CMAKE_INSTALL_PREFIX}/sbin" CACHE PATH "Installation path for admin tools and services.")
+      SET(NL_SBIN_PREFIX "sbin" CACHE PATH "Installation path for admin tools and services.")
     ENDIF(WIN32)
   ENDIF(NOT NL_SBIN_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_SBIN_PREFIX NL_SBIN_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/bin path.
   IF(NOT NL_BIN_PREFIX)
     IF(WIN32)
-      SET(NL_BIN_PREFIX "../bin" CACHE PATH "Installation path for tools and applications.")
+      SET(NL_BIN_PREFIX "." CACHE PATH "Installation path for tools and applications.")
     ELSE(WIN32)
-      SET(NL_BIN_PREFIX "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation path for tools and applications.")
+      SET(NL_BIN_PREFIX "bin" CACHE PATH "Installation path for tools and applications.")
     ENDIF(WIN32)
   ENDIF(NOT NL_BIN_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_BIN_PREFIX NL_BIN_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/lib path.
   IF(NOT NL_LIB_PREFIX)
-    IF(WIN32)
+    IF(LIBRARY_ARCHITECTURE)
-      SET(NL_LIB_PREFIX "../lib" CACHE PATH "Installation path for libraries.")
+      SET(NL_LIB_PREFIX "lib/${LIBRARY_ARCHITECTURE}" CACHE PATH "Installation path for libraries.")
-    ELSE(WIN32)
+    ELSE(LIBRARY_ARCHITECTURE)
-      IF(CMAKE_LIBRARY_ARCHITECTURE)
+      SET(NL_LIB_PREFIX "lib" CACHE PATH "Installation path for libraries.")
-        SET(NL_LIB_PREFIX "${CMAKE_INSTALL_PREFIX}/lib/${CMAKE_LIBRARY_ARCHITECTURE}" CACHE PATH "Installation path for libraries.")
+    ENDIF(LIBRARY_ARCHITECTURE)
-      ELSE(CMAKE_LIBRARY_ARCHITECTURE)
-        SET(NL_LIB_PREFIX "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation path for libraries.")
-      ENDIF(CMAKE_LIBRARY_ARCHITECTURE)
-    ENDIF(WIN32)
   ENDIF(NOT NL_LIB_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_LIB_PREFIX NL_LIB_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/lib path.
   IF(NOT NL_DRIVER_PREFIX)
     IF(WIN32)
-      SET(NL_DRIVER_PREFIX "../lib" CACHE PATH "Installation path for drivers.")
+      SET(NL_DRIVER_PREFIX "." CACHE PATH "Installation path for drivers.")
     ELSE(WIN32)
-      IF(CMAKE_LIBRARY_ARCHITECTURE)
+      IF(LIBRARY_ARCHITECTURE)
-        SET(NL_DRIVER_PREFIX "${CMAKE_INSTALL_PREFIX}/lib/${CMAKE_LIBRARY_ARCHITECTURE}/nel" CACHE PATH "Installation path for drivers.")
+        SET(NL_DRIVER_PREFIX "lib/${LIBRARY_ARCHITECTURE}/nel" CACHE PATH "Installation path for drivers.")
-      ELSE(CMAKE_LIBRARY_ARCHITECTURE)
+      ELSE(LIBRARY_ARCHITECTURE)
-        SET(NL_DRIVER_PREFIX "${CMAKE_INSTALL_PREFIX}/lib/nel" CACHE PATH "Installation path for drivers.")
+        SET(NL_DRIVER_PREFIX "lib/nel" CACHE PATH "Installation path for drivers.")
-      ENDIF(CMAKE_LIBRARY_ARCHITECTURE)
+      ENDIF(LIBRARY_ARCHITECTURE)
     ENDIF(WIN32)
   ENDIF(NOT NL_DRIVER_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(NL_DRIVER_PREFIX NL_DRIVER_ABSOLUTE_PREFIX)
 
 ENDMACRO(NL_SETUP_PREFIX_PATHS)
 
 MACRO(RYZOM_SETUP_PREFIX_PATHS)
-  ## Allow override of install_prefix path.
-  IF(NOT RYZOM_PREFIX)
-    IF(WIN32)
-      SET(RYZOM_PREFIX "." CACHE PATH "Installation path")
-    ELSE(WIN32)
-      SET(RYZOM_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "Installation path")
-    ENDIF(WIN32)
-  ENDIF(NOT RYZOM_PREFIX)
-
   ## Allow override of install_prefix/etc path.
   IF(NOT RYZOM_ETC_PREFIX)
     IF(WIN32)
       SET(RYZOM_ETC_PREFIX "." CACHE PATH "Installation path for configurations")
     ELSE(WIN32)
-      SET(RYZOM_ETC_PREFIX "${RYZOM_PREFIX}/etc/ryzom" CACHE PATH "Installation path for configurations")
+      SET(RYZOM_ETC_PREFIX "etc/ryzom" CACHE PATH "Installation path for configurations")
     ENDIF(WIN32)
   ENDIF(NOT RYZOM_ETC_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_ETC_PREFIX RYZOM_ETC_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/share path.
   IF(NOT RYZOM_SHARE_PREFIX)
     IF(WIN32)
       SET(RYZOM_SHARE_PREFIX "." CACHE PATH "Installation path for data.")
     ELSE(WIN32)
-      SET(RYZOM_SHARE_PREFIX "${RYZOM_PREFIX}/share/ryzom" CACHE PATH "Installation path for data.")
+      SET(RYZOM_SHARE_PREFIX "share/ryzom" CACHE PATH "Installation path for data.")
     ENDIF(WIN32)
   ENDIF(NOT RYZOM_SHARE_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_SHARE_PREFIX RYZOM_SHARE_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/sbin path.
   IF(NOT RYZOM_SBIN_PREFIX)
     IF(WIN32)
       SET(RYZOM_SBIN_PREFIX "." CACHE PATH "Installation path for admin tools and services.")
     ELSE(WIN32)
-      SET(RYZOM_SBIN_PREFIX "${RYZOM_PREFIX}/sbin" CACHE PATH "Installation path for admin tools and services.")
+      SET(RYZOM_SBIN_PREFIX "sbin" CACHE PATH "Installation path for admin tools and services.")
     ENDIF(WIN32)
   ENDIF(NOT RYZOM_SBIN_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_SBIN_PREFIX RYZOM_SBIN_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/bin path.
   IF(NOT RYZOM_BIN_PREFIX)
     IF(WIN32)
       SET(RYZOM_BIN_PREFIX "." CACHE PATH "Installation path for tools and applications.")
     ELSE(WIN32)
-      SET(RYZOM_BIN_PREFIX "${RYZOM_PREFIX}/bin" CACHE PATH "Installation path for tools.")
+      SET(RYZOM_BIN_PREFIX "bin" CACHE PATH "Installation path for tools.")
     ENDIF(WIN32)
   ENDIF(NOT RYZOM_BIN_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_BIN_PREFIX RYZOM_BIN_ABSOLUTE_PREFIX)
+
+  ## Allow override of install_prefix/lib path.
+  IF(NOT RYZOM_LIB_PREFIX)
+    IF(LIBRARY_ARCHITECTURE)
+      SET(RYZOM_LIB_PREFIX "lib/${LIBRARY_ARCHITECTURE}" CACHE PATH "Installation path for libraries.")
+    ELSE(LIBRARY_ARCHITECTURE)
+      SET(RYZOM_LIB_PREFIX "lib" CACHE PATH "Installation path for libraries.")
+    ENDIF(LIBRARY_ARCHITECTURE)
+  ENDIF(NOT RYZOM_LIB_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_LIB_PREFIX RYZOM_LIB_ABSOLUTE_PREFIX)
 
   ## Allow override of install_prefix/games path.
   IF(NOT RYZOM_GAMES_PREFIX)
     IF(WIN32)
       SET(RYZOM_GAMES_PREFIX "." CACHE PATH "Installation path for tools and applications.")
     ELSE(WIN32)
-      SET(RYZOM_GAMES_PREFIX "${RYZOM_PREFIX}/games" CACHE PATH "Installation path for client.")
+      SET(RYZOM_GAMES_PREFIX "games" CACHE PATH "Installation path for client.")
     ENDIF(WIN32)
   ENDIF(NOT RYZOM_GAMES_PREFIX)
+  NL_MAKE_ABSOLUTE_PREFIX(RYZOM_GAMES_PREFIX RYZOM_GAMES_ABSOLUTE_PREFIX)
 
 ENDMACRO(RYZOM_SETUP_PREFIX_PATHS)
 
@@ -742,11 +1078,41 @@ MACRO(SETUP_EXTERNAL)
   IF(WIN32)
     FIND_PACKAGE(External REQUIRED)
 
-    IF(MSVC10)
+    IF(NOT VC_DIR)
-      IF(NOT MSVC10_REDIST_DIR)
+      SET(VC_DIR $ENV{VC_DIR})
+    ENDIF(NOT VC_DIR)
+
+    IF(MSVC11)
+      IF(NOT MSVC_REDIST_DIR)
+        # If you have VC++ 2012 Express, put x64/Microsoft.VC110.CRT/*.dll in ${EXTERNAL_PATH}/redist
+        SET(MSVC_REDIST_DIR "${EXTERNAL_PATH}/redist")
+      ENDIF(NOT MSVC_REDIST_DIR)
+
+      IF(NOT VC_DIR)
+        IF(NOT VC_ROOT_DIR)
+          GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\11.0_Config;InstallDir]" ABSOLUTE)
+          # VC_ROOT_DIR is set to "registry" when a key is not found
+          IF(VC_ROOT_DIR MATCHES "registry")
+            GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\WDExpress\\11.0_Config\\Setup\\VC;InstallDir]" ABSOLUTE)
+            IF(VC_ROOT_DIR MATCHES "registry")
+              SET(VS110COMNTOOLS $ENV{VS110COMNTOOLS})
+              IF(VS110COMNTOOLS)
+                FILE(TO_CMAKE_PATH ${VS110COMNTOOLS} VC_ROOT_DIR)
+              ENDIF(VS110COMNTOOLS)
+              IF(NOT VC_ROOT_DIR)
+                MESSAGE(FATAL_ERROR "Unable to find VC++ 2012 directory!")
+              ENDIF(NOT VC_ROOT_DIR)
+            ENDIF(VC_ROOT_DIR MATCHES "registry")
+          ENDIF(VC_ROOT_DIR MATCHES "registry")
+        ENDIF(NOT VC_ROOT_DIR)
+        # convert IDE fullpath to VC++ path
+        STRING(REGEX REPLACE "Common7/.*" "VC" VC_DIR ${VC_ROOT_DIR})
+      ENDIF(NOT VC_DIR)
+    ELSEIF(MSVC10)
+      IF(NOT MSVC_REDIST_DIR)
         # If you have VC++ 2010 Express, put x64/Microsoft.VC100.CRT/*.dll in ${EXTERNAL_PATH}/redist
-        SET(MSVC10_REDIST_DIR "${EXTERNAL_PATH}/redist")
+        SET(MSVC_REDIST_DIR "${EXTERNAL_PATH}/redist")
-      ENDIF(NOT MSVC10_REDIST_DIR)
+      ENDIF(NOT MSVC_REDIST_DIR)
 
       IF(NOT VC_DIR)
         IF(NOT VC_ROOT_DIR)
@@ -755,7 +1121,10 @@ MACRO(SETUP_EXTERNAL)
           IF(VC_ROOT_DIR MATCHES "registry")
             GET_FILENAME_COMPONENT(VC_ROOT_DIR "[HKEY_CURRENT_USER\\Software\\Microsoft\\VCExpress\\10.0_Config;InstallDir]" ABSOLUTE)
             IF(VC_ROOT_DIR MATCHES "registry")
-              FILE(TO_CMAKE_PATH $ENV{VS100COMNTOOLS} VC_ROOT_DIR)
+              SET(VS100COMNTOOLS $ENV{VS100COMNTOOLS})
+              IF(VS100COMNTOOLS)
+                FILE(TO_CMAKE_PATH ${VS100COMNTOOLS} VC_ROOT_DIR)
+              ENDIF(VS100COMNTOOLS)
               IF(NOT VC_ROOT_DIR)
                 MESSAGE(FATAL_ERROR "Unable to find VC++ 2010 directory!")
               ENDIF(NOT VC_ROOT_DIR)
@@ -765,7 +1134,7 @@ MACRO(SETUP_EXTERNAL)
         # convert IDE fullpath to VC++ path
         STRING(REGEX REPLACE "Common7/.*" "VC" VC_DIR ${VC_ROOT_DIR})
       ENDIF(NOT VC_DIR)
-    ELSE(MSVC10)
+    ELSE(MSVC11)
       IF(NOT VC_DIR)
         IF(${CMAKE_MAKE_PROGRAM} MATCHES "Common7")
           # convert IDE fullpath to VC++ path
@@ -775,7 +1144,7 @@ MACRO(SETUP_EXTERNAL)
           STRING(REGEX REPLACE "VC/bin/.+" "VC" VC_DIR ${CMAKE_CXX_COMPILER})
         ENDIF(${CMAKE_MAKE_PROGRAM} MATCHES "Common7")
       ENDIF(NOT VC_DIR)
-    ENDIF(MSVC10)
+    ENDIF(MSVC11)
   ELSE(WIN32)
     IF(APPLE)
       IF(WITH_STATIC_EXTERNAL)
@@ -800,7 +1169,7 @@ MACRO(SETUP_EXTERNAL)
 
       FIND_PACKAGE(WindowsSDK REQUIRED)
       # use VC++ and Windows SDK include paths
-      INCLUDE_DIRECTORIES(${VC_INCLUDE_DIR} ${WINSDK_INCLUDE_DIR})
+      INCLUDE_DIRECTORIES(${VC_INCLUDE_DIR} ${WINSDK_INCLUDE_DIRS})
     ENDIF(MSVC)
   ENDIF(WITH_STLPORT)
 ENDMACRO(SETUP_EXTERNAL)

code/config.h.cmake

@@ -43,15 +43,14 @@
 #cmakedefine NL_DSOUND_AVAILABLE ${NL_DSOUND_AVAILABLE}
 #cmakedefine NL_XAUDIO2_AVAILABLE ${NL_XAUDIO2_AVAILABLE}
 
-#cmakedefine NL_BIN_PREFIX "${NL_BIN_PREFIX}"
+#cmakedefine NL_BIN_PREFIX "${NL_BIN_ABSOLUTE_PREFIX}"
-#cmakedefine NL_ETC_PREFIX "${NL_ETC_PREFIX}"
+#cmakedefine NL_ETC_PREFIX "${NL_ETC_ABSOLUTE_PREFIX}"
-#cmakedefine NL_SHARE_PREFIX "${NL_SHARE_PREFIX}"
+#cmakedefine NL_SHARE_PREFIX "${NL_SHARE_ABSOLUTE_PREFIX}"
-#cmakedefine NL_LIB_PREFIX "${NL_LIB_PREFIX}"
+#cmakedefine NL_LIB_PREFIX "${NL_LIB_ABSOLUTE_PREFIX}"
-#cmakedefine NL_DRIVER_PREFIX "${NL_DRIVER_PREFIX}"
+#cmakedefine NL_DRIVER_PREFIX "${NL_DRIVER_ABSOLUTE_PREFIX}"
 
-#cmakedefine RYZOM_PREFIX "${RYZOM_PREFIX}"
+#cmakedefine RYZOM_BIN_PREFIX "${RYZOM_BIN_ABSOLUTE_PREFIX}"
-#cmakedefine RYZOM_BIN_PREFIX "${RYZOM_BIN_PREFIX}"
+#cmakedefine RYZOM_ETC_PREFIX "${RYZOM_ETC_ABSOLUTE_PREFIX}"
-#cmakedefine RYZOM_ETC_PREFIX "${RYZOM_ETC_PREFIX}"
+#cmakedefine RYZOM_SHARE_PREFIX "${RYZOM_SHARE_ABSOLUTE_PREFIX}"
-#cmakedefine RYZOM_SHARE_PREFIX "${RYZOM_SHARE_PREFIX}"
 
 #endif // CONFIG_H

code/nel/CMakeLists.txt

@@ -44,8 +44,8 @@ ENDIF(WITH_GTK)
 IF(WITH_INSTALL_LIBRARIES)
   IF(UNIX)
     SET(prefix ${CMAKE_INSTALL_PREFIX})
-    SET(exec_prefix ${CMAKE_INSTALL_PREFIX}/bin)
+    SET(exec_prefix ${NL_BIN_ABSOLUTE_PREFIX})
-    SET(libdir ${CMAKE_INSTALL_PREFIX}/lib)
+    SET(libdir ${NL_LIB_ABSOLUTE_PREFIX})
     SET(includedir ${CMAKE_INSTALL_PREFIX}/include)
     SET(enable_ligo ${WITH_LIGO})
     SET(enable_logic ${WITH_LOGIC})
@@ -56,7 +56,7 @@ IF(WITH_INSTALL_LIBRARIES)
     SET(enable_sound ${WITH_SOUND})
     CONFIGURE_FILE(nel-config.in ${CMAKE_CURRENT_BINARY_DIR}/nel-config)
 
-    INSTALL(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/nel-config DESTINATION bin)
+    INSTALL(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/nel-config DESTINATION ${NL_BIN_PREFIX})
   ENDIF(UNIX)
 
   ADD_SUBDIRECTORY(include)

code/nel/include/nel/3d/driver.h

@@ -293,6 +293,11 @@ public:
 	 */
 	virtual void			forceDXTCCompression(bool dxtcComp)=0;
 
+	/** if different from 0, enable anisotropic filter on textures. -1 enables max value.
+	 *	Default is 0.
+	 */
+	virtual void			setAnisotropicFilter(sint filter)=0;
+
 	/** if !=1, force mostly all the textures (but TextureFonts lightmaps, interfaces  etc..)
 	 *	to be divided by Divisor (2, 4, 8...)
 	 *	Default is 1.

code/nel/include/nel/3d/driver_user.h

@@ -471,6 +471,7 @@ public:
 	virtual void delete3dMouseListener (U3dMouseListener *listener);
 	virtual TPolygonMode 	getPolygonMode ();
 	virtual void			forceDXTCCompression(bool dxtcComp);
+	virtual void			setAnisotropicFilter(sint filter);
 	virtual void			forceTextureResize(uint divisor);
 	virtual void			forceNativeFragmentPrograms(bool nativeOnly);
 	virtual bool			setMonitorColorProperties (const CMonitorColorProperties &properties);

code/nel/include/nel/3d/landscape_def.h

@@ -158,7 +158,7 @@ public:
 
 
 // ***************************************************************************
-// Out of CLandscapeGlobals, because myabe used in __asm{}
+// Out of CLandscapeGlobals, because maybe used in __asm{}
 extern	uint					NL3D_LandscapeGlobals_PassNTri;
 extern	void					*NL3D_LandscapeGlobals_PassTriCurPtr;
 extern  CIndexBuffer::TFormat	NL3D_LandscapeGlobals_PassTriFormat;

code/nel/include/nel/3d/u_driver.h

@@ -660,6 +660,11 @@ public:
 	 */
 	virtual void			forceDXTCCompression(bool dxtcComp)=0;
 
+	/** if different from 0, enable anisotropic filter on textures. -1 enables max value.
+	 *	Default is 0.
+	 */
+	virtual void			setAnisotropicFilter(sint filter)=0;
+
 	/** if !=1, force mostly all the textures (but TextureFonts lightmaps, interfaces  etc..)
 	 *	to be divided by Divisor (2, 4, 8...)
 	 *	Default is 1.

code/nel/include/nel/georges/header.h

@@ -19,6 +19,9 @@
 
 #include "nel/misc/types_nl.h"
 
+// Include from libxml2
+#include <libxml/parser.h>
+
 namespace NLGEORGES
 {
 

code/nel/include/nel/misc/big_file.h

@@ -19,6 +19,7 @@
 
 #include "types_nl.h"
 #include "tds.h"
+#include "singleton.h"
 
 
 namespace NLMISC {

code/nel/include/nel/misc/bitmap.h

@@ -297,8 +297,8 @@ public:
 	void	swap(CBitmap &other);
 
 	/**
-	 * Read a bitmap(TGA or DDS) from an IStream.
+	 * Read a bitmap(TGA, JPEG, PNG or DDS) from an IStream.
-	 * Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5, and
+	 * Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5), PNG, JPEG and
 	 * uncompressed TGA (24 and 32 bits).
 	 * \param IStream The stream must be in reading mode.
 	 * \param mipMapSkip if the file is a DDS with mipMap. N=mipMapSkip mipmaps are skipped.
@@ -310,7 +310,7 @@ public:
 
 	/**
 	 * Determinate the bitmap size from a bitmap(TGA or DDS) from an IStream. load just header of the file.
-	 * Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5, and
+	 * Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5), PNG, JPEG and
 	 * uncompressed TGA (24 and 32 bits).
 	 * NB: at the end, f is seeked to begin.
 	 * \param IStream The stream must be in reading mode.

code/nel/include/nel/misc/contiguous_block_allocator.h

@@ -17,6 +17,7 @@
 #ifndef NL_CONTIGUOUS_BLOCK_ALLOCATOR_H
 #define NL_CONTIGUOUS_BLOCK_ALLOCATOR_H
 
+#include "types_nl.h"
 
 namespace NLMISC
 {

code/nel/include/nel/misc/debug.h

@@ -17,14 +17,14 @@
 #ifndef NL_DEBUG_H
 #define NL_DEBUG_H
 
-#include <cstdio>
-
 #include "common.h"
 #include "log.h"
 #include "mutex.h"
 #include "mem_displayer.h"
 #include "displayer.h"
 #include "app_context.h"
+
+#include <cstdio>
 #include <set>
 
 namespace NLMISC
@@ -169,7 +169,7 @@ void	setCrashAlreadyReported(bool state);
  *\endcode
  */
 #ifdef NL_NO_DEBUG
-#	if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9) || defined(NL_COMP_VC10)
+#	if defined(NL_COMP_VC) && NL_COMP_VC_VERSION >= 71
 #		define nldebug __noop
 #	else
 #		define nldebug 0&&
@@ -184,7 +184,7 @@ void	setCrashAlreadyReported(bool state);
  * Same as nldebug but it will be display in debug and in release mode.
  */
 #ifdef NL_NO_DEBUG
-#	if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9) || defined(NL_COMP_VC10)
+#	if defined(NL_COMP_VC) && NL_COMP_VC_VERSION >= 71
 #		define nlinfo __noop
 #	else
 #		define nlinfo 0&&
@@ -212,7 +212,7 @@ void	setCrashAlreadyReported(bool state);
  */
 
 #ifdef NL_NO_DEBUG
-#	if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9) || defined(NL_COMP_VC10)
+#	if defined(NL_COMP_VC) && NL_COMP_VC_VERSION >= 71
 #		define nlwarning __noop
 #	else
 #		define nlwarning 0&&

code/nel/include/nel/misc/eval_num_expr.h

@@ -241,7 +241,7 @@ private:
 		LogicalXor,		// ^^
 		OperatorCount,	//
 		NotOperator, // This is not an operator
-		ExtOperator, // This is a 2 charcters operator
+		ExtOperator, // This is a 2 characters operator
 	};
 
 	// Functions

code/nel/include/nel/misc/file.h

@@ -17,6 +17,7 @@
 #ifndef NL_FILE_H
 #define NL_FILE_H
 
+#include "types_nl.h"
 #include "stream.h"
 
 

code/nel/include/nel/misc/fixed_size_allocator.h

@@ -17,6 +17,7 @@
 #ifndef NL_FIXED_SIZE_ALLOCATOR_H
 #define NL_FIXED_SIZE_ALLOCATOR_H
 
+#include "types_nl.h"
 
 namespace NLMISC
 {

code/nel/include/nel/misc/grid_traversal.h

@@ -17,6 +17,8 @@
 #ifndef _GRID_TRAVERSAL_H
 #define _GRID_TRAVERSAL_H
 
+#include "types_nl.h"
+
 namespace NLMISC
 {
 

code/nel/include/nel/misc/input_device_manager.h

@@ -19,7 +19,7 @@
 
 #include "types_nl.h"
 #include "game_device.h"
-
+#include "common.h"
 
 namespace NLMISC
 {

code/nel/include/nel/misc/inter_window_msg_queue.h

@@ -17,6 +17,7 @@
 #ifndef RY_INTER_WINDOW_MSG_QUEUE_H
 #define RY_INTER_WINDOW_MSG_QUEUE_H
 
+#include "types_nl.h"
 
 #ifdef NL_OS_WINDOWS
 

code/nel/include/nel/misc/mutex.h

@@ -586,7 +586,7 @@ extern uint32 NbMutexes;
 
 
 /**
- * This class ensure that the Value is accessed by only one thread. First you have to create a CSynchronized class with you type.
+ * This class ensure that the Value is accessed by only one thread. First you have to create a CSynchronized class with your type.
  * Then, if a thread want to modify or do anything on it, you create a CAccessor in a \b sub \b scope. You can modify the value
  * of the CUnfairSynchronized using the value() function \b until the end of the scope. So you have to put the smaller scope as you can.
  *

code/nel/include/nel/misc/object_arena_allocator.h

@@ -17,6 +17,7 @@
 #ifndef NL_OBJECT_ARENA_ALLOCATOR_H
 #define NL_OBJECT_ARENA_ALLOCATOR_H
 
+#include "types_nl.h"
 #include "singleton.h"
 
 namespace NLMISC

code/nel/include/nel/misc/p_thread.h

@@ -17,9 +17,10 @@
 #ifndef NL_P_THREAD_H
 #define NL_P_THREAD_H
 
+#include "types_nl.h"
+
 #ifdef NL_OS_UNIX
 
-#include "types_nl.h"
 #include "thread.h"
 #include <pthread.h>
 

code/nel/include/nel/misc/path.h

@@ -19,14 +19,13 @@
 
 #include "types_nl.h"
 #include "time_nl.h"
+#include "common.h"
+#include "string_mapper.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "common.h"
-#include "string_mapper.h"
-
 namespace NLMISC {
 
 /// Exception throw when a find is not found in a lookup() call

code/nel/include/nel/misc/polygon.h

@@ -21,6 +21,7 @@
 #include "matrix.h"
 #include "stream.h"
 #include "vector_2f.h"
+
 #include <vector>
 
 

code/nel/include/nel/misc/pool_memory.h

@@ -18,6 +18,7 @@
 #define NL_POOL_MEMORY_H
 
 #include "types_nl.h"
+
 #include <list>
 #include <vector>
 

code/nel/include/nel/misc/quat.h

@@ -20,6 +20,7 @@
 #include "types_nl.h"
 #include "vector.h"
 #include "stream.h"
+
 #include <cmath>
 
 namespace	NLMISC

code/nel/include/nel/misc/resource_ptr_inline.h

@@ -18,6 +18,8 @@
 #ifndef NL_RESOURCE_PTR_INLINE_H
 #define NL_RESOURCE_PTR_INLINE_H
 
+#include "types_nl.h"
+
 namespace	NLMISC
 {
 

code/nel/include/nel/misc/rgba.h

@@ -17,11 +17,11 @@
 #ifndef NL_RGBA_H
 #define NL_RGBA_H
 
-#include <algorithm>
-
 #include "types_nl.h"
 #include "common.h"
 
+#include <algorithm>
+
 
 namespace NLMISC
 {

code/nel/include/nel/misc/sha1.h

@@ -17,11 +17,12 @@
 #ifndef NL_SHA1_H
 #define NL_SHA1_H
 
-#include <string>
+#include "types_nl.h"
-
 #include "common.h"
 #include "stream.h"
 
+#include <string>
+
 struct CHashKey
 {
 	CHashKey () { HashKeyString.resize(20); }

code/nel/include/nel/misc/smart_ptr.h

@@ -352,7 +352,7 @@ public:
 	}
 };
 
-#if defined(NL_COMP_VC8) || defined(NL_COMP_VC9) || defined(NL_COMP_VC10)
+#if defined(NL_COMP_VC) && NL_COMP_VC_VERSION >= 80
 
 // This operator only purpose is to compare with NULL value
 template <class T>

code/nel/include/nel/misc/smart_ptr_inline.h

@@ -18,6 +18,8 @@
 #ifndef NL_SMARTPTR_INLINE_H
 #define NL_SMARTPTR_INLINE_H
 
+#include "types_nl.h"
+
 namespace	NLMISC
 {
 

code/nel/include/nel/misc/stl_block_list.h

@@ -19,6 +19,7 @@
 
 #include "types_nl.h"
 #include "stl_block_allocator.h"
+
 #include <list>
 
 

code/nel/include/nel/misc/stop_watch.h

@@ -19,6 +19,7 @@
 
 #include "types_nl.h"
 #include "time_nl.h"
+
 #include <deque>
 
 

code/nel/include/nel/misc/stream.h

@@ -21,6 +21,7 @@
 #include	"ucstring.h"
 #include	"class_registry.h"
 #include	"common.h"
+
 #include	<utility>
 #include	<string>
 #include	<vector>

code/nel/include/nel/misc/stream_inline.h

@@ -17,10 +17,11 @@
 #ifndef NL_STREAM_INLINE_H
 #define NL_STREAM_INLINE_H
 
-#include <cstdio>
+#include "types_nl.h"
-
 #include "debug.h"
 
+#include <cstdio>
+
 
 namespace	NLMISC
 {

code/nel/include/nel/misc/string_conversion.h

@@ -19,6 +19,7 @@
 
 #include "types_nl.h"
 #include "common.h"
+
 #include <map>
 
 namespace NLMISC

code/nel/include/nel/misc/string_id_array.h

@@ -18,6 +18,7 @@
 #define NL_STRING_ID_ARRAY_H
 
 #include "types_nl.h"
+#include "debug.h"
 
 #include <cmath>
 #include <string>
@@ -25,8 +26,6 @@
 #include <set>
 #include <algorithm>
 
-#include "debug.h"
-
 
 namespace NLMISC {
 

code/nel/include/nel/misc/string_mapper.h

@@ -18,13 +18,12 @@
 #define STRING_MAPPER_H
 
 #include "types_nl.h"
+#include "stream.h"
+#include "mutex.h"
 
 #include <vector>
 #include <set>
 
-#include "stream.h"
-#include "mutex.h"
-
 namespace NLMISC
 {
 

code/nel/include/nel/misc/types_nl.h

@@ -51,12 +51,20 @@
 #	ifndef _WIN32_WINNT
 #		define _WIN32_WINNT 0x0500	// Minimal OS = Windows 2000 (NeL is not supported on Windows 95/98)
 #	endif
-#	if _MSC_VER >= 1600
+#	ifdef _MSC_VER
+#		define NL_COMP_VC
+#		if _MSC_VER >= 1700
+#			define NL_COMP_VC11
+#			define NL_COMP_VC_VERSION 110
+#		elif _MSC_VER >= 1600
 #			define NL_COMP_VC10
+#			define NL_COMP_VC_VERSION 100
 #		elif _MSC_VER >= 1500
 #			define NL_COMP_VC9
+#			define NL_COMP_VC_VERSION 90
 #		elif _MSC_VER >= 1400
 #			define NL_COMP_VC8
+#			define NL_COMP_VC_VERSION 80
 #			undef nl_time
 #			define nl_time _time32		// use the old 32 bit time function
 #			undef nl_mktime
@@ -69,12 +77,16 @@
 #			define nl_difftime _difftime32	// use the old 32 bit time function
 #		elif _MSC_VER >= 1310
 #			define NL_COMP_VC71
+#			define NL_COMP_VC_VERSION 71
 #		elif _MSC_VER >= 1300
 #			define NL_COMP_VC7
+#			define NL_COMP_VC_VERSION 70
 #		elif _MSC_VER >= 1200
 #			define NL_COMP_VC6
+#			define NL_COMP_VC_VERSION 60
 #			define NL_COMP_NEED_PARAM_ON_METHOD
 #		endif
+#	endif
 #	if defined(_HAS_TR1) && (_HAS_TR1 + 0) // VC9 TR1 feature pack or later
 #		define NL_ISO_STDTR1_AVAILABLE
 #		define NL_ISO_STDTR1_HEADER(header) <header>
@@ -320,7 +332,7 @@ typedef	unsigned	int			uint;			// at least 32bits (depend of processor)
 #	define CHashMap std::tr1::unordered_map
 #	define CHashSet std::tr1::unordered_set
 #	define CHashMultiMap std::tr1::unordered_multimap
-#elif defined(NL_COMP_VC7) || defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9) // VC7 through 9
+#elif defined(NL_COMP_VC) && (NL_COMP_VC_VERSION >= 70 && NL_COMP_VC_VERSION <= 90) // VC7 through 9
 #	include <hash_map>
 #	include <hash_set>
 #	define CHashMap stdext::hash_map
@@ -366,7 +378,7 @@ typedef	uint16	ucchar;
 
 // To define a 64bits constant; ie: UINT64_CONSTANT(0x123456781234)
 #ifdef NL_OS_WINDOWS
-#	if defined(NL_COMP_VC8) || defined(NL_COMP_VC9) || defined(NL_COMP_VC10)
+#	if defined(NL_COMP_VC) && (NL_COMP_VC_VERSION >= 80)
 #		define INT64_CONSTANT(c)	(c##LL)
 #		define SINT64_CONSTANT(c)	(c##LL)
 #		define UINT64_CONSTANT(c)	(c##LL)

code/nel/include/nel/misc/win32_util.h

@@ -17,6 +17,7 @@
 #ifndef NL_WIN32_UTIL_H
 #define NL_WIN32_UTIL_H
 
+#include "types_nl.h"
 
 #ifdef NL_OS_WINDOWS
 

code/nel/include/nel/net/message_recorder.h

@@ -79,7 +79,7 @@ struct TMessageRecord
 			stream.serial( s_event );
 			uint32 sockId;
 			stream.serialHex( sockId );
-			SockId = (NLNET::TSockId)sockId;
+			SockId = (NLNET::TSockId)(size_t)sockId;
 			len = Message.length();
 			stream.serial( len );
 			stream.serialBuffer( const_cast<uint8*>(Message.buffer()), len ); // assumes the message contains plain text

code/nel/include/nel/pacs/retriever_bank.h

@@ -142,7 +142,7 @@ public:
 				for (i=0; i<num; ++i)
 				{
 					std::string	fname = NLMISC::CPath::lookup(_NamePrefix + "_" + NLMISC::toString(i) + ".lr", false, true);
-					if (fname == "")
+					if (fname.empty())
 						continue;
 
 					NLMISC::CIFile	f(fname);

code/nel/samples/3d/cegui/CMakeLists.txt

@@ -2,7 +2,7 @@ FILE(GLOB SRC *.cpp *.h)
 
 ADD_EXECUTABLE(nl_sample_cegui WIN32 ${SRC})
 
-ADD_DEFINITIONS(-DCEGUI_DATA_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_cegui/datafiles/\\"")
+ADD_DEFINITIONS(-DCEGUI_DATA_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_cegui/datafiles/\\"")
 
 INCLUDE_DIRECTORIES(${CEGUI_INCLUDE_DIRS})
 
@@ -10,9 +10,9 @@ TARGET_LINK_LIBRARIES(nl_sample_cegui ${CEGUI_LIBRARY} nelmisc nel3d)
 NL_DEFAULT_PROPS(nl_sample_cegui "NeL, Samples, 3D: NeL CEGUI Demo")
 NL_ADD_RUNTIME_FLAGS(nl_sample_cegui)
 
-INSTALL(TARGETS nl_sample_cegui RUNTIME DESTINATION bin COMPONENT samples3d)
+INSTALL(TARGETS nl_sample_cegui RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samples3d)
 INSTALL(DIRECTORY datafiles/ 
-	DESTINATION share/nel/nl_sample_cegui/datafiles
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_cegui/datafiles
 	COMPONENT samples3d
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE

code/nel/samples/3d/cluster_viewer/CMakeLists.txt

@@ -2,34 +2,34 @@ FILE(GLOB SRC *.cpp)
 
 ADD_EXECUTABLE(nl_sample_clusterview WIN32 ${SRC})
 
-ADD_DEFINITIONS(-DCV_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_clusterview/\\"")
+ADD_DEFINITIONS(-DCV_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_clusterview/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_clusterview nelmisc nel3d)
 NL_ADD_RUNTIME_FLAGS(nl_sample_clusterview)
 NL_DEFAULT_PROPS(nl_sample_clusterview "NeL, Samples, 3D: Cluster Viewer")
 
-INSTALL(TARGETS nl_sample_clusterview RUNTIME DESTINATION bin COMPONENT samples3d)
+INSTALL(TARGETS nl_sample_clusterview RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samples3d)
-INSTALL(FILES main.cvs readme.txt DESTINATION share/nel/nl_sample_clusterview COMPONENT samples3d)
+INSTALL(FILES main.cvs readme.txt DESTINATION ${NL_SHARE_PREFIX}/nl_sample_clusterview COMPONENT samples3d)
 INSTALL(DIRECTORY groups/
-	DESTINATION share/nel/nl_sample_clusterview/groups
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_clusterview/groups
 	COMPONENT samples3d
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE
 	PATTERN "Makefile*" EXCLUDE)
 INSTALL(DIRECTORY fonts/
-	DESTINATION share/nel/nl_sample_clusterview/fonts
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_clusterview/fonts
 	COMPONENT samples3d
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE
 	PATTERN "Makefile*" EXCLUDE)
 INSTALL(DIRECTORY max/
-	DESTINATION share/nel/nl_sample_clusterview/max
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_clusterview/max
 	COMPONENT samples3d
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE
 	PATTERN "Makefile*" EXCLUDE)
 INSTALL(DIRECTORY shapes/
-	DESTINATION share/nel/nl_sample_clusterview/shapes
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_clusterview/shapes
 	COMPONENT samples3d
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE

code/nel/samples/3d/font/CMakeLists.txt

@@ -2,11 +2,11 @@ FILE(GLOB SRC *.cpp)
 
 ADD_EXECUTABLE(nl_sample_font WIN32 ${SRC})
 
-ADD_DEFINITIONS(-DFONT_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_font/\\"")
+ADD_DEFINITIONS(-DFONT_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_font/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_font nelmisc nel3d)
 NL_DEFAULT_PROPS(nl_sample_font "NeL, Samples, 3D: Font")
 NL_ADD_RUNTIME_FLAGS(nl_sample_font)
 
-INSTALL(TARGETS nl_sample_font RUNTIME DESTINATION bin COMPONENT samples3d)
+INSTALL(TARGETS nl_sample_font RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samples3d)
-INSTALL(FILES beteckna.ttf DESTINATION share/nel/nl_sample_font COMPONENT samples3d)
+INSTALL(FILES beteckna.ttf DESTINATION ${NL_SHARE_PREFIX}/nl_sample_font COMPONENT samples3d)

code/nel/samples/3d/qtnel/CMakeLists.txt

@@ -27,5 +27,5 @@ NL_ADD_RUNTIME_FLAGS(qtnel)
 
 ADD_DEFINITIONS(${QT_DEFINITIONS})
 
-INSTALL(TARGETS qtnel RUNTIME DESTINATION bin COMPONENT samples3d)
+INSTALL(TARGETS qtnel RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samples3d)
 

code/nel/samples/3d/shape_viewer/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_shapeview nelmisc nel3d)
 NL_DEFAULT_PROPS(nl_sample_shapeview "NeL, Samples, 3D: Shape Viewer")
 NL_ADD_RUNTIME_FLAGS(nl_sample_shapeview)
 
-INSTALL(TARGETS nl_sample_shapeview RUNTIME DESTINATION bin COMPONENT samples3d)
+INSTALL(TARGETS nl_sample_shapeview RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samples3d)

code/nel/samples/georges/CMakeLists.txt

@@ -2,12 +2,12 @@ FILE(GLOB SRC *.cpp)
 
 ADD_EXECUTABLE(nl_sample_georges ${SRC})
 
-ADD_DEFINITIONS(-DGF_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_georges/\\"")
+ADD_DEFINITIONS(-DGF_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_georges/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_georges nelgeorges nelmisc)
 NL_DEFAULT_PROPS(nl_sample_georges "NeL, Samples: Georges")
 NL_ADD_RUNTIME_FLAGS(nl_sample_georges)
 
-INSTALL(TARGETS nl_sample_georges RUNTIME DESTINATION bin COMPONENT samplesgeorges)
+INSTALL(TARGETS nl_sample_georges RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesgeorges)
 INSTALL(FILES boolean.typ coolfilesinfo.dfn default.sample_config int.typ positiondata.dfn sample_config.dfn string.typ sheet_id.bin
-	DESTINATION share/nel/nl_sample_georges/ COMPONENT samplesgeorges)
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_georges/ COMPONENT samplesgeorges)

code/nel/samples/misc/command/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_command nelmisc)
 NL_DEFAULT_PROPS(nl_sample_command "NeL, Samples, Misc: Commands")
 NL_ADD_RUNTIME_FLAGS(nl_sample_command)
 
-INSTALL(TARGETS nl_sample_command RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_command RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)

code/nel/samples/misc/configfile/CMakeLists.txt

@@ -2,11 +2,11 @@ FILE(GLOB SRC *.cpp)
 
 ADD_EXECUTABLE(nl_sample_configfile ${SRC})
 
-ADD_DEFINITIONS(-DNL_SAMPLE_CFG="\\"${NL_SHARE_PREFIX}/nl_sample_configfile/\\"")
+ADD_DEFINITIONS(-DNL_SAMPLE_CFG="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_configfile/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_configfile nelmisc)
 NL_DEFAULT_PROPS(nl_sample_configfile "NeL, Samples, Misc: Config Files")
 NL_ADD_RUNTIME_FLAGS(nl_sample_configfile)
 
-INSTALL(TARGETS nl_sample_configfile RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_configfile RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)
-INSTALL(FILES simpletest.txt DESTINATION share/nel/nl_sample_configfile COMPONENT samplesmisc)
+INSTALL(FILES simpletest.txt DESTINATION ${NL_SHARE_PREFIX}/nl_sample_configfile COMPONENT samplesmisc)

code/nel/samples/misc/debug/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_debug nelmisc)
 NL_DEFAULT_PROPS(nl_sample_debug "NeL, Samples, Misc: Debugging")
 NL_ADD_RUNTIME_FLAGS(nl_sample_debug)
 
-INSTALL(TARGETS nl_sample_debug RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_debug RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)

code/nel/samples/misc/i18n/CMakeLists.txt

@@ -2,11 +2,11 @@ FILE(GLOB SRC *.cpp)
 
 ADD_EXECUTABLE(nl_sample_i18n ${SRC})
 
-ADD_DEFINITIONS(-DNL_LANG_DATA="\\"${NL_SHARE_PREFIX}/nl_sample_i18n/\\"")
+ADD_DEFINITIONS(-DNL_LANG_DATA="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_i18n/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_i18n nelmisc)
 NL_DEFAULT_PROPS(nl_sample_i18n "NeL, Samples, Misc: I18N")
 NL_ADD_RUNTIME_FLAGS(nl_sample_i18n)
 
-INSTALL(TARGETS nl_sample_i18n RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_i18n RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)
-INSTALL(FILES de.uxt en.uxt fr.uxt DESTINATION share/nel/nl_sample_i18n COMPONENT samplesmisc)
+INSTALL(FILES de.uxt en.uxt fr.uxt DESTINATION ${NL_SHARE_PREFIX}/nl_sample_i18n COMPONENT samplesmisc)

code/nel/samples/misc/log/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_log nelmisc)
 NL_DEFAULT_PROPS(nl_sample_log "NeL, Samples, Misc: Logging")
 NL_ADD_RUNTIME_FLAGS(nl_sample_log)
 
-INSTALL(TARGETS nl_sample_log RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_log RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)

code/nel/samples/misc/strings/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_strings nelmisc)
 NL_DEFAULT_PROPS(nl_sample_strings "NeL, Samples, Misc: Strings")
 NL_ADD_RUNTIME_FLAGS(nl_sample_strings)
 
-INSTALL(TARGETS nl_sample_strings RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_strings RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)

code/nel/samples/misc/types_check/CMakeLists.txt

@@ -6,4 +6,4 @@ TARGET_LINK_LIBRARIES(nl_sample_types_check nelmisc)
 NL_DEFAULT_PROPS(nl_sample_types_check "Samples, MISC: Types check sample")
 NL_ADD_RUNTIME_FLAGS(nl_sample_types_check)
 
-INSTALL(TARGETS nl_sample_types_check RUNTIME DESTINATION bin COMPONENT samplesmisc)
+INSTALL(TARGETS nl_sample_types_check RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesmisc)

code/nel/samples/net/chat/CMakeLists.txt

@@ -2,7 +2,7 @@ ADD_EXECUTABLE(nl_sample_chatclient client.cpp kbhit.cpp kbhit.h)
 
 ADD_EXECUTABLE(nl_sample_chatserver WIN32 server.cpp)
 
-ADD_DEFINITIONS(-DCHAT_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_chat/\\"")
+ADD_DEFINITIONS(-DCHAT_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_chat/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_chatclient nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_chatclient "NeL, Samples, Net, Chat: Chat Client")
@@ -12,5 +12,5 @@ TARGET_LINK_LIBRARIES(nl_sample_chatserver nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_chatserver "NeL, Samples, Net, Chat: Chat Server")
 NL_ADD_RUNTIME_FLAGS(nl_sample_chatserver)
 
-INSTALL(TARGETS nl_sample_chatclient nl_sample_chatserver RUNTIME DESTINATION bin COMPONENT samplesnet)
+INSTALL(TARGETS nl_sample_chatclient nl_sample_chatserver RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesnet)
-INSTALL(FILES chat_service.cfg client.cfg DESTINATION share/nel/nl_sample_chat COMPONENT samplesnet)
+INSTALL(FILES chat_service.cfg client.cfg DESTINATION ${NL_SHARE_PREFIX}/nl_sample_chat COMPONENT samplesnet)

code/nel/samples/net/class_transport/CMakeLists.txt

@@ -2,7 +2,7 @@ ADD_EXECUTABLE(nl_sample_ct_ai_service WIN32 ai_service.cpp)
 
 ADD_EXECUTABLE(nl_sample_ct_gd_service WIN32 gd_service.cpp)
 
-ADD_DEFINITIONS(-DNL_CT_CFG="\\"${NL_SHARE_PREFIX}/nl_sample_class_transport/\\"")
+ADD_DEFINITIONS(-DNL_CT_CFG="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_class_transport/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_ct_ai_service nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_ct_ai_service "NeL, Samples, Net, Class Transport: AI Service")
@@ -12,5 +12,5 @@ TARGET_LINK_LIBRARIES(nl_sample_ct_gd_service nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_ct_gd_service "NeL, Samples, Net, Class Transport: GD Service")
 NL_ADD_RUNTIME_FLAGS(nl_sample_ct_gd_service)
 
-INSTALL(TARGETS nl_sample_ct_ai_service nl_sample_ct_gd_service RUNTIME DESTINATION bin COMPONENT samplesnet)
+INSTALL(TARGETS nl_sample_ct_ai_service nl_sample_ct_gd_service RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesnet)
-INSTALL(FILES ai_service.cfg gd_service.cfg DESTINATION share/nel/nl_sample_class_transport COMPONENT samplesnet)
+INSTALL(FILES ai_service.cfg gd_service.cfg DESTINATION ${NL_SHARE_PREFIX}/nl_sample_class_transport COMPONENT samplesnet)

code/nel/samples/net/login_system/CMakeLists.txt

@@ -2,7 +2,7 @@ ADD_EXECUTABLE(nl_sample_ls_client client.cpp)
 
 ADD_EXECUTABLE(nl_sample_ls_fes WIN32 frontend_service.cpp)
 
-ADD_DEFINITIONS(-DNL_LS_CFG="\\"${NL_SHARE_PREFIX}/nl_sample_login_system/\\"")
+ADD_DEFINITIONS(-DNL_LS_CFG="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_login_system/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_ls_client nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_ls_client "NeL, Samples, Net, Login Service: LS Client")
@@ -12,5 +12,5 @@ TARGET_LINK_LIBRARIES(nl_sample_ls_fes nelmisc nelnet)
 NL_DEFAULT_PROPS(nl_sample_ls_fes "NeL, Samples, Net, Login Service: LS Frontend")
 NL_ADD_RUNTIME_FLAGS(nl_sample_ls_fes)
 
-INSTALL(TARGETS nl_sample_ls_client nl_sample_ls_fes RUNTIME DESTINATION bin COMPONENT samplesnet)
+INSTALL(TARGETS nl_sample_ls_client nl_sample_ls_fes RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesnet)
-INSTALL(FILES frontend_service.cfg client.cfg DESTINATION share/nel/nl_sample_login_system COMPONENT samplesnet)
+INSTALL(FILES frontend_service.cfg client.cfg DESTINATION ${NL_SHARE_PREFIX}/nl_sample_login_system COMPONENT samplesnet)

code/nel/samples/net/udp/CMakeLists.txt

@@ -4,7 +4,7 @@ ADD_EXECUTABLE(nl_sample_udpclient client.cpp graph.cpp graph.h simlag.cpp simla
 
 ADD_EXECUTABLE(nl_sample_udpserver WIN32 bench_service.cpp receive_task.cpp receive_task.h)
 
-ADD_DEFINITIONS(-DUDP_DIR="\\"${NL_SHARE_PREFIX}/nl_sample_udp/\\"")
+ADD_DEFINITIONS(-DUDP_DIR="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_udp/\\"")
 
 IF(WITH_3D)
   ADD_DEFINITIONS(-DUSE_3D)
@@ -17,9 +17,9 @@ NL_DEFAULT_PROPS(nl_sample_udpserver "NeL, Samples, Net, UDP: UDP Server")
 NL_ADD_RUNTIME_FLAGS(nl_sample_udpclient)
 NL_ADD_RUNTIME_FLAGS(nl_sample_udpserver)
 
-INSTALL(TARGETS nl_sample_udpclient nl_sample_udpserver RUNTIME DESTINATION bin COMPONENT samplesnet)
+INSTALL(TARGETS nl_sample_udpclient nl_sample_udpserver RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplesnet)
-INSTALL(FILES bench_service.cfg client.cfg readme.txt DESTINATION share/nel/nl_sample_udp COMPONENT samplesnet)
+INSTALL(FILES bench_service.cfg client.cfg readme.txt DESTINATION ${NL_SHARE_PREFIX}/nl_sample_udp COMPONENT samplesnet)
 
 IF(WITH_3D)
-  INSTALL(FILES n019003l.pfb DESTINATION share/nel/nl_sample_udp COMPONENT samplesnet)
+  INSTALL(FILES n019003l.pfb DESTINATION ${NL_SHARE_PREFIX}/nl_sample_udp COMPONENT samplesnet)
 ENDIF(WITH_3D)

code/nel/samples/pacs/CMakeLists.txt

@@ -2,16 +2,16 @@ FILE(GLOB SRC *.cpp *.h)
 
 ADD_EXECUTABLE(nl_sample_pacs WIN32 ${SRC})
 
-ADD_DEFINITIONS(-DNL_PACS_DATA="\\"${NL_SHARE_PREFIX}/nl_sample_pacs/\\"")
+ADD_DEFINITIONS(-DNL_PACS_DATA="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_pacs/\\"")
 
 TARGET_LINK_LIBRARIES(nl_sample_pacs nelmisc nelpacs nel3d)
 NL_DEFAULT_PROPS(nl_sample_pacs "NeL, Samples: PACS")
 NL_ADD_RUNTIME_FLAGS(nl_sample_pacs)
 
-INSTALL(TARGETS nl_sample_pacs RUNTIME DESTINATION bin COMPONENT samplespacs)
+INSTALL(TARGETS nl_sample_pacs RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplespacs)
-INSTALL(FILES readme.txt DESTINATION share/nel/nl_sample_pacs COMPONENT samplespacs)
+INSTALL(FILES readme.txt DESTINATION ${NL_SHARE_PREFIX}/nl_sample_pacs COMPONENT samplespacs)
 INSTALL(DIRECTORY shapes/
-	DESTINATION share/nel/nl_sample_pacs/shapes
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_pacs/shapes
 	COMPONENT samplespacs
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE

code/nel/samples/sound/sound_sources/CMakeLists.txt

@@ -2,7 +2,7 @@ FILE(GLOB SRC *.cpp *.h)
 
 ADD_EXECUTABLE(nl_sample_sound_sources ${SRC})
 
-ADD_DEFINITIONS(-DNL_SOUND_DATA="\\"${NL_SHARE_PREFIX}/nl_sample_sound/\\"" ${LIBXML2_DEFINITIONS})
+ADD_DEFINITIONS(-DNL_SOUND_DATA="\\"${NL_SHARE_ABSOLUTE_PREFIX}/nl_sample_sound/\\"" ${LIBXML2_DEFINITIONS})
 
 INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
 
@@ -10,9 +10,9 @@ TARGET_LINK_LIBRARIES(nl_sample_sound_sources nelmisc nelsound)
 NL_DEFAULT_PROPS(nl_sample_sound_sources "NeL, Samples: Sound: Sound Sources")
 NL_ADD_RUNTIME_FLAGS(nl_sample_sound_sources)
 
-INSTALL(TARGETS nl_sample_sound_sources RUNTIME DESTINATION bin COMPONENT samplessound)
+INSTALL(TARGETS nl_sample_sound_sources RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplessound)
 INSTALL(DIRECTORY data/
-	DESTINATION share/nel/nl_sample_sound/data
+	DESTINATION ${NL_SHARE_PREFIX}/nl_sample_sound/data
 	COMPONENT samplespacs
 	PATTERN "CVS" EXCLUDE
 	PATTERN ".svn" EXCLUDE

code/nel/samples/sound/stream_file/CMakeLists.txt

@@ -8,5 +8,5 @@ TARGET_LINK_LIBRARIES(nl_sample_stream_file nelmisc nelsound)
 NL_DEFAULT_PROPS(nl_sample_stream_file "NeL, Samples: Sound: Stream File")
 NL_ADD_RUNTIME_FLAGS(nl_sample_stream_file)
 
-INSTALL(TARGETS nl_sample_stream_file RUNTIME DESTINATION bin COMPONENT samplessound)
+INSTALL(TARGETS nl_sample_stream_file RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplessound)
 

code/nel/samples/sound/stream_ogg_vorbis/CMakeLists.txt

@@ -8,5 +8,5 @@ TARGET_LINK_LIBRARIES(nl_sample_stream_ogg_vorbis nelmisc nelsound)
 NL_DEFAULT_PROPS(nl_sample_stream_ogg_vorbis "NeL, Samples: Sound: Stream OGG Vorbis")
 NL_ADD_RUNTIME_FLAGS(nl_sample_stream_ogg_vorbis)
 
-INSTALL(TARGETS nl_sample_stream_ogg_vorbis RUNTIME DESTINATION bin COMPONENT samplessound)
+INSTALL(TARGETS nl_sample_stream_ogg_vorbis RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT samplessound)
 

code/nel/src/3d/CMakeLists.txt

@@ -708,7 +708,7 @@ ENDIF(WITH_PCH)
 NL_GEN_PC(nel-3d.pc)
 
 IF((WITH_INSTALL_LIBRARIES AND WITH_STATIC) OR NOT WITH_STATIC)
-  INSTALL(TARGETS nel3d LIBRARY DESTINATION lib ARCHIVE DESTINATION lib COMPONENT libraries)
+  INSTALL(TARGETS nel3d LIBRARY DESTINATION ${NL_LIB_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} COMPONENT libraries)
 ENDIF((WITH_INSTALL_LIBRARIES AND WITH_STATIC) OR NOT WITH_STATIC)
 
 ADD_SUBDIRECTORY(driver)

code/nel/src/3d/cloud_scape.cpp

@@ -193,7 +193,7 @@ void SCloudTextureClamp::init (uint32 nWidth, uint32 nHeight, uint32 nDepth, con
 	Mem = new uint8[NbW*Width*NbH*Height];
 	uint32 i, j;
 
-	if (filename == "")
+	if (filename.empty())
 	{
 		// No filename so init with default
 		for (i = 0; i < NbW; ++i)

code/nel/src/3d/cluster.cpp

@@ -307,7 +307,7 @@ void CCluster::serial (NLMISC::IStream&f)
 			_SoundGroupId = CStringMapper::map(soundGroup);
 
 			f.serial(envFxName);
-			if (envFxName == "")
+			if (envFxName.empty())
 				envFxName = "no fx";
 			_EnvironmentFxId = CStringMapper::map(envFxName);
 		}

code/nel/src/3d/driver.cpp

@@ -33,7 +33,7 @@ namespace NL3D
 {
 
 // ***************************************************************************
-const uint32 IDriver::InterfaceVersion = 0x6a; // added cursors methods
+const uint32 IDriver::InterfaceVersion = 0x6b; // added anisotropic filter
 
 // ***************************************************************************
 IDriver::IDriver() : _SyncTexDrvInfos( "IDriver::_SyncTexDrvInfos" )

code/nel/src/3d/driver/direct3d/CMakeLists.txt

@@ -17,7 +17,7 @@ IF(WITH_PCH)
 ENDIF(WITH_PCH)
 
 IF((WITH_INSTALL_LIBRARIES AND WITH_STATIC_DRIVERS) OR NOT WITH_STATIC_DRIVERS)
-  INSTALL(TARGETS nel_drv_direct3d_win LIBRARY DESTINATION ${NL_DRIVER_PREFIX} ARCHIVE DESTINATION lib RUNTIME DESTINATION bin COMPONENT drivers3d)
+  INSTALL(TARGETS nel_drv_direct3d_win LIBRARY DESTINATION ${NL_DRIVER_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_DRIVER_PREFIX} COMPONENT drivers3d)
   IF(WITH_MAXPLUGIN)
     INSTALL(TARGETS nel_drv_direct3d_win RUNTIME DESTINATION maxplugin COMPONENT drivers3d)
   ENDIF(WITH_MAXPLUGIN)