build: CMake/build-system fixes, de-duplication and cleanups

- Read the CEF version per-platform from src/version/cef_version_*.h.
- Select the CEF directory matching the exact CEF_VERSION (top-level
  CMakeLists, subprocess CMakeLists, and build.py) so a leftover dir for
  a different CEF version in build/ is never picked up by accident.
- De-duplicate compile flags into a cefpython_common_flags INTERFACE
  library; share a single filter_sources() function for platform source
  filtering (was duplicated in client_handler and subprocess).
- Target Windows 10 (WINVER/_WIN32_WINNT=0x0A00, NTDDI_WIN10_FE) to match
  upstream CEF; define the triple once in CEFPYTHON_WIN_TARGET_DEFS.
- Remove tools/cmake_fix_header.py: include the raw Cython header directly
  via CEFPYTHON_API_H_FILE="<module>.h"; the C4190 warning is already
  suppressed by /wd4190 and the renderer subprocess doesn't include it.
- Harden except_all_missing() in cmake_prepare_pyx.py to also catch bare
  nogil/gil signatures (still ignores except*/noexcept).
- Restore the license/copyright header in build.py.

Addresses review feedback on PR cztomczak#691 (cztomczak/cefpython).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: linesight

CMakeLists.txt

@@ -1,10 +1,26 @@
 cmake_minimum_required(VERSION 3.21)
 
