stepcode · starseeker · Aug 4, 2026 · Aug 2, 2026 · Aug 2, 2026 · Aug 2, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -129,6 +129,18 @@ if (SC_ENABLE_COVERAGE AND ${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
   set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "-fprofile-arcs -ftest-coverage" CACHE STRING "Extra linker flags required by code coverage" FORCE)
 endif (SC_ENABLE_COVERAGE AND ${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
 
+option(SC_ENABLE_ADDRESS_SANITIZER "Enable AddressSanitizer instrumentation" OFF)
+option(SC_ENABLE_UNDEFINED_SANITIZER "Enable UndefinedBehaviorSanitizer instrumentation" OFF)
+option(SC_ENABLE_THREAD_SANITIZER "Enable ThreadSanitizer instrumentation" OFF)
+
+if(SC_ENABLE_THREAD_SANITIZER AND
+   (SC_ENABLE_ADDRESS_SANITIZER OR SC_ENABLE_UNDEFINED_SANITIZER))
+  message(FATAL_ERROR
+    "SC_ENABLE_THREAD_SANITIZER must use a separate build from "
+    "AddressSanitizer and UndefinedBehaviorSanitizer"
+  )
+endif()
+
 option(SC_BUILD_EXPRESS_ONLY "Only build express parser." OFF)
 mark_as_advanced(SC_BUILD_EXPRESS_ONLY)
 
@@ -155,6 +167,111 @@ include(SC_Regenerate)
 # create config.h header
 include(SC_Config_Headers)
 
+# Apply sanitizer instrumentation after configure-time feature tests so their
+# try-compile executables do not depend on sanitizer runtime behavior.  Keep
+# link flags explicit for CMake 3.12 compatibility (add_link_options was added
+# in CMake 3.13).
+if(SC_ENABLE_ADDRESS_SANITIZER OR
+   SC_ENABLE_UNDEFINED_SANITIZER OR
+   SC_ENABLE_THREAD_SANITIZER)
+  if(MSVC)
+    message(FATAL_ERROR "STEPcode sanitizer builds are not yet supported with MSVC")
+  endif()
+
+  include(CMakePushCheckState)
+  include(CheckCSourceCompiles)
+  include(CheckCXXSourceCompiles)
+  include(CheckCCompilerFlag)
+  include(CheckCXXCompilerFlag)
+
+  set(_sc_sanitizer_compile_options)
+  set(_sc_sanitizer_link_options)
+
+  function(sc_require_sanitizer FLAG RESULT_PREFIX)
+    cmake_push_check_state()
+    set(CMAKE_REQUIRED_FLAGS "${FLAG}")
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "${FLAG}")
+    check_c_source_compiles("int main(void) { return 0; }" ${RESULT_PREFIX}_C_SUPPORTED)
+    check_cxx_source_compiles("int main() { return 0; }" ${RESULT_PREFIX}_CXX_SUPPORTED)
+    cmake_pop_check_state()
+    if(NOT ${RESULT_PREFIX}_C_SUPPORTED OR NOT ${RESULT_PREFIX}_CXX_SUPPORTED)
+      message(FATAL_ERROR
+        "STEPcode sanitizer mode was requested, but the C/C++ compiler and "
+        "linker do not support ${FLAG}"
+      )
+    endif()
+  endfunction()
+
+  if(SC_ENABLE_ADDRESS_SANITIZER)
+    sc_require_sanitizer("-fsanitize=address" SC_ASAN)
+    list(APPEND _sc_sanitizer_compile_options -fsanitize=address)
+    list(APPEND _sc_sanitizer_link_options -fsanitize=address)
+    # exp2cxx is executed during the build to generate schema bindings.  It
+    # remains address-instrumented, but leak checking a short-lived build
+    # tool is both outside the test scope and unsupported under common build
+    # tracers/sandboxes.  Limit this environment to schema generation; CTest
+    # and installed tools retain the user's normal ASan settings.
+    set(SC_SCHEMA_GENERATOR_ENVIRONMENT "ASAN_OPTIONS=detect_leaks=0")
+  endif()
+
+  if(SC_ENABLE_UNDEFINED_SANITIZER)
+    sc_require_sanitizer("-fsanitize=undefined" SC_UBSAN)
+    cmake_push_check_state()
+    set(CMAKE_REQUIRED_FLAGS "-fsanitize=undefined")
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "-fsanitize=undefined")
+    check_c_compiler_flag(
+      "-fno-sanitize-recover=undefined"
+      SC_UBSAN_C_NO_RECOVER_SUPPORTED
+    )
+    check_cxx_compiler_flag(
+      "-fno-sanitize-recover=undefined"
+      SC_UBSAN_CXX_NO_RECOVER_SUPPORTED
+    )
+    cmake_pop_check_state()
+    if(NOT SC_UBSAN_C_NO_RECOVER_SUPPORTED OR
+       NOT SC_UBSAN_CXX_NO_RECOVER_SUPPORTED)
+      message(FATAL_ERROR
+        "STEPcode's fail-fast UndefinedBehaviorSanitizer mode was requested, "
+        "but the C/C++ compiler does not support "
+        "-fno-sanitize-recover=undefined"
+      )
+    endif()
+    list(APPEND _sc_sanitizer_compile_options
+      -fsanitize=undefined
+      -fno-sanitize-recover=undefined
+    )
+    list(APPEND _sc_sanitizer_link_options -fsanitize=undefined)
+  endif()
+
+  if(SC_ENABLE_THREAD_SANITIZER)
+    sc_require_sanitizer("-fsanitize=thread" SC_TSAN)
+    list(APPEND _sc_sanitizer_compile_options -fsanitize=thread)
+    list(APPEND _sc_sanitizer_link_options -fsanitize=thread)
+  endif()
+
+  check_c_compiler_flag("-fno-omit-frame-pointer" SC_SANITIZER_C_FRAME_POINTER_SUPPORTED)
+  check_cxx_compiler_flag("-fno-omit-frame-pointer" SC_SANITIZER_CXX_FRAME_POINTER_SUPPORTED)
+  if(SC_SANITIZER_C_FRAME_POINTER_SUPPORTED)
+    list(APPEND _sc_sanitizer_compile_options
+      $<$<COMPILE_LANGUAGE:C>:-fno-omit-frame-pointer>
+    )
+  endif()
+  if(SC_SANITIZER_CXX_FRAME_POINTER_SUPPORTED)
+    list(APPEND _sc_sanitizer_compile_options
+      $<$<COMPILE_LANGUAGE:CXX>:-fno-omit-frame-pointer>
+    )
+  endif()
+
+  add_compile_options(${_sc_sanitizer_compile_options})
+  string(JOIN " " _sc_sanitizer_link_flags ${_sc_sanitizer_link_options})
+  foreach(_sc_link_type EXE SHARED MODULE)
+    set(
+      CMAKE_${_sc_link_type}_LINKER_FLAGS
+      "${CMAKE_${_sc_link_type}_LINKER_FLAGS} ${_sc_sanitizer_link_flags}"
+    )
+  endforeach()
+endif()
+
 if(NOT DEFINED SC_SDAI_ADDITIONAL_EXES_SRCS)
   set(SC_SDAI_ADDITIONAL_EXES_SRCS "" CACHE STRING "Source files for additional executables to be linked with SDAI libs")
 endif(NOT DEFINED SC_SDAI_ADDITIONAL_EXES_SRCS)
@@ -230,4 +347,3 @@ endforeach(_msg ${CONFIG_END_MESSAGES})
 # indent-tabs-mode: t
 # End:
 # ex: shiftwidth=2 tabstop=8
-
diff --git a/INSTALL b/INSTALL
@@ -51,6 +51,12 @@ Installation
   -DSC_BUILD_SCHEMAS=ALL
     - Added to make use of ctest easier. If SC_BUILD_SCHEMAS == ALL,
       then CMake adds each *.exp file found in data/.
+  -DSC_EXP2CXX_API_VERSION=2
+    - opts in to compact descriptor-driven SELECTs and dependency-bounded
+      entity headers in the generated C++ API.
+    - clients include the entity headers they use (for example,
+      entity/SdaiProduct.h); schema.h no longer expands every entity class.
+    - version 1 remains the default for source compatibility.
   -DCMAKE_BUILD_TYPE=Release
     - this causes binaries to be built without debugging information
     - without this, cmake defaults to a Debug build

diff --git a/cmake/SC_CXX_schema_macros.cmake b/cmake/SC_CXX_schema_macros.cmake
@@ -100,6 +100,11 @@ macro(SCHEMA_TARGETS expFile schemaName sourceFiles)
     COMMAND ${CMAKE_COMMAND} -DEXE=\"$<TARGET_FILE:exp2cxx>\"  -DEXP=\"${expFile}\"
     -DONESHOT=\"${SC_GENERATE_CXX_ONESHOT}\" -DSDIR=\"${CMAKE_CURRENT_LIST_DIR}\"
     -DCHUNK_SIZE=\"${SC_EXP2CXX_CHUNK_SIZE}\"
+    -DAPI_VERSION=\"${SC_EXP2CXX_API_VERSION}\"
+    -DLATE_BOUND=\"${SC_EXP2CXX_LATE_BOUND}\"
+    -DCOMPAT_NAMES=\"${SC_EXP2CXX_COMPAT_NAMES}\"
+    -DMETADATA_PROFILE=\"${SC_EXP2CXX_METADATA}\"
+    -DGENERATOR_ENVIRONMENT=\"${SC_SCHEMA_GENERATOR_ENVIRONMENT}\"
     -P ${SC_CMAKE_DIR}/SC_Run_exp2cxx.cmake
     DEPENDS exp2cxx ${expFile}
     WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}

