Merge pull request #27325 from VadimLevin/dev:vlevin/header-parser-conditional-inclusion-directives-handling

asmorkalov · web-flow · commit 23f8e523a027 · 2025-05-20T18:11:12.000+03:00
feat: add conditional inclusion support to header parser
diff --git a/cmake/OpenCVBindingsPreprocessorDefinitions.cmake b/cmake/OpenCVBindingsPreprocessorDefinitions.cmake
@@ -0,0 +1,63 @@
+function(ocv_bindings_generator_populate_preprocessor_definitions
+         opencv_modules
+         output_variable)
+  set(defs "\"CV_VERSION_MAJOR\": ${OPENCV_VERSION_MAJOR}")
+
+  macro(ocv_add_definition name value)
+    set(defs "${defs},\n\"${name}\": ${value}")
+  endmacro()
+
+  ocv_add_definition(CV_VERSION_MINOR ${OPENCV_VERSION_MINOR})
+  ocv_add_definition(CV_VERSION_PATCH ${OPENCV_VERSION_PATCH})
+  ocv_add_definition(OPENCV_ABI_COMPATIBILITY "${OPENCV_VERSION_MAJOR}00")
+
+  foreach(module IN LISTS ${opencv_modules})
+    if(HAVE_${module})
+        string(TOUPPER "${module}" module)
+        ocv_add_definition("HAVE_${module}" 1)
+    endif()
+  endforeach()
+  if(HAVE_EIGEN)
+    ocv_add_definition(HAVE_EIGEN 1)
+    ocv_add_definition(EIGEN_WORLD_VERSION ${EIGEN_WORLD_VERSION})
+    ocv_add_definition(EIGEN_MAJOR_VERSION ${EIGEN_MAJOR_VERSION})
+    ocv_add_definition(EIGEN_MINOR_VERSION ${EIGEN_MINOR_VERSION})
+  else()
+    # Some checks in parsed headers might not be protected with HAVE_EIGEN check
+    ocv_add_definition(EIGEN_WORLD_VERSION 0)
+    ocv_add_definition(EIGEN_MAJOR_VERSION 0)
+    ocv_add_definition(EIGEN_MINOR_VERSION 0)
+  endif()
+  if(HAVE_LAPACK)
+    ocv_add_definition(HAVE_LAPACK 1)
+  endif()
+
+  if(OPENCV_DISABLE_FILESYSTEM_SUPPORT)
+    ocv_add_definition(OPENCV_HAVE_FILESYSTEM_SUPPORT 0)
+  else()
+    ocv_add_definition(OPENCV_HAVE_FILESYSTEM_SUPPORT 1)
+  endif()
+
+  ocv_add_definition(OPENCV_BINDINGS_PARSER 1)
+
+  # Implementation details definitions, having no impact on how bindings are
+  # generated, so their real values can be safely ignored
+  ocv_add_definition(CV_ENABLE_UNROLLED 0)
+  ocv_add_definition(CV__EXCEPTION_PTR 0)
+  ocv_add_definition(CV_NEON 0)
+  ocv_add_definition(TBB_INTERFACE_VERSION 0)
+  ocv_add_definition(CV_SSE2 0)
+  ocv_add_definition(CV_VSX 0)
+  ocv_add_definition(OPENCV_SUPPORTS_FP_DENORMALS_HINT 0)
+  ocv_add_definition(CV_LOG_STRIP_LEVEL 0)
+  ocv_add_definition(CV_LOG_LEVEL_SILENT 0)
+  ocv_add_definition(CV_LOG_LEVEL_FATAL 1)
+  ocv_add_definition(CV_LOG_LEVEL_ERROR 2)
+  ocv_add_definition(CV_LOG_LEVEL_WARN 3)
+  ocv_add_definition(CV_LOG_LEVEL_INFO 4)
+  ocv_add_definition(CV_LOG_LEVEL_DEBUG 5)
+  ocv_add_definition(CV_LOG_LEVEL_VERBOSE 6)
+  ocv_add_definition(CERES_FOUND 0)
+
+  set(${output_variable} ${defs} PARENT_SCOPE)
+endfunction()
diff --git a/modules/java/generator/CMakeLists.txt b/modules/java/generator/CMakeLists.txt
@@ -56,13 +56,22 @@ foreach(m ${OPENCV_JAVA_MODULES})
   ocv_remap_files(misc_files)
 endforeach(m)
 