-# Read CEF major version from the Windows header (used on all platforms at
-# configure time; the per-platform header values are identical for this field).
-file(STRINGS "src/version/cef_version_win.h" _ver_line
+# Read the CEF major version from the version header for the platform being
+# built, so each platform uses its own CEF version (the values may differ
+# across platforms). This runs before project() sets WIN32/APPLE/UNIX, and
+# builds are always native (no cross-compiling), so select by host platform.
+if(CMAKE_HOST_WIN32)
+    set(_cef_version_header "src/version/cef_version_win.h")
+elseif(CMAKE_HOST_APPLE)
+    set(_cef_version_header "src/version/cef_version_macarm64.h")
+else()
+    set(_cef_version_header "src/version/cef_version_linux.h")
+endif()
+file(STRINGS "${_cef_version_header}" _ver_line
      REGEX "^#define CHROME_VERSION_MAJOR ")
 string(REGEX REPLACE "^#define CHROME_VERSION_MAJOR ([0-9]+).*" "\\1" _chrome_major "${_ver_line}")
+# Full CEF version string, e.g. "147.0.10+gd58e84d+chromium-147.0.7727.118".
+# Used to select the matching prebuilt CEF directory under build/ so a leftover
+# directory from a different CEF version is never picked up by accident.
+file(STRINGS "${_cef_version_header}" _cef_version_line
+     REGEX "^#define CEF_VERSION ")
+string(REGEX REPLACE "^#define CEF_VERSION \"([^\"]+)\".*" "\\1" _cef_version "${_cef_version_line}")
+message(STATUS "CEF version header: ${_cef_version_header} -> ${_cef_version} (major ${_chrome_major})")
 
 project(cefpython3 VERSION "${_chrome_major}.0" LANGUAGES CXX)
 
@@ -46,16 +62,23 @@ if(NOT CEF_ROOT)
         set(_cef_glob_pat "${CMAKE_SOURCE_DIR}/build/cef*_linux64")
     endif()
     file(GLOB _cef_candidates LIST_DIRECTORIES true "${_cef_glob_pat}")
-    # Prefer the versioned directory over cef_<os> fallback
+    # Select the directory matching the exact CEF version from the header, so a
+    # leftover prebuilt dir for a different CEF version in build/ is never picked
+    # up by accident. string(FIND) is a literal substring search (the version
+    # contains regex-special chars like '+' and '.', so MATCHES is unsafe here).
     foreach(_d IN LISTS _cef_candidates)
         if(IS_DIRECTORY "${_d}")
-            set(CEF_ROOT "${_d}")
-            break()
+            string(FIND "${_d}" "${_cef_version}" _ver_match)
+            if(NOT _ver_match EQUAL -1)
+                set(CEF_ROOT "${_d}")
+                break()
+            endif()
         endif()
     endforeach()
     if(NOT CEF_ROOT)
         message(FATAL_ERROR
-            "CEF_ROOT not set and cannot be auto-detected. "
+            "CEF_ROOT not set and no prebuilt CEF ${_cef_version} found under "
+            "build/ (matching ${_cef_glob_pat}). "
             "Download and prepare CEF first (python tools/download_cef.py && "
             "python tools/automate.py --prebuilt-cef), or pass -DCEF_ROOT=<path>.")
     endif()
@@ -122,34 +145,90 @@ add_custom_command(
     VERBATIM
 )
 
-# ---- Fix Cython API header --------------------------------------------------
-# Generates:
-#   cefpython_pyXX_fixed.h  – original .h with #pragma warning(disable:4190)
-#   cefpython_api_fixed.h   – stable single-name wrapper for cefpython_public_api.h
-set(CEFPYTHON_H_FIXED  "${PYX_STAGE_DIR}/${MODULE_NAME}_fixed.h")
-set(CEF_API_FIXED_H    "${PYX_STAGE_DIR}/cefpython_api_fixed.h")
-
-add_custom_command(
-    OUTPUT "${CEFPYTHON_H_FIXED}" "${CEF_API_FIXED_H}"
-    COMMAND "${Python_EXECUTABLE}"
-            "${CMAKE_SOURCE_DIR}/tools/cmake_fix_header.py"
-            "${CEFPYTHON_H}"
-            "${CEFPYTHON_H_FIXED}"
-            "${CEF_API_FIXED_H}"
-            "${MODULE_NAME}"
-    DEPENDS "${CEFPYTHON_H}" "${CMAKE_SOURCE_DIR}/tools/cmake_fix_header.py"
-    COMMENT "Generating ${MODULE_NAME}_fixed.h + cefpython_api_fixed.h"
-    VERBATIM
-)
-add_custom_target(cefpython_headers
-    DEPENDS "${CEFPYTHON_H_FIXED}" "${CEF_API_FIXED_H}")
+# ---- Cython API header ------------------------------------------------------
+# C++ sources include the Cython-generated public API header directly via the
+# CEFPYTHON_API_H_FILE define (= "${MODULE_NAME}.h"); it sits in PYX_STAGE_DIR
+# which is on each target's include path. No post-processing is needed: the
+# C4190 warning is suppressed by the /wd4190 compile flag (and the renderer
+# subprocess, which lacks that flag, doesn't include the header at all).
+# cefpython_headers gates C++ compilation on the header being generated.
+add_custom_target(cefpython_headers DEPENDS "${CEFPYTHON_H}")
 
 # ---- Static C++ libraries ---------------------------------------------------
 # All three libs share these settings so pass them via cache variables that
 # the subdirectory CMakeLists files can read.
 set(CEFPYTHON_PYX_STAGE_DIR "${PYX_STAGE_DIR}" CACHE INTERNAL "")
 set(CEFPYTHON_CEF_ROOT      "${CEF_ROOT}"       CACHE INTERNAL "")
 set(CEFPYTHON_SRC_DIR       "${SRC_DIR}"        CACHE INTERNAL "")
+set(CEFPYTHON_CEF_VERSION   "${_cef_version}"   CACHE INTERNAL "")
+
+# Windows API target level. Match upstream CEF, which builds for Windows 10
+# (see cef_variables.cmake: WINVER/_WIN32_WINNT=0x0A00, NTDDI_WIN10_FE).
+# Chromium 147 only runs on Windows 10+, so targeting an older Windows here
+# would just hide newer Win32 APIs without buying real backward compatibility.
+# Defined once and consumed by both cefpython_common_flags (browser-process
+# targets) and the subprocess executable so the value can't drift between files.
+set(CEFPYTHON_WIN_TARGET_DEFS
+    WINVER=0x0A00 _WIN32_WINNT=0x0A00 NTDDI_VERSION=NTDDI_WIN10_FE
+    CACHE INTERNAL "Windows API target level (matches upstream CEF: Windows 10)")
+
+# Shared compile settings for the browser-process C++ targets (the Python
+# extension module, client_handler, cpp_utils, cefpython_app). These flags
+# were previously duplicated verbatim in every CMake file - in particular the
+# Windows definition block with the NTDDI_VERSION/WINVER/_WIN32_WINNT triple.
+# Define them once here as an INTERFACE library that those targets link.
+#
+# NOTE: the subprocess executable is a *renderer*-process target with different
+# settings (RENDERER_PROCESS, static /MT CRT, _HAS_EXCEPTIONS=0, no /EHsc) and
+# deliberately does NOT use this. BROWSER_PROCESS only affects
+# src/subprocess/cefpython_app.cpp; it is a no-op for the other sources.
+add_library(cefpython_common_flags INTERFACE)
+target_compile_definitions(cefpython_common_flags INTERFACE
+    BROWSER_PROCESS
+    CEFPYTHON_API_H_FILE="${MODULE_NAME}.h"
+)
+if(WIN32)
+    target_compile_options(cefpython_common_flags INTERFACE /EHsc /wd4190)
+    target_compile_definitions(cefpython_common_flags INTERFACE
+        WIN32 _WIN32 _WINDOWS
+        ${CEFPYTHON_WIN_TARGET_DEFS}
+        NDEBUG _NDEBUG _CRT_SECURE_NO_WARNINGS NOMINMAX
+    )
+else()
+    target_compile_options(cefpython_common_flags INTERFACE -DNDEBUG -O3)
+endif()
+
+# Filter a list of source files for the current platform: drop *_win.cpp,
+# *_linux.cpp, *_mac.cpp/.mm, x11.cpp and gtk* files that don't belong on the
+# OS being built. Shared by the client_handler and subprocess CMakeLists so the
+# rules live in one place. IN_LIST is the *name* of the input list variable;
+# the result is written to the variable named by OUT_VAR in the caller's scope.
+function(filter_sources IN_LIST OUT_VAR)
+    set(_result "")
+    foreach(_f IN LISTS ${IN_LIST})
+        get_filename_component(_name "${_f}" NAME)
+        set(_skip FALSE)
+        if(_name MATCHES "_win\\.cpp$"   AND NOT WIN32)
+            set(_skip TRUE)
+        endif()
+        if(_name MATCHES "_linux\\.cpp$" AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
+            set(_skip TRUE)
+        endif()
+        if(_name MATCHES "_mac\\.(cpp|mm)$" AND NOT APPLE)
+            set(_skip TRUE)
+        endif()
+        if(_name MATCHES "^x11\\.cpp$"   AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
+            set(_skip TRUE)
+        endif()
+        if(_name MATCHES "gtk"           AND NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
+            set(_skip TRUE)
+        endif()
+        if(NOT _skip)
+            list(APPEND _result "${_f}")
+        endif()
+    endforeach()
+    set(${OUT_VAR} "${_result}" PARENT_SCOPE)
+endfunction()
 
 add_subdirectory("${SRC_DIR}/client_handler"
                  "${CMAKE_CURRENT_BINARY_DIR}/client_handler")
@@ -179,16 +258,13 @@ if(ENABLE_LINE_TRACING)
     target_compile_definitions(${MODULE_NAME} PRIVATE CYTHON_TRACE=1)
 endif()
 
+# Common browser-process flags come from cefpython_common_flags; only the
+# module-specific extras are listed per platform below.
+target_link_libraries(${MODULE_NAME} PRIVATE cefpython_common_flags)
+
 if(WIN32)
     target_include_directories(${MODULE_NAME} PRIVATE "${SRC_DIR}/windows")
-    target_compile_options(${MODULE_NAME} PRIVATE /EHsc /wd4305 /wd4190)
-    target_compile_definitions(${MODULE_NAME} PRIVATE
-        WIN32 _WIN32 _WINDOWS
-        NTDDI_VERSION=0x06010000 WINVER=0x0601 _WIN32_WINNT=0x0601
-        NDEBUG _NDEBUG _CRT_SECURE_NO_WARNINGS NOMINMAX
-        BROWSER_PROCESS
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
-    )
+    target_compile_options(${MODULE_NAME} PRIVATE /wd4305)
     target_link_libraries(${MODULE_NAME} PRIVATE
         cefpython_app
         client_handler
@@ -200,16 +276,11 @@ if(WIN32)
     target_link_options(${MODULE_NAME} PRIVATE /ignore:4217)
 elseif(APPLE)
     target_compile_options(${MODULE_NAME} PRIVATE
-        -DNDEBUG -O3
         -Wno-return-type-c-linkage -Wno-constant-logical-operand
         -stdlib=libc++ -fno-strict-aliasing -fno-rtti
         -fno-threadsafe-statics -fobjc-call-cxx-cdtors
         -fvisibility=hidden -fvisibility-inlines-hidden
     )
-    target_compile_definitions(${MODULE_NAME} PRIVATE
-        BROWSER_PROCESS
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
-    )
     target_link_options(${MODULE_NAME} PRIVATE
         -mmacosx-version-min=11.0
         -Wl,-search_paths_first -Wl,-dead_strip
@@ -223,14 +294,9 @@ elseif(APPLE)
     )
 else()
     target_compile_options(${MODULE_NAME} PRIVATE
-        -DNDEBUG -O3
         -flto -fdata-sections -ffunction-sections
         -Wno-stringop-overflow
     )
-    target_compile_definitions(${MODULE_NAME} PRIVATE
-        BROWSER_PROCESS
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
-    )
     target_include_directories(${MODULE_NAME} PRIVATE
         ${GTK3_INCLUDE_DIRS}
     )

src/client_handler/CMakeLists.txt

@@ -4,25 +4,9 @@ if(APPLE)
     list(APPEND _all_cpp ${_mm_files})
 endif()
 
-set(_sources "")
-foreach(_f IN LISTS _all_cpp)
-    get_filename_component(_name "${_f}" NAME)
-    set(_skip FALSE)
-    if(_name MATCHES "_win\\.cpp$" AND NOT WIN32)
-        set(_skip TRUE)
-    elseif(_name MATCHES "_linux\\.cpp$" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        set(_skip TRUE)
-    elseif(_name MATCHES "_mac\\.(cpp|mm)$" AND NOT APPLE)
-        set(_skip TRUE)
-    elseif(_name MATCHES "^x11\\.cpp$" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        set(_skip TRUE)
-    elseif(_name MATCHES "gtk" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        set(_skip TRUE)
-    endif()
-    if(NOT _skip)
-        list(APPEND _sources "${_f}")
-    endif()
-endforeach()
+# filter_sources() is defined in the top-level CMakeLists and shared with the
+# subprocess CMakeLists so the platform skip rules live in one place.
+filter_sources(_all_cpp _sources)
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     find_package(PkgConfig REQUIRED)
@@ -43,21 +27,10 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     target_include_directories(client_handler PRIVATE ${GTK3_INCLUDE_DIRS})
 endif()
 
-if(WIN32)
-    target_compile_options(client_handler PRIVATE /EHsc /wd4190)
-    target_compile_definitions(client_handler PRIVATE
-        WIN32 _WIN32 _WINDOWS
-        NTDDI_VERSION=0x06010000 WINVER=0x0601 _WIN32_WINNT=0x0601
-        NDEBUG _NDEBUG _CRT_SECURE_NO_WARNINGS NOMINMAX
-        BROWSER_PROCESS
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
-    )
-elseif(APPLE)
-    target_compile_options(client_handler PRIVATE -DNDEBUG -O3)
-    target_compile_definitions(client_handler PRIVATE
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h")
-else()
-    target_compile_options(client_handler PRIVATE -DNDEBUG -O3 -Wno-stringop-overflow)
-    target_compile_definitions(client_handler PRIVATE
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h")
+# Common browser-process flags (Windows def block, -DNDEBUG -O3, API header
+# define, etc.) come from cefpython_common_flags defined in the top-level
+# CMakeLists. Only the Linux-specific extra is listed here.
+target_link_libraries(client_handler PRIVATE cefpython_common_flags)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    target_compile_options(client_handler PRIVATE -Wno-stringop-overflow)
 endif()

src/common/cefpython_public_api.h

@@ -15,22 +15,22 @@
 // Python.h must be included first (avoids _POSIX_C_SOURCE redefinition on Linux)
 #include "Python.h"
 
-// Includes required by the generated cefpython_*_fixed.h
+// Includes required by the Cython-generated public API header
 #include "include/cef_client.h"
 #include "include/cef_urlrequest.h"
 #include "include/cef_command_line.h"
 #include "util.h"
 
-// cefpython_fixed.h uses DL_IMPORT/DL_EXPORT which were removed in Python 3.
+// The generated header uses DL_IMPORT/DL_EXPORT which were removed in Python 3.
 #ifndef DL_IMPORT
 #define DL_IMPORT(RTYPE) RTYPE
 #endif
 #ifndef DL_EXPORT
 #define DL_EXPORT(RTYPE) RTYPE
 #endif
 
-// CMake sets CEFPYTHON_API_H_FILE to "cefpython_api_fixed.h", a generated
-// stable-name wrapper in the pyx_stage/ build directory resolved via the
+// CMake sets CEFPYTHON_API_H_FILE to the Cython-generated header name
+// ("cefpython_pyXX.h"), found in the pyx_stage/ build directory via the
 // target's include path.
 #include CEFPYTHON_API_H_FILE
 

src/cpp_utils/CMakeLists.txt

@@ -10,21 +10,9 @@ target_include_directories(cpp_utils PRIVATE
     ${Python_INCLUDE_DIRS}
 )
 
-if(WIN32)
-    target_compile_options(cpp_utils PRIVATE /EHsc /wd4190)
-    target_compile_definitions(cpp_utils PRIVATE
-        WIN32 _WIN32 _WINDOWS
-        NTDDI_VERSION=0x06010000 WINVER=0x0601 _WIN32_WINNT=0x0601
-        NDEBUG _NDEBUG _CRT_SECURE_NO_WARNINGS NOMINMAX
-        BROWSER_PROCESS
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h"
-    )
-elseif(APPLE)
-    target_compile_options(cpp_utils PRIVATE -DNDEBUG -O3)
-    target_compile_definitions(cpp_utils PRIVATE
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h")
-else()
-    target_compile_options(cpp_utils PRIVATE -DNDEBUG -O3 -Wno-stringop-overflow)
-    target_compile_definitions(cpp_utils PRIVATE
-        CEFPYTHON_API_H_FILE="cefpython_api_fixed.h")
+# Common browser-process flags come from cefpython_common_flags defined in the
+# top-level CMakeLists. Only the Linux-specific extra is listed here.
+target_link_libraries(cpp_utils PRIVATE cefpython_common_flags)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    target_compile_options(cpp_utils PRIVATE -Wno-stringop-overflow)
 endif()