Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package aws-c-common for openSUSE:Factory 
checked in at 2024-10-27 11:25:12
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/aws-c-common (Old)
 and      /work/SRC/openSUSE:Factory/.aws-c-common.new.2020 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "aws-c-common"

Sun Oct 27 11:25:12 2024 rev:14 rq:1218384 version:0.10.0

Changes:
--------
--- /work/SRC/openSUSE:Factory/aws-c-common/aws-c-common.changes        
2024-09-24 17:32:19.878705720 +0200
+++ /work/SRC/openSUSE:Factory/.aws-c-common.new.2020/aws-c-common.changes      
2024-10-27 11:25:34.211138572 +0100
@@ -1,0 +2,14 @@
+Thu Oct 24 11:48:38 UTC 2024 - John Paul Adrian Glaubitz 
<adrian.glaub...@suse.com>
+
+- Update to version 0.10.0
+  * Update CMake to 3.9 by @waahm7 in (#1159)
+- from version 0.9.31
+  * Support Swift CXX Interop by @waahm7 in (#1160)
+- from version 0.9.30
+  * Improve condition_variable documentation by @jmklix in (#1157)
+  * Fix Cmake Prebuild Remove -S Option by @waahm7 in (#1158)
+- from version 0.9.29
+  * Add comment about tuning for "neoverse-v1" by @graebm in (#1153)
+  * [fix] prebuild set CMAKE_PREFIX_PATH properly by @TingDaoK in (#1154)
+
+-------------------------------------------------------------------

Old:
----
  v0.9.28.tar.gz

New:
----
  v0.10.0.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ aws-c-common.spec ++++++
--- /var/tmp/diff_new_pack.Va4N2T/_old  2024-10-27 11:25:35.499191965 +0100
+++ /var/tmp/diff_new_pack.Va4N2T/_new  2024-10-27 11:25:35.511192462 +0100
@@ -19,7 +19,7 @@
 %define library_version 1.0.0
 %define library_soversion 1
 Name:           aws-c-common
-Version:        0.9.28
+Version:        0.10.0
 Release:        0
 Summary:        Core C99 package for AWS SDK for C
 License:        Apache-2.0

++++++ v0.9.28.tar.gz -> v0.10.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' 
old/aws-c-common-0.9.28/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt 
new/aws-c-common-0.10.0/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt
--- 
old/aws-c-common-0.9.28/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt 
    2024-09-06 21:07:00.000000000 +0200
+++ 
new/aws-c-common-0.10.0/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt 
    2024-10-23 18:56:03.000000000 +0200
@@ -3,7 +3,7 @@
 
 # Sets the minimum version of CMake required to build the native library.
 
-cmake_minimum_required(VERSION 3.4.1)
+cmake_minimum_required(VERSION 3.9)
 
 # AWS lib
 set(path_to_common "${CMAKE_CURRENT_LIST_DIR}/../../../../..")
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/CMakeLists.txt 
new/aws-c-common-0.10.0/CMakeLists.txt
--- old/aws-c-common-0.9.28/CMakeLists.txt      2024-09-06 21:07:00.000000000 
+0200
+++ new/aws-c-common-0.10.0/CMakeLists.txt      2024-10-23 18:56:03.000000000 
+0200
@@ -1,17 +1,15 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0.
 
-cmake_minimum_required(VERSION 3.0)
+# As of October 2024, we picked 3.9 as our version because internally we still 
support RHEL5 and AL2012, and CMake 3.9
+# was the latest version available on those platforms.
+cmake_minimum_required(VERSION 3.9)
 option(ALLOW_CROSS_COMPILED_TESTS "Allow tests to be compiled via cross 
compile, for use with qemu" OFF)
 
 project(aws-c-common LANGUAGES C VERSION 0.1.0)
 
 message(STATUS "CMake ${CMAKE_VERSION}")
 
-if (POLICY CMP0069)
-    cmake_policy(SET CMP0069 NEW) # Enable LTO/IPO if available in the 
compiler, see AwsCFlags
-endif()
-
 if (POLICY CMP0077)
     cmake_policy(SET CMP0077 OLD) # Enable options to get their values from 
normal variables
 endif()
@@ -189,7 +187,6 @@
         ${AWS_COMMON_EXTERNAL_SRC}
         )
 
-
 add_library(${PROJECT_NAME} ${COMMON_SRC})
 aws_set_common_properties(${PROJECT_NAME} NO_WEXTRA)
 aws_prepare_symbol_visibility_args(${PROJECT_NAME} "AWS_COMMON")
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/cmake/AwsCFlags.cmake 
new/aws-c-common-0.10.0/cmake/AwsCFlags.cmake
--- old/aws-c-common-0.9.28/cmake/AwsCFlags.cmake       2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/cmake/AwsCFlags.cmake       2024-10-23 
18:56:03.000000000 +0200
@@ -4,7 +4,6 @@
 include(CheckCCompilerFlag)
 include(CheckIncludeFile)
 include(CheckSymbolExists)
-include(CMakeParseArguments) # needed for CMake v3.4 and lower
 
 option(AWS_ENABLE_LTO "Enables LTO on libraries. Ensure this is set on all 
consumed targets, or linking will fail" OFF)
 option(LEGACY_COMPILER_SUPPORT "This enables builds with compiler versions 
such as gcc 4.1.2. This is not a 'supported' feature; it's just a best effort." 
OFF)
@@ -173,6 +172,7 @@
             set_property(TARGET ${target} APPEND_STRING PROPERTY LINK_FLAGS " 
-Wl,--exclude-libs,libcrypto.a")
         endif()
 
+
     endif()
 
     check_include_file(stdint.h HAS_STDINT)
@@ -230,30 +230,18 @@
         set(_ENABLE_LTO_EXPR $<NOT:$<CONFIG:Debug>>)
 
         # try to check whether compiler supports LTO/IPO
-        if (POLICY CMP0069)
-            cmake_policy(SET CMP0069 NEW)
-            include(CheckIPOSupported OPTIONAL RESULT_VARIABLE 
ipo_check_exists)
-            if (ipo_check_exists)
-                check_ipo_supported(RESULT ipo_supported)
-                if (ipo_supported)
-                    message(STATUS "Enabling IPO/LTO for Release builds")
-                else()
-                    message(STATUS "AWS_ENABLE_LTO is enabled, but 
cmake/compiler does not support it, disabling")
-                    set(_ENABLE_LTO_EXPR OFF)
-                endif()
-            endif()
+        include(CheckIPOSupported) 
+        check_ipo_supported(RESULT ipo_supported)
+        if (ipo_supported)
+            message(STATUS "Enabling IPO/LTO for Release builds")
+        else()
+            message(STATUS "AWS_ENABLE_LTO is enabled, but cmake/compiler does 
not support it, disabling")
+            set(_ENABLE_LTO_EXPR OFF)
         endif()
     else()
         set(_ENABLE_LTO_EXPR OFF)
     endif()
 
-    if(BUILD_SHARED_LIBS)
-        if (NOT MSVC)
-            # this should only be set when building shared libs.
-            list(APPEND AWS_C_FLAGS "-fvisibility=hidden")
-        endif()
-    endif()
-
     if(AWS_ENABLE_TRACING)
         target_link_libraries(${target} PRIVATE ittnotify)
     else()
@@ -264,4 +252,11 @@
     target_compile_definitions(${target} PRIVATE ${AWS_C_DEFINES_PRIVATE} 
PUBLIC ${AWS_C_DEFINES_PUBLIC})
     set_target_properties(${target} PROPERTIES LINKER_LANGUAGE C C_STANDARD 99 
C_STANDARD_REQUIRED ON)
     set_target_properties(${target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION 
${_ENABLE_LTO_EXPR}>)
+
+    # Don't hide symbols in Debug builds.
+    # We do this so that backtraces are more likely to show function names.
+    # We mostly use backtraces to diagnose memory leaks.
+    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set_target_properties(${target} PROPERTIES C_VISIBILITY_PRESET hidden 
CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
+    endif ()
 endfunction()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' 
old/aws-c-common-0.9.28/cmake/AwsPrebuildDependency.cmake 
new/aws-c-common-0.10.0/cmake/AwsPrebuildDependency.cmake
--- old/aws-c-common-0.9.28/cmake/AwsPrebuildDependency.cmake   2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/cmake/AwsPrebuildDependency.cmake   2024-10-23 
18:56:03.000000000 +0200
@@ -25,11 +25,13 @@
     set(depInstallDir ${depBinaryDir}/install)
     file(MAKE_DIRECTORY ${depBinaryDir})
 
+    # Convert prefix path from list to escaped string, to be passed on command 
line
+    string(REPLACE ";" "\\\\;" ESCAPED_PREFIX_PATH "${CMAKE_PREFIX_PATH}")
     # For execute_process to accept a dynamically constructed command, it 
should be passed in a list format.
-    set(cmakeCommand "COMMAND" "${CMAKE_COMMAND}")
-    list(APPEND cmakeCommand -S ${AWS_PREBUILD_SOURCE_DIR})
+    set(cmakeCommand "${CMAKE_COMMAND}")
+    list(APPEND cmakeCommand ${AWS_PREBUILD_SOURCE_DIR})
     list(APPEND cmakeCommand -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE})
-    list(APPEND cmakeCommand -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH})
+    list(APPEND cmakeCommand -DCMAKE_PREFIX_PATH=${ESCAPED_PREFIX_PATH})
     list(APPEND cmakeCommand -DCMAKE_INSTALL_PREFIX=${depInstallDir})
     list(APPEND cmakeCommand -DCMAKE_INSTALL_RPATH=${CMAKE_INSTALL_RPATH})
     list(APPEND cmakeCommand -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS})
@@ -39,11 +41,13 @@
         list(APPEND cmakeCommand ${AWS_PREBUILD_CMAKE_ARGUMENTS})
     endif()
 
-    list(APPEND cmakeCommand WORKING_DIRECTORY ${depBinaryDir})
-    list(APPEND cmakeCommand RESULT_VARIABLE result)
-
     # Configure dependency project.
-    execute_process(${cmakeCommand})
+    execute_process(
+        COMMAND ${cmakeCommand}
+        WORKING_DIRECTORY ${depBinaryDir}
+        RESULT_VARIABLE result
+    )
+
     if (NOT ${result} EQUAL 0)
         message(FATAL_ERROR "Configuration failed for dependency project 
${AWS_PREBUILD_DEPENDENCY_NAME}")
     endif()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/cmake/AwsSIMD.cmake 
new/aws-c-common-0.10.0/cmake/AwsSIMD.cmake
--- old/aws-c-common-0.9.28/cmake/AwsSIMD.cmake 2024-09-06 21:07:00.000000000 
+0200
+++ new/aws-c-common-0.10.0/cmake/AwsSIMD.cmake 2024-10-23 18:56:03.000000000 
+0200
@@ -19,6 +19,7 @@
     set(AWS_CLMUL_FLAG "-mpclmul")
     set(AWS_SSE4_2_FLAG "-msse4.2")
 
+    # AWS Graviton3 processors use neoverse-v1
     check_c_compiler_flag("-mtune=neoverse-v1" HAVE_MTUNE_NEOVERSE_V1)
     if (HAVE_MTUNE_NEOVERSE_V1)
         set(AWS_ARMv8_1_FLAG "-march=armv8-a+crc+crypto -mtune=neoverse-v1")
@@ -58,7 +59,7 @@
             _mm256_permutevar8x32_epi32(vec, vec);
 
             return 0;
-        }"  AWS_HAVE_AVX2_INTRINSICS)          
+        }"  AWS_HAVE_AVX2_INTRINSICS)
 
     check_c_source_compiles("
         #include <immintrin.h>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/cmake/AwsTestHarness.cmake 
new/aws-c-common-0.10.0/cmake/AwsTestHarness.cmake
--- old/aws-c-common-0.9.28/cmake/AwsTestHarness.cmake  2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/cmake/AwsTestHarness.cmake  2024-10-23 
18:56:03.000000000 +0200
@@ -39,9 +39,9 @@
     add_executable(${driver_exe_name} 
${CMAKE_CURRENT_BINARY_DIR}/test_runner.c ${TESTS})
     aws_set_common_properties(${driver_exe_name} NO_WEXTRA NO_PEDANTIC)
 
-     # Some versions of CMake (3.9-3.11) generate a test_runner.c file with
-     # a strncpy() call that triggers the "stringop-overflow" warning in GCC 
8.1+
-     # This warning doesn't exist until GCC 7 though, so test for it before 
disabling.
+    # Some versions of CMake (3.9-3.11) generate a test_runner.c file with
+    # a strncpy() call that triggers the "stringop-overflow" warning in GCC 
8.1+
+    # This warning doesn't exist until GCC 7 though, so test for it before 
disabling.
     if (NOT MSVC)
         check_c_compiler_flag(-Wno-stringop-overflow HAS_WNO_STRINGOP_OVERFLOW)
         if (HAS_WNO_STRINGOP_OVERFLOW)
@@ -57,6 +57,9 @@
     target_compile_definitions(${driver_exe_name} PRIVATE 
AWS_UNSTABLE_TESTING_API=1)
     target_include_directories(${driver_exe_name} PRIVATE 
${CMAKE_CURRENT_LIST_DIR})
 
+    # Export symbols so that backtraces are more likely to show function names.
+    set_target_properties(${driver_exe_name} PROPERTIES ENABLE_EXPORTS ON)
+
     foreach(name IN LISTS TEST_CASES)
         add_test(${name} ${driver_exe_name} "${name}")
         set_tests_properties("${name}" PROPERTIES SKIP_RETURN_CODE 
${SKIP_RETURN_CODE_VALUE})
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/array_list.h 
new/aws-c-common-0.10.0/include/aws/common/array_list.h
--- old/aws-c-common-0.9.28/include/aws/common/array_list.h     2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/array_list.h     2024-10-23 
18:56:03.000000000 +0200
@@ -231,11 +231,11 @@
 AWS_COMMON_API
 void aws_array_list_sort(struct aws_array_list *AWS_RESTRICT list, 
aws_array_list_comparator_fn *compare_fn);
 
+AWS_EXTERN_C_END
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/array_list.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_ARRAY_LIST_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/atomics.h 
new/aws-c-common-0.10.0/include/aws/common/atomics.h
--- old/aws-c-common-0.9.28/include/aws/common/atomics.h        2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/atomics.h        2024-10-23 
18:56:03.000000000 +0200
@@ -318,11 +318,12 @@
 AWS_STATIC_IMPL
 void aws_atomic_thread_fence(enum aws_memory_order order);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/atomics.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/atomics.inl 
new/aws-c-common-0.10.0/include/aws/common/atomics.inl
--- old/aws-c-common-0.9.28/include/aws/common/atomics.inl      2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/atomics.inl      2024-10-23 
18:56:03.000000000 +0200
@@ -127,6 +127,7 @@
 size_t aws_atomic_fetch_xor(volatile struct aws_atomic_var *var, size_t n) {
     return aws_atomic_fetch_xor_explicit(var, n, aws_memory_order_seq_cst);
 }
+AWS_EXTERN_C_END
 
 /* Include the backend implementation now, because we'll use its typedefs and 
#defines below */
 #if defined(__GNUC__) || defined(__clang__)
@@ -143,6 +144,4 @@
 
 #include <aws/common/atomics_fallback.inl>
 
-AWS_EXTERN_C_END
-
 #endif /* AWS_COMMON_ATOMICS_INL */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/byte_order.h 
new/aws-c-common-0.10.0/include/aws/common/byte_order.h
--- old/aws-c-common-0.9.28/include/aws/common/byte_order.h     2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/byte_order.h     2024-10-23 
18:56:03.000000000 +0200
@@ -66,11 +66,11 @@
  */
 AWS_STATIC_IMPL uint16_t aws_ntoh16(uint16_t x);
 
+AWS_EXTERN_C_END
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/byte_order.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_BYTE_ORDER_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/clock.h 
new/aws-c-common-0.10.0/include/aws/common/clock.h
--- old/aws-c-common-0.9.28/include/aws/common/clock.h  2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/clock.h  2024-10-23 
18:56:03.000000000 +0200
@@ -54,11 +54,12 @@
 AWS_COMMON_API
 int aws_sys_clock_get_ticks(uint64_t *timestamp);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/clock.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_CLOCK_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' 
old/aws-c-common-0.9.28/include/aws/common/condition_variable.h 
new/aws-c-common-0.10.0/include/aws/common/condition_variable.h
--- old/aws-c-common-0.9.28/include/aws/common/condition_variable.h     
2024-09-06 21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/condition_variable.h     
2024-10-23 18:56:03.000000000 +0200
@@ -69,14 +69,17 @@
 int aws_condition_variable_notify_all(struct aws_condition_variable 
*condition_variable);
 
 /**
- * Waits the calling thread on a notification from another thread.
+ * Waits the calling thread on a notification from another thread. This 
function must be called with the mutex locked
+ * by the calling thread otherwise the behavior is undefined. Spurious wakeups 
can occur and to avoid this causing
+ * any problems use the _pred version of this function.
  */
 AWS_COMMON_API
 int aws_condition_variable_wait(struct aws_condition_variable 
*condition_variable, struct aws_mutex *mutex);
 
 /**
  * Waits the calling thread on a notification from another thread. If 
predicate returns false, the wait is reentered,
- * otherwise control returns to the caller.
+ * otherwise control returns to the caller. This function must be called with 
the mutex locked by the calling thread
+ * otherwise the behavior is undefined.
  */
 AWS_COMMON_API
 int aws_condition_variable_wait_pred(
@@ -87,7 +90,8 @@
 
 /**
  * Waits the calling thread on a notification from another thread. Times out 
after time_to_wait. time_to_wait is in
- * nanoseconds.
+ * nanoseconds. This function must be called with the mutex locked by the 
calling thread otherwise the behavior is
+ * undefined. Spurious wakeups can occur and to avoid this causing any 
problems use the _pred version of this function.
  */
 AWS_COMMON_API
 int aws_condition_variable_wait_for(
@@ -97,7 +101,8 @@
 
 /**
  * Waits the calling thread on a notification from another thread. Times out 
after time_to_wait. time_to_wait is in
- * nanoseconds. If predicate returns false, the wait is reentered, otherwise 
control returns to the caller.
+ * nanoseconds. If predicate returns false, the wait is reentered, otherwise 
control returns to the caller. This
+ * function must be called with the mutex locked by the calling thread 
otherwise the behavior is undefined.
  */
 AWS_COMMON_API
 int aws_condition_variable_wait_for_pred(
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/encoding.h 
new/aws-c-common-0.10.0/include/aws/common/encoding.h
--- old/aws-c-common-0.9.28/include/aws/common/encoding.h       2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/encoding.h       2024-10-23 
18:56:03.000000000 +0200
@@ -224,11 +224,12 @@
  */
 AWS_COMMON_API int aws_utf8_decoder_finalize(struct aws_utf8_decoder *decoder);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/encoding.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_ENCODING_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/error.h 
new/aws-c-common-0.10.0/include/aws/common/error.h
--- old/aws-c-common-0.9.28/include/aws/common/error.h  2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/error.h  2024-10-23 
18:56:03.000000000 +0200
@@ -149,12 +149,11 @@
 AWS_COMMON_API
 int aws_translate_and_raise_io_error(int error_no);
 
+AWS_EXTERN_C_END
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/error.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
-
 enum aws_common_error {
     AWS_ERROR_SUCCESS = AWS_ERROR_ENUM_BEGIN_RANGE(AWS_C_COMMON_PACKAGE_ID),
     AWS_ERROR_OOM,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/linked_list.h 
new/aws-c-common-0.10.0/include/aws/common/linked_list.h
--- old/aws-c-common-0.9.28/include/aws/common/linked_list.h    2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/linked_list.h    2024-10-23 
18:56:03.000000000 +0200
@@ -186,11 +186,11 @@
  * Returns true if the node is currently in a list, false otherwise.
  */
 AWS_STATIC_IMPL bool aws_linked_list_node_is_in_list(struct 
aws_linked_list_node *node);
+AWS_EXTERN_C_END
 
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/linked_list.inl>
 #endif /* AWS_NO_STATIC_IMPL */
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_LINKED_LIST_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/math.h 
new/aws-c-common-0.10.0/include/aws/common/math.h
--- old/aws-c-common-0.9.28/include/aws/common/math.h   2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/math.h   2024-10-23 
18:56:03.000000000 +0200
@@ -200,11 +200,11 @@
 AWS_STATIC_IMPL double aws_min_double(double a, double b);
 AWS_STATIC_IMPL double aws_max_double(double a, double b);
 
+AWS_EXTERN_C_END
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/math.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_MATH_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/math.inl 
new/aws-c-common-0.10.0/include/aws/common/math.inl
--- old/aws-c-common-0.9.28/include/aws/common/math.inl 2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/math.inl 2024-10-23 
18:56:03.000000000 +0200
@@ -13,8 +13,6 @@
 #include <limits.h>
 #include <stdlib.h>
 
-AWS_EXTERN_C_BEGIN
-
 #if defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS) && (defined(__clang__) || 
!defined(__cplusplus))
 /*
  * GCC and clang have these super convenient overflow checking builtins...
@@ -48,6 +46,8 @@
 #    include <aws/common/math.gcc_builtin.inl>
 #endif
 
+AWS_EXTERN_C_BEGIN
+
 #ifdef _MSC_VER
 #    pragma warning(push)
 #    pragma warning(disable : 4127) /*Disable "conditional expression is 
constant" */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/ring_buffer.h 
new/aws-c-common-0.10.0/include/aws/common/ring_buffer.h
--- old/aws-c-common-0.9.28/include/aws/common/ring_buffer.h    2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/ring_buffer.h    2024-10-23 
18:56:03.000000000 +0200
@@ -93,11 +93,12 @@
     const struct aws_ring_buffer *ring_buffer,
     const struct aws_byte_buf *buf);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/ring_buffer.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_RING_BUFFER_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/string.h 
new/aws-c-common-0.10.0/include/aws/common/string.h
--- old/aws-c-common-0.9.28/include/aws/common/string.h 2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/string.h 2024-10-23 
18:56:03.000000000 +0200
@@ -373,11 +373,12 @@
 AWS_STATIC_IMPL
 bool aws_char_is_space(uint8_t c);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/string.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_STRING_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/include/aws/common/zero.h 
new/aws-c-common-0.10.0/include/aws/common/zero.h
--- old/aws-c-common-0.9.28/include/aws/common/zero.h   2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/include/aws/common/zero.h   2024-10-23 
18:56:03.000000000 +0200
@@ -56,11 +56,12 @@
 AWS_COMMON_API
 void aws_secure_zero(void *pBuf, size_t bufsize);
 
+AWS_EXTERN_C_END
+
 #ifndef AWS_NO_STATIC_IMPL
 #    include <aws/common/zero.inl>
 #endif /* AWS_NO_STATIC_IMPL */
 
-AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 
 #endif /* AWS_COMMON_ZERO_H */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/aws-c-common-0.9.28/tests/memtrace_test.c 
new/aws-c-common-0.10.0/tests/memtrace_test.c
--- old/aws-c-common-0.9.28/tests/memtrace_test.c       2024-09-06 
21:07:00.000000000 +0200
+++ new/aws-c-common-0.10.0/tests/memtrace_test.c       2024-10-23 
18:56:03.000000000 +0200
@@ -101,7 +101,7 @@
     /* only bother to run this test if the platform can do a backtrace */
     void *probe_stack[1];
     if (!aws_backtrace(probe_stack, 1)) {
-        return 0;
+        return AWS_OP_SKIP;
     }
 
     test_logger_init(&s_test_logger, allocator, AWS_LL_TRACE, 0);
@@ -146,27 +146,26 @@
     /* if this is not a debug build, there may not be symbols, so the test 
cannot
      * verify if a best effort was made */
 #if defined(DEBUG_BUILD)
-    /* fprintf(stderr, "%s\n", test_logger->log_buffer.buffer); */
+    fprintf(stderr, "%s\n", test_logger->log_buffer.buffer);
     char s_alloc_1_addr[32];
     char s_alloc_2_addr[32];
     char s_alloc_3_addr[32];
     char s_alloc_4_addr[32];
 #    if defined(_MSC_VER)
-#        pragma warning(push)
 #        pragma warning(disable : 4054) /* type cast function pointer to data 
pointer */
+#    endif
+
     snprintf(s_alloc_1_addr, AWS_ARRAY_SIZE(s_alloc_1_addr), "0x%tx", 
(uintptr_t)(void *)s_alloc_1);
     snprintf(s_alloc_2_addr, AWS_ARRAY_SIZE(s_alloc_2_addr), "0x%tx", 
(uintptr_t)(void *)s_alloc_2);
     snprintf(s_alloc_3_addr, AWS_ARRAY_SIZE(s_alloc_3_addr), "0x%tx", 
(uintptr_t)(void *)s_alloc_3);
     snprintf(s_alloc_4_addr, AWS_ARRAY_SIZE(s_alloc_4_addr), "0x%tx", 
(uintptr_t)(void *)s_alloc_4);
-#        pragma warning(pop)
-#    endif /* defined(_MSC_VER) */
 
     const char *log_buffer = (const char *)test_logger->log_buffer.buffer;
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_1") || strstr(log_buffer, 
s_alloc_1_addr));
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_2") || strstr(log_buffer, 
s_alloc_2_addr));
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_3") || strstr(log_buffer, 
s_alloc_3_addr));
     ASSERT_TRUE(strstr(log_buffer, "s_alloc_4") || strstr(log_buffer, 
s_alloc_4_addr));
-#endif
+#endif /* DEBUG_BUILD */
 
     /* reset log */
     aws_byte_buf_reset(&test_logger->log_buffer, true);

Reply via email to