+include("${OpenCV_SOURCE_DIR}/cmake/OpenCVBindingsPreprocessorDefinitions.cmake")
+ocv_bindings_generator_populate_preprocessor_definitions(
+  OPENCV_MODULES_BUILD
+  opencv_preprocessor_defs
+)
+
 set(CONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/gen_java.json")
 set(__config_str
 "{
   \"rootdir\": \"${OpenCV_SOURCE_DIR}\",
   \"modules\": [
 ${__modules_config}
   ],
+  \"preprocessor_definitions\": {
+${opencv_preprocessor_defs}
+  },
   \"files_remap\": [
 ${__remap_config}
   ]
diff --git a/modules/java/generator/gen_java.py b/modules/java/generator/gen_java.py
@@ -591,12 +591,16 @@ def save(self, path, buf):
             f.write(buf)
         updated_files += 1
 
-    def gen(self, srcfiles, module, output_path, output_jni_path, output_java_path, common_headers):
+    def gen(self, srcfiles, module, output_path, output_jni_path, output_java_path, common_headers,
+            preprocessor_definitions=None):
         self.clear()
         self.module = module
         self.Module = module.capitalize()
         # TODO: support UMat versions of declarations (implement UMat-wrapper for Java)
-        parser = hdr_parser.CppHeaderParser(generate_umat_decls=False)
+        parser = hdr_parser.CppHeaderParser(
+            generate_umat_decls=False,
+            preprocessor_definitions=preprocessor_definitions
+        )
 
         self.add_class( ['class cv.' + self.Module, '', [], []] ) # [ 'class/struct cname', ':bases', [modlist] [props] ]
 
@@ -1444,6 +1448,7 @@ def sanitize_java_documentation_string(doc, type):
     gen_dict_files = []
 
     print("JAVA: Processing OpenCV modules: %d" % len(config['modules']))
+    preprocessor_definitions = config.get('preprocessor_definitions', None)
     for e in config['modules']:
         (module, module_location) = (e['name'], os.path.join(ROOT_DIR, e['location']))
         logging.info("\n=== MODULE: %s (%s) ===\n" % (module, module_location))
@@ -1508,7 +1513,8 @@ def sanitize_java_documentation_string(doc, type):
             copy_java_files(java_test_files_dir, java_test_base_path, 'org/opencv/test/' + module)
 
         if len(srcfiles) > 0:
-            generator.gen(srcfiles, module, dstdir, jni_path, java_path, common_headers)
+            generator.gen(srcfiles, module, dstdir, jni_path, java_path, common_headers,
+                          preprocessor_definitions)
         else:
             logging.info("No generated code for module: %s", module)
     generator.finalize(jni_path)
