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);
