Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 15:53:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

Browse source
This commit is contained in:
Colin Finck 2017-10-03 07:45:34 +00:00
parent b94e2d8ca0
commit c2c66aff7d
24198 changed files with 0 additions and 37285 deletions
Download patch file Download diff file Expand all files Collapse all files

346
sdk/cmake/CMakeDetermineASMCompiler.cmake Normal file
View file

@ -0,0 +1,346 @@
#=============================================================================
# Copyright 2007-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
if(CMAKE_VERSION VERSION_LESS 2.8.10)
# determine the compiler to use for ASM programs
IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
# prefer the environment variable ASM
IF($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT "$ENV{ASM${ASM_DIALECT}}")
ENDIF($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
# finally list compilers to try
IF("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
IF(CMAKE_ASM_COMPILER_INIT)
SET(CMAKE_ASM_COMPILER_LIST ${CMAKE_ASM_COMPILER_INIT})
ELSE(CMAKE_ASM_COMPILER_INIT)
IF(CMAKE_C_COMPILER)
SET(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}" CACHE FILEPATH "The ASM compiler")
SET(CMAKE_ASM_COMPILER_ID "${CMAKE_C_COMPILER_ID}")
ELSEIF(CMAKE_CXX_COMPILER)
SET(CMAKE_ASM_COMPILER "${CMAKE_CXX_COMPILER}" CACHE FILEPATH "The ASM compiler")
SET(CMAKE_ASM_COMPILER_ID "${CMAKE_CXX_COMPILER_ID}")
ELSE(CMAKE_CXX_COMPILER)
# List all default C and CXX compilers
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gcc ${_CMAKE_TOOLCHAIN_PREFIX}cc cl bcc xlc
${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ CC aCC cl bcc xlC)
ENDIF(CMAKE_C_COMPILER)
ENDIF(CMAKE_ASM_COMPILER_INIT)
ELSE("ASM${ASM_DIALECT}" STREQUAL "ASM") # some specific assembler "dialect"
IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT})
ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
MESSAGE(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT must be preset !")
ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
ENDIF("ASM${ASM_DIALECT}" STREQUAL "ASM")
# Find the compiler.
IF (_CMAKE_USER_CXX_COMPILER_PATH OR _CMAKE_USER_C_COMPILER_PATH)
FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST} PATHS ${_CMAKE_USER_C_COMPILER_PATH} ${_CMAKE_USER_CXX_COMPILER_PATH} DOC "Assembler" NO_DEFAULT_PATH)
ENDIF (_CMAKE_USER_CXX_COMPILER_PATH OR _CMAKE_USER_C_COMPILER_PATH)
FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST} PATHS ${_CMAKE_TOOLCHAIN_LOCATION} DOC "Assembler")
ELSE(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
# we only get here if CMAKE_ASM${ASM_DIALECT}_COMPILER was specified using -D or a pre-made CMakeCache.txt
# (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
#
# if a compiler was specified by the user but without path,
# now try to find it with the full path
# if it is found, force it into the cache,
# if not, don't overwrite the setting (which was given by the user) with "NOTFOUND"
GET_FILENAME_COMPONENT(_CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
IF(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER})
MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER ${CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH} CACHE FILEPATH "Assembler" FORCE)
ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
ENDIF(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_COMPILER)
IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
# Table of per-vendor compiler id flags with expected output.
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS GNU )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "(GNU assembler)|(GCC)|(Free Software Foundation)")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS HP )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_HP "-V")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_HP "HP C")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Intel )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS XL )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_XL "-qversion")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI_DSP )
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI_DSP "-h")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI_DSP "Texas Instruments")
LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS VISUAL)
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_VISUAL "/?")
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_VISUAL "Microsoft Corporation")
INCLUDE(CMakeDetermineCompilerId)
CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT})
ENDIF()
IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
MESSAGE(STATUS "The ASM${ASM_DIALECT} compiler identification is ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
MESSAGE(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
# If we have a gas/as cross compiler, they have usually some prefix, like
# e.g. powerpc-linux-gas, arm-elf-gas or i586-mingw32msvc-gas , optionally
# with a 3-component version number at the end
# The other tools of the toolchain usually have the same prefix
# NAME_WE cannot be used since then this test will fail for names lile
# "arm-unknown-nto-qnx6.3.0-gas.exe", where BASENAME would be
# "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME)
IF (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
# Now try the C compiler regexp:
IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
IF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
# Finally try the CXX compiler regexp:
IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
IF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
ENDIF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
INCLUDE(CMakeFindBinUtils)
SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR "ASM${ASM_DIALECT}")
IF(CMAKE_ASM${ASM_DIALECT}_COMPILER)
MESSAGE(STATUS "Found assembler: ${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER)
MESSAGE(STATUS "Didn't find assembler")
ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER)
SET(_CMAKE_ASM_COMPILER "${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
SET(_CMAKE_ASM_COMPILER_ID "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
SET(_CMAKE_ASM_COMPILER_ARG1 "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARG1}")
SET(_CMAKE_ASM_COMPILER_ENV_VAR "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR}")
# configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
SET(_CMAKE_ASM_COMPILER)
SET(_CMAKE_ASM_COMPILER_ARG1)
SET(_CMAKE_ASM_COMPILER_ENV_VAR)
else()
# determine the compiler to use for ASM programs
include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
# prefer the environment variable ASM
if($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT "$ENV{ASM${ASM_DIALECT}}")
endif()
# finally list compilers to try
if("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
if(NOT CMAKE_ASM_COMPILER_INIT)
if(CMAKE_C_COMPILER)
set(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}" CACHE FILEPATH "The ASM compiler")
set(CMAKE_ASM_COMPILER_ID "${CMAKE_C_COMPILER_ID}")
elseif(CMAKE_CXX_COMPILER)
set(CMAKE_ASM_COMPILER "${CMAKE_CXX_COMPILER}" CACHE FILEPATH "The ASM compiler")
set(CMAKE_ASM_COMPILER_ID "${CMAKE_CXX_COMPILER_ID}")
else()
# List all default C and CXX compilers
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST
${_CMAKE_TOOLCHAIN_PREFIX}cc ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc
CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC)
endif()
endif()
else() # some specific assembler "dialect"
if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
message(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT must be preset !")
endif()
endif()
# Find the compiler.
_cmake_find_compiler(ASM${ASM_DIALECT})
else()
# we only get here if CMAKE_ASM${ASM_DIALECT}_COMPILER was specified using -D or a pre-made CMakeCache.txt
# (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
#
# if a compiler was specified by the user but without path,
# now try to find it with the full path
# if it is found, force it into the cache,
# if not, don't overwrite the setting (which was given by the user) with "NOTFOUND"
get_filename_component(_CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
if(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
find_program(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER})
mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
if(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
set(CMAKE_ASM${ASM_DIALECT}_COMPILER ${CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH} CACHE FILEPATH "Assembler" FORCE)
endif()
endif()
endif()
mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER)
if (NOT _CMAKE_TOOLCHAIN_LOCATION)
get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
endif ()
if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
# Table of per-vendor compiler id flags with expected output.
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS GNU )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "(GNU assembler)|(GCC)|(Free Software Foundation)")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS HP )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_HP "-V")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_HP "HP C")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Intel )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS XL )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_XL "-qversion")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "/?")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")
list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI_DSP )
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI_DSP "-h")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI_DSP "Texas Instruments")
include(CMakeDetermineCompilerId)
CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT})
endif()
if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
message(STATUS "The ASM${ASM_DIALECT} compiler identification is ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
else()
message(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
endif()
# If we have a gas/as cross compiler, they have usually some prefix, like
# e.g. powerpc-linux-gas, arm-elf-gas or i586-mingw32msvc-gas , optionally
# with a 3-component version number at the end
# The other tools of the toolchain usually have the same prefix
# NAME_WE cannot be used since then this test will fail for names lile
# "arm-unknown-nto-qnx6.3.0-gas.exe", where BASENAME would be
# "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
if (NOT _CMAKE_TOOLCHAIN_PREFIX)
get_filename_component(COMPILER_BASENAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME)
if (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
endif ()
endif ()
# Now try the C compiler regexp:
if (NOT _CMAKE_TOOLCHAIN_PREFIX)
if (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
endif ()
endif ()
# Finally try the CXX compiler regexp:
if (NOT _CMAKE_TOOLCHAIN_PREFIX)
if (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
endif ()
endif ()
include(CMakeFindBinUtils)
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR "ASM${ASM_DIALECT}")
if(CMAKE_ASM${ASM_DIALECT}_COMPILER)
message(STATUS "Found assembler: ${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
else()
message(STATUS "Didn't find assembler")
endif()
set(_CMAKE_ASM_COMPILER "${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
set(_CMAKE_ASM_COMPILER_ID "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
set(_CMAKE_ASM_COMPILER_ARG1 "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARG1}")
set(_CMAKE_ASM_COMPILER_ENV_VAR "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR}")
# configure variables set in this file for fast reload later on
configure_file(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
${CMAKE_PLATFORM_INFO_DIR}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
set(_CMAKE_ASM_COMPILER)
set(_CMAKE_ASM_COMPILER_ARG1)
set(_CMAKE_ASM_COMPILER_ENV_VAR)
endif()

315
sdk/cmake/CMakeDetermineCompilerId.cmake Normal file
View file

@ -0,0 +1,315 @@
#=============================================================================
# Copyright 2007-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# Function to compile a source file to identify the compiler. This is
# used internally by CMake and should not be included by user code.
# If successful, sets CMAKE_<lang>_COMPILER_ID and CMAKE_<lang>_PLATFORM_ID
FUNCTION(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
# Make sure the compiler arguments are clean.
STRING(STRIP "${CMAKE_${lang}_COMPILER_ARG1}" CMAKE_${lang}_COMPILER_ID_ARG1)
STRING(REGEX REPLACE " +" ";" CMAKE_${lang}_COMPILER_ID_ARG1 "${CMAKE_${lang}_COMPILER_ID_ARG1}")
# Make sure user-specified compiler flags are used.
IF(CMAKE_${lang}_FLAGS)
SET(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS})
ELSE(CMAKE_${lang}_FLAGS)
SET(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}})
ENDIF(CMAKE_${lang}_FLAGS)
STRING(REGEX REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
# Compute the directory in which to run the test.
SET(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
# Try building with no extra flags and then try each set
# of helper flags. Stop when the compiler is identified.
FOREACH(flags "" ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS})
IF(NOT CMAKE_${lang}_COMPILER_ID)
CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${flags}" "${src}")
FOREACH(file ${COMPILER_${lang}_PRODUCED_FILES})
CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
ENDFOREACH(file)
ENDIF(NOT CMAKE_${lang}_COMPILER_ID)
ENDFOREACH(flags)
# If the compiler is still unknown, try to query its vendor.
IF(NOT CMAKE_${lang}_COMPILER_ID)
CMAKE_DETERMINE_COMPILER_ID_VENDOR(${lang})
ENDIF()
# if the format is unknown after all files have been checked, put "Unknown" in the cache
IF(NOT CMAKE_EXECUTABLE_FORMAT)
SET(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format")
ENDIF(NOT CMAKE_EXECUTABLE_FORMAT)
# Display the final identification result.
IF(CMAKE_${lang}_COMPILER_ID)
MESSAGE(STATUS "The ${lang} compiler identification is "
"${CMAKE_${lang}_COMPILER_ID}")
ELSE(CMAKE_${lang}_COMPILER_ID)
MESSAGE(STATUS "The ${lang} compiler identification is unknown")
ENDIF(CMAKE_${lang}_COMPILER_ID)
SET(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
SET(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
SET(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
PARENT_SCOPE)
ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID)
#-----------------------------------------------------------------------------
# Function to write the compiler id source file.
FUNCTION(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src)
FILE(READ ${CMAKE_ROOT}/Modules/${src}.in ID_CONTENT_IN)
STRING(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
FILE(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_WRITE)
#-----------------------------------------------------------------------------
# Function to build the compiler id source file and look for output
# files.
FUNCTION(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags src)
# Create a clean working directory.
FILE(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
FILE(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
CMAKE_DETERMINE_COMPILER_ID_WRITE("${lang}" "${src}")
# Construct a description of this test case.
SET(COMPILER_DESCRIPTION
"Compiler: ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_ARG1}
Build flags: ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
Id flags: ${testflags}
")
# Compile the compiler identification source.
IF(COMMAND EXECUTE_PROCESS)
EXECUTE_PROCESS(
COMMAND ${CMAKE_${lang}_COMPILER}
${CMAKE_${lang}_COMPILER_ID_ARG1}
${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
${testflags}
"${src}"
WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
)
ELSE(COMMAND EXECUTE_PROCESS)
EXEC_PROGRAM(
${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_DIR}
ARGS ${CMAKE_${lang}_COMPILER_ID_ARG1}
${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
${testflags}
\"${src}\"
OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
RETURN_VALUE CMAKE_${lang}_COMPILER_ID_RESULT
)
ENDIF(COMMAND EXECUTE_PROCESS)
# Check the result of compilation.
IF(CMAKE_${lang}_COMPILER_ID_RESULT)
# Compilation failed.
SET(MSG
"Compiling the ${lang} compiler identification source file \"${src}\" failed.
${COMPILER_DESCRIPTION}
The output was:
${CMAKE_${lang}_COMPILER_ID_RESULT}
${CMAKE_${lang}_COMPILER_ID_OUTPUT}
")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
#IF(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
# MESSAGE(FATAL_ERROR "${MSG}")
#ENDIF(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
# No output files should be inspected.
SET(COMPILER_${lang}_PRODUCED_FILES)
ELSE(CMAKE_${lang}_COMPILER_ID_RESULT)
# Compilation succeeded.
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
${COMPILER_DESCRIPTION}
The output was:
${CMAKE_${lang}_COMPILER_ID_RESULT}
${CMAKE_${lang}_COMPILER_ID_OUTPUT}
")
# Find the executable produced by the compiler, try all files in the
# binary dir.
FILE(GLOB COMPILER_${lang}_PRODUCED_FILES
RELATIVE ${CMAKE_${lang}_COMPILER_ID_DIR}
${CMAKE_${lang}_COMPILER_ID_DIR}/*)
LIST(REMOVE_ITEM COMPILER_${lang}_PRODUCED_FILES "${src}")
FOREACH(file ${COMPILER_${lang}_PRODUCED_FILES})
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Compilation of the ${lang} compiler identification source \""
"${src}\" produced \"${file}\"\n\n")
ENDFOREACH(file)
IF(NOT COMPILER_${lang}_PRODUCED_FILES)
# No executable was found.
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Compilation of the ${lang} compiler identification source \""
"${src}\" did not produce an executable in \""
"${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
ENDIF(NOT COMPILER_${lang}_PRODUCED_FILES)
ENDIF(CMAKE_${lang}_COMPILER_ID_RESULT)
# Return the files produced by the compilation.
SET(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags src)
#-----------------------------------------------------------------------------
# Function to extract the compiler id from an executable.
FUNCTION(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
# Look for a compiler id if not yet known.
IF(NOT CMAKE_${lang}_COMPILER_ID)
# Read the compiler identification string from the executable file.
SET(COMPILER_ID)
SET(PLATFORM_ID)
FILE(STRINGS ${file}
CMAKE_${lang}_COMPILER_ID_STRINGS LIMIT_COUNT 3 REGEX "INFO:")
SET(HAVE_COMPILER_TWICE 0)
FOREACH(info ${CMAKE_${lang}_COMPILER_ID_STRINGS})
IF("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
IF(COMPILER_ID)
SET(COMPILER_ID_TWICE 1)
ENDIF(COMPILER_ID)
STRING(REGEX REPLACE ".*INFO:compiler\\[([^]]*)\\].*" "\\1"
COMPILER_ID "${info}")
ENDIF("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
IF("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
STRING(REGEX REPLACE ".*INFO:platform\\[([^]]*)\\].*" "\\1"
PLATFORM_ID "${info}")
ENDIF("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
IF("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
STRING(REGEX REPLACE ".*INFO:arch\\[([^]]*)\\].*" "\\1"
ARCHITECTURE_ID "${info}")
ENDIF("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
ENDFOREACH(info)
# Check if a valid compiler and platform were found.
IF(COMPILER_ID AND NOT COMPILER_ID_TWICE)
SET(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}")
SET(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}")
SET(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
ENDIF(COMPILER_ID AND NOT COMPILER_ID_TWICE)
# Check the compiler identification string.
IF(CMAKE_${lang}_COMPILER_ID)
# The compiler identification was found.
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
"${file}\"\n\n")
ELSE(CMAKE_${lang}_COMPILER_ID)
# The compiler identification could not be found.
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"The ${lang} compiler identification could not be found in \""
"${file}\"\n\n")
ENDIF(CMAKE_${lang}_COMPILER_ID)
ENDIF(NOT CMAKE_${lang}_COMPILER_ID)
# try to figure out the executable format: ELF, COFF, Mach-O
IF(NOT CMAKE_EXECUTABLE_FORMAT)
FILE(READ ${file} CMAKE_EXECUTABLE_MAGIC LIMIT 4 HEX)
# ELF files start with 0x7f"ELF"
IF("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
SET(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format")
ENDIF("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
# # COFF (.exe) files start with "MZ"
# IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
# SET(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE STRING "Executable file format")
# ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
#
# # Mach-O files start with CAFEBABE or FEEDFACE, according to http://radio.weblogs.com/0100490/2003/01/28.html
# IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
# SET(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
# ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
# IF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
# SET(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
# ENDIF("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
ENDIF(NOT CMAKE_EXECUTABLE_FORMAT)
IF(NOT DEFINED CMAKE_EXECUTABLE_FORMAT)
SET(CMAKE_EXECUTABLE_FORMAT)
ENDIF()
# Return the information extracted.
SET(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
SET(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
SET(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
PARENT_SCOPE)
SET(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE)
ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_CHECK lang)
#-----------------------------------------------------------------------------
# Function to query the compiler vendor.
# This uses a table with entries of the form
# list(APPEND CMAKE_${lang}_COMPILER_ID_VENDORS ${vendor})
# set(CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor} -some-vendor-flag)
# set(CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor} "Some Vendor Output")
# We try running the compiler with the flag for each vendor and
# matching its regular expression in the output.
FUNCTION(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang)
IF(NOT CMAKE_${lang}_COMPILER_ID_DIR)
# We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID()
# This is done e.g. for detecting the compiler ID for assemblers.
# Compute the directory in which to run the test and Create a clean working directory.
SET(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
FILE(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
FILE(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
ENDIF(NOT CMAKE_${lang}_COMPILER_ID_DIR)
FOREACH(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS})
SET(flags ${CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor}})
SET(regex ${CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor}})
EXECUTE_PROCESS(
COMMAND ${CMAKE_${lang}_COMPILER}
${CMAKE_${lang}_COMPILER_ID_ARG1}
${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}
${flags}
WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
OUTPUT_VARIABLE output ERROR_VARIABLE output
RESULT_VARIABLE result
TIMEOUT 10
)
IF("${lang}" STREQUAL "ASM")
MESSAGE(STATUS "Checked for ${vendor}")
MESSAGE(STATUS " Output: -${output}-")
MESSAGE(STATUS " Result: -${result}-")
ENDIF("${lang}" STREQUAL "ASM")
IF("${output}" MATCHES "${regex}")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
"matched \"${regex}\":\n${output}")
SET(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE)
BREAK()
ELSE()
IF("${result}" MATCHES "timeout")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
"terminated after 10 s due to timeout.")
ELSE()
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
"did not match \"${regex}\":\n${output}")
ENDIF()
ENDIF()
ENDFOREACH()
ENDFUNCTION(CMAKE_DETERMINE_COMPILER_ID_VENDOR)

854
sdk/cmake/CMakeMacros.cmake Normal file
View file

@ -0,0 +1,854 @@
# set_cpp
# Marks the current folder as containing C++ modules, additionally enabling
# specific C++ language features as specified (all of these default to off):
#
# WITH_RUNTIME
# Links with the C++ runtime. Enable this for modules which use new/delete or
# RTTI, but do not require STL. This is the right choice if you see undefined
# references to operator new/delete, vector constructor/destructor iterator,
# type_info::vtable, ...
# Note: this only affects linking, so cannot be used for static libraries.
# WITH_RTTI
# Enables run-time type information. Enable this if the module uses typeid or
# dynamic_cast. You will probably need to enable WITH_RUNTIME as well, if
# you're not already using STL.
# WITH_EXCEPTIONS
# Enables C++ exception handling. Enable this if the module uses try/catch or
# throw. You might also need this if you use a standard operator new (the one
# without nothrow).
# WITH_STL
# Enables standard C++ headers and links to the Standard Template Library.
# Use this for modules using anything from the std:: namespace, e.g. maps,
# strings, vectors, etc.
# Note: this affects both compiling (via include directories) and
# linking (by adding STL). Implies WITH_RUNTIME.
# FIXME: WITH_STL is currently also required for runtime headers such as
# <new> and <exception>. This is not a big issue because in stl-less
# environments you usually don't want those anyway; but we might want
# to have modules like this in the future.
#
# Examples:
# set_cpp()
# Enables the C++ language, but will cause errors if any runtime or standard
# library features are used. This should be the default for C++ in kernel
# mode or otherwise restricted environments.
# Note: this is required to get libgcc (for multiplication/division) linked
# in for C++ modules, and to set the correct language for precompiled
# header files, so it IS required even with no features specified.
# set_cpp(WITH_RUNTIME)
# Links with the C++ runtime, so that e.g. custom operator new implementations
# can be used in a restricted environment. This is also required for linking
# with libraries (such as ATL) which have RTTI enabled, even if the module in
# question does not use WITH_RTTI.
# set_cpp(WITH_RTTI WITH_EXCEPTIONS WITH_STL)
# The full package. This will adjust compiler and linker so that all C++
# features can be used.
macro(set_cpp)
cmake_parse_arguments(__cppopts "WITH_RUNTIME;WITH_RTTI;WITH_EXCEPTIONS;WITH_STL" "" "" ${ARGN})
if(__cppopts_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "set_cpp: unparsed arguments ${__cppopts_UNPARSED_ARGUMENTS}")
endif()
if(__cppopts_WITH_RUNTIME)
set(CPP_USE_RT 1)
endif()
if(__cppopts_WITH_RTTI)
if(MSVC)
replace_compile_flags("/GR-" "/GR")
else()
replace_compile_flags_language("-fno-rtti" "-frtti" "CXX")
endif()
endif()
if(__cppopts_WITH_EXCEPTIONS)
if(MSVC)
replace_compile_flags("/EHs-c-" "/EHsc")
else()
replace_compile_flags_language("-fno-exceptions" "-fexceptions" "CXX")
endif()
endif()
if(__cppopts_WITH_STL)
set(CPP_USE_STL 1)
if(MSVC)
add_definitions(-DNATIVE_CPP_INCLUDE=${REACTOS_SOURCE_DIR}/sdk/include/c++)
include_directories(${REACTOS_SOURCE_DIR}/sdk/include/c++/stlport)
else()
replace_compile_flags("-nostdinc" " ")
endif()
endif()
set(IS_CPP 1)
endmacro()
function(add_dependency_node _node)
if(GENERATE_DEPENDENCY_GRAPH)
get_target_property(_type ${_node} TYPE)
if(_type MATCHES SHARED_LIBRARY OR ${_node} MATCHES ntoskrnl)
file(APPEND ${REACTOS_BINARY_DIR}/dependencies.graphml " <node id=\"${_node}\"/>\n")
endif()
endif()
endfunction()
function(add_dependency_edge _source _target)
if(GENERATE_DEPENDENCY_GRAPH)
get_target_property(_type ${_source} TYPE)
if(_type MATCHES SHARED_LIBRARY)
file(APPEND ${REACTOS_BINARY_DIR}/dependencies.graphml " <edge source=\"${_source}\" target=\"${_target}\"/>\n")
endif()
endif()
endfunction()
function(add_dependency_header)
file(APPEND ${REACTOS_BINARY_DIR}/dependencies.graphml "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<graphml>\n <graph id=\"ReactOS dependencies\" edgedefault=\"directed\">\n")
endfunction()
function(add_dependency_footer)
add_dependency_node(ntdll)
file(APPEND ${REACTOS_BINARY_DIR}/dependencies.graphml " </graph>\n</graphml>\n")
endfunction()
function(add_message_headers _type)
if(${_type} STREQUAL UNICODE)
set(_flag "-U")
else()
set(_flag "-A")
endif()
foreach(_file ${ARGN})
get_filename_component(_file_name ${_file} NAME_WE)
set(_converted_file ${CMAKE_CURRENT_BINARY_DIR}/${_file}) ## ${_file_name}.mc
set(_source_file ${CMAKE_CURRENT_SOURCE_DIR}/${_file}) ## ${_file_name}.mc
add_custom_command(
OUTPUT "${_converted_file}"
COMMAND native-utf16le "${_source_file}" "${_converted_file}" nobom
DEPENDS native-utf16le "${_source_file}")
macro_mc(${_flag} ${_converted_file})
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.h ${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.rc
COMMAND ${COMMAND_MC}
DEPENDS "${_converted_file}")
set_source_files_properties(
${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.h ${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.rc
PROPERTIES GENERATED TRUE)
add_custom_target(${_file_name} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.h ${CMAKE_CURRENT_BINARY_DIR}/${_file_name}.rc)
endforeach()
endfunction()
function(add_link)
cmake_parse_arguments(_LINK "MINIMIZE" "NAME;PATH;CMD_LINE_ARGS;ICON;GUID" "" ${ARGN})
if(NOT _LINK_NAME OR NOT _LINK_PATH)
message(FATAL_ERROR "You must provide name and path")
endif()
if(_LINK_CMD_LINE_ARGS)
set(_LINK_CMD_LINE_ARGS -c ${_LINK_CMD_LINE_ARGS})
endif()
if(_LINK_ICON)
set(_LINK_ICON -i ${_LINK_ICON})
endif()
if(_LINK_GUID)
set(_LINK_GUID -g ${_LINK_GUID})
endif()
if(_LINK_MINIMIZE)
set(_LINK_MINIMIZE "-m")
endif()
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_LINK_NAME}.lnk
COMMAND native-mkshelllink -o ${CMAKE_CURRENT_BINARY_DIR}/${_LINK_NAME}.lnk ${_LINK_CMD_LINE_ARGS} ${_LINK_ICON} ${_LINK_GUID} ${_LINK_MINIMIZE} ${_LINK_PATH}
DEPENDS native-mkshelllink)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_LINK_NAME}.lnk PROPERTIES GENERATED TRUE)
endfunction()
macro(dir_to_num dir var)
if(${dir} STREQUAL reactos/system32)
set(${var} 1)
elseif(${dir} STREQUAL reactos/system32/drivers)
set(${var} 2)
elseif(${dir} STREQUAL reactos/Fonts)
set(${var} 3)
elseif(${dir} STREQUAL reactos)
set(${var} 4)
elseif(${dir} STREQUAL reactos/system32/drivers/etc)
set(${var} 5)
elseif(${dir} STREQUAL reactos/inf)
set(${var} 6)
elseif(${dir} STREQUAL reactos/bin)
set(${var} 7)
elseif(${dir} STREQUAL reactos/bin/testdata)
set(${var} 8)
elseif(${dir} STREQUAL reactos/media)
set(${var} 9)
elseif(${dir} STREQUAL reactos/Microsoft.NET)
set(${var} 10)
elseif(${dir} STREQUAL reactos/Microsoft.NET/Framework)
set(${var} 11)
elseif(${dir} STREQUAL reactos/Microsoft.NET/Framework/v1.0.3705)
set(${var} 12)
elseif(${dir} STREQUAL reactos/Microsoft.NET/Framework/v1.1.4322)
set(${var} 13)
elseif(${dir} STREQUAL reactos/Microsoft.NET/Framework/v2.0.50727)
set(${var} 14)
elseif(${dir} STREQUAL reactos/Resources)
set(${var} 15)
elseif(${dir} STREQUAL reactos/Resources/Themes)
set(${var} 16)
elseif(${dir} STREQUAL reactos/system32/wbem)
set(${var} 17)
elseif(${dir} STREQUAL reactos/Resources/Themes/Lautus)
set(${var} 18)
elseif(${dir} STREQUAL reactos/Help)
set(${var} 19)
elseif(${dir} STREQUAL reactos/Config)
set(${var} 20)
elseif(${dir} STREQUAL reactos/Cursors)
set(${var} 21)
elseif(${dir} STREQUAL reactos/system32/ShellExt)
set(${var} 22)
elseif(${dir} STREQUAL reactos/Temp)
set(${var} 23)
elseif(${dir} STREQUAL reactos/system32/spool)
set(${var} 24)
elseif(${dir} STREQUAL reactos/system32/spool/drivers)
set(${var} 25)
elseif(${dir} STREQUAL reactos/system32/spool/drivers/color)
set(${var} 26)
elseif(${dir} STREQUAL reactos/system32/spool/drivers/w32x86)
set(${var} 27)
elseif(${dir} STREQUAL reactos/system32/spool/drivers/w32x86/3)
set(${var} 28)
elseif(${dir} STREQUAL reactos/system32/spool/prtprocs)
set(${var} 29)
elseif(${dir} STREQUAL reactos/system32/spool/prtprocs/w32x86)
set(${var} 30)
elseif(${dir} STREQUAL reactos/system32/spool/PRINTERS)
set(${var} 31)
elseif(${dir} STREQUAL reactos/system32/wbem/Repository)
set(${var} 32)
elseif(${dir} STREQUAL reactos/system32/wbem/Repository/FS)
set(${var} 33)
elseif(${dir} STREQUAL reactos/system32/wbem/mof/good)
set(${var} 34)
elseif(${dir} STREQUAL reactos/system32/wbem/mof/bad)
set(${var} 35)
elseif(${dir} STREQUAL reactos/system32/wbem/AdStatus)
set(${var} 36)
elseif(${dir} STREQUAL reactos/system32/wbem/xml)
set(${var} 37)
elseif(${dir} STREQUAL reactos/system32/wbem/Logs)
set(${var} 38)
elseif(${dir} STREQUAL reactos/system32/wbem/AutoRecover)
set(${var} 39)
elseif(${dir} STREQUAL reactos/system32/wbem/snmp)
set(${var} 40)
elseif(${dir} STREQUAL reactos/system32/wbem/Performance)
set(${var} 41)
elseif(${dir} STREQUAL reactos/twain_32)
set(${var} 42)
elseif(${dir} STREQUAL reactos/repair)
set(${var} 43)
elseif(${dir} STREQUAL reactos/Web)
set(${var} 44)
elseif(${dir} STREQUAL reactos/Web/Wallpaper)
set(${var} 45)
elseif(${dir} STREQUAL reactos/Prefetch)
set(${var} 46)
elseif(${dir} STREQUAL reactos/security)
set(${var} 47)
elseif(${dir} STREQUAL reactos/security/Database)
set(${var} 48)
elseif(${dir} STREQUAL reactos/security/logs)
set(${var} 49)
elseif(${dir} STREQUAL reactos/security/templates)
set(${var} 50)
elseif(${dir} STREQUAL reactos/system32/CatRoot)
set(${var} 51)
elseif(${dir} STREQUAL reactos/system32/CatRoot2)
set(${var} 52)
elseif(${dir} STREQUAL reactos/AppPatch)
set(${var} 53)
else()
message(FATAL_ERROR "Wrong destination: ${dir}")
endif()
endmacro()
function(add_cd_file)
cmake_parse_arguments(_CD "NO_CAB;NOT_IN_HYBRIDCD" "DESTINATION;NAME_ON_CD;TARGET" "FILE;FOR" ${ARGN})
if(NOT (_CD_TARGET OR _CD_FILE))
message(FATAL_ERROR "You must provide a target or a file to install!")
endif()
if(NOT _CD_DESTINATION)
message(FATAL_ERROR "You must provide a destination")
elseif(${_CD_DESTINATION} STREQUAL root)
set(_CD_DESTINATION "")
endif()
if(NOT _CD_FOR)
message(FATAL_ERROR "You must provide a cd name (or \"all\" for all of them) to install the file on!")
endif()
# get file if we need to
if(NOT _CD_FILE)
get_target_property(_CD_FILE ${_CD_TARGET} LOCATION_${CMAKE_BUILD_TYPE})
endif()
# do we add it to all CDs?
list(FIND _CD_FOR all __cd)
if(NOT __cd EQUAL -1)
list(REMOVE_AT _CD_FOR __cd)
list(INSERT _CD_FOR __cd "bootcd;livecd;regtest")
endif()
# do we add it to bootcd?
list(FIND _CD_FOR bootcd __cd)
if(NOT __cd EQUAL -1)
# whether or not we should put it in reactos.cab or directly on cd
if(_CD_NO_CAB)
# directly on cd
foreach(item ${_CD_FILE})
if(_CD_NAME_ON_CD)
# rename it in the cd tree
set(__file ${_CD_NAME_ON_CD})
else()
get_filename_component(__file ${item} NAME)
endif()
set_property(GLOBAL APPEND PROPERTY BOOTCD_FILE_LIST "${_CD_DESTINATION}/${__file}=${item}")
# add it also into the hybridcd if not specified otherwise
if(NOT _CD_NOT_IN_HYBRIDCD)
set_property(GLOBAL APPEND PROPERTY HYBRIDCD_FILE_LIST "bootcd/${_CD_DESTINATION}/${__file}=${item}")
endif()
endforeach()
# manage dependency
if(_CD_TARGET)
add_dependencies(bootcd ${_CD_TARGET} registry_inf)
endif()
else()
# add it in reactos.cab
dir_to_num(${_CD_DESTINATION} _num)
file(RELATIVE_PATH __relative_file ${REACTOS_SOURCE_DIR} ${_CD_FILE})
file(APPEND ${REACTOS_BINARY_DIR}/boot/bootdata/packages/reactos.dff.dyn "\"${__relative_file}\" ${_num}\n")
unset(__relative_file)
# manage dependency - target level
if(_CD_TARGET)
add_dependencies(reactos_cab_inf ${_CD_TARGET})
endif()
# manage dependency - file level
set_property(GLOBAL APPEND PROPERTY REACTOS_CAB_DEPENDS ${_CD_FILE})
endif()
endif() #end bootcd
# do we add it to livecd?
list(FIND _CD_FOR livecd __cd)
if(NOT __cd EQUAL -1)
# manage dependency
if(_CD_TARGET)
add_dependencies(livecd ${_CD_TARGET} registry_inf)
endif()
foreach(item ${_CD_FILE})
if(_CD_NAME_ON_CD)
# rename it in the cd tree
set(__file ${_CD_NAME_ON_CD})
else()
get_filename_component(__file ${item} NAME)
endif()
set_property(GLOBAL APPEND PROPERTY LIVECD_FILE_LIST "${_CD_DESTINATION}/${__file}=${item}")
# add it also into the hybridcd if not specified otherwise
if(NOT _CD_NOT_IN_HYBRIDCD)
set_property(GLOBAL APPEND PROPERTY HYBRIDCD_FILE_LIST "livecd/${_CD_DESTINATION}/${__file}=${item}")
endif()
endforeach()
endif() #end livecd
# do we need also to add it to hybridcd?
list(FIND _CD_FOR hybridcd __cd)
if(NOT __cd EQUAL -1)
# manage dependency
if(_CD_TARGET)
add_dependencies(hybridcd ${_CD_TARGET})
endif()
foreach(item ${_CD_FILE})
if(_CD_NAME_ON_CD)
# rename it in the cd tree
set(__file ${_CD_NAME_ON_CD})
else()
get_filename_component(__file ${item} NAME)
endif()
set_property(GLOBAL APPEND PROPERTY HYBRIDCD_FILE_LIST "${_CD_DESTINATION}/${__file}=${item}")
endforeach()
endif() #end hybridcd
# do we add it to regtest?
list(FIND _CD_FOR regtest __cd)
if(NOT __cd EQUAL -1)
# whether or not we should put it in reactos.cab or directly on cd
if(_CD_NO_CAB)
# directly on cd
foreach(item ${_CD_FILE})
if(_CD_NAME_ON_CD)
# rename it in the cd tree
set(__file ${_CD_NAME_ON_CD})
else()
get_filename_component(__file ${item} NAME)
endif()
set_property(GLOBAL APPEND PROPERTY BOOTCDREGTEST_FILE_LIST "${_CD_DESTINATION}/${__file}=${item}")
endforeach()
# manage dependency
if(_CD_TARGET)
add_dependencies(bootcdregtest ${_CD_TARGET} registry_inf)
endif()
else()
#add it in reactos.cab
#dir_to_num(${_CD_DESTINATION} _num)
#file(APPEND ${REACTOS_BINARY_DIR}/boot/bootdata/packages/reactos.dff.dyn "${_CD_FILE} ${_num}\n")
#if(_CD_TARGET)
# #manage dependency
# add_dependencies(reactos_cab ${_CD_TARGET})
#endif()
endif()
endif() #end bootcd
endfunction()
function(create_iso_lists)
# generate reactos.cab before anything else
get_property(_filelist GLOBAL PROPERTY REACTOS_CAB_DEPENDS)
# begin with reactos.inf. We want this command to be always executed, so we pretend it generates another file although it will never do.
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/reactos.inf ${CMAKE_CURRENT_BINARY_DIR}/__some_non_existent_file
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${REACTOS_BINARY_DIR}/boot/bootdata/packages/reactos.inf ${CMAKE_CURRENT_BINARY_DIR}/reactos.inf
DEPENDS ${REACTOS_BINARY_DIR}/boot/bootdata/packages/reactos.inf reactos_cab_inf)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/reactos.cab
COMMAND native-cabman -C ${REACTOS_BINARY_DIR}/boot/bootdata/packages/reactos.dff -RC ${CMAKE_CURRENT_BINARY_DIR}/reactos.inf -N -P ${REACTOS_SOURCE_DIR}
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/reactos.inf native-cabman ${_filelist})
add_custom_target(reactos_cab DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/reactos.cab)
add_dependencies(reactos_cab reactos_cab_inf)
add_cd_file(
TARGET reactos_cab
FILE ${CMAKE_CURRENT_BINARY_DIR}/reactos.cab
DESTINATION reactos
NO_CAB FOR bootcd regtest)
add_cd_file(
FILE ${CMAKE_CURRENT_BINARY_DIR}/livecd.iso
DESTINATION livecd
FOR hybridcd)
get_property(_filelist GLOBAL PROPERTY BOOTCD_FILE_LIST)
string(REPLACE ";" "\n" _filelist "${_filelist}")
file(APPEND ${REACTOS_BINARY_DIR}/boot/bootcd.lst "${_filelist}")
unset(_filelist)
get_property(_filelist GLOBAL PROPERTY LIVECD_FILE_LIST)
string(REPLACE ";" "\n" _filelist "${_filelist}")
file(APPEND ${REACTOS_BINARY_DIR}/boot/livecd.lst "${_filelist}")
unset(_filelist)
get_property(_filelist GLOBAL PROPERTY HYBRIDCD_FILE_LIST)
string(REPLACE ";" "\n" _filelist "${_filelist}")
file(APPEND ${REACTOS_BINARY_DIR}/boot/hybridcd.lst "${_filelist}")
unset(_filelist)
get_property(_filelist GLOBAL PROPERTY BOOTCDREGTEST_FILE_LIST)
string(REPLACE ";" "\n" _filelist "${_filelist}")
file(APPEND ${REACTOS_BINARY_DIR}/boot/bootcdregtest.lst "${_filelist}")
unset(_filelist)
endfunction()
# Create module_clean targets
function(add_clean_target _target)
set(_clean_working_directory ${CMAKE_CURRENT_BINARY_DIR})
if(CMAKE_GENERATOR STREQUAL "Unix Makefiles" OR CMAKE_GENERATOR STREQUAL "MinGW Makefiles")
set(_clean_command make clean)
elseif(CMAKE_GENERATOR STREQUAL "NMake Makefiles")
set(_clean_command nmake /nologo clean)
elseif(CMAKE_GENERATOR STREQUAL "Ninja")
set(_clean_command ninja -t clean ${_target})
set(_clean_working_directory ${REACTOS_BINARY_DIR})
endif()
add_custom_target(${_target}_clean
COMMAND ${_clean_command}
WORKING_DIRECTORY ${_clean_working_directory}
COMMENT "Cleaning ${_target}")
endfunction()
if(NOT MSVC_IDE)
function(add_library name)
_add_library(${name} ${ARGN})
add_clean_target(${name})
endfunction()
function(add_executable name)
_add_executable(${name} ${ARGN})
add_clean_target(${name})
endfunction()
elseif(USE_FOLDER_STRUCTURE)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
string(LENGTH ${CMAKE_SOURCE_DIR} CMAKE_SOURCE_DIR_LENGTH)
function(add_custom_target name)
_add_custom_target(${name} ${ARGN})
string(SUBSTRING ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR_LENGTH} -1 CMAKE_CURRENT_SOURCE_DIR_RELATIVE)
set_property(TARGET "${name}" PROPERTY FOLDER "${CMAKE_CURRENT_SOURCE_DIR_RELATIVE}")
endfunction()
function(add_library name)
_add_library(${name} ${ARGN})
get_target_property(_target_excluded ${name} EXCLUDE_FROM_ALL)
if(_target_excluded AND ${name} MATCHES "^lib.*")
set_property(TARGET "${name}" PROPERTY FOLDER "Importlibs")
else()
string(SUBSTRING ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR_LENGTH} -1 CMAKE_CURRENT_SOURCE_DIR_RELATIVE)
set_property(TARGET "${name}" PROPERTY FOLDER "${CMAKE_CURRENT_SOURCE_DIR_RELATIVE}")
endif()
endfunction()
function(add_executable name)
_add_executable(${name} ${ARGN})
string(SUBSTRING ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR_LENGTH} -1 CMAKE_CURRENT_SOURCE_DIR_RELATIVE)
set_property(TARGET "${name}" PROPERTY FOLDER "${CMAKE_CURRENT_SOURCE_DIR_RELATIVE}")
endfunction()
endif()
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
function(concatenate_files _output _file1)
file(TO_NATIVE_PATH "${_output}" _real_output)
file(TO_NATIVE_PATH "${_file1}" _file_list)
foreach(_file ${ARGN})
file(TO_NATIVE_PATH "${_file}" _real_file)
set(_file_list "${_file_list} + ${_real_file}")
endforeach()
add_custom_command(
OUTPUT ${_output}
COMMAND cmd.exe /C "copy /Y /B ${_file_list} ${_real_output} > nul"
DEPENDS ${_file1} ${ARGN})
endfunction()
else()
macro(concatenate_files _output)
add_custom_command(
OUTPUT ${_output}
COMMAND cat ${ARGN} > ${_output}
DEPENDS ${ARGN})
endmacro()
endif()
function(add_importlibs _module)
add_dependency_node(${_module})
foreach(LIB ${ARGN})
if("${LIB}" MATCHES "msvcrt")
add_target_compile_definitions(${_module} _DLL __USE_CRTIMP)
target_link_libraries(${_module} msvcrtex)
endif()
target_link_libraries(${_module} lib${LIB})
add_dependencies(${_module} lib${LIB})
add_dependency_edge(${_module} ${LIB})
endforeach()
endfunction()
function(set_module_type MODULE TYPE)
cmake_parse_arguments(__module "UNICODE" "IMAGEBASE" "ENTRYPOINT" ${ARGN})
if(__module_UNPARSED_ARGUMENTS)
message(STATUS "set_module_type : unparsed arguments ${__module_UNPARSED_ARGUMENTS}, module : ${MODULE}")
endif()
# Add the module to the module group list, if it is defined
if(DEFINED CURRENT_MODULE_GROUP)
set_property(GLOBAL APPEND PROPERTY ${CURRENT_MODULE_GROUP}_MODULE_LIST "${MODULE}")
endif()
# Set subsystem. Also take this as an occasion
# to error out if someone gave a non existing type
if((${TYPE} STREQUAL nativecui) OR (${TYPE} STREQUAL nativedll)
OR (${TYPE} STREQUAL kernelmodedriver) OR (${TYPE} STREQUAL wdmdriver) OR (${TYPE} STREQUAL kerneldll))
set(__subsystem native)
elseif(${TYPE} STREQUAL win32cui)
set(__subsystem console)
elseif(${TYPE} STREQUAL win32gui)
set(__subsystem windows)
elseif(NOT ((${TYPE} STREQUAL win32dll) OR (${TYPE} STREQUAL win32ocx)
OR (${TYPE} STREQUAL cpl) OR (${TYPE} STREQUAL module)))
message(FATAL_ERROR "Unknown type ${TYPE} for module ${MODULE}")
endif()
if(DEFINED __subsystem)
set_subsystem(${MODULE} ${__subsystem})
endif()
# Set the PE image version numbers from the NT OS version ReactOS is based on
if (MSVC)
add_target_link_flags(${MODULE} "/VERSION:5.01")
else()
add_target_link_flags(${MODULE} "-Wl,--major-image-version,5 -Wl,--minor-image-version,01")
add_target_link_flags(${MODULE} "-Wl,--major-os-version,5 -Wl,--minor-os-version,01")
endif()
# Set unicode definitions
if(__module_UNICODE)
add_target_compile_definitions(${MODULE} UNICODE _UNICODE)
endif()
# Set entry point
if(__module_ENTRYPOINT OR (__module_ENTRYPOINT STREQUAL "0"))
list(GET __module_ENTRYPOINT 0 __entrypoint)
list(LENGTH __module_ENTRYPOINT __length)
if(${__length} EQUAL 2)
list(GET __module_ENTRYPOINT 1 __entrystack)
elseif(NOT ${__length} EQUAL 1)
message(FATAL_ERROR "Wrong arguments for ENTRYPOINT parameter of set_module_type : ${__module_ENTRYPOINT}")
endif()
unset(__length)
elseif(${TYPE} STREQUAL nativecui)
set(__entrypoint NtProcessStartup)
set(__entrystack 4)
elseif(${TYPE} STREQUAL win32cui)
if(__module_UNICODE)
set(__entrypoint wmainCRTStartup)
else()
set(__entrypoint mainCRTStartup)
endif()
elseif(${TYPE} STREQUAL win32gui)
if(__module_UNICODE)
set(__entrypoint wWinMainCRTStartup)
else()
set(__entrypoint WinMainCRTStartup)
endif()
elseif((${TYPE} STREQUAL win32dll) OR (${TYPE} STREQUAL win32ocx)
OR (${TYPE} STREQUAL cpl))
set(__entrypoint DllMainCRTStartup)
set(__entrystack 12)
elseif((${TYPE} STREQUAL kernelmodedriver) OR (${TYPE} STREQUAL wdmdriver))
set(__entrypoint DriverEntry)
set(__entrystack 8)
elseif(${TYPE} STREQUAL nativedll)
set(__entrypoint DllMain)
set(__entrystack 12)
elseif(${TYPE} STREQUAL module)
set(__entrypoint 0)
endif()
if(DEFINED __entrypoint)
if(DEFINED __entrystack)
set_entrypoint(${MODULE} ${__entrypoint} ${__entrystack})
else()
set_entrypoint(${MODULE} ${__entrypoint})
endif()
endif()
# Set base address
if(__module_IMAGEBASE)
set_image_base(${MODULE} ${__module_IMAGEBASE})
elseif(${TYPE} STREQUAL win32dll)
if(DEFINED baseaddress_${MODULE})
set_image_base(${MODULE} ${baseaddress_${MODULE}})
else()
message(STATUS "${MODULE} has no base address")
endif()
elseif((${TYPE} STREQUAL kernelmodedriver) OR (${TYPE} STREQUAL wdmdriver) OR (${TYPE} STREQUAL kerneldll))
set_image_base(${MODULE} 0x00010000)
endif()
# Now do some stuff which is specific to each type
if((${TYPE} STREQUAL kernelmodedriver) OR (${TYPE} STREQUAL wdmdriver) OR (${TYPE} STREQUAL kerneldll))
add_dependencies(${MODULE} bugcodes xdk)
if((${TYPE} STREQUAL kernelmodedriver) OR (${TYPE} STREQUAL wdmdriver))
set_target_properties(${MODULE} PROPERTIES SUFFIX ".sys")
endif()
endif()
if(${TYPE} STREQUAL win32ocx)
set_target_properties(${MODULE} PROPERTIES SUFFIX ".ocx")
endif()
if(${TYPE} STREQUAL cpl)
set_target_properties(${MODULE} PROPERTIES SUFFIX ".cpl")
endif()
# Do compiler specific stuff
set_module_type_toolchain(${MODULE} ${TYPE})
endfunction()
function(start_module_group __name)
if(DEFINED CURRENT_MODULE_GROUP)
message(FATAL_ERROR "CURRENT_MODULE_GROUP is already set ('${CURRENT_MODULE_GROUP}')")
endif()
set(CURRENT_MODULE_GROUP ${__name} PARENT_SCOPE)
endfunction()
function(end_module_group)
get_property(__modulelist GLOBAL PROPERTY ${CURRENT_MODULE_GROUP}_MODULE_LIST)
add_custom_target(${CURRENT_MODULE_GROUP})
foreach(__module ${__modulelist})
add_dependencies(${CURRENT_MODULE_GROUP} ${__module})
endforeach()
set(CURRENT_MODULE_GROUP PARENT_SCOPE)
endfunction()
function(preprocess_file __in __out)
set(__arg ${__in})
foreach(__def ${ARGN})
list(APPEND __arg -D${__def})
endforeach()
if(MSVC)
add_custom_command(OUTPUT ${_out}
COMMAND ${CMAKE_C_COMPILER} /EP ${__arg}
DEPENDS ${__in})
else()
add_custom_command(OUTPUT ${_out}
COMMAND ${CMAKE_C_COMPILER} -E ${__arg}
DEPENDS ${__in})
endif()
endfunction()
function(get_includes OUTPUT_VAR)
get_directory_property(_includes INCLUDE_DIRECTORIES)
foreach(arg ${_includes})
list(APPEND __tmp_var -I${arg})
endforeach()
set(${OUTPUT_VAR} ${__tmp_var} PARENT_SCOPE)
endfunction()
function(get_defines OUTPUT_VAR)
get_directory_property(_defines COMPILE_DEFINITIONS)
foreach(arg ${_defines})
list(APPEND __tmp_var -D${arg})
endforeach()
set(${OUTPUT_VAR} ${__tmp_var} PARENT_SCOPE)
endfunction()
if(NOT MSVC)
function(add_object_library _target)
add_library(${_target} OBJECT ${ARGN})
endfunction()
else()
function(add_object_library _target)
add_library(${_target} ${ARGN})
endfunction()
endif()
function(add_registry_inf)
# Add to the inf files list
foreach(_file ${ARGN})
set(_source_file "${CMAKE_CURRENT_SOURCE_DIR}/${_file}")
set_property(GLOBAL APPEND PROPERTY REGISTRY_INF_LIST ${_source_file})
endforeach()
endfunction()
function(create_registry_hives)
# Shortcut to the registry.inf file
set(_registry_inf "${CMAKE_BINARY_DIR}/boot/bootdata/registry.inf")
# Get the list of inf files
get_property(_inf_files GLOBAL PROPERTY REGISTRY_INF_LIST)
# Convert files to utf16le
foreach(_file ${_inf_files})
get_filename_component(_file_name ${_file} NAME_WE)
string(REPLACE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} _converted_file "${_file}")
string(REPLACE ${_file_name} "${_file_name}_utf16" _converted_file ${_converted_file})
add_custom_command(OUTPUT ${_converted_file}
COMMAND native-utf16le ${_file} ${_converted_file}
DEPENDS native-utf16le ${_file})
list(APPEND _converted_files ${_converted_file})
endforeach()
# Concatenate all registry files to registry.inf
concatenate_files(${_registry_inf} ${_converted_files})
# Add registry.inf to bootcd
add_custom_target(registry_inf DEPENDS ${_registry_inf})
add_cd_file(TARGET registry_inf
FILE ${_registry_inf}
DESTINATION reactos
NO_CAB
FOR bootcd regtest)
# livecd hives
list(APPEND _livecd_inf_files
${_registry_inf}
${CMAKE_SOURCE_DIR}/boot/bootdata/livecd.inf
${CMAKE_SOURCE_DIR}/boot/bootdata/hiveinst.inf)
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/security
${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/system
${CMAKE_BINARY_DIR}/boot/bootdata/BCD
COMMAND native-mkhive ${CMAKE_BINARY_DIR}/boot/bootdata ${_livecd_inf_files}
DEPENDS native-mkhive ${_livecd_inf_files})
add_custom_target(livecd_hives
DEPENDS ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/security
${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/system
${CMAKE_BINARY_DIR}/boot/bootdata/BCD)
add_cd_file(
FILE ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/security
${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/system
TARGET livecd_hives
DESTINATION reactos/system32/config
FOR livecd)
add_cd_file(
FILE ${CMAKE_BINARY_DIR}/boot/bootdata/BCD
TARGET livecd_hives
DESTINATION efi/boot
NO_CAB
FOR bootcd regtest livecd)
endfunction()
if(KDBG)
set(ROSSYM_LIB "rossym")
else()
set(ROSSYM_LIB "")
endif()
function(add_rc_deps _target_rc)
set_source_files_properties(${_target_rc} PROPERTIES OBJECT_DEPENDS "${ARGN}")
endfunction()
add_custom_target(rostests_install COMMAND ${CMAKE_COMMAND} -DCOMPONENT=rostests -P ${CMAKE_BINARY_DIR}/cmake_install.cmake)
function(add_rostests_file)
cmake_parse_arguments(_ROSTESTS "" "RENAME;SUBDIR;TARGET" "FILE" ${ARGN})
if(NOT (_ROSTESTS_TARGET OR _ROSTESTS_FILE))
message(FATAL_ERROR "You must provide a target or a file to install!")
endif()
if(NOT _ROSTESTS_FILE)
get_target_property(_ROSTESTS_FILE ${_ROSTESTS_TARGET} LOCATION_${CMAKE_BUILD_TYPE})
endif()
if(NOT _ROSTESTS_RENAME)
get_filename_component(_ROSTESTS_RENAME ${_ROSTESTS_FILE} NAME)
endif()
if(_ROSTESTS_SUBDIR)
set(_ROSTESTS_SUBDIR "/${_ROSTESTS_SUBDIR}")
endif()
if(_ROSTESTS_TARGET)
add_cd_file(TARGET ${_ROSTESTS_TARGET} FILE ${_ROSTESTS_FILE} DESTINATION "reactos/bin${_ROSTESTS_SUBDIR}" NAME_ON_CD ${_ROSTESTS_RENAME} FOR all)
else()
add_cd_file(FILE ${_ROSTESTS_FILE} DESTINATION "reactos/bin${_ROSTESTS_SUBDIR}" NAME_ON_CD ${_ROSTESTS_RENAME} FOR all)
endif()
if(DEFINED ENV{ROSTESTS_INSTALL})
install(FILES ${_ROSTESTS_FILE} DESTINATION "$ENV{ROSTESTS_INSTALL}${_ROSTESTS_SUBDIR}" COMPONENT rostests RENAME ${_ROSTESTS_RENAME})
endif()
endfunction()

157
sdk/cmake/CMakeParseArguments.cmake Normal file
View file

@ -0,0 +1,157 @@
# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...)
#
# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for
# parsing the arguments given to that macro or function.
# It processes the arguments and defines a set of variables which hold the
# values of the respective options.
#
# The <options> argument contains all options for the respective macro,
# i.e. keywords which can be used when calling the macro without any value
# following, like e.g. the OPTIONAL keyword of the install() command.
#
# The <one_value_keywords> argument contains all keywords for this macro
# which are followed by one value, like e.g. DESTINATION keyword of the
# install() command.
#
# The <multi_value_keywords> argument contains all keywords for this macro
# which can be followed by more than one value, like e.g. the TARGETS or
# FILES keywords of the install() command.
#
# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
# keywords listed in <options>, <one_value_keywords> and
# <multi_value_keywords> a variable composed of the given <prefix>
# followed by "_" and the name of the respective keyword.
# These variables will then hold the respective value from the argument list.
# For the <options> keywords this will be TRUE or FALSE.
#
# All remaining arguments are collected in a variable
# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether
# your macro was called with unrecognized parameters.
#
# As an example here a my_install() macro, which takes similar arguments as the
# real install() command:
#
# function(MY_INSTALL)
# set(options OPTIONAL FAST)
# set(oneValueArgs DESTINATION RENAME)
# set(multiValueArgs TARGETS CONFIGURATIONS)
# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
# ...
#
# Assume my_install() has been called like this:
# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
#
# After the cmake_parse_arguments() call the macro will have set the following
# variables:
# MY_INSTALL_OPTIONAL = TRUE
# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
# MY_INSTALL_DESTINATION = "bin"
# MY_INSTALL_RENAME = "" (was not used)
# MY_INSTALL_TARGETS = "foo;bar"
# MY_INSTALL_CONFIGURATIONS = "" (was not used)
# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
#
# You can the continue and process these variables.
#
# Keywords terminate lists of values, e.g. if directly after a one_value_keyword
# another recognized keyword follows, this is interpreted as the beginning of
# the new option.
# E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
#=============================================================================
# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# * Neither the names of Kitware, Inc., the Insight Software Consortium,
# nor the names of their contributors may be used to endorse or promote
# products derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#=============================================================================
if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
return()
endif()
set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
# first set all result variables to empty/FALSE
foreach(arg_name ${_singleArgNames} ${_multiArgNames})
set(${prefix}_${arg_name})
endforeach(arg_name)
foreach(option ${_optionNames})
set(${prefix}_${option} FALSE)
endforeach(option)
set(${prefix}_UNPARSED_ARGUMENTS)
set(insideValues FALSE)
set(currentArgName)
# now iterate over all arguments and fill the result variables
foreach(currentArg ${ARGN})
list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword
list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword
list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword
if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1)
if(insideValues)
if("${insideValues}" STREQUAL "SINGLE")
set(${prefix}_${currentArgName} ${currentArg})
set(insideValues FALSE)
elseif("${insideValues}" STREQUAL "MULTI")
list(APPEND ${prefix}_${currentArgName} ${currentArg})
endif()
else(insideValues)
list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
endif(insideValues)
else()
if(NOT ${optionIndex} EQUAL -1)
set(${prefix}_${currentArg} TRUE)
set(insideValues FALSE)
elseif(NOT ${singleArgIndex} EQUAL -1)
set(currentArgName ${currentArg})
set(${prefix}_${currentArgName})
set(insideValues "SINGLE")
elseif(NOT ${multiArgIndex} EQUAL -1)
set(currentArgName ${currentArg})
set(${prefix}_${currentArgName})
set(insideValues "MULTI")
endif()
endif()
endforeach(currentArg)
# propagate the result variables to the caller:
foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE)
endforeach(arg_name)
set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
endfunction(CMAKE_PARSE_ARGUMENTS _options _singleArgs _multiArgs)

63
sdk/cmake/Compiler/GNU.cmake Normal file
View file

@ -0,0 +1,63 @@
#=============================================================================
# Copyright 2002-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# This module is shared by multiple languages; use include blocker.
if(__COMPILER_GNU)
return()
endif()
set(__COMPILER_GNU 1)
macro(__compiler_gnu lang)
# Feature flags.
set(CMAKE_${lang}_VERBOSE_FLAG "-v")
set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC")
if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4)
set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
endif()
if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.2)
set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=")
endif()
set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "-fPIC")
set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared")
set(CMAKE_${lang}_COMPILE_OPTIONS_SYSROOT "--sysroot=")
# Older versions of gcc (< 4.5) contain a bug causing them to report a missing
# header file as a warning if depfiles are enabled, causing check_header_file
# tests to always succeed. Work around this by disabling dependency tracking
# in try_compile mode.
get_property(_IN_TC GLOBAL PROPERTY IN_TRY_COMPILE)
if(NOT _IN_TC OR CMAKE_FORCE_DEPFILES)
# distcc does not transform -o to -MT when invoking the preprocessor
# internally, as it ought to. Work around this bug by setting -MT here
# even though it isn't strictly necessary.
set(CMAKE_DEPFILE_FLAGS_${lang} "-MMD -MT <OBJECT> -MF <DEPFILE>")
endif()
# Initial configuration flags.
set(CMAKE_${lang}_FLAGS_INIT "")
set(CMAKE_${lang}_FLAGS_DEBUG_INIT "")
set(CMAKE_${lang}_FLAGS_MINSIZEREL_INIT "-Os -DNDEBUG")
set(CMAKE_${lang}_FLAGS_RELEASE_INIT "")
set(CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT "-O2 -g -DNDEBUG")
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
else()
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
endif()
if(NOT APPLE)
set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
endif()
endmacro()

2
sdk/cmake/Compiler/VISUAL-ASM.cmake Normal file
View file

@ -0,0 +1,2 @@
set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S)

256
sdk/cmake/Platform/Windows-MSVC.cmake Normal file
View file

@ -0,0 +1,256 @@
#=============================================================================
# Copyright 2001-2012 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# This module is shared by multiple languages; use include blocker.
if(__WINDOWS_MSVC)
return()
endif()
set(__WINDOWS_MSVC 1)
set(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
set(CMAKE_LINK_LIBRARY_FLAG "")
set(MSVC 1)
# hack: if a new cmake (which uses CMAKE_LINKER) runs on an old build tree
# (where link was hardcoded) and where CMAKE_LINKER isn't in the cache
# and still cmake didn't fail in CMakeFindBinUtils.cmake (because it isn't rerun)
# hardcode CMAKE_LINKER here to link, so it behaves as it did before, Alex
if(NOT DEFINED CMAKE_LINKER)
set(CMAKE_LINKER link)
endif()
if(CMAKE_VERBOSE_MAKEFILE)
set(CMAKE_CL_NOLOGO)
else()
set(CMAKE_CL_NOLOGO "/nologo")
endif()
set(WIN32 1)
if(CMAKE_SYSTEM_NAME MATCHES "WindowsCE")
set(CMAKE_CREATE_WIN32_EXE "/subsystem:windowsce /entry:WinMainCRTStartup")
set(CMAKE_CREATE_CONSOLE_EXE "/subsystem:windowsce /entry:mainACRTStartup")
set(WINCE 1)
else()
set(CMAKE_CREATE_WIN32_EXE "/subsystem:windows")
set(CMAKE_CREATE_CONSOLE_EXE "/subsystem:console")
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
set (CMAKE_NO_BUILD_TYPE 1)
endif()
if(NOT CMAKE_NO_BUILD_TYPE AND CMAKE_GENERATOR MATCHES "Visual Studio")
set (CMAKE_NO_BUILD_TYPE 1)
set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING
"Semicolon separated list of supported configuration types, only supports Debug, Release, MinSizeRel, and RelWithDebInfo, anything else will be ignored.")
mark_as_advanced(CMAKE_CONFIGURATION_TYPES)
endif()
# make sure to enable languages after setting configuration types
enable_language(RC)
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_COMPILE_RESOURCE "rc <FLAGS> /fo<OBJECT> <SOURCE>")
else()
set(CMAKE_COMPILE_RESOURCE "rc <INCLUDES> <FLAGS> /fo<OBJECT> <SOURCE>")
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
set(MSVC_IDE 1)
else()
set(MSVC_IDE 0)
endif()
if(NOT MSVC_VERSION)
if(CMAKE_C_COMPILER_VERSION)
set(_compiler_version ${CMAKE_C_COMPILER_VERSION})
else()
set(_compiler_version ${CMAKE_CXX_COMPILER_VERSION})
endif()
if("${_compiler_version}" MATCHES "^([0-9]+)\\.([0-9]+)")
math(EXPR MSVC_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}")
else()
message(FATAL_ERROR "MSVC compiler version not detected properly: ${_compiler_version}")
endif()
set(MSVC10)
set(MSVC11)
set(MSVC12)
set(MSVC60)
set(MSVC70)
set(MSVC71)
set(MSVC80)
set(MSVC90)
set(CMAKE_COMPILER_2005)
set(CMAKE_COMPILER_SUPPORTS_PDBTYPE)
if(NOT "${_compiler_version}" VERSION_LESS 18)
set(MSVC12 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 17)
set(MSVC11 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 16)
set(MSVC10 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 15)
set(MSVC90 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 14)
set(MSVC80 1)
set(CMAKE_COMPILER_2005 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 13.10)
set(MSVC71 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 13)
set(MSVC70 1)
else()
set(MSVC60 1)
set(CMAKE_COMPILER_SUPPORTS_PDBTYPE 1)
endif()
endif()
if(MSVC_C_ARCHITECTURE_ID MATCHES 64 OR MSVC_CXX_ARCHITECTURE_ID MATCHES 64)
set(CMAKE_CL_64 1)
else()
set(CMAKE_CL_64 0)
endif()
if(CMAKE_FORCE_WIN64 OR CMAKE_FORCE_IA64)
set(CMAKE_CL_64 1)
endif()
if(MSVC_VERSION GREATER 1599)
set(MSVC_INCREMENTAL_DEFAULT ON)
endif()
# default to Debug builds
set(CMAKE_BUILD_TYPE_INIT Debug)
if(CMAKE_SYSTEM_NAME MATCHES "WindowsCE")
string(TOUPPER "${MSVC_C_ARCHITECTURE_ID}" _MSVC_C_ARCHITECTURE_ID_UPPER)
string(TOUPPER "${MSVC_CXX_ARCHITECTURE_ID}" _MSVC_CXX_ARCHITECTURE_ID_UPPER)
if("${CMAKE_SYSTEM_VERSION}" MATCHES "^([0-9]+)\\.([0-9]+)")
math(EXPR _CE_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}")
elseif("${CMAKE_SYSTEM_VERSION}" STREQUAL "")
set(_CE_VERSION "500")
else()
message(FATAL_ERROR "Invalid Windows CE version: ${CMAKE_SYSTEM_VERSION}")
endif()
set(_PLATFORM_DEFINES "/D_WIN32_WCE=0x${_CE_VERSION} /DUNDER_CE")
set(_PLATFORM_DEFINES_C " /D${MSVC_C_ARCHITECTURE_ID} /D_${_MSVC_C_ARCHITECTURE_ID_UPPER}_")
set(_PLATFORM_DEFINES_CXX " /D${MSVC_CXX_ARCHITECTURE_ID} /D_${_MSVC_CXX_ARCHITECTURE_ID_UPPER}_")
set(_RTC1 "")
set(_FLAGS_CXX " /GR /EHsc")
set(CMAKE_C_STANDARD_LIBRARIES_INIT "coredll.lib corelibc.lib ole32.lib oleaut32.lib uuid.lib commctrl.lib")
set(CMAKE_EXE_LINKER_FLAGS_INIT "${CMAKE_EXE_LINKER_FLAGS_INIT} /NODEFAULTLIB:libc.lib /NODEFAULTLIB:oldnames.lib")
else()
set(_PLATFORM_DEFINES "/DWIN32")
if(MSVC_VERSION GREATER 1310)
set(_RTC1 "/RTC1")
set(_FLAGS_CXX " /GR /EHsc")
set(CMAKE_C_STANDARD_LIBRARIES_INIT "")
else()
set(_RTC1 "/GZ")
set(_FLAGS_CXX " /GR /GX")
set(CMAKE_C_STANDARD_LIBRARIES_INIT "")
endif()
endif()
set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}")
# executable linker flags
set (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
# set the machine type
set(_MACHINE_ARCH_FLAG ${MSVC_C_ARCHITECTURE_ID})
if(NOT _MACHINE_ARCH_FLAG)
set(_MACHINE_ARCH_FLAG ${MSVC_CXX_ARCHITECTURE_ID})
endif()
if(CMAKE_SYSTEM_NAME MATCHES "WindowsCE")
if(_MACHINE_ARCH_FLAG MATCHES "ARM")
set(_MACHINE_ARCH_FLAG "THUMB")
elseif(_MACHINE_ARCH_FLAG MATCHES "SH")
set(_MACHINE_ARCH_FLAG "SH4")
endif()
endif()
set (CMAKE_EXE_LINKER_FLAGS_INIT
"${CMAKE_EXE_LINKER_FLAGS_INIT} /machine:${_MACHINE_ARCH_FLAG} /MANIFEST:NO")
# add /debug and /INCREMENTAL:YES to DEBUG and RELWITHDEBINFO also add pdbtype
# on versions that support it
set( MSVC_INCREMENTAL_YES_FLAG "")
if(NOT MSVC_INCREMENTAL_DEFAULT)
set( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL:YES")
else()
set( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL" )
endif()
if (CMAKE_COMPILER_SUPPORTS_PDBTYPE)
set (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug /pdbtype:sept")
set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug /pdbtype:sept ${MSVC_INCREMENTAL_YES_FLAG}")
else ()
set (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug")
set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug ${MSVC_INCREMENTAL_YES_FLAG}")
endif ()
# for release and minsize release default to no incremental linking
set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT "/INCREMENTAL:NO")
set(CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT "/INCREMENTAL:NO")
# copy the EXE_LINKER flags to SHARED and MODULE linker flags
# shared linker flags
set (CMAKE_SHARED_LINKER_FLAGS_INIT ${CMAKE_EXE_LINKER_FLAGS_INIT})
set (CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
set (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
set (CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT})
set (CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL_INIT ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT})
# module linker flags
set (CMAKE_MODULE_LINKER_FLAGS_INIT ${CMAKE_SHARED_LINKER_FLAGS_INIT})
set (CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT})
set (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT})
set (CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT})
set (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT})
macro(__windows_compiler_msvc lang)
if(NOT "${CMAKE_${lang}_COMPILER_VERSION}" VERSION_LESS 14)
# for 2005 make sure the manifest is put in the dll with mt
set(_CMAKE_VS_LINK_DLL "<CMAKE_COMMAND> -E vs_link_dll ")
set(_CMAKE_VS_LINK_EXE "<CMAKE_COMMAND> -E vs_link_exe ")
endif()
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY "<CMAKE_LINKER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} /out:<TARGET> /pdb:<TARGET_PDB> /dll /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <LINK_FLAGS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_SHARED_MODULE ${CMAKE_${lang}_CREATE_SHARED_LIBRARY})
set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_LINKER> /lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_${lang}_COMPILE_OBJECT
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> /Fo<OBJECT> /Fd<OBJECT_DIR>/ -c <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
"<CMAKE_${lang}_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> /FoNUL /FAs /Fa<ASSEMBLY_SOURCE> /c <SOURCE>${CMAKE_END_TEMP_FILE}")
else()
set(CMAKE_${lang}_COMPILE_OBJECT
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <INCLUDES> <FLAGS> <DEFINES> /Fo<OBJECT> /Fd<OBJECT_DIR>/ -c <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
"<CMAKE_${lang}_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <INCLUDES> <FLAGS> <DEFINES> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <INCLUDES> <FLAGS> <DEFINES> /FoNUL /FAs /Fa<ASSEMBLY_SOURCE> /c <SOURCE>${CMAKE_END_TEMP_FILE}")
endif()
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1)
set(CMAKE_${lang}_LINK_EXECUTABLE
"${_CMAKE_VS_LINK_EXE}<CMAKE_LINKER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} /out:<TARGET> /pdb:<TARGET_PDB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_FLAGS_INIT "")
set(CMAKE_${lang}_FLAGS_DEBUG_INIT "")
set(CMAKE_${lang}_FLAGS_RELEASE_INIT "")
set(CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT "/MD /Zi /O2 /Ob1 /D NDEBUG")
set(CMAKE_${lang}_FLAGS_MINSIZEREL_INIT "/MD /O1 /Ob1 /D NDEBUG")
endmacro()

36
sdk/cmake/Platform/Windows.cmake Normal file
View file

@ -0,0 +1,36 @@
SET(WIN32 1)
SET(CMAKE_STATIC_LIBRARY_PREFIX "")
SET(CMAKE_STATIC_LIBRARY_SUFFIX ".lib")
SET(CMAKE_SHARED_LIBRARY_PREFIX "") # lib
SET(CMAKE_SHARED_LIBRARY_SUFFIX ".dll") # .so
SET(CMAKE_IMPORT_LIBRARY_PREFIX "")
SET(CMAKE_IMPORT_LIBRARY_SUFFIX ".lib")
SET(CMAKE_EXECUTABLE_SUFFIX ".exe") # .exe
SET(CMAKE_LINK_LIBRARY_SUFFIX ".lib")
SET(CMAKE_DL_LIBS "")
SET(CMAKE_FIND_LIBRARY_PREFIXES "")
SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
# for borland make long command lines are redirected to a file
# with the following syntax, see Windows-bcc32.cmake for use
IF(CMAKE_GENERATOR MATCHES "Borland")
SET(CMAKE_START_TEMP_FILE "@&&|\n")
SET(CMAKE_END_TEMP_FILE "\n|")
ENDIF(CMAKE_GENERATOR MATCHES "Borland")
# for nmake make long command lines are redirected to a file
# with the following syntax, see Windows-bcc32.cmake for use
IF(CMAKE_GENERATOR MATCHES "NMake")
# SET(CMAKE_START_TEMP_FILE "@<<\n")
# SET(CMAKE_END_TEMP_FILE "\n<<")
ENDIF(CMAKE_GENERATOR MATCHES "NMake")
INCLUDE(Platform/WindowsPaths)
# uncomment these out to debug nmake and borland makefiles
#SET(CMAKE_START_TEMP_FILE "")
#SET(CMAKE_END_TEMP_FILE "")
#SET(CMAKE_VERBOSE_MAKEFILE 1)

356
sdk/cmake/baseaddress.cmake Normal file
View file

@ -0,0 +1,356 @@
set(baseaddress_ntdll 0x7c920000) # should be above 0x7c920000
set(baseaddress_kernel32 0x7cc70000)
set(baseaddress_msvcrt 0x7c6b0000)
set(baseaddress_advapi32 0x7c600000)
set(baseaddress_gdi32 0x7c560000)
set(baseaddress_user32 0x7c3e0000)
set(baseaddress_dhcpcsvc 0x7c390000)
set(baseaddress_dnsapi 0x7c340000)
set(baseaddress_icmp 0x7c310000)
set(baseaddress_iphlpapi 0x7c2c0000)
set(baseaddress_ws2_32 0x7c280000)
set(baseaddress_ws2help 0x7c250000)
set(baseaddress_shlwapi 0x7c1a0000)
set(baseaddress_rpcrt4 0x7c0e0000)
set(baseaddress_comctl32 0x7bf20000)
set(baseaddress_ole32 0x7bd20000)
set(baseaddress_winmm 0x7bc70000)
set(baseaddress_comdlg32 0x7bb70000)
set(baseaddress_shell32 0x7b1b0000)
set(baseaddress_lz32 0x7b190000)
set(baseaddress_version 0x7b160000)
set(baseaddress_oleaut32 0x7af90000)
set(baseaddress_setupapi 0x7ae20000)
set(baseaddress_mpr 0x7ade0000)
set(baseaddress_crypt32 0x7acd0000)
set(baseaddress_wininet 0x7ac10000)
set(baseaddress_urlmon 0x7ab10000)
set(baseaddress_psapi 0x7aae0000)
set(baseaddress_imm32 0x7aaa0000)
set(baseaddress_msvfw32 0x7aa50000)
set(baseaddress_dbghelp 0x7a9a0000)
set(baseaddress_devmgr 0x7a8c0000)
set(baseaddress_msacm32 0x7a880000)
set(baseaddress_netapi32 0x7a810000)
set(baseaddress_powrprof 0x7a7e0000)
set(baseaddress_secur32 0x7a7a0000)
set(baseaddress_wintrust 0x7a740000)
set(baseaddress_avicap32 0x7a710000)
set(baseaddress_cabinet 0x7a6c0000)
set(baseaddress_dsound 0x7a640000)
set(baseaddress_glu32 0x7a540000)
set(baseaddress_opengl32 0x7a330000)
set(baseaddress_riched20 0x7a270000)
set(baseaddress_smdll 0x7a250000)
set(baseaddress_userenv 0x7a200000)
set(baseaddress_uxtheme 0x7a1a0000)
set(baseaddress_cryptui 0x7a0f0000)
set(baseaddress_csrsrv 0x7a0c0000)
set(baseaddress_basesrv 0x7a090000)
set(baseaddress_winsrv 0x79ff0000)
set(baseaddress_dplayx 0x79f80000)
set(baseaddress_gdiplus 0x79eb0000)
set(baseaddress_msimg32 0x79e80000)
set(baseaddress_mswsock 0x79e50000)
set(baseaddress_oledlg 0x79e00000)
set(baseaddress_rasapi32 0x79dd0000)
set(baseaddress_rsaenh 0x79d60000)
set(baseaddress_samlib 0x79d20000)
set(baseaddress_sensapi 0x79cf0000)
set(baseaddress_sfc_os 0x79cc0000)
set(baseaddress_snmpapi 0x79c90000)
set(baseaddress_spoolss 0x79c60000)
set(baseaddress_usp10 0x79be0000)
set(baseaddress_aclayers 0x79bb0000)
set(baseaddress_acledit 0x79b80000)
set(baseaddress_aclui 0x79b40000)
set(baseaddress_acppage 0x79af0000)
set(baseaddress_activeds 0x79ac0000)
set(baseaddress_actxprxy 0x798c0000)
set(baseaddress_advapi32_vista 0x798a0000)
set(baseaddress_advpack 0x79860000)
set(baseaddress_amstream 0x79810000)
set(baseaddress_apphelp 0x797d0000)
set(baseaddress_atl 0x79790000)
set(baseaddress_atl100 0x79750000)
set(baseaddress_atl80 0x79710000)
set(baseaddress_authz 0x796e0000)
set(baseaddress_avifil32 0x79660000)
set(baseaddress_batt 0x79630000)
set(baseaddress_bcrypt 0x79600000)
set(baseaddress_beepmidi 0x795d0000)
set(baseaddress_browseui 0x794c0000)
set(baseaddress_cards 0x79400000)
set(baseaddress_cfgmgr32 0x793d0000)
set(baseaddress_clusapi 0x793a0000)
set(baseaddress_comcat 0x79370000)
set(baseaddress_compstui 0x79340000)
set(baseaddress_console 0x792f0000)
set(baseaddress_credui 0x792b0000)
set(baseaddress_crtdll 0x79250000)
set(baseaddress_cryptdlg 0x79220000)
set(baseaddress_cryptdll 0x791f0000)
set(baseaddress_cryptnet 0x791c0000)
set(baseaddress_d3d8 0x79160000)
set(baseaddress_d3d8thk 0x79140000)
set(baseaddress_d3d9 0x790d0000)
set(baseaddress_d3dcompiler_43 0x79020000)
set(baseaddress_d3drm 0x78f90000)
set(baseaddress_d3dwine 0x78d80000)
set(baseaddress_d3dx9_24 0x78d50000)
set(baseaddress_d3dx9_25 0x78d10000)
set(baseaddress_d3dx9_26 0x78ce0000)
set(baseaddress_d3dx9_27 0x78cb0000)
set(baseaddress_d3dx9_28 0x78c80000)
set(baseaddress_d3dx9_29 0x78c50000)
set(baseaddress_d3dx9_30 0x78c20000)
set(baseaddress_d3dx9_31 0x78bf0000)
set(baseaddress_d3dx9_32 0x78bc0000)
set(baseaddress_d3dx9_33 0x78b90000)
set(baseaddress_d3dx9_34 0x78b60000)
set(baseaddress_d3dx9_35 0x78b30000)
set(baseaddress_d3dx9_36 0x78a40000)
set(baseaddress_d3dx9_37 0x78a10000)
set(baseaddress_d3dx9_38 0x789e0000)
set(baseaddress_d3dx9_39 0x789b0000)
set(baseaddress_d3dx9_40 0x78980000)
set(baseaddress_d3dx9_41 0x78950000)
set(baseaddress_d3dx9_42 0x78920000)
set(baseaddress_d3dx9_43 0x788f0000)
set(baseaddress_d3dxof 0x788b0000)
set(baseaddress_dciman32 0x78880000)
set(baseaddress_ddraw 0x787c0000)
set(baseaddress_deskadp 0x78790000)
set(baseaddress_deskmon 0x78760000)
set(baseaddress_devcpux 0x78730000)
set(baseaddress_devenum 0x786e0000)
set(baseaddress_dinput 0x78680000)
set(baseaddress_dinput8 0x78650000)
set(baseaddress_dmusic 0x78600000)
set(baseaddress_dplay 0x785d0000)
set(baseaddress_dxdiagn 0x78580000)
set(baseaddress_esent 0x78550000)
set(baseaddress_faultrep 0x78520000)
set(baseaddress_fltlib 0x784f0000)
set(baseaddress_fmifs 0x784d0000)
set(baseaddress_fontext 0x784a0000)
set(baseaddress_fontsub 0x78470000)
set(baseaddress_framebuf 0x78450000)
set(baseaddress_framebuf_new 0x78430000)
set(baseaddress_framedyn 0x783f0000)
set(baseaddress_genincdata 0x783c0000)
set(baseaddress_getuname 0x780f0000)
set(baseaddress_hid 0x780c0000)
set(baseaddress_hlink 0x78080000)
set(baseaddress_hnetcfg 0x78040000)
set(baseaddress_httpapi 0x78010000)
set(baseaddress_iccvid 0x77fe0000)
set(baseaddress_ieframe 0x77ef0000)
set(baseaddress_iernonce 0x77ec0000)
set(baseaddress_imagehlp 0x77e90000)
set(baseaddress_inetcomm 0x77e30000)
set(baseaddress_inetmib1 0x77e00000)
set(baseaddress_initpki 0x77dd0000)
set(baseaddress_input 0x77d70000)
set(baseaddress_inseng 0x77d40000)
set(baseaddress_iologmsg 0x77d20000)
set(baseaddress_itircl 0x77cf0000)
set(baseaddress_itss 0x77cb0000)
set(baseaddress_jscript 0x77ba0000)
set(baseaddress_jsproxy 0x77b70000)
set(baseaddress_kbsdll 0x77b40000)
set(baseaddress_kernel32_vista 0x77b20000)
set(baseaddress_ksuser 0x77af0000)
set(baseaddress_libjpeg 0x77a60000)
set(baseaddress_libpng 0x779d0000)
set(baseaddress_libtiff 0x778f0000)
set(baseaddress_libxslt 0x77620000)
set(baseaddress_loadperf 0x775f0000)
set(baseaddress_localspl 0x775b0000)
set(baseaddress_localui 0x77580000)
set(baseaddress_lpk 0x77550000)
set(baseaddress_lsasrv 0x774e0000)
set(baseaddress_mapi32 0x774a0000)
set(baseaddress_mciavi32 0x77460000)
set(baseaddress_mcicda 0x77430000)
set(baseaddress_mciqtz32 0x773f0000)
set(baseaddress_mciseq 0x773c0000)
set(baseaddress_mciwave 0x77390000)
set(baseaddress_mgmtapi 0x77360000)
set(baseaddress_midimap 0x77330000)
set(baseaddress_mlang 0x772f0000)
set(baseaddress_mmdrv 0x772c0000)
set(baseaddress_modemui 0x77250000)
set(baseaddress_mprapi 0x77220000)
set(baseaddress_msafd 0x771e0000)
set(baseaddress_mscat32 0x771b0000)
set(baseaddress_mscms 0x77180000)
set(baseaddress_mscoree 0x77130000)
set(baseaddress_msctf 0x770d0000)
set(baseaddress_msdmo 0x770a0000)
set(baseaddress_msftedit 0x77070000)
set(baseaddress_msgina 0x76fe0000)
set(baseaddress_mshtml 0x76ce0000)
set(baseaddress_msi 0x76b70000)
set(baseaddress_msimtf 0x76b40000)
set(baseaddress_msisip 0x76b10000)
set(baseaddress_mspatcha 0x76ae0000)
set(baseaddress_msports 0x76ab0000)
set(baseaddress_msrle32 0x76a80000)
set(baseaddress_mssign32 0x76a50000)
set(baseaddress_mssip32 0x76a20000)
set(baseaddress_mstask 0x769e0000)
set(baseaddress_msv1_0 0x769b0000)
set(baseaddress_msvcrt_crt_dll_startup 0x76980000)
set(baseaddress_msvcrt20 0x768b0000)
set(baseaddress_msvcrt40 0x767e0000)
set(baseaddress_msvidc32 0x767b0000)
set(baseaddress_msxml 0x76780000)
set(baseaddress_msxml2 0x76750000)
set(baseaddress_msxml3 0x76370000)
set(baseaddress_msxml4 0x76330000)
set(baseaddress_msxml6 0x762f0000)
set(baseaddress_mycomput 0x762d0000)
set(baseaddress_nddeapi 0x762a0000)
set(baseaddress_netcfgx 0x76210000)
set(baseaddress_netevent 0x761f0000)
set(baseaddress_netid 0x761a0000)
set(baseaddress_netshell 0x760f0000)
set(baseaddress_newdev 0x76090000)
set(baseaddress_normaliz 0x76060000)
set(baseaddress_npptools 0x76030000)
set(baseaddress_ntdsapi 0x76000000)
set(baseaddress_ntlanman 0x75fd0000)
set(baseaddress_ntmarta 0x75fa0000)
set(baseaddress_ntobjshex 0x75f00000)
set(baseaddress_ntprint 0x75ed0000)
set(baseaddress_objsel 0x75ea0000)
set(baseaddress_odbc32 0x75e60000)
set(baseaddress_odbccp32 0x75e30000)
set(baseaddress_oleacc 0x75da0000)
set(baseaddress_olecli32 0x75d70000)
set(baseaddress_olepro32 0x75d40000)
set(baseaddress_olesvr32 0x75d10000)
set(baseaddress_olethk32 0x75ce0000)
set(baseaddress_pdh 0x75ca0000)
set(baseaddress_pidgen 0x75c70000)
set(baseaddress_pifmgr 0x75bf0000)
set(baseaddress_printui 0x75bc0000)
set(baseaddress_propsys 0x75b80000)
set(baseaddress_pstorec 0x75b50000)
set(baseaddress_qedit 0x75b00000)
set(baseaddress_qmgr 0x75ac0000)
set(baseaddress_qmgrprxy 0x75a60000)
set(baseaddress_quartz 0x758e0000)
set(baseaddress_query 0x758b0000)
set(baseaddress_rasadhlp 0x75880000)
set(baseaddress_rasdlg 0x756b0000)
set(baseaddress_rasman 0x75680000)
set(baseaddress_resutils 0x75650000)
set(baseaddress_riched32 0x75620000)
set(baseaddress_rsabase 0x75600000)
set(baseaddress_rshell 0x75570000)
set(baseaddress_samsrv 0x75500000)
set(baseaddress_sccbase 0x754d0000)
set(baseaddress_schannel 0x75490000)
set(baseaddress_schedsvc 0x75460000)
set(baseaddress_scrrun 0x75400000)
set(baseaddress_security 0x753e0000)
set(baseaddress_serialui 0x753b0000)
set(baseaddress_sfc 0x75380000)
set(baseaddress_shdoclc 0x75340000)
set(baseaddress_shdocvw 0x752f0000)
set(baseaddress_shfolder 0x752d0000)
set(baseaddress_shimgvw 0x75280000)
set(baseaddress_slayer 0x75250000)
set(baseaddress_slbcsp 0x75220000)
set(baseaddress_sndblst 0x751f0000)
set(baseaddress_softpub 0x751d0000)
set(baseaddress_srclient 0x751a0000)
set(baseaddress_srvsvc 0x75170000)
set(baseaddress_sti 0x75130000)
set(baseaddress_stobject 0x750c0000)
set(baseaddress_streamci 0x75090000)
set(baseaddress_sxs 0x75060000)
set(baseaddress_syssetup 0x74fb0000)
set(baseaddress_t2embed 0x74f80000)
set(baseaddress_tapi32 0x74f40000)
set(baseaddress_tapiui 0x74ec0000)
set(baseaddress_testvdd 0x74e90000)
set(baseaddress_themeui 0x74e70000)
set(baseaddress_traffic 0x74e40000)
set(baseaddress_twain_32 0x74e10000)
set(baseaddress_ubtrfs 0x74df0000)
set(baseaddress_uext2 0x74db0000)
set(baseaddress_ufat 0x74d70000)
set(baseaddress_ufatx 0x74d50000)
set(baseaddress_uffs 0x74d30000)
set(baseaddress_umpnpmgr 0x74d00000)
set(baseaddress_untfs 0x74ce0000)
set(baseaddress_updspapi 0x74cb0000)
set(baseaddress_ureiserfs 0x74c90000)
set(baseaddress_url 0x74c60000)
set(baseaddress_vbscript 0x74bc0000)
set(baseaddress_vdmdbg 0x74b90000)
set(baseaddress_vssapi 0x74b60000)
set(baseaddress_wbemdisp 0x74b20000)
set(baseaddress_wbemprox 0x74ac0000)
set(baseaddress_win32kdll 0x74a90000)
set(baseaddress_win32kdll_2k3sp2 0x74a60000)
set(baseaddress_win32kdll_xpsp2 0x74a30000)
set(baseaddress_windowscodecs 0x74910000)
set(baseaddress_windowscodecsext 0x748e0000)
set(baseaddress_winfax 0x748b0000)
set(baseaddress_wing32 0x74880000)
set(baseaddress_winhttp 0x74810000)
set(baseaddress_winscard 0x747e0000)
set(baseaddress_winsta 0x747b0000)
set(baseaddress_wkssvc 0x74780000)
set(baseaddress_wlanapi 0x74750000)
set(baseaddress_wldap32 0x74710000)
set(baseaddress_wmi 0x746f0000)
set(baseaddress_wmisvc 0x746c0000)
set(baseaddress_wmiutils 0x74690000)
set(baseaddress_wmvcore 0x74660000)
set(baseaddress_ws2_32_new 0x74610000)
set(baseaddress_wshirda 0x745e0000)
set(baseaddress_wshtcpip 0x745b0000)
set(baseaddress_wsock32 0x74580000)
set(baseaddress_wtsapi32 0x74550000)
set(baseaddress_wuapi 0x74510000)
set(baseaddress_xinput1_1 0x744e0000)
set(baseaddress_xinput1_2 0x744b0000)
set(baseaddress_xinput1_3 0x74480000)
set(baseaddress_xinput9_1_0 0x74450000)
set(baseaddress_xmllite 0x74410000)
set(baseaddress_access 0x74390000)
set(baseaddress_appwiz 0x74310000)
set(baseaddress_cmicpl 0x742d0000)
set(baseaddress_desk 0x74230000)
set(baseaddress_hdwwiz 0x741b0000)
set(baseaddress_hhctrl 0x74160000)
set(baseaddress_imaadp32.acm 0x74130000)
set(baseaddress_inetcpl 0x740d0000)
set(baseaddress_intl 0x74060000)
set(baseaddress_joy 0x74020000)
set(baseaddress_main 0x73f80000)
set(baseaddress_mmsys 0x73eb0000)
set(baseaddress_msacm32.drv 0x73e80000)
set(baseaddress_msadp32.acm 0x73e50000)
set(baseaddress_msg711.acm 0x73e20000)
set(baseaddress_msgsm32.acm 0x73df0000)
set(baseaddress_msisys 0x73dc0000)
set(baseaddress_ncpa 0x73d90000)
set(baseaddress_odbccp32i 0x73d60000)
set(baseaddress_powercfg 0x73d00000)
set(baseaddress_sysdm 0x73c20000)
set(baseaddress_telephon 0x73bf0000)
set(baseaddress_timedate 0x73b70000)
set(baseaddress_usrmgr 0x73b20000)
set(baseaddress_wdmaud.drv 0x73960000)
set(baseaddress_wined3dcfg 0x73930000)
set(baseaddress_winemp3.acm 0x738b0000)
set(baseaddress_wshom 0x73860000)
set(baseaddress_fusion 0x73830000)
set(baseaddress_fusion_1_1 0x737f0000)
set(baseaddress_fusion_2_0 0x737b0000)

330
sdk/cmake/baseaddress_dwarf.cmake Normal file
View file

@ -0,0 +1,330 @@
set(baseaddress_ntdll 0x7c920000) # should be above 0x7c920000
set(baseaddress_kernel32 0x77ca0000)
set(baseaddress_msvcrt 0x77b90000)
set(baseaddress_advapi32 0x77aa0000)
set(baseaddress_gdi32 0x77a20000)
set(baseaddress_user32 0x77820000)
set(baseaddress_dhcpcsvc 0x777c0000)
set(baseaddress_dnsapi 0x77760000)
set(baseaddress_icmp 0x77730000)
set(baseaddress_iphlpapi 0x776e0000)
set(baseaddress_ws2_32 0x77690000)
set(baseaddress_ws2help 0x77660000)
set(baseaddress_shlwapi 0x775a0000)
set(baseaddress_rpcrt4 0x77490000)
set(baseaddress_comctl32 0x772b0000)
set(baseaddress_ole32 0x77020000)
set(baseaddress_winspool.drv 0x76fe0000)
set(baseaddress_winmm 0x76f20000)
set(baseaddress_comdlg32 0x76e10000)
set(baseaddress_shell32 0x76010000)
set(baseaddress_lz32 0x75ff0000)
set(baseaddress_version 0x75fb0000)
set(baseaddress_oleaut32 0x75d60000)
set(baseaddress_setupapi 0x75b50000)
set(baseaddress_mpr 0x75b00000)
set(baseaddress_crypt32 0x759a0000)
set(baseaddress_wininet 0x758b0000)
set(baseaddress_urlmon 0x75760000)
set(baseaddress_psapi 0x75720000)
set(baseaddress_imm32 0x756d0000)
set(baseaddress_msvfw32 0x75680000)
set(baseaddress_dbghelp 0x75590000)
set(baseaddress_devmgr 0x754f0000)
set(baseaddress_msacm32 0x754a0000)
set(baseaddress_netapi32 0x75420000)
set(baseaddress_powrprof 0x753e0000)
set(baseaddress_secur32 0x75390000)
set(baseaddress_wintrust 0x75320000)
set(baseaddress_avicap32 0x752f0000)
set(baseaddress_cabinet 0x75290000)
set(baseaddress_dsound 0x751f0000)
set(baseaddress_glu32 0x750a0000)
set(baseaddress_wlnotify 0x75040000)
set(baseaddress_opengl32 0x74d90000)
set(baseaddress_riched20 0x74cd0000)
set(baseaddress_smdll 0x74cb0000)
set(baseaddress_userenv 0x74c50000)
set(baseaddress_uxtheme 0x74bd0000)
set(baseaddress_cryptui 0x74b10000)
set(baseaddress_csrsrv 0x74ad0000)
set(baseaddress_basesrv 0x74a90000)
set(baseaddress_consrv 0x74a70000)
set(baseaddress_winsrv 0x74980000)
set(baseaddress_dplayx 0x748f0000)
set(baseaddress_gdiplus 0x747e0000)
set(baseaddress_msimg32 0x747b0000)
set(baseaddress_mswsock 0x74780000)
set(baseaddress_oledlg 0x74730000)
set(baseaddress_rasapi32 0x746f0000)
set(baseaddress_rsaenh 0x74670000)
set(baseaddress_samlib 0x74620000)
set(baseaddress_sensapi 0x745f0000)
set(baseaddress_sfc_os 0x745c0000)
set(baseaddress_snmpapi 0x74580000)
set(baseaddress_spoolss 0x74540000)
set(baseaddress_usp10 0x744a0000)
set(baseaddress_acledit 0x74470000)
set(baseaddress_aclui 0x74420000)
set(baseaddress_activeds 0x743f0000)
set(baseaddress_actxprxy 0x74170000)
set(baseaddress_advpack 0x74120000)
set(baseaddress_amstream 0x740b0000)
set(baseaddress_atl 0x74050000)
set(baseaddress_atl100 0x74000000)
set(baseaddress_atl80 0x73fb0000)
set(baseaddress_authz 0x73f80000)
set(baseaddress_avifil32 0x73f00000)
set(baseaddress_batt 0x73ec0000)
set(baseaddress_bcrypt 0x73e80000)
set(baseaddress_beepmidi 0x73e50000)
set(baseaddress_browseui 0x73d10000)
set(baseaddress_cards 0x73c40000)
set(baseaddress_cfgmgr32 0x73c10000)
set(baseaddress_clusapi 0x73bd0000)
set(baseaddress_comcat 0x73ba0000)
set(baseaddress_compstui 0x73b70000)
set(baseaddress_console 0x73ae0000)
set(baseaddress_credui 0x73a90000)
set(baseaddress_crtdll 0x73a10000)
set(baseaddress_cryptdlg 0x739d0000)
set(baseaddress_cryptdll 0x739a0000)
set(baseaddress_cryptnet 0x73960000)
set(baseaddress_d3d8 0x738e0000)
set(baseaddress_d3d8thk 0x738c0000)
set(baseaddress_d3d9 0x73830000)
set(baseaddress_d3dcompiler_43 0x73750000)
set(baseaddress_d3drm 0x736a0000)
set(baseaddress_d3dx9_24 0x73670000)
set(baseaddress_d3dx9_25 0x73640000)
set(baseaddress_d3dx9_26 0x73610000)
set(baseaddress_d3dx9_27 0x735e0000)
set(baseaddress_d3dx9_28 0x735b0000)
set(baseaddress_d3dx9_29 0x73580000)
set(baseaddress_d3dx9_30 0x73550000)
set(baseaddress_d3dx9_31 0x73520000)
set(baseaddress_d3dx9_32 0x734f0000)
set(baseaddress_d3dx9_33 0x734c0000)
set(baseaddress_d3dx9_34 0x73490000)
set(baseaddress_d3dx9_35 0x73460000)
set(baseaddress_d3dx9_36 0x73330000)
set(baseaddress_d3dx9_37 0x73300000)
set(baseaddress_d3dx9_38 0x732d0000)
set(baseaddress_d3dx9_39 0x732a0000)
set(baseaddress_d3dx9_40 0x73270000)
set(baseaddress_d3dx9_41 0x73240000)
set(baseaddress_d3dx9_42 0x73210000)
set(baseaddress_d3dx9_43 0x731e0000)
set(baseaddress_d3dxof 0x73190000)
set(baseaddress_dciman32 0x73160000)
set(baseaddress_ddraw 0x73070000)
set(baseaddress_deskadp 0x73030000)
set(baseaddress_deskmon 0x72ff0000)
set(baseaddress_devcpux 0x72fc0000)
set(baseaddress_devenum 0x72f60000)
set(baseaddress_dinput 0x72ee0000)
set(baseaddress_dinput8 0x72ea0000)
set(baseaddress_dmusic 0x72e40000)
set(baseaddress_dplay 0x72e10000)
set(baseaddress_dwmapi 0x72de0000)
set(baseaddress_dxdiagn 0x72d80000)
set(baseaddress_dxgi 0x72d30000)
set(baseaddress_faultrep 0x72d00000)
set(baseaddress_fltlib 0x72cd0000)
set(baseaddress_fmifs 0x72ca0000)
set(baseaddress_fontext 0x72c70000)
set(baseaddress_framebuf 0x72c40000)
set(baseaddress_framebuf_new 0x72c10000)
set(baseaddress_framedyn 0x72bc0000)
set(baseaddress_genincdata 0x72b90000)
set(baseaddress_getuname 0x728b0000)
set(baseaddress_hid 0x72880000)
set(baseaddress_hlink 0x72830000)
set(baseaddress_hnetcfg 0x727e0000)
set(baseaddress_httpapi 0x727a0000)
set(baseaddress_iccvid 0x72760000)
set(baseaddress_ieframe 0x72660000)
set(baseaddress_iernonce 0x72630000)
set(baseaddress_imagehlp 0x725f0000)
set(baseaddress_inetcomm 0x72570000)
set(baseaddress_inetmib1 0x72530000)
set(baseaddress_initpki 0x72500000)
set(baseaddress_input 0x724a0000)
set(baseaddress_inseng 0x72460000)
set(baseaddress_iologmsg 0x72440000)
set(baseaddress_itircl 0x72410000)
set(baseaddress_itss 0x723b0000)
set(baseaddress_jscript 0x72230000)
set(baseaddress_jsproxy 0x721f0000)
set(baseaddress_kbsdll 0x721c0000)
set(baseaddress_kernel32_vista 0x721a0000)
set(baseaddress_ksuser 0x72170000)
set(baseaddress_libjpeg 0x720b0000)
set(baseaddress_libpng 0x72010000)
set(baseaddress_libtiff 0x71f00000)
set(baseaddress_libxslt 0x71b80000)
set(baseaddress_loadperf 0x71b50000)
set(baseaddress_localspl 0x71b00000)
set(baseaddress_localui 0x71ac0000)
set(baseaddress_lpk 0x71a90000)
set(baseaddress_lsasrv 0x71a10000)
set(baseaddress_mapi32 0x719b0000)
set(baseaddress_mciavi32 0x71960000)
set(baseaddress_mcicda 0x71920000)
set(baseaddress_mciqtz32 0x718d0000)
set(baseaddress_mciseq 0x71890000)
set(baseaddress_mciwave 0x71850000)
set(baseaddress_mgmtapi 0x71820000)
set(baseaddress_midimap 0x717e0000)
set(baseaddress_mlang 0x71790000)
set(baseaddress_mmdevapi 0x71740000)
set(baseaddress_mmdrv 0x71710000)
set(baseaddress_modemui 0x71690000)
set(baseaddress_mprapi 0x71650000)
set(baseaddress_msafd 0x71610000)
set(baseaddress_mscat32 0x715e0000)
set(baseaddress_mscms 0x715a0000)
set(baseaddress_mscoree 0x71530000)
set(baseaddress_msctf 0x714b0000)
set(baseaddress_msdmo 0x71470000)
set(baseaddress_msftedit 0x71440000)
set(baseaddress_msgina 0x713b0000)
set(baseaddress_mshtml 0x70f90000)
set(baseaddress_msi 0x70d70000)
set(baseaddress_msimtf 0x70d30000)
set(baseaddress_msisip 0x70d00000)
set(baseaddress_mspatcha 0x70cd0000)
set(baseaddress_msports 0x70c90000)
set(baseaddress_msrle32 0x70c50000)
set(baseaddress_mssign32 0x70c20000)
set(baseaddress_mssip32 0x70bf0000)
set(baseaddress_mstask 0x70ba0000)
set(baseaddress_msv1_0 0x70b70000)
set(baseaddress_msvcrt20 0x70a40000)
set(baseaddress_msvcrt40 0x70910000)
set(baseaddress_msvidc32 0x708d0000)
set(baseaddress_msxml 0x70890000)
set(baseaddress_msxml2 0x70850000)
set(baseaddress_msxml3 0x70370000)
set(baseaddress_msxml4 0x70320000)
set(baseaddress_msxml6 0x702d0000)
set(baseaddress_nddeapi 0x702a0000)
set(baseaddress_netcfgx 0x70200000)
set(baseaddress_netevent 0x701e0000)
set(baseaddress_netid 0x70190000)
set(baseaddress_netshell 0x700f0000)
set(baseaddress_newdev 0x70080000)
set(baseaddress_notifyhook 0x70050000)
set(baseaddress_ntdsapi 0x70010000)
set(baseaddress_ntlanman 0x6ffe0000)
set(baseaddress_ntmarta 0x6ffb0000)
set(baseaddress_ntprint 0x6ff80000)
set(baseaddress_objsel 0x6ff40000)
set(baseaddress_odbc32 0x6fef0000)
set(baseaddress_odbccp32 0x6feb0000)
set(baseaddress_oleacc 0x6fe40000)
set(baseaddress_olecli32 0x6fe00000)
set(baseaddress_olepro32 0x6fdd0000)
set(baseaddress_olesvr32 0x6fda0000)
set(baseaddress_olethk32 0x6fd70000)
set(baseaddress_pdh 0x6fd30000)
set(baseaddress_pidgen 0x6fd00000)
set(baseaddress_printui 0x6fcc0000)
set(baseaddress_propsys 0x6fc70000)
set(baseaddress_pstorec 0x6fc30000)
set(baseaddress_qedit 0x6fbd0000)
set(baseaddress_qmgr 0x6fb80000)
set(baseaddress_qmgrprxy 0x6fb10000)
set(baseaddress_quartz 0x6f910000)
set(baseaddress_query 0x6f8e0000)
set(baseaddress_rasadhlp 0x6f8b0000)
set(baseaddress_rasdlg 0x6f6d0000)
set(baseaddress_rasman 0x6f690000)
set(baseaddress_resutils 0x6f650000)
set(baseaddress_riched32 0x6f620000)
set(baseaddress_rsabase 0x6f600000)
set(baseaddress_samsrv 0x6f570000)
set(baseaddress_sccbase 0x6f540000)
set(baseaddress_schannel 0x6f4f0000)
set(baseaddress_scrrun 0x6f490000)
set(baseaddress_security 0x6f470000)
set(baseaddress_serialui 0x6f440000)
set(baseaddress_sfc 0x6f410000)
set(baseaddress_shdoclc 0x6f3d0000)
set(baseaddress_shdocvw 0x6f370000)
set(baseaddress_shfolder 0x6f350000)
set(baseaddress_shimgvw 0x6f310000)
set(baseaddress_slayer 0x6f2d0000)
set(baseaddress_slbcsp 0x6f2a0000)
set(baseaddress_sndblst 0x6f260000)
set(baseaddress_softpub 0x6f240000)
set(baseaddress_srclient 0x6f210000)
set(baseaddress_sti 0x6f1c0000)
set(baseaddress_sxs 0x6f180000)
set(baseaddress_syssetup 0x6f0c0000)
set(baseaddress_t2embed 0x6f090000)
set(baseaddress_tapi32 0x6f040000)
set(baseaddress_tapiui 0x6efd0000)
set(baseaddress_traffic 0x6efa0000)
set(baseaddress_twain_32 0x6ef60000)
set(baseaddress_uext2 0x6ef20000)
set(baseaddress_ufat 0x6eef0000)
set(baseaddress_ufatx 0x6eec0000)
set(baseaddress_umpnpmgr 0x6ee80000)
set(baseaddress_unicows 0x6ee40000)
set(baseaddress_untfs 0x6ee20000)
set(baseaddress_updspapi 0x6edf0000)
set(baseaddress_url 0x6edc0000)
set(baseaddress_vbscript 0x6ecf0000)
set(baseaddress_vdmdbg 0x6ecc0000)
set(baseaddress_wbemdisp 0x6ec80000)
set(baseaddress_wbemprox 0x6ebf0000)
set(baseaddress_windowscodecs 0x6ea60000)
set(baseaddress_windowscodecsext 0x6ea30000)
set(baseaddress_d3dwine 0x6e790000)
set(baseaddress_winfax 0x6e760000)
set(baseaddress_wing32 0x6e730000)
set(baseaddress_winhttp 0x6e6b0000)
set(baseaddress_winscard 0x6e670000)
set(baseaddress_winsta 0x6e630000)
set(baseaddress_wlanapi 0x6e5f0000)
set(baseaddress_wldap32 0x6e590000)
set(baseaddress_wmi 0x6e570000)
set(baseaddress_ws2_32_new 0x6e500000)
set(baseaddress_wshirda 0x6e4d0000)
set(baseaddress_wshtcpip 0x6e4a0000)
set(baseaddress_wsock32 0x6e470000)
set(baseaddress_wtsapi32 0x6e430000)
set(baseaddress_wuapi 0x6e3e0000)
set(baseaddress_xinput1_1 0x6e3b0000)
set(baseaddress_xinput1_2 0x6e380000)
set(baseaddress_xinput1_3 0x6e350000)
set(baseaddress_xinput9_1_0 0x6e320000)
set(baseaddress_xmllite 0x6e2d0000)
set(baseaddress_access 0x6e240000)
set(baseaddress_appwiz 0x6e1d0000)
set(baseaddress_cmicpl 0x6e190000)
set(baseaddress_desk 0x6e0e0000)
set(baseaddress_hdwwiz 0x6e050000)
set(baseaddress_hhctrl 0x6dfe0000)
set(baseaddress_imaadp32.acm 0x6dfa0000)
set(baseaddress_inetcpl 0x6df30000)
set(baseaddress_intl 0x6dec0000)
set(baseaddress_joy 0x6de70000)
set(baseaddress_main 0x6ddb0000)
set(baseaddress_mmsys 0x6dca0000)
set(baseaddress_msacm32.drv 0x6dc60000)
set(baseaddress_msadp32.acm 0x6dc20000)
set(baseaddress_msg711.acm 0x6dbe0000)
set(baseaddress_msgsm32.acm 0x6dbb0000)
set(baseaddress_msisys 0x6db80000)
set(baseaddress_ncpa 0x6db50000)
set(baseaddress_odbccp32i 0x6db20000)
set(baseaddress_powercfg 0x6dab0000)
set(baseaddress_sysdm 0x6d9c0000)
set(baseaddress_telephon 0x6d990000)
set(baseaddress_timedate 0x6d930000)
set(baseaddress_usrmgr 0x6d8d0000)
set(baseaddress_wdmaud.drv 0x6d6f0000)
set(baseaddress_wined3dcfg 0x6d6b0000)
set(baseaddress_winemp3.acm 0x6d620000)

361
sdk/cmake/baseaddress_msvc.cmake Normal file
View file

@ -0,0 +1,361 @@
set(baseaddress_ntdll 0x7c920000) # should be above 0x7c920000
set(baseaddress_kernel32 0x7c760000)
set(baseaddress_msvcrt 0x7c6e0000)
set(baseaddress_advapi32 0x7c660000)
set(baseaddress_gdi32 0x7c600000)
set(baseaddress_user32 0x7c4f0000)
set(baseaddress_dhcpcsvc 0x7c4b0000)
set(baseaddress_dnsapi 0x7c470000)
set(baseaddress_icmp 0x7c450000)
set(baseaddress_iphlpapi 0x7c410000)
set(baseaddress_ws2_32 0x7c3e0000)
set(baseaddress_ws2help 0x7c3c0000)
set(baseaddress_shlwapi 0x7c350000)
set(baseaddress_rpcrt4 0x7c2c0000)
set(baseaddress_comctl32 0x7c1a0000)
set(baseaddress_ole32 0x7c060000)
set(baseaddress_winspool.drv 0x7c030000)
set(baseaddress_winmm 0x7bf90000)
set(baseaddress_comdlg32 0x7bec0000)
set(baseaddress_shell32 0x7b5d0000)
set(baseaddress_lz32 0x7b5b0000)
set(baseaddress_version 0x7b580000)
set(baseaddress_oleaut32 0x7b440000)
set(baseaddress_setupapi 0x7b310000)
set(baseaddress_mpr 0x7b2e0000)
set(baseaddress_crypt32 0x7b210000)
set(baseaddress_wininet 0x7b180000)
set(baseaddress_urlmon 0x7b0d0000)
set(baseaddress_psapi 0x7b0b0000)
set(baseaddress_imm32 0x7b080000)
set(baseaddress_msvfw32 0x7b040000)
set(baseaddress_dbghelp 0x7afc0000)
set(baseaddress_devmgr 0x7af20000)
set(baseaddress_msacm32 0x7aee0000)
set(baseaddress_netapi32 0x7ae80000)
set(baseaddress_powrprof 0x7ae60000)
set(baseaddress_secur32 0x7ae30000)
set(baseaddress_wintrust 0x7adf0000)
set(baseaddress_avicap32 0x7add0000)
set(baseaddress_cabinet 0x7ad90000)
set(baseaddress_dsound 0x7ad30000)
set(baseaddress_glu32 0x7acb0000)
set(baseaddress_opengl32 0x7ab40000)
set(baseaddress_riched20 0x7aab0000)
set(baseaddress_smdll 0x7aa90000)
set(baseaddress_userenv 0x7aa50000)
set(baseaddress_uxtheme 0x7aa00000)
set(baseaddress_cryptui 0x7a960000)
set(baseaddress_csrsrv 0x7a930000)
set(baseaddress_basesrv 0x7a900000)
set(baseaddress_winsrv 0x7a890000)
set(baseaddress_dplayx 0x7a840000)
set(baseaddress_gdiplus 0x7a7b0000)
set(baseaddress_msimg32 0x7a790000)
set(baseaddress_mswsock 0x7a770000)
set(baseaddress_oledlg 0x7a730000)
set(baseaddress_rasapi32 0x7a700000)
set(baseaddress_rsaenh 0x7a6b0000)
set(baseaddress_samlib 0x7a680000)
set(baseaddress_sensapi 0x7a660000)
set(baseaddress_sfc_os 0x7a640000)
set(baseaddress_snmpapi 0x7a620000)
set(baseaddress_spoolss 0x7a5f0000)
set(baseaddress_usp10 0x7a590000)
set(baseaddress_aclayers 0x7a570000)
set(baseaddress_acledit 0x7a550000)
set(baseaddress_aclui 0x7a520000)
set(baseaddress_acppage 0x7a4f0000)
set(baseaddress_activeds 0x7a4d0000)
set(baseaddress_actxprxy 0x7a370000)
set(baseaddress_advapi32_vista 0x7a350000)
set(baseaddress_advpack 0x7a320000)
set(baseaddress_amstream 0x7a2f0000)
set(baseaddress_apphelp 0x7a2c0000)
set(baseaddress_atl 0x7a290000)
set(baseaddress_atl100 0x7a260000)
set(baseaddress_atl80 0x7a230000)
set(baseaddress_authz 0x7a210000)
set(baseaddress_avifil32 0x7a1b0000)
set(baseaddress_batt 0x7a190000)
set(baseaddress_bcrypt 0x7a160000)
set(baseaddress_beepmidi 0x7a140000)
set(baseaddress_browseui 0x7a0b0000)
set(baseaddress_cards 0x79ff0000)
set(baseaddress_cfgmgr32 0x79fd0000)
set(baseaddress_clusapi 0x79fa0000)
set(baseaddress_comcat 0x79f80000)
set(baseaddress_compstui 0x79f60000)
set(baseaddress_console 0x79f10000)
set(baseaddress_credui 0x79ed0000)
set(baseaddress_crtdll 0x79e90000)
set(baseaddress_cryptdlg 0x79e60000)
set(baseaddress_cryptdll 0x79e40000)
set(baseaddress_cryptnet 0x79e10000)
set(baseaddress_d3d8 0x79dd0000)
set(baseaddress_d3d8thk 0x79db0000)
set(baseaddress_d3d9 0x79d60000)
set(baseaddress_d3dcompiler_43 0x79cd0000)
set(baseaddress_d3drm 0x79c60000)
set(baseaddress_d3dwine 0x79a70000)
set(baseaddress_d3dx9_24 0x79a50000)
set(baseaddress_d3dx9_25 0x79a20000)
set(baseaddress_d3dx9_26 0x79a00000)
set(baseaddress_d3dx9_27 0x799e0000)
set(baseaddress_d3dx9_28 0x799c0000)
set(baseaddress_d3dx9_29 0x799a0000)
set(baseaddress_d3dx9_30 0x79970000)
set(baseaddress_d3dx9_31 0x79950000)
set(baseaddress_d3dx9_32 0x79930000)
set(baseaddress_d3dx9_33 0x79910000)
set(baseaddress_d3dx9_34 0x798f0000)
set(baseaddress_d3dx9_35 0x798d0000)
set(baseaddress_d3dx9_36 0x79820000)
set(baseaddress_d3dx9_37 0x79800000)
set(baseaddress_d3dx9_38 0x797e0000)
set(baseaddress_d3dx9_39 0x797c0000)
set(baseaddress_d3dx9_40 0x797a0000)
set(baseaddress_d3dx9_41 0x79780000)
set(baseaddress_d3dx9_42 0x79760000)
set(baseaddress_d3dx9_43 0x79740000)
set(baseaddress_d3dxof 0x79710000)
set(baseaddress_dciman32 0x796f0000)
set(baseaddress_ddraw 0x79660000)
set(baseaddress_deskadp 0x79630000)
set(baseaddress_deskmon 0x79600000)
set(baseaddress_devcpux 0x795e0000)
set(baseaddress_devenum 0x795b0000)
set(baseaddress_dinput 0x79570000)
set(baseaddress_dinput8 0x79550000)
set(baseaddress_dmusic 0x79510000)
set(baseaddress_dplay 0x794f0000)
set(baseaddress_dxdiagn 0x794c0000)
set(baseaddress_esent 0x79490000)
set(baseaddress_faultrep 0x79470000)
set(baseaddress_fltlib 0x79450000)
set(baseaddress_fmifs 0x79430000)
set(baseaddress_fontext 0x79410000)
set(baseaddress_fontsub 0x793f0000)
set(baseaddress_framebuf 0x793d0000)
set(baseaddress_framebuf_new 0x793b0000)
set(baseaddress_framedyn 0x79390000)
set(baseaddress_genincdata 0x79360000)
set(baseaddress_getuname 0x79090000)
set(baseaddress_hid 0x79070000)
set(baseaddress_hlink 0x79040000)
set(baseaddress_hnetcfg 0x79010000)
set(baseaddress_httpapi 0x78ff0000)
set(baseaddress_iccvid 0x78fc0000)
set(baseaddress_ieframe 0x78f30000)
set(baseaddress_iernonce 0x78f00000)
set(baseaddress_imagehlp 0x78ed0000)
set(baseaddress_inetcomm 0x78e80000)
set(baseaddress_inetmib1 0x78e60000)
set(baseaddress_initpki 0x78e40000)
set(baseaddress_input 0x78de0000)
set(baseaddress_inseng 0x78dc0000)
set(baseaddress_iologmsg 0x78da0000)
set(baseaddress_itircl 0x78d80000)
set(baseaddress_itss 0x78d50000)
set(baseaddress_jscript 0x78cb0000)
set(baseaddress_jsproxy 0x78c90000)
set(baseaddress_kbsdll 0x78c70000)
set(baseaddress_kernel32_vista 0x78c50000)
set(baseaddress_ksuser 0x78c30000)
set(baseaddress_libjpeg 0x78bd0000)
set(baseaddress_libpng 0x78b70000)
set(baseaddress_libtiff 0x78b00000)
set(baseaddress_libxslt 0x789c0000)
set(baseaddress_loadperf 0x789a0000)
set(baseaddress_localspl 0x78970000)
set(baseaddress_localui 0x78940000)
set(baseaddress_lpk 0x78920000)
set(baseaddress_lsasrv 0x788d0000)
set(baseaddress_mapi32 0x788a0000)
set(baseaddress_mbedtls 0x78840000)
set(baseaddress_mciavi32 0x78810000)
set(baseaddress_mcicda 0x787e0000)
set(baseaddress_mciqtz32 0x787b0000)
set(baseaddress_mciseq 0x78780000)
set(baseaddress_mciwave 0x78750000)
set(baseaddress_mgmtapi 0x78730000)
set(baseaddress_midimap 0x78710000)
set(baseaddress_mlang 0x786e0000)
set(baseaddress_mmdrv 0x786c0000)
set(baseaddress_modemui 0x78650000)
set(baseaddress_mprapi 0x78620000)
set(baseaddress_msafd 0x785f0000)
set(baseaddress_mscat32 0x785d0000)
set(baseaddress_mscms 0x785a0000)
set(baseaddress_mscoree 0x78560000)
set(baseaddress_msctf 0x78520000)
set(baseaddress_msdmo 0x78500000)
set(baseaddress_msftedit 0x784e0000)
set(baseaddress_msgina 0x78460000)
set(baseaddress_mshtml 0x782c0000)
set(baseaddress_msi 0x781d0000)
set(baseaddress_msimtf 0x781b0000)
set(baseaddress_msisip 0x78190000)
set(baseaddress_mspatcha 0x78170000)
set(baseaddress_msports 0x78140000)
set(baseaddress_msrle32 0x78110000)
set(baseaddress_mssign32 0x780f0000)
set(baseaddress_mssip32 0x780d0000)
set(baseaddress_mstask 0x780a0000)
set(baseaddress_msv1_0 0x78080000)
set(baseaddress_msvcrt_crt_dll_startup 0x78060000)
set(baseaddress_msvcrt20 0x77fd0000)
set(baseaddress_msvcrt40 0x77f40000)
set(baseaddress_msvidc32 0x77f20000)
set(baseaddress_msxml 0x77ef0000)
set(baseaddress_msxml2 0x77ec0000)
set(baseaddress_msxml3 0x77cc0000)
set(baseaddress_msxml4 0x77c80000)
set(baseaddress_msxml6 0x77c40000)
set(baseaddress_mycomput 0x77c20000)
set(baseaddress_nddeapi 0x77c00000)
set(baseaddress_netcfgx 0x77b90000)
set(baseaddress_netevent 0x77b70000)
set(baseaddress_netid 0x77b30000)
set(baseaddress_netshell 0x77ab0000)
set(baseaddress_newdev 0x77a60000)
set(baseaddress_normaliz 0x77a40000)
set(baseaddress_notifyhook 0x77a20000)
set(baseaddress_npptools 0x77a00000)
set(baseaddress_ntdsapi 0x779d0000)
set(baseaddress_ntlanman 0x779b0000)
set(baseaddress_ntmarta 0x77990000)
set(baseaddress_ntobjshex 0x77930000)
set(baseaddress_ntprint 0x77910000)
set(baseaddress_objsel 0x778f0000)
set(baseaddress_odbc32 0x778b0000)
set(baseaddress_odbccp32 0x77880000)
set(baseaddress_oleacc 0x77830000)
set(baseaddress_olecli32 0x77810000)
set(baseaddress_olepro32 0x777f0000)
set(baseaddress_olesvr32 0x777d0000)
set(baseaddress_olethk32 0x777b0000)
set(baseaddress_pdh 0x77780000)
set(baseaddress_pidgen 0x77760000)
set(baseaddress_pifmgr 0x776e0000)
set(baseaddress_printui 0x776c0000)
set(baseaddress_propsys 0x77690000)
set(baseaddress_pstorec 0x77670000)
set(baseaddress_qedit 0x77640000)
set(baseaddress_qmgr 0x77610000)
set(baseaddress_qmgrprxy 0x775d0000)
set(baseaddress_quartz 0x774c0000)
set(baseaddress_query 0x774a0000)
set(baseaddress_rasadhlp 0x77480000)
set(baseaddress_rasdlg 0x772b0000)
set(baseaddress_rasman 0x77280000)
set(baseaddress_resutils 0x77260000)
set(baseaddress_riched32 0x77240000)
set(baseaddress_rsabase 0x77220000)
set(baseaddress_rshell 0x771c0000)
set(baseaddress_samsrv 0x77160000)
set(baseaddress_sccbase 0x77140000)
set(baseaddress_schannel 0x77110000)
set(baseaddress_schedsvc 0x770f0000)
set(baseaddress_scrrun 0x770b0000)
set(baseaddress_security 0x77090000)
set(baseaddress_serialui 0x77070000)
set(baseaddress_sfc 0x77050000)
set(baseaddress_shdoclc 0x77010000)
set(baseaddress_shdocvw 0x76fd0000)
set(baseaddress_shfolder 0x76fb0000)
set(baseaddress_shimgvw 0x76f70000)
set(baseaddress_slayer 0x76f40000)
set(baseaddress_slbcsp 0x76f20000)
set(baseaddress_sndblst 0x76ef0000)
set(baseaddress_softpub 0x76ed0000)
set(baseaddress_srclient 0x76eb0000)
set(baseaddress_srvsvc 0x76e80000)
set(baseaddress_sti 0x76e50000)
set(baseaddress_stobject 0x76e00000)
set(baseaddress_streamci 0x76de0000)
set(baseaddress_sxs 0x76db0000)
set(baseaddress_syssetup 0x76d10000)
set(baseaddress_t2embed 0x76cf0000)
set(baseaddress_tapi32 0x76cc0000)
set(baseaddress_tapiui 0x76c40000)
set(baseaddress_testvdd 0x76c20000)
set(baseaddress_themeui 0x76c00000)
set(baseaddress_traffic 0x76be0000)
set(baseaddress_twain_32 0x76bc0000)
set(baseaddress_ubtrfs 0x76ba0000)
set(baseaddress_uext2 0x76b70000)
set(baseaddress_ufat 0x76b40000)
set(baseaddress_ufatx 0x76b20000)
set(baseaddress_uffs 0x76b00000)
set(baseaddress_umpnpmgr 0x76ad0000)
set(baseaddress_untfs 0x76ab0000)
set(baseaddress_updspapi 0x76a90000)
set(baseaddress_ureiserfs 0x76a70000)
set(baseaddress_url 0x76a50000)
set(baseaddress_vbscript 0x769e0000)
set(baseaddress_vdmdbg 0x769c0000)
set(baseaddress_vssapi 0x76990000)
set(baseaddress_wbemdisp 0x76960000)
set(baseaddress_wbemprox 0x76920000)
set(baseaddress_win32kdll 0x76900000)
set(baseaddress_win32kdll_2k3sp2 0x768e0000)
set(baseaddress_win32kdll_xpsp2 0x768c0000)
set(baseaddress_windowscodecs 0x767f0000)
set(baseaddress_windowscodecsext 0x767d0000)
set(baseaddress_winfax 0x767b0000)
set(baseaddress_wing32 0x76790000)
set(baseaddress_winhttp 0x76750000)
set(baseaddress_winscard 0x76730000)
set(baseaddress_winsta 0x76700000)
set(baseaddress_wkssvc 0x766e0000)
set(baseaddress_wlanapi 0x766c0000)
set(baseaddress_wldap32 0x76690000)
set(baseaddress_wmi 0x76670000)
set(baseaddress_wmisvc 0x76650000)
set(baseaddress_wmiutils 0x76620000)
set(baseaddress_wmvcore 0x765f0000)
set(baseaddress_ws2_32_new 0x765c0000)
set(baseaddress_wshirda 0x765a0000)
set(baseaddress_wshtcpip 0x76580000)
set(baseaddress_wsock32 0x76560000)
set(baseaddress_wtsapi32 0x76540000)
set(baseaddress_wuapi 0x76510000)
set(baseaddress_xinput1_1 0x764f0000)
set(baseaddress_xinput1_2 0x764d0000)
set(baseaddress_xinput1_3 0x764b0000)
set(baseaddress_xinput9_1_0 0x76490000)
set(baseaddress_xmllite 0x76460000)
set(baseaddress_access 0x763e0000)
set(baseaddress_appwiz 0x76370000)
set(baseaddress_cmicpl 0x76340000)
set(baseaddress_desk 0x762c0000)
set(baseaddress_hdwwiz 0x76250000)
set(baseaddress_hhctrl 0x76210000)
set(baseaddress_imaadp32.acm 0x761f0000)
set(baseaddress_inetcpl 0x761a0000)
set(baseaddress_intl 0x76140000)
set(baseaddress_joy 0x76100000)
set(baseaddress_main 0x76080000)
set(baseaddress_mmsys 0x75fb0000)
set(baseaddress_msacm32.drv 0x75f80000)
set(baseaddress_msadp32.acm 0x75f60000)
set(baseaddress_msg711.acm 0x75f40000)
set(baseaddress_msgsm32.acm 0x75f20000)
set(baseaddress_msisys 0x75f00000)
set(baseaddress_ncpa 0x75ee0000)
set(baseaddress_odbccp32i 0x75ec0000)
set(baseaddress_powercfg 0x75e60000)
set(baseaddress_sysdm 0x75d80000)
set(baseaddress_telephon 0x75d60000)
set(baseaddress_timedate 0x75cf0000)
set(baseaddress_usrmgr 0x75ca0000)
set(baseaddress_wdmaud.drv 0x75b10000)
set(baseaddress_wined3dcfg 0x75ae0000)
set(baseaddress_winemp3.acm 0x75a70000)
set(baseaddress_wshom 0x75a40000)
## From baseaddress.cmake (GCC)
set(baseaddress_fusion 0x73830000)
set(baseaddress_fusion_1_1 0x737f0000)
set(baseaddress_fusion_2_0 0x737b0000)

27
sdk/cmake/bison-flex.cmake Normal file
View file

@ -0,0 +1,27 @@
# Simply use :
# add_bison_files(foo.y)
# and
# add_flex_files(foo.l)
# then add ${CMAKE_CURRENT_BINARY_DIR}/foo.tab.c
# and ${CMAKE_CURRENT_BINARY_DIR}/foo.yy.c to the source list
function(add_bison_files)
foreach(_file ${ARGN})
get_filename_component(_name ${_file} NAME_WE)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_name}.tab.c ${CMAKE_CURRENT_BINARY_DIR}/${_name}.tab.h
COMMAND bison -p ${_name}_ -o ${CMAKE_CURRENT_BINARY_DIR}/${_name}.tab.c --defines=${CMAKE_CURRENT_BINARY_DIR}/${_name}.tab.h ${CMAKE_CURRENT_SOURCE_DIR}/${_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_file})
endforeach()
endfunction()
function(add_flex_files)
foreach(_file ${ARGN})
get_filename_component(_name ${_file} NAME_WE)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_name}.yy.c ${CMAKE_CURRENT_BINARY_DIR}/${_name}.yy.h
COMMAND flex -o ${CMAKE_CURRENT_BINARY_DIR}/${_name}.yy.c --header-file=${CMAKE_CURRENT_BINARY_DIR}/${_name}.yy.h ${CMAKE_CURRENT_SOURCE_DIR}/${_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_file})
endforeach()
endfunction()

125
sdk/cmake/compilerflags.cmake Normal file
View file

@ -0,0 +1,125 @@
# add_target_property
# Adds one or more values to the specified property of the specified target.
# Note that there are properties which require (semicolon-separated) lists,
# while others require space-separated strings. The function has a list of
# properties of the former variety and handles the values accordingly
function(add_target_property _module _propname)
list(APPEND _list_properties COMPILE_DEFINITIONS INCLUDE_DIRECTORIES)
set(_newvalue "")
get_target_property(_oldvalue ${_module} ${_propname})
if(_oldvalue)
set(_newvalue ${_oldvalue})
endif()
list(FIND _list_properties ${_propname} _list_index)
if(NOT _list_index EQUAL -1)
# list property
list(APPEND _newvalue ${ARGN})
else()
# string property
foreach(_flag ${ARGN})
set(_newvalue "${_newvalue} ${_flag}")
endforeach()
endif()
set_property(TARGET ${_module} PROPERTY ${_propname} ${_newvalue})
endfunction()
# Wrapper functions for the important properties, using add_target_property
# where appropriate.
# Note that the functions for string properties take a single string
# argument while those for list properties can take a variable number of
# arguments, all of which will be added to the list
#
# Examples:
# add_target_compile_flags(mymodule "-pedantic -O5")
# add_target_link_flags(mymodule "-s --fatal-warnings")
# add_target_compile_definitions(mymodule WIN32 _WIN32 INLINE=inline)
# add_target_include_directories(mymodule include ../include)
function(add_target_compile_flags _module _flags)
if(${ARGC} GREATER 2)
message(FATAL_ERROR "Excess arguments to add_target_compile_flags! Module ${_module}, args ${ARGN}")
endif()
add_target_property(${_module} COMPILE_FLAGS ${_flags})
endfunction()
function(add_target_link_flags _module _flags)
if(${ARGC} GREATER 2)
message(FATAL_ERROR "Excess arguments to add_target_link_flags! Module ${_module}, args ${ARGN}")
endif()
add_target_property(${_module} LINK_FLAGS ${_flags})
endfunction()
function(add_target_compile_definitions _module)
add_target_property(${_module} COMPILE_DEFINITIONS ${ARGN})
endfunction()
function(add_target_include_directories _module)
add_target_property(${_module} INCLUDE_DIRECTORIES ${ARGN})
endfunction()
# replace_compiler_option
# (taken from LLVM)
# Replaces a compiler option or switch `_old' in `_var' by `_new'.
# If `_old' is not in `_var', appends `_new' to `_var'.
#
# Example:
# replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O3" "-O2")
macro(replace_compiler_option _var _old _new)
# If the option already is on the variable, don't add it:
if("${${_var}}" MATCHES "(^| )${_new}($| )")
set(__n "")
else()
set(__n "${_new}")
endif()
if("${${_var}}" MATCHES "(^| )${_old}($| )")
string(REGEX REPLACE "(^| )${_old}($| )" " ${__n} " ${_var} "${${_var}}")
else()
set(${_var} "${${_var}} ${__n}")
endif()
endmacro(replace_compiler_option)
# add_compile_flags
# add_compile_flags_language
# replace_compile_flags
# replace_compile_flags_language
# Add or replace compiler flags in the global scope for either all source
# files or only those of the specified language.
#
# Examples:
# add_compile_flags("-pedantic -O5")
# add_compile_flags_language("-std=gnu99" "C")
# replace_compile_flags("-O5" "-O3")
# replace_compile_flags_language("-fno-exceptions" "-fexceptions" "CXX")
function(add_compile_flags _flags)
if(${ARGC} GREATER 1)
message(FATAL_ERROR "Excess arguments to add_compile_flags! Args ${ARGN}")
endif()
# Adds the compiler flag for all code files: C, C++, and assembly
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_flags}" PARENT_SCOPE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flags}" PARENT_SCOPE)
set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${_flags}" PARENT_SCOPE)
endfunction()
function(add_compile_flags_language _flags _lang)
if(NOT ${ARGC} EQUAL 2)
message(FATAL_ERROR "Wrong arguments to add_compile_flags_language! Args ${ARGN}")
endif()
# Adds the compiler flag for the specified language only, e.g. CMAKE_C_FLAGS
set(CMAKE_${_lang}_FLAGS "${CMAKE_${_lang}_FLAGS} ${_flags}" PARENT_SCOPE)
endfunction()
macro(replace_compile_flags _oldflags _newflags)
if(NOT ${ARGC} EQUAL 2)
message(FATAL_ERROR "Wrong arguments to replace_compile_flags! Args ${ARGN}")
endif()
replace_compiler_option(CMAKE_C_FLAGS ${_oldflags} ${_newflags})
replace_compiler_option(CMAKE_CXX_FLAGS ${_oldflags} ${_newflags})
replace_compiler_option(CMAKE_ASM_FLAGS ${_oldflags} ${_newflags})
endmacro()
macro(replace_compile_flags_language _oldflags _newflags _lang)
if(NOT ${ARGC} EQUAL 3)
message(FATAL_ERROR "Wrong arguments to replace_compile_flags_language! Args ${ARGN}")
endif()
replace_compiler_option(CMAKE_${_lang}_FLAGS ${_oldflags} ${_newflags})
endmacro()

53
sdk/cmake/config-amd64.cmake Normal file
View file

@ -0,0 +1,53 @@
set(SARCH "" CACHE STRING
"Sub-architecture to build for.")
set(OARCH "athlon64" CACHE STRING
"Generate instructions for this CPU type. Specify one of:
k8 opteron athlon64 athlon-fx")
set (OPTIMIZE "1" CACHE STRING
"What level of optimization to use.
0 = off
1 = Default option, optimize for size (-Os) with some additional options
2 = Optimize for size (-Os)
3 = Optimize debugging experience (-Og)
4 = Optimize (-O1)
5 = Optimize even more (-O2)
6 = Optimize yet more (-O3)
7 = Disregard strict standards compliance (-Ofast)")
set(LTCG FALSE CACHE BOOL
"Whether to build with link-time code generation")
set(DBG TRUE CACHE BOOL
"Whether to compile for debugging.")
set(KDBG FALSE CACHE BOOL
"Whether to compile in the integrated kernel debugger.")
set(GDB FALSE CACHE BOOL
"Whether to compile for debugging with GDB.
If you don't use GDB, don't enable this.")
set(_WINKD_ TRUE CACHE BOOL
"Whether to compile with the KD protocol.")
set(_ELF_ FALSE CACHE BOOL
"Whether to compile support for ELF files.
Do not enable unless you know what you're doing.")
set(NSWPAT FALSE CACHE BOOL
"Whether to compile apps/libs with features covered software patents or not.
If you live in a country where software patents are valid/apply, don't
enable this (except they/you purchased a license from the patent owner).
This settings is disabled (0) by default.")
set(USERMODE TRUE CACHE BOOL
"Whether to compile any usermode parts. This is while kernel mode is under
heavy development and usermode part not relevant for bootcd.")
if(MSVC)
set(_PREFAST_ FALSE CACHE BOOL
"Whether to enable PREFAST while compiling.")
endif()

51
sdk/cmake/config-arm.cmake Normal file
View file

@ -0,0 +1,51 @@
set(SARCH "omap3-zoom2" CACHE STRING
"Sub-architecture (board) to build for. Specify one of:
kurobox versatile omap3-zoom2 omap3-beagle")
set(OARCH "armv7-a" CACHE STRING
"Generate instructions for this CPU type. Specify one of:
armv5te armv7-a")
set (OPTIMIZE "1" CACHE STRING
"What level of optimization to use.
0 = off
1 = Default option, optimize for size (-Os) with some additional options
2 = Optimize for size (-Os)
3 = Optimize debugging experience (-Og)
4 = Optimize (-O1)
5 = Optimize even more (-O2)
6 = Optimize yet more (-O3)
7 = Disregard strict standards compliance (-Ofast)")
set(LTCG FALSE CACHE BOOL
"Whether to build with link-time code generation")
set(DBG TRUE CACHE BOOL
"Whether to compile for debugging.")
set(KDBG FALSE CACHE BOOL
"Whether to compile in the integrated kernel debugger.")
set(GDB FALSE CACHE BOOL
"Whether to compile for debugging with GDB.
If you don't use GDB, don't enable this.")
set(_WINKD_ TRUE CACHE BOOL
"Whether to compile with the KD protocol.")
set(_ELF_ FALSE CACHE BOOL
"Whether to compile support for ELF files.
Do not enable unless you know what you're doing.")
set(NSWPAT FALSE CACHE BOOL
"Whether to compile apps/libs with features covered software patents or not.
If you live in a country where software patents are valid/apply, don't
enable this (except they/you purchased a license from the patent owner).
This settings is disabled (0) by default.")
set(BUILD_MP TRUE CACHE BOOL
"Whether to compile the multi processor versions for ntoskrnl and hal.")
set(NEWSPRINTF FALSE CACHE BOOL
"Whether to compile the new sprintf.")

84
sdk/cmake/config.cmake Normal file
View file

@ -0,0 +1,84 @@
set(SARCH "pc" CACHE STRING
"Sub-architecture to build for. Specify one of:
pc xbox")
set(OARCH "pentium" CACHE STRING
"Generate instructions for this CPU type. Specify one of:
pentium, pentiumpro")
set(TUNE "i686" CACHE STRING
"Which CPU ReactOS should be optimized for.")
set(OPTIMIZE "4" CACHE STRING
"What level of optimization to use.
0 = Off
1 = Optimize for size (-Os) with some additional options
2 = Optimize for size (-Os)
3 = Optimize debugging experience (-Og)
4 = Optimize (-O1)
5 = Optimize even more (-O2)
6 = Optimize yet more (-O3)
7 = Disregard strict standards compliance (-Ofast)")
set(LTCG FALSE CACHE BOOL
"Whether to build with link-time code generation")
set(GDB FALSE CACHE BOOL
"Whether to compile for debugging with GDB.
If you don't use GDB, don't enable this.")
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(DBG FALSE CACHE BOOL
"Whether to compile for debugging.")
else()
set(DBG TRUE CACHE BOOL
"Whether to compile for debugging.")
endif()
if(MSVC)
set(KDBG FALSE CACHE BOOL
"Whether to compile in the integrated kernel debugger.")
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(_WINKD_ FALSE CACHE BOOL "Whether to compile with the KD protocol.")
else()
set(_WINKD_ TRUE CACHE BOOL "Whether to compile with the KD protocol.")
endif()
else()
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(KDBG FALSE CACHE BOOL "Whether to compile in the integrated kernel debugger.")
else()
set(KDBG TRUE CACHE BOOL "Whether to compile in the integrated kernel debugger.")
endif()
set(_WINKD_ FALSE CACHE BOOL "Whether to compile with the KD protocol.")
endif()
set(_ELF_ FALSE CACHE BOOL
"Whether to compile support for ELF files.
Do not enable unless you know what you're doing.")
set(NSWPAT FALSE CACHE BOOL
"Whether to build apps/libs with features covered by software patents.
If you live in a country where software patents are valid/apply, don't
enable this (except they/you purchased a license from the patent owner).
This setting is disabled by default.")
set(BUILD_MP TRUE CACHE BOOL
"Whether to build the multiprocessor versions of NTOSKRNL and HAL.")
set(GENERATE_DEPENDENCY_GRAPH FALSE CACHE BOOL
"Whether to create a GraphML dependency graph of DLLs.")
if(MSVC)
set(_PREFAST_ FALSE CACHE BOOL
"Whether to enable PREFAST while compiling.")
set(_VS_ANALYZE_ FALSE CACHE BOOL
"Whether to enable static analysis while compiling.")
else()
set(STACK_PROTECTOR FALSE CACHE BOOL
"Whether to enbable the GCC stack checker while compiling")
endif()
set(USE_DUMMY_PSEH FALSE CACHE BOOL
"Whether to disable PSEH support.")

459
sdk/cmake/gcc.cmake Normal file
View file

@ -0,0 +1,459 @@
# Show a note about ccache build
if(ENABLE_CCACHE)
message("-- Enabling ccache build - done")
set(CMAKE_C_USE_RESPONSE_FILE_FOR_INCLUDES OFF)
set(CMAKE_CXX_USE_RESPONSE_FILE_FOR_INCLUDES OFF)
endif()
# PDB style debug info
if(NOT DEFINED SEPARATE_DBG)
set(SEPARATE_DBG FALSE)
endif()
# Dwarf based builds (no rsym)
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(NO_ROSSYM TRUE)
elseif(NOT DEFINED NO_ROSSYM)
set(NO_ROSSYM FALSE)
endif()
if(NOT DEFINED USE_PSEH3)
set(USE_PSEH3 1)
endif()
if(USE_PSEH3)
add_definitions(-D_USE_PSEH3=1)
endif()
if(NOT DEFINED USE_DUMMY_PSEH)
set(USE_DUMMY_PSEH 0)
endif()
if(USE_DUMMY_PSEH)
add_definitions(-D_USE_DUMMY_PSEH=1)
endif()
if(STACK_PROTECTOR)
add_compile_flags(${MODULE} "-fstack-protector-all")
endif()
# Compiler Core
add_compile_flags("-pipe -fms-extensions -fno-strict-aliasing")
# Prevent GCC from searching any of the default directories
add_compile_flags("-nostdinc")
if(GCC_VERSION VERSION_GREATER 4.7)
add_compile_flags("-mstackrealign")
endif()
if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
add_compile_flags_language("-std=gnu89 -Wno-microsoft" "C")
set(CMAKE_LINK_DEF_FILE_FLAG "")
set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
set(CMAKE_LINK_LIBRARY_SUFFIX "")
set(CMAKE_CREATE_WIN32_EXE "")
set(CMAKE_C_COMPILE_OPTIONS_PIC "")
set(CMAKE_CXX_COMPILE_OPTIONS_PIC "")
set(CMAKE_C_COMPILE_OPTIONS_PIE "")
set(CMAKE_CXX_COMPILE_OPTIONS_PIE "")
set(CMAKE_SHARED_LIBRARY_C_FLAGS "")
set(CMAKE_SHARED_LIBRARY_CXX_FLAGS "")
set(CMAKE_ASM_FLAGS_DEBUG "")
set(CMAKE_C_FLAGS_DEBUG "")
set(CMAKE_CXX_FLAGS_DEBUG "")
endif()
if(DBG)
if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")
add_compile_flags_language("-Wold-style-declaration" "C")
endif()
add_compile_flags_language("-Wdeclaration-after-statement" "C")
endif()
add_compile_flags_language("-fno-rtti -fno-exceptions" "CXX")
#bug
#file(TO_NATIVE_PATH ${REACTOS_SOURCE_DIR} REACTOS_SOURCE_DIR_NATIVE)
#workaround
set(REACTOS_SOURCE_DIR_NATIVE ${REACTOS_SOURCE_DIR})
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
string(REPLACE "/" "\\" REACTOS_SOURCE_DIR_NATIVE ${REACTOS_SOURCE_DIR})
endif()
if((NOT CMAKE_C_COMPILER_ID STREQUAL "Clang") AND (NOT SEPARATE_DBG))
add_compile_flags("-fdebug-prefix-map=\"${REACTOS_SOURCE_DIR_NATIVE}\"=ReactOS")
endif()
# Debugging
if(NOT CMAKE_BUILD_TYPE STREQUAL "Release")
if(SEPARATE_DBG)
add_compile_flags("-gdwarf-2 -ggdb")
else()
add_compile_flags("-gdwarf-2 -gstrict-dwarf")
if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")
add_compile_flags("-femit-struct-debug-detailed=none -feliminate-unused-debug-symbols")
endif()
endif()
endif()
# For some reason, cmake sets -fPIC, and we don't want it
if(DEFINED CMAKE_SHARED_LIBRARY_ASM_FLAGS)
string(REPLACE "-fPIC" "" CMAKE_SHARED_LIBRARY_ASM_FLAGS ${CMAKE_SHARED_LIBRARY_ASM_FLAGS})
endif()
# Tuning
if(ARCH STREQUAL "i386")
add_compile_flags("-march=${OARCH} -mtune=${TUNE}")
else()
add_compile_flags("-march=${OARCH}")
endif()
# Warnings, errors
if((NOT CMAKE_BUILD_TYPE STREQUAL "Release") AND (NOT CMAKE_C_COMPILER_ID STREQUAL "Clang"))
add_compile_flags("-Werror")
endif()
add_compile_flags("-Wall -Wpointer-arith")
add_compile_flags("-Wno-char-subscripts -Wno-multichar -Wno-unused-value")
if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")
add_compile_flags("-Wno-maybe-uninitialized")
endif()
if(ARCH STREQUAL "amd64")
add_compile_flags("-Wno-format")
elseif(ARCH STREQUAL "arm")
add_compile_flags("-Wno-attributes")
endif()
# Optimizations
# FIXME: Revisit this to see if we even need these levels
if(CMAKE_BUILD_TYPE STREQUAL "Release")
add_compile_flags("-O2 -DNDEBUG")
else()
if(OPTIMIZE STREQUAL "1")
add_compile_flags("-Os -ftracer")
elseif(OPTIMIZE STREQUAL "2")
add_compile_flags("-Os")
elseif(OPTIMIZE STREQUAL "3")
add_compile_flags("-Og")
elseif(OPTIMIZE STREQUAL "4")
add_compile_flags("-O1")
elseif(OPTIMIZE STREQUAL "5")
add_compile_flags("-O2")
elseif(OPTIMIZE STREQUAL "6")
add_compile_flags("-O3")
elseif(OPTIMIZE STREQUAL "7")
add_compile_flags("-Ofast")
endif()
endif()
# Link-time code generation
if(LTCG)
add_compile_flags("-flto -fno-fat-lto-objects")
endif()
if(ARCH STREQUAL "i386")
add_compile_flags("-fno-optimize-sibling-calls -fno-omit-frame-pointer")
if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")
add_compile_flags("-mpreferred-stack-boundary=3 -fno-set-stack-executable")
endif()
# FIXME: this doesn't work. CMAKE_BUILD_TYPE is always "Debug"
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
add_compile_flags("-momit-leaf-frame-pointer")
endif()
elseif(ARCH STREQUAL "amd64")
add_compile_flags("-mpreferred-stack-boundary=4")
endif()
# Other
if(ARCH STREQUAL "amd64")
add_definitions(-U_X86_ -UWIN32)
elseif(ARCH STREQUAL "arm")
add_definitions(-U_UNICODE -UUNICODE)
add_definitions(-D__MSVCRT__) # DUBIOUS
endif()
add_definitions(-D_inline=__inline)
# Alternative arch name
if(ARCH STREQUAL "amd64")
set(ARCH2 x86_64)
else()
set(ARCH2 ${ARCH})
endif()
if(SEPARATE_DBG)
# PDB style debug puts all dwarf debug info in a separate dbg file
message(STATUS "Building separate debug symbols")
file(MAKE_DIRECTORY ${REACTOS_BINARY_DIR}/symbols)
if(CMAKE_GENERATOR STREQUAL "Ninja")
set(SYMBOL_FILE <TARGET_PDB>)
else()
set(SYMBOL_FILE <TARGET>.gdb)
endif()
set(OBJCOPY ${CMAKE_OBJCOPY})
set(CMAKE_C_LINK_EXECUTABLE
"<CMAKE_C_COMPILER> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
"${OBJCOPY} --only-keep-debug <TARGET> ${REACTOS_BINARY_DIR}/symbols/${SYMBOL_FILE}"
"${OBJCOPY} --strip-debug <TARGET>")
set(CMAKE_CXX_LINK_EXECUTABLE
"<CMAKE_CXX_COMPILER> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
"${OBJCOPY} --only-keep-debug <TARGET> ${REACTOS_BINARY_DIR}/symbols/${SYMBOL_FILE}"
"${OBJCOPY} --strip-debug <TARGET>")
set(CMAKE_C_CREATE_SHARED_LIBRARY
"<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
"${OBJCOPY} --only-keep-debug <TARGET> ${REACTOS_BINARY_DIR}/symbols/${SYMBOL_FILE}"
"${OBJCOPY} --strip-debug <TARGET>")
set(CMAKE_CXX_CREATE_SHARED_LIBRARY
"<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
"${OBJCOPY} --only-keep-debug <TARGET> ${REACTOS_BINARY_DIR}/symbols/${SYMBOL_FILE}"
"${OBJCOPY} --strip-debug <TARGET>")
set(CMAKE_RC_CREATE_SHARED_LIBRARY
"<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
"${OBJCOPY} --only-keep-debug <TARGET> ${REACTOS_BINARY_DIR}/symbols/${SYMBOL_FILE}"
"${OBJCOPY} --strip-debug <TARGET>")
elseif(NO_ROSSYM)
# Dwarf-based build
message(STATUS "Generating a dwarf-based build (no rsym)")
set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
set(CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_CXX_COMPILER> ${CMAKE_CXX_FLAGS} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
set(CMAKE_C_CREATE_SHARED_LIBRARY "<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
set(CMAKE_CXX_CREATE_SHARED_LIBRARY "<CMAKE_CXX_COMPILER> ${CMAKE_CXX_FLAGS} <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
set(CMAKE_RC_CREATE_SHARED_LIBRARY "<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
else()
# Normal rsym build
if(NEW_STYLE_BUILD)
string(TOUPPER ${CMAKE_BUILD_TYPE} _build_type)
get_target_property(RSYM native-rsym IMPORTED_LOCATION_${_build_type})
else()
get_target_property(RSYM native-rsym IMPORTED_LOCATION_NOCONFIG)
endif()
set(CMAKE_C_LINK_EXECUTABLE
"<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
"${RSYM} -s ${REACTOS_SOURCE_DIR} <TARGET> <TARGET>")
set(CMAKE_CXX_LINK_EXECUTABLE
"<CMAKE_CXX_COMPILER> ${CMAKE_CXX_FLAGS} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
"${RSYM} -s ${REACTOS_SOURCE_DIR} <TARGET> <TARGET>")
set(CMAKE_C_CREATE_SHARED_LIBRARY
"<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
"${RSYM} -s ${REACTOS_SOURCE_DIR} <TARGET> <TARGET>")
set(CMAKE_CXX_CREATE_SHARED_LIBRARY
"<CMAKE_CXX_COMPILER> ${CMAKE_CXX_FLAGS} <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
"${RSYM} -s ${REACTOS_SOURCE_DIR} <TARGET> <TARGET>")
set(CMAKE_RC_CREATE_SHARED_LIBRARY
"<CMAKE_C_COMPILER> ${CMAKE_C_FLAGS} <CMAKE_SHARED_LIBRARY_C_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
endif()
set(CMAKE_EXE_LINKER_FLAGS "-nostdlib -Wl,--enable-auto-image-base,--disable-auto-import,--disable-stdcall-fixup")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} -Wl,--disable-stdcall-fixup")
if((NOT CMAKE_C_COMPILER_ID STREQUAL "Clang") AND (NOT CMAKE_BUILD_TYPE STREQUAL "Release"))
# FIXME: Set this once Clang toolchain works with it
set(_compress_debug_sections_flag "-Wa,--compress-debug-sections")
endif()
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_C_COMPILE_OBJECT "${CCACHE} <CMAKE_C_COMPILER> <DEFINES> ${_compress_debug_sections_flag} <FLAGS> -o <OBJECT> -c <SOURCE>")
# FIXME: Once the GCC toolchain bugs are fixed, add _compress_debug_sections_flag to CXX too
set(CMAKE_CXX_COMPILE_OBJECT "${CCACHE} <CMAKE_CXX_COMPILER> <DEFINES> <FLAGS> -o <OBJECT> -c <SOURCE>")
set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> ${_compress_debug_sections_flag} -x assembler-with-cpp -o <OBJECT> -I${REACTOS_SOURCE_DIR}/sdk/include/asm -I${REACTOS_BINARY_DIR}/sdk/include/asm <FLAGS> <DEFINES> -D__ASM__ -c <SOURCE>")
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <FLAGS> -DRC_INVOKED -D__WIN32__=1 -D__FLAT__=1 ${I18N_DEFS} <DEFINES> <SOURCE> <OBJECT>")
else()
set(CMAKE_C_COMPILE_OBJECT "${CCACHE} <CMAKE_C_COMPILER> <DEFINES> ${_compress_debug_sections_flag} <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>")
# FIXME: Once the GCC toolchain bugs are fixed, add _compress_debug_sections_flag to CXX too
set(CMAKE_CXX_COMPILE_OBJECT "${CCACHE} <CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>")
set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> ${_compress_debug_sections_flag} -x assembler-with-cpp -o <OBJECT> -I${REACTOS_SOURCE_DIR}/sdk/include/asm -I${REACTOS_BINARY_DIR}/sdk/include/asm <INCLUDES> <FLAGS> <DEFINES> -D__ASM__ -c <SOURCE>")
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <INCLUDES> <FLAGS> -DRC_INVOKED -D__WIN32__=1 -D__FLAT__=1 ${I18N_DEFS} <DEFINES> <SOURCE> <OBJECT>")
endif()
set(CMAKE_DEPFILE_FLAGS_RC "--preprocessor \"${MINGW_TOOLCHAIN_PREFIX}gcc${MINGW_TOOLCHAIN_SUFFIX} -E -xc-header -MMD -MF <DEPFILE> -MT <OBJECT>\" ")
# Optional 3rd parameter: stdcall stack bytes
function(set_entrypoint MODULE ENTRYPOINT)
if(${ENTRYPOINT} STREQUAL "0")
add_target_link_flags(${MODULE} "-Wl,-entry,0")
elseif(ARCH STREQUAL "i386")
set(_entrysymbol _${ENTRYPOINT})
if(${ARGC} GREATER 2)
set(_entrysymbol ${_entrysymbol}@${ARGV2})
endif()
add_target_link_flags(${MODULE} "-Wl,-entry,${_entrysymbol}")
else()
add_target_link_flags(${MODULE} "-Wl,-entry,${ENTRYPOINT}")
endif()
endfunction()
function(set_subsystem MODULE SUBSYSTEM)
add_target_link_flags(${MODULE} "-Wl,--subsystem,${SUBSYSTEM}:5.01")
endfunction()
function(set_image_base MODULE IMAGE_BASE)
add_target_link_flags(${MODULE} "-Wl,--image-base,${IMAGE_BASE}")
endfunction()
function(set_module_type_toolchain MODULE TYPE)
if(CPP_USE_STL)
if((${TYPE} STREQUAL "kernelmodedriver") OR (${TYPE} STREQUAL "wdmdriver"))
message(FATAL_ERROR "Use of STL in kernelmodedriver or wdmdriver type module prohibited")
endif()
target_link_libraries(${MODULE} -lstdc++ -lsupc++ -lgcc -lmingwex)
elseif(CPP_USE_RT)
target_link_libraries(${MODULE} -lsupc++ -lgcc)
elseif(IS_CPP)
target_link_libraries(${MODULE} -lgcc)
endif()
if((${TYPE} STREQUAL "kernelmodedriver") OR (${TYPE} STREQUAL "wdmdriver"))
add_target_link_flags(${MODULE} "-Wl,--exclude-all-symbols,-file-alignment=0x1000,-section-alignment=0x1000")
if(${TYPE} STREQUAL "wdmdriver")
add_target_link_flags(${MODULE} "-Wl,--wdmdriver")
endif()
endif()
if(STACK_PROTECTOR)
target_link_libraries(${MODULE} gcc_ssp)
endif()
endfunction()
function(add_delay_importlibs _module)
get_target_property(_module_type ${_module} TYPE)
if(_module_type STREQUAL "STATIC_LIBRARY")
message(FATAL_ERROR "Cannot add delay imports to a static library")
endif()
foreach(_lib ${ARGN})
target_link_libraries(${_module} lib${_lib}_delayed)
endforeach()
target_link_libraries(${_module} delayimp)
endfunction()
if(NOT ARCH STREQUAL "i386")
set(DECO_OPTION "-@")
endif()
function(generate_import_lib _libname _dllname _spec_file)
# Generate the def for the import lib
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_libname}_implib.def
COMMAND native-spec2def -n=${_dllname} -a=${ARCH2} ${ARGN} --implib -d=${CMAKE_CURRENT_BINARY_DIR}/${_libname}_implib.def ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file} native-spec2def)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_libname}_implib.def PROPERTIES EXTERNAL_OBJECT TRUE)
# Create normal importlib
_add_library(${_libname} STATIC EXCLUDE_FROM_ALL ${CMAKE_CURRENT_BINARY_DIR}/${_libname}_implib.def)
set_target_properties(${_libname} PROPERTIES LINKER_LANGUAGE "IMPLIB" PREFIX "")
# Create delayed importlib
_add_library(${_libname}_delayed STATIC EXCLUDE_FROM_ALL ${CMAKE_CURRENT_BINARY_DIR}/${_libname}_implib.def)
set_target_properties(${_libname}_delayed PROPERTIES LINKER_LANGUAGE "IMPLIB_DELAYED" PREFIX "")
endfunction()
# Cute little hack to produce import libs
set(CMAKE_IMPLIB_CREATE_STATIC_LIBRARY "${CMAKE_DLLTOOL} --def <OBJECTS> --kill-at --output-lib=<TARGET>")
set(CMAKE_IMPLIB_DELAYED_CREATE_STATIC_LIBRARY "${CMAKE_DLLTOOL} --def <OBJECTS> --kill-at --output-delaylib=<TARGET>")
function(spec2def _dllname _spec_file)
cmake_parse_arguments(__spec2def "ADD_IMPORTLIB;NO_PRIVATE_WARNINGS;WITH_RELAY" "" "" ${ARGN})
# Get library basename
get_filename_component(_file ${_dllname} NAME_WE)
# Error out on anything else than spec
if(NOT ${_spec_file} MATCHES ".*\\.spec")
message(FATAL_ERROR "spec2def only takes spec files as input.")
endif()
if (__spec2def_WITH_RELAY)
set(__with_relay_arg "--with-tracing")
endif()
# Generate exports def and C stubs file for the DLL
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_file}.def ${CMAKE_CURRENT_BINARY_DIR}/${_file}_stubs.c
COMMAND native-spec2def -n=${_dllname} -a=${ARCH2} -d=${CMAKE_CURRENT_BINARY_DIR}/${_file}.def -s=${CMAKE_CURRENT_BINARY_DIR}/${_file}_stubs.c ${__with_relay_arg} ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file} native-spec2def)
if(__spec2def_ADD_IMPORTLIB)
set(_extraflags)
if(__spec2def_NO_PRIVATE_WARNINGS)
set(_extraflags --no-private-warnings)
endif()
generate_import_lib(lib${_file} ${_dllname} ${_spec_file} ${_extraflags})
endif()
endfunction()
macro(macro_mc FLAG FILE)
set(COMMAND_MC ${CMAKE_MC_COMPILER} -u ${FLAG} -b -h ${CMAKE_CURRENT_BINARY_DIR}/ -r ${CMAKE_CURRENT_BINARY_DIR}/ ${FILE})
endmacro()
# PSEH lib, needed with mingw
set(PSEH_LIB "pseh")
# Macros
if(PCH AND (NOT ENABLE_CCACHE) AND (NOT CMAKE_HOST_APPLE))
add_compile_flags("-Winvalid-pch -Werror=invalid-pch")
macro(add_pch _target _pch _sources)
# When including x.h GCC looks for x.h.gch first
set(_pch_final_name "${_target}_pch.h")
set(_gch ${CMAKE_CURRENT_BINARY_DIR}/${_pch_final_name}.gch)
if(IS_CPP)
set(_pch_language CXX)
else()
set(_pch_language C)
endif()
# Build the precompiled header
# HEADER_FILE_ONLY FALSE: force compiling the header
# EXTERNAL_SOURCE TRUE: don't use the .gch file when linking
set_source_files_properties(${_pch} PROPERTIES
HEADER_FILE_ONLY FALSE
LANGUAGE ${_pch_language}
EXTERNAL_SOURCE TRUE
OBJECT_LOCATION ${_gch})
# Include the gch in the specified source files, skipping the pch file itself
list(REMOVE_ITEM ${_sources} ${_pch})
foreach(_src ${${_sources}})
set_property(SOURCE ${_src} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_ccache_flag} -include ${CMAKE_CURRENT_BINARY_DIR}/${_pch_final_name}")
set_property(SOURCE ${_src} APPEND PROPERTY OBJECT_DEPENDS ${_gch})
endforeach()
endmacro()
else()
macro(add_pch _target _pch _sources)
endmacro()
endif()
function(CreateBootSectorTarget _target_name _asm_file _binary_file _base_address)
set(_object_file ${_binary_file}.o)
add_custom_command(
OUTPUT ${_object_file}
COMMAND ${CMAKE_ASM_COMPILER} -x assembler-with-cpp -o ${_object_file} -I${REACTOS_SOURCE_DIR}/sdk/include/asm -I${REACTOS_BINARY_DIR}/sdk/include/asm -I${REACTOS_SOURCE_DIR}/boot/freeldr -D__ASM__ -c ${_asm_file}
DEPENDS ${_asm_file})
add_custom_command(
OUTPUT ${_binary_file}
COMMAND native-obj2bin ${_object_file} ${_binary_file} ${_base_address}
# COMMAND objcopy --output-target binary --image-base 0x${_base_address} ${_object_file} ${_binary_file}
DEPENDS ${_object_file} native-obj2bin)
set_source_files_properties(${_object_file} ${_binary_file} PROPERTIES GENERATED TRUE)
add_custom_target(${_target_name} ALL DEPENDS ${_binary_file})
endfunction()
function(allow_warnings __module)
# We don't allow warnings in trunk, this needs to be reworked. See CORE-6959.
#add_target_compile_flags(${__module} "-Wno-error")
endfunction()
macro(add_asm_files _target)
list(APPEND ${_target} ${ARGN})
endmacro()

37
sdk/cmake/host-tools.cmake Normal file
View file

@ -0,0 +1,37 @@
if(CMAKE_HOST_WIN32)
set(native_suffix ".exe")
endif()
string(TOUPPER ${CMAKE_BUILD_TYPE} _build_type)
# List of host tools
list(APPEND host_tools_list bin2c hpp widl gendib cabman fatten isohybrid mkhive mkisofs obj2bin spec2def geninc mkshelllink utf16le xml2sdb)
if(NOT MSVC)
list(APPEND host_tools_list rsym)
endif()
foreach(_host_tool ${host_tools_list})
if(MSVC_IDE)
get_filename_component(_tool_location "${CMAKE_CURRENT_BINARY_DIR}/host-tools/${CMAKE_BUILD_TYPE}/${_host_tool}${native_suffix}" ABSOLUTE)
else()
get_filename_component(_tool_location "${CMAKE_CURRENT_BINARY_DIR}/host-tools/${_host_tool}${native_suffix}" ABSOLUTE)
endif()
list(APPEND tools_binaries ${_tool_location})
add_executable(native-${_host_tool} IMPORTED)
set_property(TARGET native-${_host_tool} PROPERTY IMPORTED_LOCATION_${_build_type} ${_tool_location})
add_dependencies(native-${_host_tool} host-tools)
endforeach()
include(ExternalProject)
ExternalProject_Add(host-tools
SOURCE_DIR ${REACTOS_SOURCE_DIR}
BINARY_DIR ${REACTOS_BINARY_DIR}/host-tools
STAMP_DIR ${REACTOS_BINARY_DIR}/host-tools/stamps
BUILD_ALWAYS 1
PREFIX host-tools
EXCLUDE_FROM_ALL 1
CMAKE_ARGS "-DNEW_STYLE_BUILD=1;-DARCH:STRING=${ARCH}"
INSTALL_COMMAND ""
BUILD_BYPRODUCTS ${tools_binaries})

287
sdk/cmake/localization.cmake Normal file
View file

@ -0,0 +1,287 @@
if(NOT DEFINED I18N_LANG)
set(I18N_LANG all)
endif()
function(set_i18n_language I18N_LANG)
if(I18N_LANG STREQUAL "af-ZA")
set(I18N_DEFS -DLANGUAGE_AF_ZA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-AE")
set(I18N_DEFS -DLANGUAGE_AR_AE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-BH")
set(I18N_DEFS -DLANGUAGE_AR_BH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-DZ")
set(I18N_DEFS -DLANGUAGE_AR_DZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-EG")
set(I18N_DEFS -DLANGUAGE_AR_EG PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-IQ")
set(I18N_DEFS -DLANGUAGE_AR_IQ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-JO")
set(I18N_DEFS -DLANGUAGE_AR_JO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-KW")
set(I18N_DEFS -DLANGUAGE_AR_KW PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-LB")
set(I18N_DEFS -DLANGUAGE_AR_LB PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-LY")
set(I18N_DEFS -DLANGUAGE_AR_LY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-MA")
set(I18N_DEFS -DLANGUAGE_AR_MA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-OM")
set(I18N_DEFS -DLANGUAGE_AR_OM PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-QA")
set(I18N_DEFS -DLANGUAGE_AR_QA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-SA")
set(I18N_DEFS -DLANGUAGE_AR_SA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-SY")
set(I18N_DEFS -DLANGUAGE_AR_SY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-TN")
set(I18N_DEFS -DLANGUAGE_AR_TN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ar-YE")
set(I18N_DEFS -DLANGUAGE_AR_YE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "az-AZ")
set(I18N_DEFS -DLANGUAGE_AZ_AZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "be-BY")
set(I18N_DEFS -DLANGUAGE_BE_BY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "bg-BG")
set(I18N_DEFS -DLANGUAGE_BG_BG PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "bn-BD")
set(I18N_DEFS -DLANGUAGE_BN_BD PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "bn-IN")
set(I18N_DEFS -DLANGUAGE_BN_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ca-ES")
set(I18N_DEFS -DLANGUAGE_CA_ES PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "cs-CZ")
set(I18N_DEFS -DLANGUAGE_CS_CZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "da-DK")
set(I18N_DEFS -DLANGUAGE_DA_DK PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "de-AT")
set(I18N_DEFS -DLANGUAGE_DE_AT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "de-CH")
set(I18N_DEFS -DLANGUAGE_DE_CH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "de-DE")
set(I18N_DEFS -DLANGUAGE_DE_DE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "de-LI")
set(I18N_DEFS -DLANGUAGE_DE_LI PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "de-LU")
set(I18N_DEFS -DLANGUAGE_DE_LU PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "dv-MV")
set(I18N_DEFS -DLANGUAGE_DV_MV PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "el-GR")
set(I18N_DEFS -DLANGUAGE_EL_GR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-AU")
set(I18N_DEFS -DLANGUAGE_EN_AU PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-BZ")
set(I18N_DEFS -DLANGUAGE_EN_BZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-CA")
set(I18N_DEFS -DLANGUAGE_EN_CA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-CB")
set(I18N_DEFS -DLANGUAGE_EN_CB PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-GB")
set(I18N_DEFS -DLANGUAGE_EN_GB PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-IE")
set(I18N_DEFS -DLANGUAGE_EN_IE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-JM")
set(I18N_DEFS -DLANGUAGE_EN_JM PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-NZ")
set(I18N_DEFS -DLANGUAGE_EN_NZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-PH")
set(I18N_DEFS -DLANGUAGE_EN_PH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-TT")
set(I18N_DEFS -DLANGUAGE_EN_TT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-US")
set(I18N_DEFS -DLANGUAGE_EN_US PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-ZA")
set(I18N_DEFS -DLANGUAGE_EN_ZA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "en-ZW")
set(I18N_DEFS -DLANGUAGE_EN_ZW PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "eo-AA")
set(I18N_DEFS -DLANGUAGE_EO_AA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-AR")
set(I18N_DEFS -DLANGUAGE_ES_AR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-BO")
set(I18N_DEFS -DLANGUAGE_ES_BO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-CL")
set(I18N_DEFS -DLANGUAGE_ES_CL PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-CO")
set(I18N_DEFS -DLANGUAGE_ES_CO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-CR")
set(I18N_DEFS -DLANGUAGE_ES_CR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-DO")
set(I18N_DEFS -DLANGUAGE_ES_DO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-EC")
set(I18N_DEFS -DLANGUAGE_ES_EC PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-ES")
set(I18N_DEFS -DLANGUAGE_ES_ES PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-GT")
set(I18N_DEFS -DLANGUAGE_ES_GT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-HN")
set(I18N_DEFS -DLANGUAGE_ES_HN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-MX")
set(I18N_DEFS -DLANGUAGE_ES_MX PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-NI")
set(I18N_DEFS -DLANGUAGE_ES_NI PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-PA")
set(I18N_DEFS -DLANGUAGE_ES_PA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-PE")
set(I18N_DEFS -DLANGUAGE_ES_PE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-PR")
set(I18N_DEFS -DLANGUAGE_ES_PR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-PY")
set(I18N_DEFS -DLANGUAGE_ES_PY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-SV")
set(I18N_DEFS -DLANGUAGE_ES_SV PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-UY")
set(I18N_DEFS -DLANGUAGE_ES_UY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "es-VE")
set(I18N_DEFS -DLANGUAGE_ES_VE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "et-EE")
set(I18N_DEFS -DLANGUAGE_ET_EE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "eu-ES")
set(I18N_DEFS -DLANGUAGE_EU_ES PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fa-IR")
set(I18N_DEFS -DLANGUAGE_FA_IR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fi-FI")
set(I18N_DEFS -DLANGUAGE_FI_FI PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fo-FO")
set(I18N_DEFS -DLANGUAGE_FO_FO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-BE")
set(I18N_DEFS -DLANGUAGE_FR_BE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-CA")
set(I18N_DEFS -DLANGUAGE_FR_CA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-CH")
set(I18N_DEFS -DLANGUAGE_FR_CH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-FR")
set(I18N_DEFS -DLANGUAGE_FR_FR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-LU")
set(I18N_DEFS -DLANGUAGE_FR_LU PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "fr-MC")
set(I18N_DEFS -DLANGUAGE_FR_MC PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "gl-ES")
set(I18N_DEFS -DLANGUAGE_GL_ES PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "gu-IN")
set(I18N_DEFS -DLANGUAGE_GU_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "he-IL")
set(I18N_DEFS -DLANGUAGE_HE_IL PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "hi-IN")
set(I18N_DEFS -DLANGUAGE_HI_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "hr-HR")
set(I18N_DEFS -DLANGUAGE_HR_HR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "hu-HU")
set(I18N_DEFS -DLANGUAGE_HU_HU PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "hy-AM")
set(I18N_DEFS -DLANGUAGE_HY_AM PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "id-ID")
set(I18N_DEFS -DLANGUAGE_ID_ID PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "is-IS")
set(I18N_DEFS -DLANGUAGE_IS_IS PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "it-CH")
set(I18N_DEFS -DLANGUAGE_IT_CH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "it-IT")
set(I18N_DEFS -DLANGUAGE_IT_IT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ja-JP")
set(I18N_DEFS -DLANGUAGE_JA_JP PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ka-GE")
set(I18N_DEFS -DLANGUAGE_KA_GE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "kk-KZ")
set(I18N_DEFS -DLANGUAGE_KK_KZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "kn-IN")
set(I18N_DEFS -DLANGUAGE_KN_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "kok-IN")
set(I18N_DEFS -DLANGUAGE_KOK_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ko-KR")
set(I18N_DEFS -DLANGUAGE_KO_KR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ky-KG")
set(I18N_DEFS -DLANGUAGE_KY_KG PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "lt-LT")
set(I18N_DEFS -DLANGUAGE_LT_LT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "lv-LV")
set(I18N_DEFS -DLANGUAGE_LV_LV PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "mk-MK")
set(I18N_DEFS -DLANGUAGE_MK_MK PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "mn-MN")
set(I18N_DEFS -DLANGUAGE_MN_MN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "mr-IN")
set(I18N_DEFS -DLANGUAGE_MR_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ms-BN")
set(I18N_DEFS -DLANGUAGE_MS_BN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ms-MY")
set(I18N_DEFS -DLANGUAGE_MS_MY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "my-MM")
set(I18N_DEFS -DLANGUAGE_MY_MM PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "nl-BE")
set(I18N_DEFS -DLANGUAGE_NL_BE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "nl-NL")
set(I18N_DEFS -DLANGUAGE_NL_NL PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "nn-NO")
set(I18N_DEFS -DLANGUAGE_NN_NO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "pa-IN")
set(I18N_DEFS -DLANGUAGE_PA_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "pl-PL")
set(I18N_DEFS -DLANGUAGE_PL_PL PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "pt-BR")
set(I18N_DEFS -DLANGUAGE_PT_BR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "pt-PT")
set(I18N_DEFS -DLANGUAGE_PT_PT PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "rm-CH")
set(I18N_DEFS -DLANGUAGE_RM_CH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ro-RO")
set(I18N_DEFS -DLANGUAGE_RO_RO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ru-RU")
set(I18N_DEFS -DLANGUAGE_RU_RU PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sa-IN")
set(I18N_DEFS -DLANGUAGE_SA_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sk-SK")
set(I18N_DEFS -DLANGUAGE_SK_SK PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sl-SI")
set(I18N_DEFS -DLANGUAGE_SL_SI PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sq-AL")
set(I18N_DEFS -DLANGUAGE_SQ_AL PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sr-SP")
set(I18N_DEFS -DLANGUAGE_SR_SP PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sv-FI")
set(I18N_DEFS -DLANGUAGE_SV_FI PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sv-SE")
set(I18N_DEFS -DLANGUAGE_SV_SE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "sw-KE")
set(I18N_DEFS -DLANGUAGE_SW_KE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "syr-SY")
set(I18N_DEFS -DLANGUAGE_SYR_SY PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ta-IN")
set(I18N_DEFS -DLANGUAGE_TA_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "te-IN")
set(I18N_DEFS -DLANGUAGE_TE_IN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "th-TH")
set(I18N_DEFS -DLANGUAGE_TH_TH PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "tr-TR")
set(I18N_DEFS -DLANGUAGE_TR_TR PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "tt-TA")
set(I18N_DEFS -DLANGUAGE_TT_TA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "uk-UA")
set(I18N_DEFS -DLANGUAGE_UK_UA PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "ur-PK")
set(I18N_DEFS -DLANGUAGE_UR_PK PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "uz-UZ")
set(I18N_DEFS -DLANGUAGE_UZ_UZ PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "vi-VN")
set(I18N_DEFS -DLANGUAGE_VI_VN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "wa-BE")
set(I18N_DEFS -DLANGUAGE_WA_BE PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "zh-CN")
set(I18N_DEFS -DLANGUAGE_ZH_CN PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "zh-HK")
set(I18N_DEFS -DLANGUAGE_ZH_HK PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "zh-MO")
set(I18N_DEFS -DLANGUAGE_ZH_MO PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "zh-SG")
set(I18N_DEFS -DLANGUAGE_ZH_SG PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "zh-TW")
set(I18N_DEFS -DLANGUAGE_ZH_TW PARENT_SCOPE)
elseif(I18N_LANG STREQUAL "all")
set(I18N_DEFS "-DLANGUAGE_AF_ZA -DLANGUAGE_AR_AE -DLANGUAGE_AR_BH -DLANGUAGE_AR_DZ -DLANGUAGE_AR_EG -DLANGUAGE_AR_IQ -DLANGUAGE_AR_JO -DLANGUAGE_AR_KW -DLANGUAGE_AR_LB -DLANGUAGE_AR_LY -DLANGUAGE_AR_MA -DLANGUAGE_AR_OM -DLANGUAGE_AR_QA -DLANGUAGE_AR_SA -DLANGUAGE_AR_SY -DLANGUAGE_AR_TN -DLANGUAGE_AR_YE -DLANGUAGE_AZ_AZ -DLANGUAGE_BE_BY -DLANGUAGE_BG_BG -DLANGUAGE_BN_BD -DLANGUAGE_BN_IN -DLANGUAGE_CA_ES -DLANGUAGE_CS_CZ -DLANGUAGE_DA_DK -DLANGUAGE_DE_AT -DLANGUAGE_DE_CH -DLANGUAGE_DE_DE -DLANGUAGE_DE_LI -DLANGUAGE_DE_LU -DLANGUAGE_DV_MV -DLANGUAGE_EL_GR -DLANGUAGE_EN_AU -DLANGUAGE_EN_BZ -DLANGUAGE_EN_CA -DLANGUAGE_EN_CB -DLANGUAGE_EN_GB -DLANGUAGE_EN_IE -DLANGUAGE_EN_JM -DLANGUAGE_EN_NZ -DLANGUAGE_EN_PH -DLANGUAGE_EN_TT -DLANGUAGE_EN_US -DLANGUAGE_EN_ZA -DLANGUAGE_EN_ZW -DLANGUAGE_EO_AA -DLANGUAGE_ES_AR -DLANGUAGE_ES_BO -DLANGUAGE_ES_CL -DLANGUAGE_ES_CO -DLANGUAGE_ES_CR -DLANGUAGE_ES_DO -DLANGUAGE_ES_EC -DLANGUAGE_ES_ES -DLANGUAGE_ES_GT -DLANGUAGE_ES_HN -DLANGUAGE_ES_MX -DLANGUAGE_ES_NI -DLANGUAGE_ES_PA -DLANGUAGE_ES_PE -DLANGUAGE_ES_PR -DLANGUAGE_ES_PY -DLANGUAGE_ES_SV -DLANGUAGE_ES_UY -DLANGUAGE_ES_VE -DLANGUAGE_ET_EE -DLANGUAGE_EU_ES -DLANGUAGE_FA_IR -DLANGUAGE_FI_FI -DLANGUAGE_FO_FO -DLANGUAGE_FR_BE -DLANGUAGE_FR_CA -DLANGUAGE_FR_CH -DLANGUAGE_FR_FR -DLANGUAGE_FR_LU -DLANGUAGE_FR_MC -DLANGUAGE_GL_ES -DLANGUAGE_GU_IN -DLANGUAGE_HE_IL -DLANGUAGE_HI_IN -DLANGUAGE_HR_HR -DLANGUAGE_HU_HU -DLANGUAGE_HY_AM -DLANGUAGE_ID_ID -DLANGUAGE_IS_IS -DLANGUAGE_IT_CH -DLANGUAGE_IT_IT -DLANGUAGE_JA_JP -DLANGUAGE_KA_GE -DLANGUAGE_KK_KZ -DLANGUAGE_KN_IN -DLANGUAGE_KOK_IN -DLANGUAGE_KO_KR -DLANGUAGE_KY_KG -DLANGUAGE_LT_LT -DLANGUAGE_LV_LV -DLANGUAGE_MK_MK -DLANGUAGE_MN_MN -DLANGUAGE_MR_IN -DLANGUAGE_MS_BN -DLANGUAGE_MS_MY -DLANGUAGE_MY_MM -DLANGUAGE_NL_BE -DLANGUAGE_NL_NL -DLANGUAGE_NN_NO -DLANGUAGE_PA_IN -DLANGUAGE_PL_PL -DLANGUAGE_PT_BR -DLANGUAGE_PT_PT -DLANGUAGE_RM_CH -DLANGUAGE_RO_RO -DLANGUAGE_RU_RU -DLANGUAGE_SA_IN -DLANGUAGE_SK_SK -DLANGUAGE_SL_SI -DLANGUAGE_SQ_AL -DLANGUAGE_SR_SP -DLANGUAGE_SV_FI -DLANGUAGE_SV_SE -DLANGUAGE_SW_KE -DLANGUAGE_SYR_SY -DLANGUAGE_TA_IN -DLANGUAGE_TE_IN -DLANGUAGE_TH_TH -DLANGUAGE_TR_TR -DLANGUAGE_TT_TA -DLANGUAGE_UK_UA -DLANGUAGE_UR_PK -DLANGUAGE_UZ_UZ -DLANGUAGE_VI_VN -DLANGUAGE_WA_BE -DLANGUAGE_ZH_CN -DLANGUAGE_ZH_HK -DLANGUAGE_ZH_MO -DLANGUAGE_ZH_SG -DLANGUAGE_ZH_TW" PARENT_SCOPE)
else()
message(SEND_ERROR "${I18N_LANG} doesn't exist in our list. Please select a correct localization.")
endif()
message("-- Selected localization: ${I18N_LANG}")
endfunction()

113
sdk/cmake/midl-support.cmake Normal file
View file

@ -0,0 +1,113 @@
#idl files support
if(ARCH STREQUAL "i386")
set(IDL_FLAGS /nologo /win32 /no_def_idir)
elseif(ARCH STREQUAL "amd64")
set(IDL_FLAGS /nologo /amd64 /no_def_idir)
else()
set(IDL_FLAGS /nologo /no_def_idir)
endif()
function(add_typelib)
get_includes(_includes)
get_defines(_defines)
foreach(_idl_file ${ARGN})
get_filename_component(_name_we ${_idl_file} NAME_WE)
add_custom_command(
OUTPUT ${_name_we}.tlb
COMMAND midl ${_includes} ${_defines} ${IDL_FLAGS} /tlb ${_name_we}.tlb ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file})
endforeach()
endfunction()
function(add_idl_headers TARGET)
get_includes(_includes)
get_defines(_defines)
foreach(_idl_file ${ARGN})
get_filename_component(_name_we ${_idl_file} NAME_WE)
add_custom_command(
OUTPUT ${_name_we}.h
COMMAND midl ${_includes} ${_defines} ${IDL_FLAGS} /h ${_name_we}.h /client none /server none /iid ${_name_we}_dummy_i.c ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file})
list(APPEND _target_dependencies ${_name_we}.h)
endforeach()
add_custom_target(${TARGET} DEPENDS ${_target_dependencies})
endfunction()
function(add_rpcproxy_files)
get_includes(_includes)
get_defines(_defines)
set(_chain_dependency "")
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/proxy.dlldata.c PROPERTIES GENERATED TRUE)
foreach(_idl_file ${ARGN})
get_filename_component(_name_we ${_idl_file} NAME_WE)
add_custom_command(
OUTPUT ${_name_we}_p.c ${_name_we}_p.h
COMMAND midl ${_includes} ${_defines} ${IDL_FLAGS} /client none /server none /proxy ${_name_we}_p.c /h ${_name_we}_p.h /dlldata proxy.dlldata.c ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file} ${_chain_dependency})
list(APPEND _chain_dependency ${CMAKE_CURRENT_BINARY_DIR}/${_name_we}_p.c)
list(APPEND _chain_dependency ${CMAKE_CURRENT_BINARY_DIR}/${_name_we}_p.h)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/proxy.dlldata.c PROPERTIES OBJECT_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file})
endforeach()
endfunction()
function(add_rpc_files _type)
get_includes(_includes)
get_defines(_defines)
# Is it a client or server module?
if(_type STREQUAL "server")
set(_server_client /sstub)
set(_suffix _s)
set(_prevent_second_type /client none)
elseif(_type STREQUAL "client")
set(_server_client /cstub)
set(_suffix _c)
set(_prevent_second_type /server none)
else()
message(FATAL_ERROR "Please pass either server or client as argument to add_rpc_files")
endif()
foreach(_idl_file ${ARGN})
if(NOT IS_ABSOLUTE ${_idl_file})
set(_idl_file ${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file})
endif()
get_filename_component(_name_we ${_idl_file} NAME_WE)
set(_name_we ${_name_we}${_suffix})
add_custom_command(
OUTPUT ${_name_we}.c ${_name_we}.h
COMMAND midl ${_includes} ${_defines} ${IDL_FLAGS} /h ${_name_we}.h ${_server_client} ${_name_we}.c ${_prevent_second_type} ${_idl_file}
DEPENDS ${_idl_file})
endforeach()
endfunction()
function(generate_idl_iids)
foreach(_idl_file ${ARGN})
get_includes(_includes)
get_defines(_defines)
if(NOT IS_ABSOLUTE ${_idl_file})
set(_idl_file "${CMAKE_CURRENT_SOURCE_DIR}/${_idl_file}")
endif()
get_filename_component(_name_we ${_idl_file} NAME_WE)
add_custom_command(
OUTPUT ${_name_we}_i.c ${_name_we}_i.h
COMMAND midl ${_includes} ${_defines} ${IDL_FLAGS} /h ${_name_we}_i.h /client none /server none /iid ${_name_we}_i.c /proxy ${_name_we}_dummy_p.c ${_idl_file}
DEPENDS ${_idl_file})
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${_name_we}_i.c PROPERTIES GENERATED TRUE)
endforeach()
endfunction()
function(add_iid_library _target)
foreach(_idl_file ${ARGN})
generate_idl_iids(${_idl_file})
get_filename_component(_name_we ${_idl_file} NAME_WE)
list(APPEND _iid_sources ${CMAKE_CURRENT_BINARY_DIR}/${_name_we}_i.c)
endforeach()
add_library(${_target} ${_iid_sources})
# for wtypes.h
add_dependencies(${_target} psdk)
set_target_properties(${_target} PROPERTIES EXCLUDE_FROM_ALL TRUE)
endfunction()

483
sdk/cmake/msvc.cmake Normal file
View file

@ -0,0 +1,483 @@
#if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
# no optimization
add_compile_flags("/Ob0 /Od")
elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
add_compile_flags("/Ox /Ob2 /Ot /Oy /GT /GF")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /OPT:REF /OPT:ICF")
elseif(OPTIMIZE STREQUAL "1")
add_definitions(/O1)
elseif(OPTIMIZE STREQUAL "2")
add_definitions(/O2)
elseif(OPTIMIZE STREQUAL "3")
add_definitions(/Ot /Ox /GS-)
elseif(OPTIMIZE STREQUAL "4")
add_definitions(/Os /Ox /GS-)
elseif(OPTIMIZE STREQUAL "5")
add_definitions(/GF /Gy /Ob2 /Os /Ox /GS-)
endif()
# Enable function level linking and comdat folding
add_compile_flags("/Gy")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /OPT:REF /OPT:ICF")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /OPT:REF /OPT:ICF")
if(ARCH STREQUAL "i386")
add_definitions(/DWIN32 /D_WINDOWS)
endif()
add_definitions(/Dinline=__inline /D__STDC__=1)
add_compile_flags("/X /GR- /EHs-c- /GS- /Zl /W3")
# HACK: for VS 11+ we need to explicitly disable SSE, which is off by
# default for older compilers. See CORE-6507
if(MSVC_VERSION GREATER 1699 AND ARCH STREQUAL "i386")
add_compile_flags("/arch:IA32")
endif ()
# VS 12+ requires /FS when used in parallel compilations
if(MSVC_VERSION GREATER 1799 AND NOT MSVC_IDE)
add_compile_flags("/FS")
endif ()
# VS14+ tries to use thread-safe initialization
if(MSVC_VERSION GREATER 1899)
add_compile_flags("/Zc:threadSafeInit-")
endif ()
# Disable overly sensitive warnings as well as those that generally aren't
# useful to us.
# - C4244: implicit integer truncation
# - C4290: C++ exception specification ignored
# - C4800: forcing value to bool 'true' or 'false' (performance warning)
# - C4200: nonstandard extension used : zero-sized array in struct/union
# - C4214: nonstandard extension used : bit field types other than int
add_compile_flags("/wd4244 /wd4290 /wd4800 /wd4200 /wd4214")
# FIXME: Temporarily disable C4018 until we fix more of the others. CORE-10113
add_compile_flags("/wd4018")
# The following warnings are treated as errors:
# - C4013: implicit function declaration
# - C4020: too many actual parameters
# - C4022: pointer type mismatch for parameter
# - TODO: C4028: formal parameter different from declaration
# - C4047: different level of indirection
# - TODO: C4090: different 'modifier' qualifiers (for C programs only;
# for C++ programs, the compiler error C2440 is issued)
# - C4098: void function returning a value
# - C4113: parameter lists differ
# - C4129: unrecognized escape sequence
# - TODO: C4133: incompatible types
# - C4163: 'identifier': not available as an intrinsic function
# - C4229: modifiers on data are ignored
# - C4700: uninitialized variable usage
# - C4603: macro is not defined or definition is different after precompiled header use
# - C4716: function must return a value
add_compile_flags("/we4013 /we4020 /we4022 /we4047 /we4098 /we4113 /we4129 /we4163 /we4229 /we4700 /we4603 /we4716")
# - C4189: local variable initialized but not referenced
# Not in Release mode and not with MSVC 2010
if((NOT CMAKE_BUILD_TYPE STREQUAL "Release") AND (NOT MSVC_VERSION LESS 1700))
add_compile_flags("/we4189")
endif()
# Enable warnings above the default level, but don't treat them as errors:
# - C4115: named type definition in parentheses
add_compile_flags("/w14115")
# Debugging
#if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
if(NOT (_PREFAST_ OR _VS_ANALYZE_))
add_compile_flags("/Zi")
endif()
#elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
add_definitions("/D NDEBUG")
endif()
# Hotpatchable images
if(ARCH STREQUAL "i386")
add_compile_flags("/hotpatch")
set(_hotpatch_link_flag "/FUNCTIONPADMIN:5")
elseif(ARCH STREQUAL "amd64")
set(_hotpatch_link_flag "/FUNCTIONPADMIN:6")
endif()
if(MSVC_IDE AND (NOT DEFINED USE_FOLDER_STRUCTURE))
set(USE_FOLDER_STRUCTURE TRUE)
endif()
if(NOT DEFINED RUNTIME_CHECKS)
set(RUNTIME_CHECKS FALSE)
endif()
if(RUNTIME_CHECKS)
add_definitions(-D__RUNTIME_CHECKS__)
add_compile_flags("/RTC1")
endif()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO /INCREMENTAL:NO /SAFESEH:NO /NODEFAULTLIB /RELEASE ${_hotpatch_link_flag}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO /INCREMENTAL:NO /SAFESEH:NO /NODEFAULTLIB /RELEASE /IGNORE:4104 ${_hotpatch_link_flag}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO /INCREMENTAL:NO /SAFESEH:NO /NODEFAULTLIB /RELEASE ${_hotpatch_link_flag}")
if(CMAKE_DISABLE_NINJA_DEPSLOG)
set(cl_includes_flag "")
else()
set(cl_includes_flag "/showIncludes")
endif()
if(MSVC_IDE AND (CMAKE_VERSION MATCHES "ReactOS"))
# For VS builds we'll only have en-US in resource files
add_definitions(/DLANGUAGE_EN_US)
else()
# Only VS 10+ resource compiler supports /nologo
if(MSVC_VERSION GREATER 1599)
set(rc_nologo_flag "/nologo")
else()
set(rc_nologo_flag)
endif()
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> ${rc_nologo_flag} <FLAGS> <DEFINES> ${I18N_DEFS} /fo<OBJECT> <SOURCE>")
if(ARCH STREQUAL "arm")
set(CMAKE_ASM_COMPILE_OBJECT
"cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
"<CMAKE_ASM_COMPILER> -nologo -o <OBJECT> <OBJECT>.tmp")
else()
set(CMAKE_ASM_COMPILE_OBJECT
"cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
"<CMAKE_ASM_COMPILER> /nologo /Cp /Fo<OBJECT> /c /Ta <OBJECT>.tmp")
endif()
else()
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> ${rc_nologo_flag} <INCLUDES> <FLAGS> <DEFINES> ${I18N_DEFS} /fo<OBJECT> <SOURCE>")
if(ARCH STREQUAL "arm")
set(CMAKE_ASM_COMPILE_OBJECT
"cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm <INCLUDES> <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
"<CMAKE_ASM_COMPILER> -nologo -o <OBJECT> <OBJECT>.tmp")
else()
set(CMAKE_ASM_COMPILE_OBJECT
"cl ${cl_includes_flag} /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm <INCLUDES> <FLAGS> <DEFINES> /D__ASM__ /D_USE_ML /EP /c <SOURCE> > <OBJECT>.tmp"
"<CMAKE_ASM_COMPILER> /nologo /Cp /Fo<OBJECT> /c /Ta <OBJECT>.tmp")
endif()
endif()
endif()
if(_VS_ANALYZE_)
message("VS static analysis enabled!")
add_compile_flags("/analyze")
elseif(_PREFAST_)
message("PREFAST enabled!")
if(CMAKE_VERSION VERSION_LESS 3.4.0)
set(CMAKE_C_COMPILE_OBJECT "prefast <CMAKE_C_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <FLAGS> <DEFINES> /Fo<OBJECT> -c <SOURCE>${CMAKE_END_TEMP_FILE}"
"prefast LIST")
set(CMAKE_CXX_COMPILE_OBJECT "prefast <CMAKE_CXX_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <FLAGS> <DEFINES> /TP /Fo<OBJECT> -c <SOURCE>${CMAKE_END_TEMP_FILE}"
"prefast LIST")
set(CMAKE_C_LINK_EXECUTABLE
"<CMAKE_C_COMPILER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} <FLAGS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
set(CMAKE_CXX_LINK_EXECUTABLE
"<CMAKE_CXX_COMPILER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} <FLAGS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
else()
set(CMAKE_C_COMPILE_OBJECT "prefast <CMAKE_C_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <INCLUDES> <FLAGS> <DEFINES> /Fo<OBJECT> -c <SOURCE>${CMAKE_END_TEMP_FILE}"
"prefast LIST")
set(CMAKE_CXX_COMPILE_OBJECT "prefast <CMAKE_CXX_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <INCLUDES> <FLAGS> <DEFINES> /TP /Fo<OBJECT> -c <SOURCE>${CMAKE_END_TEMP_FILE}"
"prefast LIST")
set(CMAKE_C_LINK_EXECUTABLE
"<CMAKE_C_COMPILER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} <INCLUDES> <FLAGS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
set(CMAKE_CXX_LINK_EXECUTABLE
"<CMAKE_CXX_COMPILER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} <INCLUDES> <FLAGS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
endif()
endif()
set(CMAKE_RC_CREATE_SHARED_LIBRARY ${CMAKE_C_CREATE_SHARED_LIBRARY})
set(CMAKE_ASM_CREATE_SHARED_LIBRARY ${CMAKE_C_CREATE_SHARED_LIBRARY})
set(CMAKE_ASM_CREATE_STATIC_LIBRARY ${CMAKE_C_CREATE_STATIC_LIBRARY})
if(PCH)
macro(add_pch _target _pch _sources)
# Workaround for the MSVC toolchain (MSBUILD) /MP bug
set(_temp_gch ${CMAKE_CURRENT_BINARY_DIR}/${_target}.pch)
if(MSVC_IDE)
file(TO_NATIVE_PATH ${_temp_gch} _gch)
else()
set(_gch ${_temp_gch})
endif()
if(IS_CPP)
set(_pch_language CXX)
set(_cl_lang_flag "/TP")
else()
set(_pch_language C)
set(_cl_lang_flag "/TC")
endif()
if(MSVC_IDE)
set(_pch_path_name_flag "/Fp${_gch}")
endif()
# Build the precompiled header
# HEADER_FILE_ONLY FALSE: force compiling the header
set_source_files_properties(${_pch} PROPERTIES
HEADER_FILE_ONLY FALSE
LANGUAGE ${_pch_language}
COMPILE_FLAGS "${_cl_lang_flag} /Yc /Fp${_gch}"
OBJECT_OUTPUTS ${_gch})
# Prevent a race condition related to writing to the PDB files between the PCH and the excluded list of source files
get_target_property(_target_sources ${_target} SOURCES)
list(REMOVE_ITEM _target_sources ${_pch})
foreach(_target_src ${_target_sources})
set_property(SOURCE ${_target_src} APPEND PROPERTY OBJECT_DEPENDS ${_gch})
endforeach()
# Use the precompiled header with the specified source files, skipping the pch itself
list(REMOVE_ITEM ${_sources} ${_pch})
foreach(_src ${${_sources}})
set_property(SOURCE ${_src} APPEND_STRING PROPERTY COMPILE_FLAGS " /FI${_gch} /Yu${_gch} ${_pch_path_name_flag}")
endforeach()
endmacro()
else()
macro(add_pch _target _pch _sources)
endmacro()
endif()
function(set_entrypoint _module _entrypoint)
if(${_entrypoint} STREQUAL "0")
add_target_link_flags(${_module} "/NOENTRY")
elseif(ARCH STREQUAL "i386")
set(_entrysymbol ${_entrypoint})
if(${ARGC} GREATER 2)
set(_entrysymbol ${_entrysymbol}@${ARGV2})
endif()
add_target_link_flags(${_module} "/ENTRY:${_entrysymbol}")
else()
add_target_link_flags(${_module} "/ENTRY:${_entrypoint}")
endif()
endfunction()
function(set_subsystem MODULE SUBSYSTEM)
string(TOUPPER ${SUBSYSTEM} _subsystem)
if(ARCH STREQUAL "amd64")
add_target_link_flags(${MODULE} "/SUBSYSTEM:${_subsystem},5.02")
elseif(ARCH STREQUAL "arm")
add_target_link_flags(${MODULE} "/SUBSYSTEM:${_subsystem},6.02")
else()
add_target_link_flags(${MODULE} "/SUBSYSTEM:${_subsystem},5.01")
endif()
endfunction()
function(set_image_base MODULE IMAGE_BASE)
add_target_link_flags(${MODULE} "/BASE:${IMAGE_BASE}")
endfunction()
function(set_module_type_toolchain MODULE TYPE)
if(CPP_USE_STL)
if((${TYPE} STREQUAL "kernelmodedriver") OR (${TYPE} STREQUAL "wdmdriver"))
message(FATAL_ERROR "Use of STL in kernelmodedriver or wdmdriver type module prohibited")
endif()
target_link_libraries(${MODULE} cpprt stlport oldnames)
elseif(CPP_USE_RT)
target_link_libraries(${MODULE} cpprt)
endif()
if((${TYPE} STREQUAL "win32dll") OR (${TYPE} STREQUAL "win32ocx") OR (${TYPE} STREQUAL "cpl"))
add_target_link_flags(${MODULE} "/DLL")
elseif(${TYPE} STREQUAL "kernelmodedriver")
# Disable linker warning 4078 (multiple sections found with different attributes) for INIT section use
add_target_link_flags(${MODULE} "/DRIVER /IGNORE:4078")
elseif(${TYPE} STREQUAL "wdmdriver")
add_target_link_flags(${MODULE} "/DRIVER:WDM /IGNORE:4078")
endif()
if(RUNTIME_CHECKS)
target_link_libraries(${MODULE} runtmchk)
endif()
endfunction()
# Define those for having real libraries
set(CMAKE_IMPLIB_CREATE_STATIC_LIBRARY "LINK /LIB /NOLOGO <LINK_FLAGS> /OUT:<TARGET> <OBJECTS>")
if(ARCH STREQUAL "arm")
set(CMAKE_STUB_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> -nologo -o <OBJECT> <SOURCE>")
else()
set(CMAKE_STUB_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> /nologo /Cp /Fo<OBJECT> /c /Ta <SOURCE>")
endif()
function(add_delay_importlibs _module)
get_target_property(_module_type ${_module} TYPE)
if(_module_type STREQUAL "STATIC_LIBRARY")
message(FATAL_ERROR "Cannot add delay imports to a static library")
endif()
foreach(_lib ${ARGN})
add_target_link_flags(${_module} "/DELAYLOAD:${_lib}.dll")
target_link_libraries(${_module} lib${_lib})
endforeach()
target_link_libraries(${_module} delayimp)
endfunction()
function(generate_import_lib _libname _dllname _spec_file)
set(_def_file ${CMAKE_CURRENT_BINARY_DIR}/${_libname}_exp.def)
set(_asm_stubs_file ${CMAKE_CURRENT_BINARY_DIR}/${_libname}_stubs.asm)
# Generate the asm stub file and the def file for import library
add_custom_command(
OUTPUT ${_asm_stubs_file} ${_def_file}
COMMAND native-spec2def --ms -a=${SPEC2DEF_ARCH} --implib -n=${_dllname} -d=${_def_file} -l=${_asm_stubs_file} ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file} native-spec2def)
if(MSVC_IDE)
# Compile the generated asm stub file
if(ARCH STREQUAL "arm")
set(_asm_stub_command ${CMAKE_ASM_COMPILER} -nologo -o ${_asm_stubs_file}.obj ${_asm_stubs_file})
else()
set(_asm_stub_command ${CMAKE_ASM_COMPILER} /Cp /Fo${_asm_stubs_file}.obj /c /Ta ${_asm_stubs_file})
endif()
add_custom_command(
OUTPUT ${_asm_stubs_file}.obj
COMMAND ${_asm_stub_command}
DEPENDS ${_asm_stubs_file})
else()
# Be clear about the "language"
# Thanks MS for creating a stupid linker
set_source_files_properties(${_asm_stubs_file} PROPERTIES LANGUAGE "STUB_ASM")
endif()
# Add our library
if(MSVC_IDE)
add_library(${_libname} STATIC EXCLUDE_FROM_ALL ${_asm_stubs_file}.obj)
set_source_files_properties(${_asm_stubs_file}.obj PROPERTIES EXTERNAL_OBJECT 1)
set_target_properties(${_libname} PROPERTIES LINKER_LANGUAGE "C")
else()
# NOTE: as stub file and def file are generated in one pass, depending on one is like depending on the other
add_library(${_libname} STATIC EXCLUDE_FROM_ALL ${_asm_stubs_file})
# set correct "link rule"
set_target_properties(${_libname} PROPERTIES LINKER_LANGUAGE "IMPLIB")
endif()
set_target_properties(${_libname} PROPERTIES STATIC_LIBRARY_FLAGS "/DEF:${_def_file}")
endfunction()
if(ARCH STREQUAL "amd64")
# This is NOT a typo.
# See https://software.intel.com/en-us/forums/topic/404643
add_definitions(/D__x86_64)
set(SPEC2DEF_ARCH x86_64)
elseif(ARCH STREQUAL "arm")
add_definitions(/D__arm__)
set(SPEC2DEF_ARCH arm)
else()
set(SPEC2DEF_ARCH i386)
endif()
function(spec2def _dllname _spec_file)
cmake_parse_arguments(__spec2def "ADD_IMPORTLIB;NO_PRIVATE_WARNINGS" "" "" ${ARGN})
# Get library basename
get_filename_component(_file ${_dllname} NAME_WE)
# Error out on anything else than spec
if(NOT ${_spec_file} MATCHES ".*\\.spec")
message(FATAL_ERROR "spec2def only takes spec files as input.")
endif()
# Generate exports def and C stubs file for the DLL
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_file}.def ${CMAKE_CURRENT_BINARY_DIR}/${_file}_stubs.c
COMMAND native-spec2def --ms -a=${SPEC2DEF_ARCH} -n=${_dllname} -d=${CMAKE_CURRENT_BINARY_DIR}/${_file}.def -s=${CMAKE_CURRENT_BINARY_DIR}/${_file}_stubs.c ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_spec_file} native-spec2def)
if(__spec2def_ADD_IMPORTLIB)
generate_import_lib(lib${_file} ${_dllname} ${_spec_file})
if(__spec2def_NO_PRIVATE_WARNINGS)
add_target_property(lib${_file} STATIC_LIBRARY_FLAGS "/ignore:4104")
endif()
endif()
endfunction()
macro(macro_mc FLAG FILE)
set(COMMAND_MC ${CMAKE_MC_COMPILER} -u ${FLAG} -b -h ${CMAKE_CURRENT_BINARY_DIR}/ -r ${CMAKE_CURRENT_BINARY_DIR}/ ${FILE})
endmacro()
# PSEH workaround
set(PSEH_LIB "pseh")
# Use a full path for the x86 version of ml when using x64 VS.
# It's not a problem when using the DDK/WDK because, in x64 mode,
# both the x86 and x64 versions of ml are available.
if((ARCH STREQUAL "amd64") AND (DEFINED ENV{VCINSTALLDIR}))
set(CMAKE_ASM16_COMPILER $ENV{VCINSTALLDIR}/bin/ml.exe)
elseif(ARCH STREQUAL "arm")
set(CMAKE_ASM16_COMPILER armasm.exe)
else()
set(CMAKE_ASM16_COMPILER ml.exe)
endif()
function(CreateBootSectorTarget _target_name _asm_file _binary_file _base_address)
set(_object_file ${_binary_file}.obj)
set(_temp_file ${_binary_file}.tmp)
add_custom_command(
OUTPUT ${_temp_file}
COMMAND ${CMAKE_C_COMPILER} /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm /I${REACTOS_SOURCE_DIR}/boot/freeldr /D__ASM__ /D_USE_ML /EP /c ${_asm_file} > ${_temp_file}
DEPENDS ${_asm_file})
if(ARCH STREQUAL "arm")
set(_asm16_command ${CMAKE_ASM16_COMPILER} -nologo -o ${_object_file} ${_temp_file})
else()
set(_asm16_command ${CMAKE_ASM16_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_temp_file})
endif()
add_custom_command(
OUTPUT ${_object_file}
COMMAND ${_asm16_command}
DEPENDS ${_temp_file})
add_custom_command(
OUTPUT ${_binary_file}
COMMAND native-obj2bin ${_object_file} ${_binary_file} ${_base_address}
DEPENDS ${_object_file} native-obj2bin)
set_source_files_properties(${_object_file} ${_temp_file} ${_binary_file} PROPERTIES GENERATED TRUE)
add_custom_target(${_target_name} ALL DEPENDS ${_binary_file})
endfunction()
function(allow_warnings __module)
endfunction()
macro(add_asm_files _target)
if(MSVC_IDE AND (CMAKE_VERSION MATCHES "ReactOS"))
get_defines(_directory_defines)
get_includes(_directory_includes)
get_directory_property(_defines COMPILE_DEFINITIONS)
foreach(_source_file ${ARGN})
get_filename_component(_source_file_base_name ${_source_file} NAME_WE)
get_filename_component(_source_file_full_path ${_source_file} ABSOLUTE)
set(_preprocessed_asm_file ${CMAKE_CURRENT_BINARY_DIR}/asm/${_source_file_base_name}_${_target}.tmp)
set(_object_file ${CMAKE_CURRENT_BINARY_DIR}/asm/${_source_file_base_name}_${_target}.obj)
get_source_file_property(_defines_semicolon_list ${_source_file_full_path} COMPILE_DEFINITIONS)
unset(_source_file_defines)
foreach(_define ${_defines_semicolon_list})
if(NOT ${_define} STREQUAL "NOTFOUND")
list(APPEND _source_file_defines -D${_define})
endif()
endforeach()
if(ARCH STREQUAL "arm")
set(_pp_asm_compile_command ${CMAKE_ASM_COMPILER} -nologo -o ${_object_file} ${_preprocessed_asm_file})
else()
set(_pp_asm_compile_command ${CMAKE_ASM_COMPILER} /nologo /Cp /Fo${_object_file} /c /Ta ${_preprocessed_asm_file})
endif()
add_custom_command(
OUTPUT ${_preprocessed_asm_file} ${_object_file}
COMMAND cl /nologo /X /I${REACTOS_SOURCE_DIR}/sdk/include/asm /I${REACTOS_BINARY_DIR}/sdk/include/asm ${_directory_includes} ${_source_file_defines} ${_directory_defines} /D__ASM__ /D_USE_ML /EP /c ${_source_file_full_path} > ${_preprocessed_asm_file} && ${_pp_asm_compile_command}
DEPENDS ${_source_file_full_path})
set_source_files_properties(${_object_file} PROPERTIES EXTERNAL_OBJECT 1)
list(APPEND ${_target} ${_object_file})
endforeach()
else()
list(APPEND ${_target} ${ARGN})
endif()
endmacro()

134
sdk/cmake/widl-support.cmake Normal file
View file

@ -0,0 +1,134 @@
#idl files support
if(ARCH STREQUAL "i386")
set(IDL_FLAGS -m32 --win32)
elseif(ARCH STREQUAL "amd64")
set(IDL_FLAGS -m64 --win64)
else()
set(IDL_FLAGS "")
endif()
function(add_typelib)
get_includes(INCLUDES)
get_defines(DEFINES)
foreach(FILE ${ARGN})
if(${FILE} STREQUAL "std_ole_v1.idl")
set(IDL_FLAGS ${IDL_FLAGS} --oldtlb)
endif()
get_filename_component(NAME ${FILE} NAME_WE)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.tlb
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -t -o ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.tlb ${CMAKE_CURRENT_SOURCE_DIR}/${FILE}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${FILE} native-widl)
list(APPEND OBJECTS ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.tlb)
endforeach()
endfunction()
function(add_idl_headers TARGET)
get_includes(INCLUDES)
get_defines(DEFINES)
foreach(FILE ${ARGN})
get_filename_component(NAME ${FILE} NAME_WE)
set(HEADER ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.h)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.h
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -h -o ${CMAKE_CURRENT_BINARY_DIR}/${NAME}.h ${CMAKE_CURRENT_SOURCE_DIR}/${FILE}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${FILE} native-widl)
list(APPEND HEADERS ${HEADER})
endforeach()
add_custom_target(${TARGET} DEPENDS ${HEADERS})
endfunction()
function(add_rpcproxy_files)
get_includes(INCLUDES)
get_defines(DEFINES)
foreach(FILE ${ARGN})
get_filename_component(NAME ${FILE} NAME_WE)
list(APPEND IDLS ${CMAKE_CURRENT_SOURCE_DIR}/${FILE})
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_p.c ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_p.h
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -p -o ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_p.c -h -H ${NAME}_p.h ${CMAKE_CURRENT_SOURCE_DIR}/${FILE}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${FILE} native-widl)
endforeach()
# Extra pass to generate dlldata
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/proxy.dlldata.c
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} --dlldata-only -o ${CMAKE_CURRENT_BINARY_DIR}/proxy.dlldata.c ${IDLS}
DEPENDS ${IDLS} native-widl)
endfunction()
function(add_rpc_files __type)
get_includes(INCLUDES)
get_defines(DEFINES)
# Is it a client or server module?
if(__type STREQUAL "server")
set(__server_client -Oif -s -o)
set(__suffix _s)
elseif(__type STREQUAL "client")
set(__server_client -Oif -c -o)
set(__suffix _c)
else()
message(FATAL_ERROR "Please pass either server or client as argument to add_rpc_files")
endif()
foreach(FILE ${ARGN})
get_filename_component(__name ${FILE} NAME_WE)
set(__name ${CMAKE_CURRENT_BINARY_DIR}/${__name}${__suffix})
if(NOT IS_ABSOLUTE ${FILE})
set(FILE ${CMAKE_CURRENT_SOURCE_DIR}/${FILE})
endif()
add_custom_command(
OUTPUT ${__name}.c ${__name}.h
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -h -H ${__name}.h ${__server_client} ${__name}.c ${FILE}
DEPENDS ${FILE} native-widl)
endforeach()
endfunction()
function(generate_idl_iids)
foreach(IDL_FILE ${ARGN})
get_filename_component(FILE ${IDL_FILE} NAME)
if(FILE STREQUAL "${IDL_FILE}")
set(IDL_FILE_FULL "${CMAKE_CURRENT_SOURCE_DIR}/${IDL_FILE}")
else()
set(IDL_FILE_FULL ${IDL_FILE})
endif()
get_includes(INCLUDES)
get_defines(DEFINES)
get_filename_component(NAME ${IDL_FILE} NAME_WE)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_i.c
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -u -o ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_i.c ${IDL_FILE_FULL}
DEPENDS ${IDL_FILE_FULL} native-widl)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${NAME}_i.c PROPERTIES GENERATED TRUE)
endforeach()
endfunction()
function(add_iid_library TARGET)
foreach(IDL_FILE ${ARGN})
get_filename_component(NAME ${IDL_FILE} NAME_WE)
generate_idl_iids(${IDL_FILE})
list(APPEND IID_SOURCES ${NAME}_i.c)
endforeach()
add_library(${TARGET} ${IID_SOURCES})
add_dependencies(${TARGET} psdk)
set_target_properties(${TARGET} PROPERTIES EXCLUDE_FROM_ALL TRUE)
endfunction()
function(add_idl_reg_script IDL_FILE)
get_filename_component(FILE ${IDL_FILE} NAME)
if(FILE STREQUAL "${IDL_FILE}")
set(IDL_FILE_FULL "${CMAKE_CURRENT_SOURCE_DIR}/${IDL_FILE}")
else()
set(IDL_FILE_FULL ${IDL_FILE})
endif()
get_includes(INCLUDES)
get_defines(DEFINES)
get_filename_component(NAME ${IDL_FILE} NAME_WE)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_r.res
COMMAND native-widl ${INCLUDES} ${DEFINES} ${IDL_FLAGS} -r -o ${CMAKE_CURRENT_BINARY_DIR}/${NAME}_r.res ${IDL_FILE_FULL}
DEPENDS ${IDL_FILE_FULL} native-widl)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${NAME}_r.res PROPERTIES
GENERATED TRUE EXTERNAL_OBJECT TRUE)
endfunction()

22
sdk/cmake/writing_CmakeLists_for_ReactOS.txt Normal file
View file

@ -0,0 +1,22 @@
CMake is used to build ReactOS.
Here you will find what you'll need to write nice CMakeLists.txt files for ReactOS.
CMake standard functions are available too. See http://www.cmake.org/, or type cmake --help-html in your shell to get the full documentation.
Optional arguments are marked with [brackets], input is marked with <comparison signs>.
---------------------------------------------------------------------------------------------------------------------------------------------
set_module_type(<target> <type> [UNICODE] [BASEADDRESS <baseaddress>] [ENTRYPOINT <entrypoint> <stacksize>])
This set the type of the module, and take cares of setting common linker options or definitions to the specified target, module file extension, etc. Please always use this when adding a module to reactos build.
ARGUMENTS:
<target>: name of the target. The module must have been added with add_executable or add_library before calling this function.
<type>: one of win32gui, win32cui, win32dll, win32ocx, cpl, nativecui, nativedll, kernelmodedriver
UNICODE: provide this if the module was written for unicode API
<baseaddress>: provide this if you want your module to have a different base address than the defualt one (according to <type>). For win32dll modules, please use baseaddress.cmake instead.
<entrypoint>: name of the function which will be the entr point of the module. If it's not provided, it's guessed from the module type.
<stacksize>: Size of stack required for the parameters of <entrypoint>.
TYPICAL USE:
set_module_type(msvcrt win32dll ENTRYPOINT DllMain 12)