diff --git a/modules/js/generator/CMakeLists.txt b/modules/js/generator/CMakeLists.txt
@@ -30,7 +30,14 @@ ocv_list_filterout(opencv_hdrs "modules/core/include/opencv2/core/utils/*.privat
 ocv_list_filterout(opencv_hdrs "modules/core/include/opencv2/core/utils/instrumentation.hpp")
 ocv_list_filterout(opencv_hdrs "modules/core/include/opencv2/core/utils/trace*")
 
-ocv_update_file("${CMAKE_CURRENT_BINARY_DIR}/headers.txt" "${opencv_hdrs}")
+set(config_json_headers_list "")
+foreach(header IN LISTS opencv_hdrs)
+  if(NOT config_json_headers_list STREQUAL "")
+    set(config_json_headers_list "${config_json_headers_list},\n\"${header}\"")
+  else()
+    set(config_json_headers_list "\"${header}\"")
+  endif()
+endforeach()
 
 set(bindings_cpp "${OPENCV_JS_BINDINGS_DIR}/gen/bindings.cpp")
 
@@ -55,16 +62,42 @@ else()
   message(STATUS "Use autogenerated whitelist ${OPENCV_JS_WHITELIST_FILE}")
 endif()
 
+include("${OpenCV_SOURCE_DIR}/cmake/OpenCVBindingsPreprocessorDefinitions.cmake")
+ocv_bindings_generator_populate_preprocessor_definitions(
+  OPENCV_MODULES_BUILD
+  opencv_preprocessor_defs
+)
+
+set(__config_str
+"{
+  \"headers\": [
+${config_json_headers_list}
+  ],
+  \"preprocessor_definitions\": {
+${opencv_preprocessor_defs}
+  },
+  \"core_bindings_file_path\": \"${JS_SOURCE_DIR}/src/core_bindings.cpp\"
+}")
+set(JSON_CONFIG_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/gen_js_config.json")
+if(EXISTS "${JSON_CONFIG_FILE_PATH}")
+  file(READ "${JSON_CONFIG_FILE_PATH}" __content)
+else()
+  set(__content "")
+endif()
+if(NOT "${__content}" STREQUAL "${__config_str}")
+  file(WRITE "${JSON_CONFIG_FILE_PATH}" "${__config_str}")
+endif()
+unset(__config_str)
+
 add_custom_command(
   OUTPUT ${bindings_cpp} "${OPENCV_DEPHELPER}/gen_opencv_js_source"
   COMMAND
       ${PYTHON_DEFAULT_EXECUTABLE}
       "${CMAKE_CURRENT_SOURCE_DIR}/embindgen.py"
-      "${scripts_hdr_parser}"
-      "${bindings_cpp}"
-      "${CMAKE_CURRENT_BINARY_DIR}/headers.txt"
-      "${JS_SOURCE_DIR}/src/core_bindings.cpp"
-      "${OPENCV_JS_WHITELIST_FILE}"
+      --parser "${scripts_hdr_parser}"
+      --output_file "${bindings_cpp}"
+      --config "${JSON_CONFIG_FILE_PATH}"
+      --whitelist "${OPENCV_JS_WHITELIST_FILE}"
   COMMAND
       ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/gen_opencv_js_source"
   WORKING_DIRECTORY
@@ -73,6 +106,7 @@ add_custom_command(
       ${JS_SOURCE_DIR}/src/core_bindings.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/embindgen.py
       ${CMAKE_CURRENT_SOURCE_DIR}/templates.py
+      ${JSON_CONFIG_FILE_PATH}
       "${OPENCV_JS_WHITELIST_FILE}"
       ${scripts_hdr_parser}
       #(not needed - generated by CMake) ${CMAKE_CURRENT_BINARY_DIR}/headers.txt
diff --git a/modules/js/generator/embindgen.py b/modules/js/generator/embindgen.py
@@ -319,7 +319,7 @@ def __init__(self):
 
 
 class JSWrapperGenerator(object):
-    def __init__(self):
+    def __init__(self, preprocessor_definitions=None):
 
         self.bindings = []
         self.wrapper_funcs = []
@@ -328,7 +328,9 @@ def __init__(self):
         self.namespaces = {}
         self.enums = {}  # FIXIT 'enums' should belong to 'namespaces'
 
-        self.parser = hdr_parser.CppHeaderParser()
+        self.parser = hdr_parser.CppHeaderParser(
+            preprocessor_definitions=preprocessor_definitions
+        )
         self.class_idx = 0
 
     def add_class(self, stype, name, decl):
@@ -962,41 +964,69 @@ def gen(self, dst_file, src_files, core_bindings):
 
 
 if __name__ == "__main__":
-    if len(sys.argv) < 5:
-        print("Usage:\n", \
-            os.path.basename(sys.argv[0]), \
-            "<full path to hdr_parser.py> <bindings.cpp> <headers.txt> <core_bindings.cpp> <whitelist.json or opencv_js.config.py>")
-        print("Current args are: ", ", ".join(["'"+a+"'" for a in sys.argv]))
-        exit(1)
-
-    dstdir = "."
-    hdr_parser_path = os.path.abspath(sys.argv[1])
+    import argparse
+
+    arg_parser = argparse.ArgumentParser(
+        description="OpenCV JavaScript bindings generator"
+    )
+    arg_parser.add_argument(
+        "-p", "--parser",
+        required=True,
+        help="Full path to OpenCV header parser `hdr_parser.py`"
+    )
+    arg_parser.add_argument(
+        "-o", "--output_file",
+        dest="output_file_path",
+        required=True,
+        help="Path to output file containing js bindings"
+    )
+    arg_parser.add_argument(
+        "-c", "--config",
+        dest="config_json_path",
+        required=True,
+        help="Path to generator configuration file in .json format"
+    )
+    arg_parser.add_argument(
+        "--whitelist",
+        dest="whitelist_file_path",
+        required=True,
+        help="Path to whitelist.js or opencv_js.config.py"
+    )
+    args = arg_parser.parse_args()
+
+    # import header parser
+    hdr_parser_path = os.path.abspath(args.parser)
     if hdr_parser_path.endswith(".py"):
         hdr_parser_path = os.path.dirname(hdr_parser_path)
     sys.path.append(hdr_parser_path)
     import hdr_parser
 
-    bindingsCpp = sys.argv[2]
-    headers = open(sys.argv[3], 'r').read().split(';')
-    coreBindings = sys.argv[4]
-    whiteListFile = sys.argv[5]
+    with open(args.config_json_path, "r") as fh:
+        config_json = json.load(fh)
+    headers = config_json.get("headers", ())
 
-    if whiteListFile.endswith(".json") or whiteListFile.endswith(".JSON"):
-        with open(whiteListFile) as f:
+    bindings_cpp = args.output_file_path
+    core_bindings_path = config_json["core_bindings_file_path"]
+    whitelist_file_path = args.whitelist_file_path
+
+    if whitelist_file_path.endswith(".json") or whitelist_file_path.endswith(".JSON"):
+        with open(whitelist_file_path) as f:
             gen_dict = json.load(f)
-        f.close()
         white_list = makeWhiteListJson(gen_dict)
         namespace_prefix_override = makeNamespacePrefixOverride(gen_dict)
-    elif whiteListFile.endswith(".py") or whiteListFile.endswith(".PY"):
-        exec(open(whiteListFile).read())
-        assert(white_list)
+    elif whitelist_file_path.endswith(".py") or whitelist_file_path.endswith(".PY"):
+        with open(whitelist_file_path) as fh:
+            exec(fh.read())
+        assert white_list
         namespace_prefix_override = {
             'dnn' : '',
             'aruco' : '',
         }
     else:
-        print("Unexpected format of OpenCV config file", whiteListFile)
+        print("Unexpected format of OpenCV config file", whitelist_file_path)
         exit(1)
 
-    generator = JSWrapperGenerator()
-    generator.gen(bindingsCpp, headers, coreBindings)
+    generator = JSWrapperGenerator(
+        preprocessor_definitions=config_json.get("preprocessor_definitions", None)
+    )
+    generator.gen(bindings_cpp, headers, core_bindings_path)
diff --git a/modules/objc/generator/CMakeLists.txt b/modules/objc/generator/CMakeLists.txt
@@ -38,14 +38,24 @@ if(HAVE_opencv_objc)
   set(__objc_build_dir "\"objc_build_dir\": \"${CMAKE_CURRENT_BINARY_DIR}/../objc\",")
 endif()
 
+include("${OpenCV_SOURCE_DIR}/cmake/OpenCVBindingsPreprocessorDefinitions.cmake")
+
+ocv_bindings_generator_populate_preprocessor_definitions(
+  OPENCV_MODULES_BUILD
+  opencv_preprocessor_defs
+)
+
 set(CONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/gen_objc.json")
 set(__config_str
 "{
   \"rootdir\": \"${OpenCV_SOURCE_DIR}\",
   ${__objc_build_dir}
   \"modules\": [
 ${__modules_config}
-  ]
+  ],
+  \"preprocessor_definitions\": {
+${opencv_preprocessor_defs}
+  }
 }
 ")
 #TODO: ocv_update_file("${CONFIG_FILE}" "${__config_str}" ON_CHANGE_REMOVE "${OPENCV_DEPHELPER}/gen_opencv_objc_source")
diff --git a/modules/objc/generator/gen_objc.py b/modules/objc/generator/gen_objc.py
@@ -894,7 +894,8 @@ def get_namespace_prefix(self, cname):
         namespace = self.classes[cname].namespace if cname in self.classes else "cv"
         return namespace.replace(".", "::") + "::"
 
-    def gen(self, srcfiles, module, output_path, output_objc_path, common_headers, manual_classes):
+    def gen(self, srcfiles, module, output_path, output_objc_path,
+            common_headers, manual_classes, preprocessor_definitions=None):
         self.clear()
         self.module = module
         self.objcmodule = make_objcmodule(module)
@@ -903,7 +904,10 @@ def gen(self, srcfiles, module, output_path, output_objc_path, common_headers, m
         extension_signatures = []
 
         # TODO: support UMat versions of declarations (implement UMat-wrapper for Java)
-        parser = hdr_parser.CppHeaderParser(generate_umat_decls=False)
+        parser = hdr_parser.CppHeaderParser(
+            generate_umat_decls=False,
+            preprocessor_definitions=preprocessor_definitions
+        )
 
         module_ci = self.add_class( ['class ' + self.Module, '', [], []]) # [ 'class/struct cname', ':bases', [modlist] [props] ]
         module_ci.header_import = module + '.hpp'
@@ -1715,7 +1719,9 @@ def sanitize_documentation_string(doc, type):
         manual_classes = [x for x in [x[x.rfind('/')+1:-2] for x in [x for x in copied_files if x.endswith('.h')]] if x in type_dict]
 
         if len(srcfiles) > 0:
-            generator.gen(srcfiles, module, dstdir, objc_base_path, common_headers, manual_classes)
+            generator.gen(srcfiles, module, dstdir, objc_base_path,
+                          common_headers, manual_classes,
+                          config.get("preprocessor_definitions"))
         else:
             logging.info("No generated code for module: %s", module)
     generator.finalize(args.target, objc_base_path, objc_build_dir)
diff --git a/modules/python/bindings/CMakeLists.txt b/modules/python/bindings/CMakeLists.txt
diff --git a/modules/python/src2/gen2.py b/modules/python/src2/gen2.py
diff --git a/modules/python/src2/hdr_parser.py b/modules/python/src2/hdr_parser.py