diff --git a/cmake/SC_Run_exp2cxx.cmake b/cmake/SC_Run_exp2cxx.cmake
@@ -1,10 +1,26 @@
 
 # if oneshot is true, don't run exp2cxx if source files exist. if schema.cc exists, assume others do
+if(NOT DEFINED API_VERSION OR "${API_VERSION}" STREQUAL "")
+  set(API_VERSION 1)
+endif()
+if(NOT DEFINED METADATA_PROFILE OR "${METADATA_PROFILE}" STREQUAL "")
+  set(METADATA_PROFILE full)
+endif()
+
 if(ONESHOT AND EXISTS "${SDIR}/schema.cc")
   message("WARNING: SC_GENERATE_CXX_ONESHOT is enabled. If generated code has been modified, it will NOT be rewritten!")
   message("This is ONLY for debugging STEPcode internals!")
 else()
-  execute_process(COMMAND ${EXE} -k ${CHUNK_SIZE} ${EXP}
+  set(_exp2cxx_mode_args)
+  if(LATE_BOUND)
+    list(APPEND _exp2cxx_mode_args --late-bound)
+  endif()
+  if(COMPAT_NAMES)
+    list(APPEND _exp2cxx_mode_args --compat-names)
+  endif()
+  list(APPEND _exp2cxx_mode_args --metadata ${METADATA_PROFILE})
+  execute_process(COMMAND ${CMAKE_COMMAND} -E env ${GENERATOR_ENVIRONMENT}
+    ${EXE} -k ${CHUNK_SIZE} -V ${API_VERSION} ${_exp2cxx_mode_args} ${EXP}
     WORKING_DIRECTORY ${SDIR}
     RESULT_VARIABLE _res
     OUTPUT_FILE exp2cxx_stdout.txt

diff --git a/cmake/schema_scanner/schemaScanner.cc b/cmake/schema_scanner/schemaScanner.cc
@@ -218,20 +218,32 @@ void writeLists( const char * schemaName, stringstream & eh, stringstream & ei,
 
     const int entityChunks = std::max( 1, ( ecount + static_cast<int>( entityChunkSize ) - 1 ) / static_cast<int>( entityChunkSize ) );
     const int typeChunks = std::max( 1, ( tcount + static_cast<int>( typeChunkSize ) - 1 ) / static_cast<int>( typeChunkSize ) );
-    cmLists << "set(" << shortName << "_file_count " <<
-        ( ecount + tcount ) * 2 + entityChunks + typeChunks + 11 << ")" << endl << endl;
+    cmLists << "if(SC_EXP2CXX_LATE_BOUND)" << endl;
+    cmLists << "  set(" << shortName << "_file_count 10)" << endl;
+    cmLists << "else()" << endl;
+    cmLists << "  set(" << shortName << "_file_count " <<
+        ( ecount + tcount ) * 2 + entityChunks + typeChunks + 14 << ")" << endl;
+    cmLists << "endif()" << endl << endl;
 
 
     cmLists << "PROJECT(" << shortName << ")" << endl;
     cmLists << "# list headers so they can be installed - entity, type, misc" << endl;
 
-    cmLists << "set(" << shortName << "_entity_hdrs" << endl;
+    cmLists << "if(SC_EXP2CXX_LATE_BOUND)" << endl;
+    cmLists << "  set(" << shortName << "_entity_hdrs)" << endl;
+    cmLists << "else()" << endl;
+    cmLists << "  set(" << shortName << "_entity_hdrs" << endl;
     cmLists << eh.str();
-    cmLists << "   )" << endl << endl;
+    cmLists << "  )" << endl;
+    cmLists << "endif()" << endl << endl;
 
-    cmLists << "set(" << shortName << "_type_hdrs" << endl;
+    cmLists << "if(SC_EXP2CXX_LATE_BOUND)" << endl;
+    cmLists << "  set(" << shortName << "_type_hdrs)" << endl;
+    cmLists << "else()" << endl;
+    cmLists << "  set(" << shortName << "_type_hdrs" << endl;
     cmLists << th.str();
-    cmLists << "   )" << endl << endl;
+    cmLists << "  )" << endl;
+    cmLists << "endif()" << endl << endl;
 
     cmLists << "set(" << shortName << "_misc_hdrs" << endl;
     cmLists << "     Sdaiclasses.h   schema.h" << endl;
@@ -256,7 +268,12 @@ void writeLists( const char * schemaName, stringstream & eh, stringstream & ei,
 
     cmLists << "# unity build: #include small .cc files to reduce the number" << endl;
     cmLists << "# of translation units that must be compiled" << endl;
-    cmLists << "if(SC_UNITY_BUILD)" << endl << "  # bounded unity chunks; definitions are target-local" << endl;
+    cmLists << "if(SC_EXP2CXX_LATE_BOUND)" << endl;
+    cmLists << "  set(" << shortName << "_unity_build FALSE)" << endl;
+    cmLists << "  set(" << shortName << "_entity_impls)" << endl;
+    cmLists << "  set(" << shortName << "_type_impls)" << endl;
+    cmLists << "elseif(SC_UNITY_BUILD)" << endl;
+    cmLists << "  # bounded compact chunks; definitions are target-local" << endl;
     cmLists << "  set(" << shortName << "_unity_build TRUE)" << endl;
     cmLists << "  set(" << shortName << "_entity_impls" << endl;
     for( int chunk = 1; chunk <= entityChunks; ++chunk ) {
@@ -270,15 +287,15 @@ void writeLists( const char * schemaName, stringstream & eh, stringstream & ei,
             std::setfill( '0' ) << std::setw( 4 ) << chunk << ".cc" << endl;
     }
     cmLists << "  )" << endl;
-    cmLists << "else(SC_UNITY_BUILD)" << endl;
+    cmLists << "else()" << endl;
     cmLists << "  set(" << shortName << "_entity_impls" << endl;
     cmLists << ei.str();
     cmLists << "   )" << endl << endl;
 
     cmLists << "  set(" << shortName << "_type_impls" << endl;
     cmLists << ti.str();
     cmLists << "   )" << endl;
-    cmLists << "endif(SC_UNITY_BUILD)" << endl << endl;
+    cmLists << "endif()" << endl << endl;
 
     cmLists << "set( " << shortName << "_misc_impls" << endl;
     cmLists << "     SdaiAll.cc    compstructs.cc    schema.cc" << endl;

diff --git a/cmake/schema_scanner/schemaScanner.cmake b/cmake/schema_scanner/schemaScanner.cmake
@@ -22,6 +22,40 @@ if(NOT DEFINED SC_EXP2CXX_CHUNK_SIZE)
   set(SC_EXP2CXX_CHUNK_SIZE "64:8" CACHE STRING "Maximum entity:type objects in generated unity translation units")
 endif()
 
+if(NOT DEFINED SC_EXP2CXX_API_VERSION)
+  set(SC_EXP2CXX_API_VERSION "1")
+endif()
+set(SC_EXP2CXX_API_VERSION "${SC_EXP2CXX_API_VERSION}" CACHE STRING "Generated C++ API version (1 or 2)")
+set_property(CACHE SC_EXP2CXX_API_VERSION PROPERTY STRINGS 1 2)
+if(NOT SC_EXP2CXX_API_VERSION MATCHES "^[12]$")
+  message(FATAL_ERROR "SC_EXP2CXX_API_VERSION must be 1 or 2")
+endif()
+
+option(SC_EXP2CXX_LATE_BOUND "Generate descriptor-backed entities without early-bound C++ entity classes" OFF)
+if(SC_EXP2CXX_LATE_BOUND AND NOT SC_EXP2CXX_API_VERSION STREQUAL "2")
+  message(FATAL_ERROR "SC_EXP2CXX_LATE_BOUND requires SC_EXP2CXX_API_VERSION=2")
+endif()
+
+option(SC_EXP2CXX_COMPAT_NAMES "Retain generated entity aliases in late-bound output" OFF)
+if(SC_EXP2CXX_COMPAT_NAMES AND NOT SC_EXP2CXX_LATE_BOUND)
+  message(FATAL_ERROR "SC_EXP2CXX_COMPAT_NAMES requires SC_EXP2CXX_LATE_BOUND=ON")
+endif()
+
+if(NOT DEFINED SC_EXP2CXX_METADATA)
+  set(SC_EXP2CXX_METADATA "full")
+endif()
+set(SC_EXP2CXX_METADATA "${SC_EXP2CXX_METADATA}" CACHE STRING
+  "Generated schema metadata profile (full or structural)")
+set_property(CACHE SC_EXP2CXX_METADATA PROPERTY STRINGS full structural)
+if(NOT SC_EXP2CXX_METADATA MATCHES "^(full|structural)$")
+  message(FATAL_ERROR "SC_EXP2CXX_METADATA must be full or structural")
+endif()
+if(SC_EXP2CXX_METADATA STREQUAL "structural" AND
+   NOT SC_EXP2CXX_LATE_BOUND)
+  message(FATAL_ERROR
+    "SC_EXP2CXX_METADATA=structural requires SC_EXP2CXX_LATE_BOUND=ON")
+endif()
+
 
 # --- variables ---
 # SC_ROOT: SC root dir