From f6a6b407e62484bef3cee88d0a7bf2a168231da4 Mon Sep 17 00:00:00 2001 From: William Ayd Date: Wed, 12 Jun 2024 10:55:17 -0400 Subject: [PATCH] refactor: Use inttypes.h macros instead of casts to print fixed-width integers (#520) --- src/apps/dump_stream.c | 5 +- src/nanoarrow/array.c | 193 ++++++++++++++------------ src/nanoarrow/nanoarrow_device.c | 6 +- src/nanoarrow/nanoarrow_device_cuda.c | 4 +- src/nanoarrow/nanoarrow_ipc_decoder.c | 91 ++++++------ src/nanoarrow/nanoarrow_ipc_reader.c | 6 +- src/nanoarrow/schema.c | 58 ++++---- 7 files changed, 195 insertions(+), 168 deletions(-) diff --git a/src/apps/dump_stream.c b/src/apps/dump_stream.c index ba1baec4d..e01cfd7c0 100644 --- a/src/apps/dump_stream.c +++ b/src/apps/dump_stream.c @@ -17,6 +17,7 @@ #include "nanoarrow/nanoarrow_ipc.h" +#include #include #include #include @@ -121,8 +122,8 @@ int main(int argc, char* argv[]) { end = clock(); elapsed = (end - begin) / ((double)CLOCKS_PER_SEC); - fprintf(stdout, "Read %ld rows in %ld batch(es) <%.06f seconds>\n", (long)row_count, - (long)batch_count, elapsed); + fprintf(stdout, "Read %l" PRId64 " rows in %" PRId64 " batch(es) <%.06f seconds>\n", + row_count, batch_count, elapsed); ArrowArrayStreamRelease(&stream); fclose(file_ptr); diff --git a/src/nanoarrow/array.c b/src/nanoarrow/array.c index ebd95df1e..0143d4af7 100644 --- a/src/nanoarrow/array.c +++ b/src/nanoarrow/array.c @@ -16,6 +16,7 @@ // under the License. #include +#include #include #include @@ -696,15 +697,17 @@ static int ArrowArrayViewSetArrayInternal(struct ArrowArrayView* array_view, // Check the number of buffers if (buffers_required != array->n_buffers) { - ArrowErrorSet(error, "Expected array with %d buffer(s) but found %d buffer(s)", - (int)buffers_required, (int)array->n_buffers); + ArrowErrorSet(error, + "Expected array with %" PRId64 " buffer(s) but found %" PRId64 + " buffer(s)", + buffers_required, array->n_buffers); return EINVAL; } // Check number of children if (array_view->n_children != array->n_children) { - ArrowErrorSet(error, "Expected %ld children but found %ld children", - (long)array_view->n_children, (long)array->n_children); + ArrowErrorSet(error, "Expected %" PRId64 " children but found %" PRId64 " children", + array_view->n_children, array->n_children); return EINVAL; } @@ -736,14 +739,14 @@ static int ArrowArrayViewSetArrayInternal(struct ArrowArrayView* array_view, static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, struct ArrowError* error) { if (array_view->length < 0) { - ArrowErrorSet(error, "Expected length >= 0 but found length %ld", - (long)array_view->length); + ArrowErrorSet(error, "Expected length >= 0 but found length %" PRId64, + array_view->length); return EINVAL; } if (array_view->offset < 0) { - ArrowErrorSet(error, "Expected offset >= 0 but found offset %ld", - (long)array_view->offset); + ArrowErrorSet(error, "Expected offset >= 0 but found offset %" PRId64, + array_view->offset); return EINVAL; } @@ -791,11 +794,11 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, array_view->buffer_views[i].size_bytes = min_buffer_size_bytes; } else if (array_view->buffer_views[i].size_bytes < min_buffer_size_bytes) { ArrowErrorSet(error, - "Expected %s array buffer %d to have size >= %ld bytes but found " - "buffer with %ld bytes", - ArrowTypeString(array_view->storage_type), (int)i, - (long)min_buffer_size_bytes, - (long)array_view->buffer_views[i].size_bytes); + "Expected %s array buffer %d to have size >= %" PRId64 + " bytes but found " + "buffer with %" PRId64 " bytes", + ArrowTypeString(array_view->storage_type), i, min_buffer_size_bytes, + array_view->buffer_views[i].size_bytes); return EINVAL; } } @@ -807,17 +810,17 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, case NANOARROW_TYPE_FIXED_SIZE_LIST: case NANOARROW_TYPE_MAP: if (array_view->n_children != 1) { - ArrowErrorSet(error, "Expected 1 child of %s array but found %ld child arrays", - ArrowTypeString(array_view->storage_type), - (long)array_view->n_children); + ArrowErrorSet(error, + "Expected 1 child of %s array but found %" PRId64 " child arrays", + ArrowTypeString(array_view->storage_type), array_view->n_children); return EINVAL; } break; case NANOARROW_TYPE_RUN_END_ENCODED: if (array_view->n_children != 2) { ArrowErrorSet( - error, "Expected 2 children for %s array but found %ld child arrays", - ArrowTypeString(array_view->storage_type), (long)array_view->n_children); + error, "Expected 2 children for %s array but found %" PRId64 " child arrays", + ArrowTypeString(array_view->storage_type), array_view->n_children); return EINVAL; } break; @@ -834,12 +837,11 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, child_min_length = (array_view->offset + array_view->length); for (int64_t i = 0; i < array_view->n_children; i++) { if (array_view->children[i]->length < child_min_length) { - ArrowErrorSet( - error, - "Expected struct child %d to have length >= %ld but found child with " - "length %ld", - (int)(i + 1), (long)(child_min_length), - (long)array_view->children[i]->length); + ArrowErrorSet(error, + "Expected struct child %" PRId64 " to have length >= %" PRId64 + " but found child with " + "length %" PRId64, + i + 1, child_min_length, array_view->children[i]->length); return EINVAL; } } @@ -850,9 +852,10 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, array_view->layout.child_size_elements; if (array_view->children[0]->length < child_min_length) { ArrowErrorSet(error, - "Expected child of fixed_size_list array to have length >= %ld but " - "found array with length %ld", - (long)child_min_length, (long)array_view->children[0]->length); + "Expected child of fixed_size_list array to have length >= %" PRId64 + " but " + "found array with length %" PRId64, + child_min_length, array_view->children[0]->length); return EINVAL; } break; @@ -860,8 +863,8 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, case NANOARROW_TYPE_RUN_END_ENCODED: { if (array_view->n_children != 2) { ArrowErrorSet(error, - "Expected 2 children for run-end encoded array but found %ld", - (long)array_view->n_children); + "Expected 2 children for run-end encoded array but found %" PRId64, + array_view->n_children); return EINVAL; } struct ArrowArrayView* run_ends_view = array_view->children[0]; @@ -890,27 +893,29 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, (uint64_t)max_length) { ArrowErrorSet(error, "Offset + length of a run-end encoded array must fit in a value" - " of the run end type %s, but offset + length is %ld", + " of the run end type %s, but offset + length is %" PRId64, ArrowTypeString(run_ends_view->storage_type), - (long)array_view->offset + (long)array_view->length); + array_view->offset + array_view->length); return EINVAL; } if (run_ends_view->length > values_view->length) { - ArrowErrorSet( - error, "Length of run_ends is greater than the length of values: %ld > %ld", - (long)run_ends_view->length, (long)values_view->length); + ArrowErrorSet(error, + "Length of run_ends is greater than the length of values: %" PRId64 + " > %" PRId64, + run_ends_view->length, values_view->length); return EINVAL; } if (run_ends_view->length == 0 && values_view->length != 0) { ArrowErrorSet(error, - "Run-end encoded array has zero length %ld, but values array has " + "Run-end encoded array has zero length %" PRId64 + ", but values array has " "non-zero length", - (long)values_view->length); + values_view->length); return EINVAL; } if (run_ends_view->null_count != 0) { - ArrowErrorSet(error, "Null count must be 0 for run ends array, but is %ld", - (long)run_ends_view->null_count); + ArrowErrorSet(error, "Null count must be 0 for run ends array, but is %" PRId64, + run_ends_view->null_count); return EINVAL; } break; @@ -952,8 +957,8 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, if (array_view->buffer_views[1].size_bytes != 0) { first_offset = array_view->buffer_views[1].data.as_int32[0]; if (first_offset < 0) { - ArrowErrorSet(error, "Expected first offset >= 0 but found %ld", - (long)first_offset); + ArrowErrorSet(error, "Expected first offset >= 0 but found %" PRId64, + first_offset); return EINVAL; } @@ -964,10 +969,11 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, array_view->buffer_views[2].size_bytes = last_offset; } else if (array_view->buffer_views[2].size_bytes < last_offset) { ArrowErrorSet(error, - "Expected %s array buffer 2 to have size >= %ld bytes but found " - "buffer with %ld bytes", - ArrowTypeString(array_view->storage_type), (long)last_offset, - (long)array_view->buffer_views[2].size_bytes); + "Expected %s array buffer 2 to have size >= %" PRId64 + " bytes but found " + "buffer with %" PRId64 " bytes", + ArrowTypeString(array_view->storage_type), last_offset, + array_view->buffer_views[2].size_bytes); return EINVAL; } } else if (array_view->buffer_views[2].size_bytes == -1) { @@ -982,8 +988,8 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, if (array_view->buffer_views[1].size_bytes != 0) { first_offset = array_view->buffer_views[1].data.as_int64[0]; if (first_offset < 0) { - ArrowErrorSet(error, "Expected first offset >= 0 but found %ld", - (long)first_offset); + ArrowErrorSet(error, "Expected first offset >= 0 but found %" PRId64, + first_offset); return EINVAL; } @@ -994,10 +1000,11 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, array_view->buffer_views[2].size_bytes = last_offset; } else if (array_view->buffer_views[2].size_bytes < last_offset) { ArrowErrorSet(error, - "Expected %s array buffer 2 to have size >= %ld bytes but found " - "buffer with %ld bytes", - ArrowTypeString(array_view->storage_type), (long)last_offset, - (long)array_view->buffer_views[2].size_bytes); + "Expected %s array buffer 2 to have size >= %" PRId64 + " bytes but found " + "buffer with %" PRId64 " bytes", + ArrowTypeString(array_view->storage_type), last_offset, + array_view->buffer_views[2].size_bytes); return EINVAL; } } else if (array_view->buffer_views[2].size_bytes == -1) { @@ -1010,12 +1017,11 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, case NANOARROW_TYPE_STRUCT: for (int64_t i = 0; i < array_view->n_children; i++) { if (array_view->children[i]->length < offset_plus_length) { - ArrowErrorSet( - error, - "Expected struct child %d to have length >= %ld but found child with " - "length %ld", - (int)(i + 1), (long)offset_plus_length, - (long)array_view->children[i]->length); + ArrowErrorSet(error, + "Expected struct child %" PRId64 " to have length >= %" PRId64 + " but found child with " + "length %" PRId64, + i + 1, offset_plus_length, array_view->children[i]->length); return EINVAL; } } @@ -1026,19 +1032,19 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, if (array_view->buffer_views[1].size_bytes != 0) { first_offset = array_view->buffer_views[1].data.as_int32[0]; if (first_offset < 0) { - ArrowErrorSet(error, "Expected first offset >= 0 but found %ld", - (long)first_offset); + ArrowErrorSet(error, "Expected first offset >= 0 but found %" PRId64, + first_offset); return EINVAL; } last_offset = array_view->buffer_views[1].data.as_int32[offset_plus_length]; if (array_view->children[0]->length < last_offset) { - ArrowErrorSet( - error, - "Expected child of %s array to have length >= %ld but found array with " - "length %ld", - ArrowTypeString(array_view->storage_type), (long)last_offset, - (long)array_view->children[0]->length); + ArrowErrorSet(error, + "Expected child of %s array to have length >= %" PRId64 + " but found array with " + "length %" PRId64, + ArrowTypeString(array_view->storage_type), last_offset, + array_view->children[0]->length); return EINVAL; } } @@ -1048,18 +1054,18 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, if (array_view->buffer_views[1].size_bytes != 0) { first_offset = array_view->buffer_views[1].data.as_int64[0]; if (first_offset < 0) { - ArrowErrorSet(error, "Expected first offset >= 0 but found %ld", - (long)first_offset); + ArrowErrorSet(error, "Expected first offset >= 0 but found %" PRId64, + first_offset); return EINVAL; } last_offset = array_view->buffer_views[1].data.as_int64[offset_plus_length]; if (array_view->children[0]->length < last_offset) { - ArrowErrorSet( - error, - "Expected child of large list array to have length >= %ld but found array " - "with length %ld", - (long)last_offset, (long)array_view->children[0]->length); + ArrowErrorSet(error, + "Expected child of large list array to have length >= %" PRId64 + " but found array " + "with length %" PRId64, + last_offset, array_view->children[0]->length); return EINVAL; } } @@ -1070,9 +1076,10 @@ static int ArrowArrayViewValidateDefault(struct ArrowArrayView* array_view, if (run_ends_view->length == 0) break; int64_t last_run_end = ArrowArrayViewGetIntUnsafe(run_ends_view, 0); if (last_run_end < 1) { - ArrowErrorSet(error, - "All run ends must be greater than 0 but the first run end is %ld", - (long)last_run_end); + ArrowErrorSet( + error, + "All run ends must be greater than 0 but the first run end is %" PRId64, + last_run_end); return EINVAL; } break; @@ -1129,7 +1136,7 @@ static int ArrowAssertIncreasingInt32(struct ArrowBufferView view, for (int64_t i = 1; i < view.size_bytes / (int64_t)sizeof(int32_t); i++) { if (view.data.as_int32[i] < view.data.as_int32[i - 1]) { - ArrowErrorSet(error, "[%ld] Expected element size >= 0", (long)i); + ArrowErrorSet(error, "[%" PRId64 "] Expected element size >= 0", i); return EINVAL; } } @@ -1145,7 +1152,7 @@ static int ArrowAssertIncreasingInt64(struct ArrowBufferView view, for (int64_t i = 1; i < view.size_bytes / (int64_t)sizeof(int64_t); i++) { if (view.data.as_int64[i] < view.data.as_int64[i - 1]) { - ArrowErrorSet(error, "[%ld] Expected element size >= 0", (long)i); + ArrowErrorSet(error, "[%" PRId64 "] Expected element size >= 0", i); return EINVAL; } } @@ -1158,8 +1165,9 @@ static int ArrowAssertRangeInt8(struct ArrowBufferView view, int8_t min_value, for (int64_t i = 0; i < view.size_bytes; i++) { if (view.data.as_int8[i] < min_value || view.data.as_int8[i] > max_value) { ArrowErrorSet(error, - "[%ld] Expected buffer value between %d and %d but found value %d", - (long)i, (int)min_value, (int)max_value, (int)view.data.as_int8[i]); + "[%" PRId64 "] Expected buffer value between %" PRId8 " and %" PRId8 + " but found value %" PRId8, + i, min_value, max_value, view.data.as_int8[i]); return EINVAL; } } @@ -1179,8 +1187,8 @@ static int ArrowAssertInt8In(struct ArrowBufferView view, const int8_t* values, } if (!item_found) { - ArrowErrorSet(error, "[%ld] Unexpected buffer value %d", (long)i, - (int)view.data.as_int8[i]); + ArrowErrorSet(error, "[%" PRId64 "] Unexpected buffer value %" PRId8, i, + view.data.as_int8[i]); return EINVAL; } } @@ -1235,11 +1243,12 @@ static int ArrowArrayViewValidateFull(struct ArrowArrayView* array_view, int64_t offset = ArrowArrayViewUnionChildOffset(array_view, i); int64_t child_length = array_view->children[child_id]->length; if (offset < 0 || offset > child_length) { - ArrowErrorSet( - error, - "[%ld] Expected union offset for child id %d to be between 0 and %ld but " - "found offset value %ld", - (long)i, (int)child_id, (long)child_length, (long)offset); + ArrowErrorSet(error, + "[%" PRId64 "] Expected union offset for child id %" PRId8 + " to be between 0 and %" PRId64 + " but " + "found offset value %" PRId64, + i, child_id, child_length, offset); return EINVAL; } } @@ -1255,18 +1264,20 @@ static int ArrowArrayViewValidateFull(struct ArrowArrayView* array_view, ArrowErrorSet( error, "Every run end must be strictly greater than the previous run end, " - "but run_ends[%ld] is %ld and run_ends[%ld] is %ld", - (long)i, (long)run_end, (long)i - 1, (long)last_run_end); + "but run_ends[%" PRId64 " is %" PRId64 " and run_ends[%" PRId64 + "] is %" PRId64, + i, run_end, i - 1, last_run_end); return EINVAL; } last_run_end = run_end; } last_run_end = ArrowArrayViewGetIntUnsafe(run_ends_view, run_ends_view->length - 1); if (last_run_end < (array_view->offset + array_view->length)) { - ArrowErrorSet( - error, "Last run end is %ld but it should >= %ld (offset: %ld, length: %ld)", - (long)last_run_end, (long)(array_view->offset + array_view->length), - (long)array_view->offset, (long)array_view->length); + ArrowErrorSet(error, + "Last run end is %" PRId64 " but it should >= %" PRId64 + " (offset: %" PRId64 ", length: %" PRId64 ")", + last_run_end, array_view->offset + array_view->length, + array_view->offset, array_view->length); return EINVAL; } } diff --git a/src/nanoarrow/nanoarrow_device.c b/src/nanoarrow/nanoarrow_device.c index 3acf69089..92acd69d5 100644 --- a/src/nanoarrow/nanoarrow_device.c +++ b/src/nanoarrow/nanoarrow_device.c @@ -16,6 +16,7 @@ // under the License. #include +#include #include "nanoarrow.h" @@ -365,8 +366,9 @@ ArrowErrorCode ArrowDeviceArrayViewSetArrayMinimal( struct ArrowDevice* device = ArrowDeviceResolve(device_array->device_type, device_array->device_id); if (device == NULL) { - ArrowErrorSet(error, "Can't resolve device with type %d and identifier %ld", - (int)device_array->device_type, (long)device_array->device_id); + ArrowErrorSet(error, + "Can't resolve device with type %" PRId32 " and identifier %" PRId64, + device_array->device_type, device_array->device_id); return EINVAL; } diff --git a/src/nanoarrow/nanoarrow_device_cuda.c b/src/nanoarrow/nanoarrow_device_cuda.c index 8b010319c..f2fbafd40 100644 --- a/src/nanoarrow/nanoarrow_device_cuda.c +++ b/src/nanoarrow/nanoarrow_device_cuda.c @@ -15,6 +15,8 @@ // specific language governing permissions and limitations // under the License. +#include + #include #include "nanoarrow_device.h" @@ -409,7 +411,7 @@ static ArrowErrorCode ArrowDeviceCudaInitDevice(struct ArrowDevice* device, case ARROW_DEVICE_CUDA_HOST: break; default: - ArrowErrorSet(error, "Device type code %d not supported", (int)device_type); + ArrowErrorSet(error, "Device type code %" PRId32 " not supported", device_type); return EINVAL; } diff --git a/src/nanoarrow/nanoarrow_ipc_decoder.c b/src/nanoarrow/nanoarrow_ipc_decoder.c index b893c4b0b..d52166144 100644 --- a/src/nanoarrow/nanoarrow_ipc_decoder.c +++ b/src/nanoarrow/nanoarrow_ipc_decoder.c @@ -16,6 +16,7 @@ // under the License. #include +#include #include #include @@ -300,8 +301,8 @@ static int ArrowIpcDecoderSetMetadata(struct ArrowSchema* schema, if (n_pairs > 2147483647) { ArrowErrorSet(error, - "Expected between 0 and 2147483647 key/value pairs but found %ld", - (long)n_pairs); + "Expected between 0 and 2147483647 key/value pairs but found %" PRId64, + n_pairs); return EINVAL; } @@ -381,7 +382,7 @@ static int ArrowIpcDecoderSetTypeInt(struct ArrowSchema* schema, default: ArrowErrorSet(error, "Expected signed int bitwidth of 8, 16, 32, or 64 but got %d", - (int)bitwidth); + bitwidth); return EINVAL; } } else { @@ -401,7 +402,7 @@ static int ArrowIpcDecoderSetTypeInt(struct ArrowSchema* schema, default: ArrowErrorSet(error, "Expected unsigned int bitwidth of 8, 16, 32, or 64 but got %d", - (int)bitwidth); + bitwidth); return EINVAL; } } @@ -422,8 +423,7 @@ static int ArrowIpcDecoderSetTypeFloatingPoint(struct ArrowSchema* schema, case ns(Precision_DOUBLE): return ArrowIpcDecoderSetTypeSimple(schema, NANOARROW_TYPE_DOUBLE, error); default: - ArrowErrorSet(error, "Unexpected FloatingPoint Precision value: %d", - (int)precision); + ArrowErrorSet(error, "Unexpected FloatingPoint Precision value: %d", precision); return EINVAL; } } @@ -447,7 +447,7 @@ static int ArrowIpcDecoderSetTypeDecimal(struct ArrowSchema* schema, ArrowSchemaSetTypeDecimal(schema, NANOARROW_TYPE_DECIMAL256, precision, scale); break; default: - ArrowErrorSet(error, "Unexpected Decimal bitwidth value: %d", (int)bitwidth); + ArrowErrorSet(error, "Unexpected Decimal bitwidth value: %d", bitwidth); return EINVAL; } @@ -518,7 +518,7 @@ static int ArrowIpcDecoderSetTypeTime(struct ArrowSchema* schema, break; default: - ArrowErrorSet(error, "Unexpected Time TimeUnit value: %d", (int)time_unit); + ArrowErrorSet(error, "Unexpected Time TimeUnit value: %d", time_unit); return EINVAL; } @@ -584,7 +584,7 @@ static int ArrowIpcDecoderSetTypeInterval(struct ArrowSchema* schema, return ArrowIpcDecoderSetTypeSimple(schema, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO, error); default: - ArrowErrorSet(error, "Unexpected Interval unit value: %d", (int)interval_unit); + ArrowErrorSet(error, "Unexpected Interval unit value: %d", interval_unit); return EINVAL; } } @@ -645,8 +645,8 @@ static int ArrowIpcDecoderSetTypeUnion(struct ArrowSchema* schema, if (n_children < 0 || n_children > 127) { ArrowErrorSet(error, - "Expected between 0 and 127 children for Union type but found %ld", - (long)n_children); + "Expected between 0 and 127 children for Union type but found %" PRId64, + n_children); return EINVAL; } @@ -672,7 +672,7 @@ static int ArrowIpcDecoderSetTypeUnion(struct ArrowSchema* schema, format_out_size -= n_chars; break; default: - ArrowErrorSet(error, "Unexpected Union UnionMode value: %d", (int)union_mode); + ArrowErrorSet(error, "Unexpected Union UnionMode value: %d", union_mode); return EINVAL; } @@ -686,10 +686,10 @@ static int ArrowIpcDecoderSetTypeUnion(struct ArrowSchema* schema, int64_t n_type_ids = flatbuffers_int32_vec_len(type_ids); if (n_type_ids != n_children) { - ArrowErrorSet( - error, - "Expected between %ld children for Union type with %ld typeIds but found %ld", - (long)n_type_ids, (long)n_type_ids, (long)n_children); + ArrowErrorSet(error, + "Expected between %" PRId64 " children for Union type with %" PRId64 + " typeIds but found %" PRId64, + n_type_ids, n_type_ids, n_children); return EINVAL; } @@ -705,8 +705,8 @@ static int ArrowIpcDecoderSetTypeUnion(struct ArrowSchema* schema, } for (int64_t i = 1; i < n_type_ids; i++) { - n_chars = snprintf(format_cursor, format_out_size, ",%d", - (int)flatbuffers_int32_vec_at(type_ids, i)); + n_chars = snprintf(format_cursor, format_out_size, ",%" PRId32, + flatbuffers_int32_vec_at(type_ids, i)); format_cursor += n_chars; format_out_size -= n_chars; @@ -727,7 +727,7 @@ static int ArrowIpcDecoderSetTypeUnion(struct ArrowSchema* schema, } for (int64_t i = 1; i < n_children; i++) { - n_chars = snprintf(format_cursor, format_out_size, ",%d", (int)i); + n_chars = snprintf(format_cursor, format_out_size, ",%" PRId64, i); format_cursor += n_chars; format_out_size -= n_chars; @@ -792,7 +792,7 @@ static int ArrowIpcDecoderSetType(struct ArrowSchema* schema, ns(Field_table_t) return ArrowIpcDecoderSetTypeUnion(schema, ns(Field_type_get(field)), n_children, error); default: - ArrowErrorSet(error, "Unrecognized Field type with value %d", (int)type_type); + ArrowErrorSet(error, "Unrecognized Field type with value %d", type_type); return EINVAL; } } @@ -878,7 +878,7 @@ static int ArrowIpcDecoderDecodeSchemaHeader(struct ArrowIpcDecoder* decoder, default: ArrowErrorSet(error, "Expected Schema endianness of 0 (little) or 1 (big) but got %d", - (int)endianness); + endianness); return EINVAL; } @@ -920,14 +920,14 @@ static int ArrowIpcDecoderDecodeRecordBatchHeader(struct ArrowIpcDecoder* decode // Check field node and buffer count. We have one more field and buffer // because we count the root struct and the flatbuffer message does not. if ((n_fields + 1) != private_data->n_fields) { - ArrowErrorSet(error, "Expected %ld field nodes in message but found %ld", - (long)private_data->n_fields - 1, (long)n_fields); + ArrowErrorSet(error, "Expected %" PRId64 " field nodes in message but found %" PRId64, + private_data->n_fields - 1, n_fields); return EINVAL; } if ((n_buffers + 1) != private_data->n_buffers) { - ArrowErrorSet(error, "Expected %ld buffers in message but found %ld", - (long)private_data->n_buffers - 1, (long)n_buffers); + ArrowErrorSet(error, "Expected %" PRId64 " buffers in message but found %" PRId64, + private_data->n_buffers - 1, n_buffers); return EINVAL; } @@ -981,8 +981,9 @@ static inline int ArrowIpcDecoderReadHeaderPrefix(struct ArrowIpcDecoder* decode (struct ArrowIpcDecoderPrivate*)decoder->private_data; if (data_mut->size_bytes < kMessageHeaderPrefixSize) { - ArrowErrorSet(error, "Expected data of at least 8 bytes but only %ld bytes remain", - (long)data_mut->size_bytes); + ArrowErrorSet(error, + "Expected data of at least 8 bytes but only %" PRId64 " bytes remain", + data_mut->size_bytes); return ESPIPE; } @@ -997,9 +998,10 @@ static inline int ArrowIpcDecoderReadHeaderPrefix(struct ArrowIpcDecoder* decode int32_t header_body_size_bytes = ArrowIpcReadInt32LE(data_mut, swap_endian); *message_size_bytes = header_body_size_bytes + kMessageHeaderPrefixSize; if (header_body_size_bytes < 0) { - ArrowErrorSet( - error, "Expected message body size > 0 but found message body size of %ld bytes", - (long)header_body_size_bytes); + ArrowErrorSet(error, + "Expected message body size > 0 but found message body size of %" PRId32 + " bytes", + header_body_size_bytes); return EINVAL; } @@ -1035,9 +1037,10 @@ ArrowErrorCode ArrowIpcDecoderVerifyHeader(struct ArrowIpcDecoder* decoder, int64_t message_body_size = decoder->header_size_bytes - kMessageHeaderPrefixSize; if (data.size_bytes < message_body_size) { ArrowErrorSet(error, - "Expected >= %ld bytes of remaining data but found %ld bytes in buffer", - (long)message_body_size + kMessageHeaderPrefixSize, - (long)data.size_bytes + kMessageHeaderPrefixSize); + "Expected >= %" PRId64 " bytes of remaining data but found %" PRId64 + " bytes in buffer", + message_body_size + kMessageHeaderPrefixSize, + data.size_bytes + kMessageHeaderPrefixSize); return ESPIPE; } @@ -1073,9 +1076,10 @@ ArrowErrorCode ArrowIpcDecoderDecodeHeader(struct ArrowIpcDecoder* decoder, int64_t message_body_size = decoder->header_size_bytes - kMessageHeaderPrefixSize; if (data.size_bytes < message_body_size) { ArrowErrorSet(error, - "Expected >= %ld bytes of remaining data but found %ld bytes in buffer", - (long)message_body_size + kMessageHeaderPrefixSize, - (long)data.size_bytes + kMessageHeaderPrefixSize); + "Expected >= %" PRId64 " bytes of remaining data but found %" PRId64 + " bytes in buffer", + message_body_size + kMessageHeaderPrefixSize, + data.size_bytes + kMessageHeaderPrefixSize); return ESPIPE; } @@ -1152,8 +1156,8 @@ ArrowErrorCode ArrowIpcDecoderDecodeSchema(struct ArrowIpcDecoder* decoder, int result = ArrowSchemaSetTypeStruct(&tmp, n_fields); if (result != NANOARROW_OK) { ArrowSchemaRelease(&tmp); - ArrowErrorSet(error, "Failed to allocate struct schema with %ld children", - (long)n_fields); + ArrowErrorSet(error, "Failed to allocate struct schema with %" PRId64 " children", + n_fields); return result; } @@ -1462,8 +1466,9 @@ static int ArrowIpcDecoderSwapEndian(struct ArrowIpcBufferSource* src, break; } default: - ArrowErrorSet(error, "Endian swapping for element bitwidth %d is not supported", - (int)src->element_size_bits); + ArrowErrorSet( + error, "Endian swapping for element bitwidth %" PRId64 " is not supported", + src->element_size_bits); return ENOTSUP; } break; @@ -1498,8 +1503,10 @@ static int ArrowIpcDecoderMakeBuffer(struct ArrowIpcArraySetter* setter, int64_t int64_t buffer_start = offset; int64_t buffer_end = buffer_start + length; if (buffer_start < 0 || buffer_end > setter->body_size_bytes) { - ArrowErrorSet(error, "Buffer requires body offsets [%ld..%ld) but body has size %ld", - (long)buffer_start, (long)buffer_end, (long)setter->body_size_bytes); + ArrowErrorSet(error, + "Buffer requires body offsets [%" PRId64 "..%" PRId64 + ") but body has size %" PRId64, + buffer_start, buffer_end, setter->body_size_bytes); return EINVAL; } diff --git a/src/nanoarrow/nanoarrow_ipc_reader.c b/src/nanoarrow/nanoarrow_ipc_reader.c index dcce8ea2d..593c3c60c 100644 --- a/src/nanoarrow/nanoarrow_ipc_reader.c +++ b/src/nanoarrow/nanoarrow_ipc_reader.c @@ -16,6 +16,7 @@ // under the License. #include +#include #include #include @@ -283,8 +284,9 @@ static int ArrowIpcArrayStreamReaderNextBody( if (bytes_read != bytes_to_read) { ArrowErrorSet(&private_data->error, - "Expected to be able to read %ld bytes for message body but got %ld", - (long)bytes_to_read, bytes_read); + "Expected to be able to read %" PRId64 + " bytes for message body but got %" PRId64, + bytes_to_read, bytes_read); return ESPIPE; } else { return NANOARROW_OK; diff --git a/src/nanoarrow/schema.c b/src/nanoarrow/schema.c index aa8725b21..5398dd898 100644 --- a/src/nanoarrow/schema.c +++ b/src/nanoarrow/schema.c @@ -16,6 +16,7 @@ // under the License. #include +#include #include #include #include @@ -233,10 +234,10 @@ ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema, int n_chars; switch (type) { case NANOARROW_TYPE_FIXED_SIZE_BINARY: - n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size); + n_chars = snprintf(buffer, sizeof(buffer), "w:%" PRId32, fixed_size); break; case NANOARROW_TYPE_FIXED_SIZE_LIST: - n_chars = snprintf(buffer, sizeof(buffer), "+w:%d", (int)fixed_size); + n_chars = snprintf(buffer, sizeof(buffer), "+w:%" PRId32, fixed_size); break; default: return EINVAL; @@ -429,7 +430,7 @@ ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum ArrowTyp format_out_size -= n_chars; for (int64_t i = 1; i < n_children; i++) { - n_chars = snprintf(format_cursor, format_out_size, ",%d", (int)i); + n_chars = snprintf(format_cursor, format_out_size, ",%" PRId64, i); format_cursor += n_chars; format_out_size -= n_chars; } @@ -723,8 +724,9 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view, ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_DECIMAL256); return NANOARROW_OK; default: - ArrowErrorSet(error, "Expected decimal bitwidth of 128 or 256 but found %d", - (int)schema_view->decimal_bitwidth); + ArrowErrorSet(error, + "Expected decimal bitwidth of 128 or 256 but found %" PRId32, + schema_view->decimal_bitwidth); return EINVAL; } @@ -835,11 +837,10 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view, int64_t n_type_ids = _ArrowParseUnionTypeIds(schema_view->union_type_ids, NULL); if (n_type_ids != schema_view->schema->n_children) { - ArrowErrorSet( - error, - "Expected union type_ids parameter to be a comma-separated list of %ld " - "values between 0 and 127 but found '%s'", - (long)schema_view->schema->n_children, schema_view->union_type_ids); + ArrowErrorSet(error, + "Expected union type_ids parameter to be a comma-separated " + "list of %" PRId64 " values between 0 and 127 but found '%s'", + schema_view->schema->n_children, schema_view->union_type_ids); return EINVAL; } *format_end_out = format + strlen(format); @@ -1027,8 +1028,9 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view, static ArrowErrorCode ArrowSchemaViewValidateNChildren( struct ArrowSchemaView* schema_view, int64_t n_children, struct ArrowError* error) { if (n_children != -1 && schema_view->schema->n_children != n_children) { - ArrowErrorSet(error, "Expected schema with %d children but found %d children", - (int)n_children, (int)schema_view->schema->n_children); + ArrowErrorSet( + error, "Expected schema with %" PRId64 " children but found %" PRId64 " children", + n_children, schema_view->schema->n_children); return EINVAL; } @@ -1038,15 +1040,15 @@ static ArrowErrorCode ArrowSchemaViewValidateNChildren( for (int64_t i = 0; i < schema_view->schema->n_children; i++) { child = schema_view->schema->children[i]; if (child == NULL) { - ArrowErrorSet(error, - "Expected valid schema at schema->children[%ld] but found NULL", - (long)i); + ArrowErrorSet( + error, "Expected valid schema at schema->children[%" PRId64 "] but found NULL", + i); return EINVAL; } else if (child->release == NULL) { - ArrowErrorSet( - error, - "Expected valid schema at schema->children[%ld] but found a released schema", - (long)i); + ArrowErrorSet(error, + "Expected valid schema at schema->children[%" PRId64 + "] but found a released schema", + i); return EINVAL; } } @@ -1064,8 +1066,9 @@ static ArrowErrorCode ArrowSchemaViewValidateMap(struct ArrowSchemaView* schema_ NANOARROW_RETURN_NOT_OK(ArrowSchemaViewValidateNChildren(schema_view, 1, error)); if (schema_view->schema->children[0]->n_children != 2) { - ArrowErrorSet(error, "Expected child of map type to have 2 children but found %d", - (int)schema_view->schema->children[0]->n_children); + ArrowErrorSet(error, + "Expected child of map type to have 2 children but found %" PRId64, + schema_view->schema->children[0]->n_children); return EINVAL; } @@ -1180,7 +1183,7 @@ static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView* schema_vie default: ArrowErrorSet(error, "Expected a valid enum ArrowType value but found %d", - (int)schema_view->type); + schema_view->type); return EINVAL; } @@ -1230,8 +1233,8 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view, } if ((format + format_len) != format_end_out) { - ArrowErrorSet(error, "Error parsing schema->format '%s': parsed %d/%d characters", - format, (int)(format_end_out - format), (int)(format_len)); + ArrowErrorSet(error, "Error parsing schema->format '%s': parsed %d/%zu characters", + format, (int)(format_end_out - format), format_len); return EINVAL; } @@ -1291,9 +1294,8 @@ static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView* schema_vi switch (schema_view->type) { case NANOARROW_TYPE_DECIMAL128: case NANOARROW_TYPE_DECIMAL256: - return snprintf(out, n, "%s(%d, %d)", type_string, - (int)schema_view->decimal_precision, - (int)schema_view->decimal_scale); + return snprintf(out, n, "%s(%" PRId32 ", %" PRId32 ")", type_string, + schema_view->decimal_precision, schema_view->decimal_scale); case NANOARROW_TYPE_TIMESTAMP: return snprintf(out, n, "%s('%s', '%s')", type_string, ArrowTimeUnitString(schema_view->time_unit), schema_view->timezone); @@ -1304,7 +1306,7 @@ static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView* schema_vi ArrowTimeUnitString(schema_view->time_unit)); case NANOARROW_TYPE_FIXED_SIZE_BINARY: case NANOARROW_TYPE_FIXED_SIZE_LIST: - return snprintf(out, n, "%s(%ld)", type_string, (long)schema_view->fixed_size); + return snprintf(out, n, "%s(%" PRId32 ")", type_string, schema_view->fixed_size); case NANOARROW_TYPE_SPARSE_UNION: case NANOARROW_TYPE_DENSE_UNION: return snprintf(out, n, "%s([%s])", type_string, schema_view->union_type_ids);