This is an automated email from the ASF dual-hosted git repository.
paleolimbot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new 84e92f6 [C] Fix some compiler warnings (#44)
84e92f6 is described below
commit 84e92f66a90da9b39a5cc98f4445e7dafea57078
Author: David Li <[email protected]>
AuthorDate: Tue Sep 13 11:01:16 2022 -0400
[C] Fix some compiler warnings (#44)
* [C] Fix some compiler warnings
* Address feedback
---
CMakeLists.txt | 25 +++++++++++++++++++++++++
src/nanoarrow/array_inline.h | 16 ++++++++--------
src/nanoarrow/schema.c | 26 ++++++++++++++++----------
src/nanoarrow/schema_test.cc | 15 +++++++++++++++
src/nanoarrow/utils.c | 2 +-
5 files changed, 65 insertions(+), 19 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6ba5a49..119d527 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,6 +89,31 @@ else()
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
$<INSTALL_INTERFACE:include>)
target_include_directories(nanoarrow PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated>)
+ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+ if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+ target_compile_options(
+ nanoarrow
+ PRIVATE
+ -Wall
+ -Werror
+ -Wextra
+ -Wno-type-limits
+ -Wno-unused-parameter
+ -Wpedantic
+ -Wunused-result)
+ elseif(CMAKE_C_COMPILER_ID STREQUAL "AppleClang" OR
+ CMAKE_C_COMPILER_ID STREQUAL "Clang")
+ target_compile_options(
+ nanoarrow
+ PRIVATE
+ -Wall
+ -Werror
+ -Wextra
+ -Wdocumentation
+ -Wno-unused-parameter
+ -Wshorten-64-to-32)
+ endif()
+ endif()
install(TARGETS nanoarrow DESTINATION lib)
install(DIRECTORY src/ DESTINATION include FILES_MATCHING PATTERN "*.h")
diff --git a/src/nanoarrow/array_inline.h b/src/nanoarrow/array_inline.h
index f1f838c..254b842 100644
--- a/src/nanoarrow/array_inline.h
+++ b/src/nanoarrow/array_inline.h
@@ -205,15 +205,15 @@ static inline ArrowErrorCode ArrowArrayAppendInt(struct
ArrowArray* array,
break;
case NANOARROW_TYPE_INT32:
_NANOARROW_CHECK_RANGE(value, INT32_MIN, INT32_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(data_buffer,
(int32_t)value));
break;
case NANOARROW_TYPE_INT16:
_NANOARROW_CHECK_RANGE(value, INT16_MIN, INT16_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt16(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt16(data_buffer,
(int16_t)value));
break;
case NANOARROW_TYPE_INT8:
_NANOARROW_CHECK_RANGE(value, INT8_MIN, INT8_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt8(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt8(data_buffer,
(int8_t)value));
break;
case NANOARROW_TYPE_UINT64:
case NANOARROW_TYPE_UINT32:
@@ -255,15 +255,15 @@ static inline ArrowErrorCode ArrowArrayAppendUInt(struct
ArrowArray* array,
break;
case NANOARROW_TYPE_UINT32:
_NANOARROW_CHECK_RANGE(value, 0, UINT32_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt32(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt32(data_buffer,
(uint32_t)value));
break;
case NANOARROW_TYPE_UINT16:
_NANOARROW_CHECK_RANGE(value, 0, UINT16_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt16(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt16(data_buffer,
(uint16_t)value));
break;
case NANOARROW_TYPE_UINT8:
_NANOARROW_CHECK_RANGE(value, 0, UINT8_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt8(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt8(data_buffer,
(uint8_t)value));
break;
case NANOARROW_TYPE_INT64:
case NANOARROW_TYPE_INT32:
@@ -406,7 +406,7 @@ static inline ArrowErrorCode ArrowArrayFinishElement(struct
ArrowArray* array) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppendInt32(ArrowArrayBuffer(array, 1), child_length));
+ ArrowBufferAppendInt32(ArrowArrayBuffer(array, 1),
(int32_t)child_length));
break;
case NANOARROW_TYPE_LARGE_LIST:
child_length = array->children[0]->length;
@@ -449,7 +449,7 @@ static inline int8_t ArrowArrayViewIsNull(struct
ArrowArrayView* array_view, int
case NANOARROW_TYPE_DENSE_UNION:
case NANOARROW_TYPE_SPARSE_UNION:
// Not supported yet
- return 0xff;
+ return -1;
default:
return validity_buffer != NULL && !ArrowBitGet(validity_buffer, i);
}
diff --git a/src/nanoarrow/schema.c b/src/nanoarrow/schema.c
index b498079..0bdbc15 100644
--- a/src/nanoarrow/schema.c
+++ b/src/nanoarrow/schema.c
@@ -291,7 +291,7 @@ ArrowErrorCode ArrowSchemaInitDateTime(struct ArrowSchema*
schema,
return EINVAL;
}
- if (n_chars >= sizeof(buffer)) {
+ if (((size_t)n_chars) >= sizeof(buffer)) {
schema->release(schema);
return ERANGE;
}
@@ -545,14 +545,14 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
}
parse_start = format + 2;
- schema_view->decimal_precision = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_precision = (int32_t)strtol(parse_start,
&parse_end, 10);
if (parse_end == parse_start || parse_end[0] != ',') {
ArrowErrorSet(error, "Expected 'precision,scale[,bitwidth]' following
'd:'");
return EINVAL;
}
parse_start = parse_end + 1;
- schema_view->decimal_scale = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_scale = (int32_t)strtol(parse_start, &parse_end,
10);
if (parse_end == parse_start) {
ArrowErrorSet(error, "Expected 'scale[,bitwidth]' following
'd:precision,'");
return EINVAL;
@@ -560,7 +560,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
schema_view->decimal_bitwidth = 128;
} else {
parse_start = parse_end + 1;
- schema_view->decimal_bitwidth = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_bitwidth = (int32_t)strtol(parse_start,
&parse_end, 10);
if (parse_start == parse_end) {
ArrowErrorSet(error, "Expected precision following
'd:precision,scale,'");
return EINVAL;
@@ -591,7 +591,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->fixed_size = strtol(format + 2, (char**)format_end_out, 10);
+ schema_view->fixed_size = (int32_t)strtol(format + 2,
(char**)format_end_out, 10);
return NANOARROW_OK;
// validity + offset + data
@@ -644,7 +644,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
- schema_view->fixed_size = strtol(format + 3, (char**)format_end_out,
10);
+ schema_view->fixed_size =
+ (int32_t)strtol(format + 3, (char**)format_end_out, 10);
return NANOARROW_OK;
case 's':
schema_view->storage_data_type = NANOARROW_TYPE_STRUCT;
@@ -688,6 +689,11 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
format);
return EINVAL;
}
+
+ default:
+ ArrowErrorSet(error, "Expected nested type format string but found
'%s'",
+ format);
+ return EINVAL;
}
// date/time types
@@ -1026,7 +1032,7 @@ ArrowErrorCode ArrowSchemaViewInit(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- int format_len = strlen(format);
+ size_t format_len = strlen(format);
if (format_len == 0) {
ArrowErrorSet(error, "Error parsing schema->format: Expected a string with
size > 0");
return EINVAL;
@@ -1199,15 +1205,15 @@ static ArrowErrorCode
ArrowMetadataBuilderAppendInternal(struct ArrowBuffer* buf
NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(buffer, 0));
}
- if (buffer->capacity_bytes < sizeof(int32_t)) {
+ if (((size_t)buffer->capacity_bytes) < sizeof(int32_t)) {
return EINVAL;
}
int32_t n_keys;
memcpy(&n_keys, buffer->data, sizeof(int32_t));
- int32_t key_size = key->n_bytes;
- int32_t value_size = value->n_bytes;
+ int32_t key_size = (int32_t)key->n_bytes;
+ int32_t value_size = (int32_t)value->n_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(
buffer, sizeof(int32_t) + key_size + sizeof(int32_t) + value_size));
diff --git a/src/nanoarrow/schema_test.cc b/src/nanoarrow/schema_test.cc
index 04a104b..e88977f 100644
--- a/src/nanoarrow/schema_test.cc
+++ b/src/nanoarrow/schema_test.cc
@@ -1119,6 +1119,21 @@ TEST(SchemaViewTest, SchemaViewInitNestedUnionErrors) {
schema.release(&schema);
}
+TEST(SchemaViewTest, SchemaViewInitInvalidSpecErrors) {
+ struct ArrowSchema schema;
+ struct ArrowSchemaView schema_view;
+ struct ArrowError error;
+ ASSERT_EQ(ArrowSchemaInit(&schema, NANOARROW_TYPE_NA), NANOARROW_OK);
+
+ ASSERT_EQ(ArrowSchemaSetFormat(&schema, "+Z"), NANOARROW_OK);
+ EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), EINVAL);
+ EXPECT_STREQ(ArrowErrorMessage(&error),
+ "Error parsing schema->format: Expected nested type "
+ "format string but found '+Z'");
+
+ schema.release(&schema);
+}
+
TEST(SchemaViewTest, SchemaViewInitDictionary) {
struct ArrowSchema schema;
struct ArrowSchemaView schema_view;
diff --git a/src/nanoarrow/utils.c b/src/nanoarrow/utils.c
index a817853..b87fa65 100644
--- a/src/nanoarrow/utils.c
+++ b/src/nanoarrow/utils.c
@@ -40,7 +40,7 @@ int ArrowErrorSet(struct ArrowError* error, const char* fmt,
...) {
if (chars_needed < 0) {
return EINVAL;
- } else if (chars_needed >= sizeof(error->message)) {
+ } else if (((size_t)chars_needed) >= sizeof(error->message)) {
return ERANGE;
} else {
return NANOARROW_OK;
