From: Kevin Day Date: Tue, 4 Jul 2023 03:06:35 +0000 (-0500) Subject: Update: Add f_sockets_t, add f_socketss_t, and other f_socket changes. X-Git-Url: https://git.kevux.org/?a=commitdiff_plain;h=700febeac7d7cead7b1ced8a620b17e221c35f53;p=fll Update: Add f_sockets_t, add f_socketss_t, and other f_socket changes. The socket.name is better as an f_string_static_t. Fix the outdated and incorrect documentation comments for f_socket_t. Add additional macro functions for initializing the f_socket_t. --- diff --git a/build/level_0/settings b/build/level_0/settings index da60113..a7cfcc9 100644 --- a/build/level_0/settings +++ b/build/level_0/settings @@ -56,7 +56,7 @@ build_sources_library print.c private-print.c print/common.c print/to.c print/pr build_sources_library rip.c rip/utf.c private-rip.c rip/private-utf.c build_sources_library serialize.c private-serialize.c serialize/common.c build_sources_library signal.c -build_sources_library socket.c +build_sources_library socket.c socket/socket.c socket/private-socket.c build_sources_library status_string.c build_sources_library string.c build_sources_library private-string.c string/common.c @@ -114,7 +114,7 @@ build_sources_headers print.h print/to.h print/common.h build_sources_headers rip.h rip/utf.h build_sources_headers serialize.h serialize/common.h build_sources_headers signal.h signal/common.h -build_sources_headers socket.h socket/common.h +build_sources_headers socket.h socket/socket.h socket/common.h build_sources_headers status.h build_sources_headers status_string.h build_sources_headers string.h string/common.h @@ -126,7 +126,7 @@ build_sources_headers string/range.h string/ranges.h string/rangess.h build_sources_headers string/static.h string/statics.h string/staticss.h build_sources_headers string/triple.h string/triples.h string/tripless.h build_sources_headers type.h type_file.h -build_sources_headers type_array.h type_array/common.h type_array/cell.h type_array/file.h type_array/fll_id.h type_array/int8.h type_array/int16.h type_array/int32.h type_array/int64.h type_array/int128.h type_array/number_unsigned.h type_array/poll.h type_array/state.h type_array/status.h type_array/uint8.h type_array/uint16.h type_array/uint32.h type_array/uint64.h type_array/uint128.h +build_sources_headers type_array.h type_array_file.h type_array/common.h type_array/cell.h type_array/file.h type_array/fll_id.h type_array/int8.h type_array/int16.h type_array/int32.h type_array/int64.h type_array/int128.h type_array/number_unsigned.h type_array/poll.h type_array/state.h type_array/status.h type_array/uint8.h type_array/uint16.h type_array/uint32.h type_array/uint64.h type_array/uint128.h build_sources_headers utf.h utf/common.h utf/convert.h utf/dynamic.h utf/dynamics.h utf/dynamicss.h utf/is.h utf/is_character.h utf/map.h utf/maps.h utf/mapss.h utf/map_multi.h utf/map_multis.h utf/map_multiss.h utf/static.h utf/statics.h utf/staticss.h utf/string.h utf/triple.h utf/triples.h utf/tripless.h build_sources_headers-thread thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/condition.h thread/condition_attribute.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/mutex.h thread/mutex_attribute.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h diff --git a/build/monolithic/settings b/build/monolithic/settings index d172611..905ebaf 100644 --- a/build/monolithic/settings +++ b/build/monolithic/settings @@ -56,7 +56,7 @@ build_sources_library level_0/print.c level_0/private-print.c level_0/print/comm build_sources_library level_0/rip.c level_0/rip/utf.c level_0/private-rip.c level_0/rip/private-utf.c build_sources_library level_0/serialize.c level_0/private-serialize.c level_0/serialize/common.c build_sources_library level_0/signal.c -build_sources_library level_0/socket.c +build_sources_library level_0/socket.c level_0/socket/socket.c level_0/socket/private-socket.c build_sources_library level_0/status_string.c build_sources_library level_0/string.c build_sources_library level_0/private-string.c level_0/string/common.c @@ -136,7 +136,7 @@ build_sources_headers level_0/print.h level_0/print/to.h level_0/print/common.h build_sources_headers level_0/rip.h level_0/rip/utf.h build_sources_headers level_0/serialize.h level_0/serialize/common.h build_sources_headers level_0/signal.h level_0/signal/common.h -build_sources_headers level_0/socket.h level_0/socket/common.h +build_sources_headers level_0/socket.h level_0/socket/socket.h level_0/socket/common.h build_sources_headers level_0/status.h build_sources_headers level_0/status_string.h build_sources_headers level_0/string.h level_0/string/common.h @@ -148,7 +148,7 @@ build_sources_headers level_0/string/range.h level_0/string/ranges.h level_0/str build_sources_headers level_0/string/static.h level_0/string/statics.h level_0/string/staticss.h build_sources_headers level_0/string/triple.h level_0/string/triples.h level_0/string/tripless.h build_sources_headers level_0/type.h level_0/type_file.h -build_sources_headers level_0/type_array.h level_0/type_array/common.h level_0/type_array/cell.h level_0/type_array/file.h level_0/type_array/fll_id.h level_0/type_array/int8.h level_0/type_array/int16.h level_0/type_array/int32.h level_0/type_array/int64.h level_0/type_array/int128.h level_0/type_array/number_unsigned.h level_0/type_array/poll.h level_0/type_array/state.h level_0/type_array/status.h level_0/type_array/uint8.h level_0/type_array/uint16.h level_0/type_array/uint32.h level_0/type_array/uint64.h level_0/type_array/uint128.h +build_sources_headers level_0/type_array.h level_0/type_array_file.h level_0/type_array/common.h level_0/type_array/cell.h level_0/type_array/file.h level_0/type_array/fll_id.h level_0/type_array/int8.h level_0/type_array/int16.h level_0/type_array/int32.h level_0/type_array/int64.h level_0/type_array/int128.h level_0/type_array/number_unsigned.h level_0/type_array/poll.h level_0/type_array/state.h level_0/type_array/status.h level_0/type_array/uint8.h level_0/type_array/uint16.h level_0/type_array/uint32.h level_0/type_array/uint64.h level_0/type_array/uint128.h build_sources_headers level_0/utf.h level_0/utf/common.h level_0/utf/convert.h level_0/utf/dynamic.h level_0/utf/dynamics.h level_0/utf/dynamicss.h level_0/utf/is.h level_0/utf/is_character.h level_0/utf/map.h level_0/utf/maps.h level_0/utf/mapss.h level_0/utf/map_multi.h level_0/utf/map_multis.h level_0/utf/map_multiss.h level_0/utf/static.h level_0/utf/statics.h level_0/utf/staticss.h level_0/utf/string.h level_0/utf/triple.h level_0/utf/triples.h level_0/utf/tripless.h build_sources_headers level_1/control_group.h diff --git a/level_0/f_socket/c/socket.c b/level_0/f_socket/c/socket.c index 72935d6..4bd4ae0 100644 --- a/level_0/f_socket/c/socket.c +++ b/level_0/f_socket/c/socket.c @@ -87,8 +87,9 @@ extern "C" { address->sun_family = f_socket_domain_file_d; - if (socket->name) { - strncpy(address->sun_path, socket->name, sizeof(address->sun_path) - 1); + if (socket->name.used && socket->name.string) { + strncpy(address->sun_path, socket->name.string, socket->name.used); + address->sun_path[socket->name.used] = 0; } else { address->sun_path[0] = 0; diff --git a/level_0/f_socket/c/socket.h b/level_0/f_socket/c/socket.h index 103f5c6..6f7fe36 100644 --- a/level_0/f_socket/c/socket.h +++ b/level_0/f_socket/c/socket.h @@ -27,6 +27,7 @@ // FLL-0 socket includes. #include +#include #ifdef __cplusplus extern "C" { diff --git a/level_0/f_socket/c/socket/common.h b/level_0/f_socket/c/socket/common.h index 340a0e1..b03ea69 100644 --- a/level_0/f_socket/c/socket/common.h +++ b/level_0/f_socket/c/socket/common.h @@ -289,15 +289,18 @@ extern "C" { /** * Commonly used socket related properties, loosely based off of f_file_t. * - * address: Pointer to the socket address (stored as "struct sockaddr" but may represent other types such as "struct sockaddr_un" or "struct sockaddr_in"). - * domain: The socket domain (protocol family). - * flag: Flags used for opening the file. - * id: File descriptor, with a value of -1 represents a closed file. - * name: The name of the socket, if a name is given (for UNIX sockets this represents the path) (Must be a NULL terminated string). - * protocol: The socket protocol. + * id: File descriptor, with a value of -1 represents a closed file. + * domain: The socket domain (protocol family). + * protocol: The socket protocol. + * type: The socket type. + * * size_read: The default number of 1-byte characters to read at a time and is often used for the read buffer size. * size_write: The default number of 1-byte characters to read at a time and is often used for the write buffer size. - * type: The socket type. + * + * length: The length of the socket. + * address: Pointer to the socket address (stored as "struct sockaddr" but may represent other types such as "struct sockaddr_un" or "struct sockaddr_in"). + * + * name: The name of the socket, if a name is given (for UNIX sockets this represents the path) (Must be a NULL terminated string). */ #ifndef _di_f_socket_t_ typedef struct { @@ -310,15 +313,60 @@ extern "C" { size_t size_write; socklen_t length; - struct sockaddr *address; - f_string_t name; + f_string_static_t name; } f_socket_t; - #define f_socket_t_initialize { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, 0, 0 } + #define f_socket_t_initialize { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, 0, 0, f_string_empty_s } + + #define macro_f_socket_t_initialize_1(address, length) { \ + -1, \ + 0, \ + 0, \ + 0, \ + F_socket_default_read_size_d, \ + F_socket_default_write_size_d, \ + address, \ + length, \ + f_string_empty_s \ + } + + #define macro_f_socket_t_initialize_2(address, length, name) { \ + -1, \ + 0, \ + 0, \ + 0, \ + F_socket_default_read_size_d, \ + F_socket_default_write_size_d, \ + address, \ + length, \ + name \ + } - #define macro_f_socket_t_initialize_1(address) { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, address, 0 } + #define macro_f_socket_t_initialize_3(id, domain, protocol, type, address, length, name) { \ + id, \ + domain, \ + protocol, \ + type, \ + F_socket_default_read_size_d, \ + F_socket_default_write_size_d, \ + address, \ + length, \ + name \ + } + + #define macro_f_socket_t_initialize_4(id, domain, protocol, type, size_read, size_write, address, length, name) { \ + id, \ + domain, \ + protocol, \ + type, \ + size_read, \ + size_write, \ + address, \ + length, \ + name \ + } #define macro_f_socket_t_clear(file) \ file.id = -1; \ @@ -328,7 +376,8 @@ extern "C" { file.size_read = 0; \ file.size_write = 0; \ file.length = 0; \ - file.name = 0; + file.address = 0; \ + macro_f_string_static_t_clear(file); #define macro_f_socket_t_reset(file) \ file.id = -1; \ @@ -338,9 +387,52 @@ extern "C" { file.size_read = F_socket_default_read_size_d; \ file.size_write = F_socket_default_write_size_d; \ file.length = 0; \ - file.name = 0; + file.address = 0; \ + macro_f_string_static_t_clear(file); #endif // _di_f_socket_t_ +/** + * An array of f_socket_t. + * + * array: The array of f_socket_t. + * size: Total amount of allocated space. + * used: Total number of allocated spaces used. + */ +#ifndef _di_f_sockets_t_ + typedef struct { + f_socket_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_sockets_t; + + #define f_sockets_t_initialize { 0, 0, 0 } + + #define macro_f_sockets_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_sockets_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_sockets_t_ + +/** + * This holds an array of f_sockets_t. + * + * array: The array of f_socket_t arrays. + * size: Total amount of allocated space. + * used: Total number of allocated spaces used. + */ +#ifndef _di_f_socketss_t_ + typedef struct { + f_sockets_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_socketss_t; + + #define f_socketss_t_initialize { 0, 0, 0 } + + #define macro_f_socketss_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_socketss_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_socketss_t_ + #ifdef __cplusplus } // extern "C" #endif diff --git a/level_0/f_socket/c/socket/private-socket.c b/level_0/f_socket/c/socket/private-socket.c new file mode 100644 index 0000000..76cbe66 --- /dev/null +++ b/level_0/f_socket/c/socket/private-socket.c @@ -0,0 +1,128 @@ +#include "../socket.h" +#include "private-socket.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_) + f_status_t private_f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) { + + const f_status_t status = f_memory_adjust(sockets->size, length, sizeof(f_socket_t), (void **) & sockets->array); + if (F_status_is_error(status)) return status; + + sockets->size = length; + + if (sockets->used > sockets->size) { + sockets->used = length; + } + + return F_none; + } +#endif // !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_) + +#if !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_) + extern f_status_t private_f_sockets_append(const f_socket_t source, f_sockets_t * const destination) { + + if (destination->used + 1 > destination->size) { + const f_status_t status = private_f_sockets_resize(destination->used + F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; + } + + destination->array[destination->used++] = source; + + return F_none; + } +#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_) + +#if !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_) + extern f_status_t private_f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) { + + + + if (destination->used + source.used > destination->size) { + const f_status_t status = private_f_sockets_resize(destination->used + source.used, destination); + if (F_status_is_error(status)) return status; + } + + for (f_number_unsigned_t i = 0; i < source.used; ++i) { + destination->array[destination->used++] = source.array[i]; + } // for + + return F_none; + } +#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_) + +#if !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_) + f_status_t private_f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) { + + const f_status_t status = f_memory_resize(sockets->size, length, sizeof(f_socket_t), (void **) & sockets->array); + if (F_status_is_error(status)) return status; + + sockets->size = length; + + if (sockets->used > sockets->size) { + sockets->used = length; + } + + return F_none; + } +#endif // !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_) + +#if !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_) + f_status_t private_f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) { + + f_status_t status = F_none; + + for (f_number_unsigned_t i = length; i < socketss->size; ++i) { + + status = f_memory_destroy(socketss->array[i].size, sizeof(f_socket_t), (void **) & socketss->array[i].array); + if (F_status_is_error(status)) return status; + + socketss->array[i].size = 0; + socketss->array[i].used = 0; + } // for + + status = f_memory_adjust(socketss->size, length, sizeof(f_sockets_t), (void **) & socketss->array); + if (F_status_is_error(status)) return status; + + socketss->size = length; + + if (socketss->used > socketss->size) { + socketss->used = length; + } + + return F_none; + } +#endif // !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_) + +#if !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_) + f_status_t private_f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) { + + f_status_t status = F_none; + + for (f_number_unsigned_t i = length; i < socketss->size; ++i) { + + status = f_memory_delete(socketss->array[i].size, sizeof(f_socket_t), (void **) & socketss->array[i].array); + if (F_status_is_error(status)) return status; + + socketss->array[i].size = 0; + socketss->array[i].used = 0; + } // for + + status = f_memory_resize(socketss->size, length, sizeof(f_sockets_t), (void **) & socketss->array); + if (F_status_is_error(status)) return status; + + socketss->size = length; + + if (socketss->used > socketss->size) { + socketss->used = length; + } + + return F_none; + } +#endif // !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_) + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/c/socket/private-socket.h b/level_0/f_socket/c/socket/private-socket.h new file mode 100644 index 0000000..04a62cb --- /dev/null +++ b/level_0/f_socket/c/socket/private-socket.h @@ -0,0 +1,175 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * These are provided for internal reduction in redundant code. + * These should not be exposed/used outside of this project. + */ +#ifndef _PRIVATE_F_socket_socket_h +#define _PRIVATE_F_socket_socket_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Private implementation for resizing the sockets array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to adjust to. + * @param sockets + * The sockets array to adjust. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * Errors (with error bit) from: f_memory_adjust(). + * + * @see f_sockets_adjust() + * @see f_sockets_decimate_by() + */ +#if !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_) + extern f_status_t private_f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_) + +/** + * Private implementation for appending the socket array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param source + * The source socket to append. + * @param destination + * The destination lengths the source is appended onto. + * + * @return + * F_none on success. + * + * Errors (with error bit) from: f_memory_resize(). + * + * @see f_memory_resize() + * @see f_sockets_append() + * @see f_socketss_append() + */ +#if !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_) + extern f_status_t private_f_sockets_append(const f_socket_t source, f_sockets_t * const destination) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_) + +/** + * Private implementation for appending the socket array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param source + * The source sockets to append. + * @param destination + * The destination lengths the source is appended onto. + * + * @return + * F_none on success. + * + * Errors (with error bit) from: f_memory_resize(). + * + * @see f_memory_resize() + * @see f_sockets_append_all() + * @see f_socketss_append() + * @see f_socketss_append_all() + */ +#if !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_) + extern f_status_t private_f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_) + +/** + * Private implementation for resizing the sockets array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to adjust to. + * @param sockets + * The sockets array to adjust. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * Errors (with error bit) from: f_memory_resize(). + * + * @see f_sockets_resize() + * @see f_sockets_append() + * @see f_sockets_decrease_by() + * @see f_socketss_append() + */ +#if !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_) + extern f_status_t private_f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_) + +/** + * Private implementation for resizing the socketss array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to adjust to. + * @param socketss + * The socketss array to adjust. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * F_array_too_large (with error bit) if new length is larger than max array length. + * F_memory_not (with error bit) on out of memory. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_adjust(). + * Errors (with error bit) from: f_memory_destroy(). + * + * @see f_socketss_adjust() + * @see f_socketss_decimate_by() + */ +#if !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_) + extern f_status_t private_f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_) + +/** + * Private implementation for resizing the socketss array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to resize to. + * @param socketss + * The socketss array to resize. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * F_array_too_large (with error bit) if new length is larger than max array length. + * F_memory_not (with error bit) on out of memory. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_delete(). + * Errors (with error bit) from: f_memory_resize(). + * + * @see f_socketss_decrease_by() + * @see f_socketss_increase() + * @see f_socketss_increase_by() + * @see f_socketss_resize() + */ +#if !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_) + extern f_status_t private_f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_) + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _PRIVATE_F_socket_socket_h diff --git a/level_0/f_socket/c/socket/socket.c b/level_0/f_socket/c/socket/socket.c new file mode 100644 index 0000000..6c97e53 --- /dev/null +++ b/level_0/f_socket/c/socket/socket.c @@ -0,0 +1,278 @@ +#include "../socket.h" +#include "socket.h" +#include "private-socket.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _di_f_sockets_adjust_ + f_status_t f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_sockets_adjust(length, sockets); + } +#endif // _di_f_sockets_adjust_ + +#ifndef _di_f_sockets_append_ + f_status_t f_sockets_append(const f_socket_t source, f_sockets_t * const destination) { + #ifndef _di_level_0_parameter_checking_ + if (!destination) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_sockets_append(source, destination); + } +#endif // _di_f_sockets_append_ + +#ifndef _di_f_sockets_append_all_ + f_status_t f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) { + #ifndef _di_level_0_parameter_checking_ + if (!destination) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!source.used) return F_data_not; + + return private_f_sockets_append_all(source, destination); + } +#endif // _di_f_sockets_append_all_ + +#ifndef _di_f_sockets_decimate_by_ + f_status_t f_sockets_decimate_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (sockets->size - amount > 0) { + return private_f_sockets_adjust(sockets->size - amount, sockets); + } + + return private_f_sockets_adjust(0, sockets); + } +#endif // _di_f_sockets_decimate_by_ + +#ifndef _di_f_sockets_decrease_by_ + f_status_t f_sockets_decrease_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (sockets->size - amount > 0) { + return private_f_sockets_resize(sockets->size - amount, sockets); + } + + return private_f_sockets_resize(0, sockets); + } +#endif // _di_f_sockets_decrease_by_ + +#ifndef _di_f_sockets_increase_ + f_status_t f_sockets_increase(const f_number_unsigned_t step, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (step && sockets->used + 1 > sockets->size) { + f_number_unsigned_t size = sockets->used + step; + + if (size > F_number_t_size_unsigned_d) { + if (sockets->used + 1 > F_number_t_size_unsigned_d) { + return F_status_set_error(F_array_too_large); + } + + size = F_number_t_size_unsigned_d; + } + + return private_f_sockets_resize(size, sockets); + } + + return F_data_not; + } +#endif // _di_f_sockets_increase_ + +#ifndef _di_f_sockets_increase_by_ + f_status_t f_sockets_increase_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (sockets->used + amount > sockets->size) { + if (sockets->used + amount > F_number_t_size_unsigned_d) { + return F_status_set_error(F_array_too_large); + } + + return private_f_sockets_resize(sockets->used + amount, sockets); + } + + return F_data_not; + } +#endif // _di_f_sockets_increase_by_ + +#ifndef _di_f_sockets_resize_ + f_status_t f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) { + #ifndef _di_level_0_parameter_checking_ + if (!sockets) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_sockets_resize(length, sockets); + } +#endif // _di_f_sockets_resize_ + +#ifndef _di_f_socketss_adjust_ + f_status_t f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_socketss_adjust(length, socketss); + } +#endif // _di_f_socketss_adjust_ + +#ifndef _di_f_socketss_append_ + f_status_t f_socketss_append(const f_sockets_t source, f_socketss_t * const destination) { + #ifndef _di_level_0_parameter_checking_ + if (!destination) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!source.used) return F_data_not; + + f_status_t status = F_none; + + if (destination->used + 1 > destination->size) { + status = private_f_socketss_resize(destination->used + F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; + } + + status = private_f_sockets_append_all(source, &destination->array[destination->used]); + if (F_status_is_error(status)) return status; + + ++destination->used; + + return F_none; + } +#endif // _di_f_socketss_append_ + +#ifndef _di_f_socketss_append_all_ + f_status_t f_socketss_append_all(const f_socketss_t source, f_socketss_t * const destination) { + #ifndef _di_level_0_parameter_checking_ + if (!destination) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!source.used) return F_data_not; + + f_status_t status = F_none; + + if (destination->used + source.used > destination->size) { + status = private_f_socketss_resize(destination->used + source.used, destination); + if (F_status_is_error(status)) return status; + } + + for (f_number_unsigned_t i = 0; i < source.used; ++i, ++destination->used) { + + destination->array[destination->used].used = 0; + + if (source.array[i].used) { + status = private_f_sockets_append_all(source.array[i], &destination->array[destination->used]); + if (F_status_is_error(status)) return status; + } + } // for + + return F_none; + } +#endif // _di_f_socketss_append_all_ + +#ifndef _di_f_socketss_decimate_by_ + f_status_t f_socketss_decimate_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (socketss->size - amount > 0) { + return private_f_socketss_adjust(socketss->size - amount, socketss); + } + + return private_f_socketss_adjust(0, socketss); + } +#endif // _di_f_socketss_decimate_by_ + +#ifndef _di_f_socketss_decrease_by_ + f_status_t f_socketss_decrease_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (socketss->size - amount > 0) { + return private_f_socketss_resize(socketss->size - amount, socketss); + } + + return private_f_socketss_resize(0, socketss); + } +#endif // _di_f_socketss_decrease_by_ + +#ifndef _di_f_socketss_increase_ + f_status_t f_socketss_increase(const f_number_unsigned_t step, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (step && socketss->used + 1 > socketss->size) { + f_number_unsigned_t size = socketss->used + step; + + if (size > F_number_t_size_unsigned_d) { + if (socketss->used + 1 > F_number_t_size_unsigned_d) { + return F_status_set_error(F_array_too_large); + } + + size = F_number_t_size_unsigned_d; + } + + return private_f_socketss_resize(size, socketss); + } + + return F_data_not; + } +#endif // _di_f_socketss_increase_ + +#ifndef _di_f_socketss_increase_by_ + f_status_t f_socketss_increase_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (!amount) return F_data_not; + + if (socketss->used + amount > socketss->size) { + if (socketss->used + amount > F_number_t_size_unsigned_d) { + return F_status_set_error(F_array_too_large); + } + + return private_f_socketss_resize(socketss->used + amount, socketss); + } + + return F_data_not; + } +#endif // _di_f_socketss_increase_by_ + +#ifndef _di_f_socketss_resize_ + f_status_t f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) { + #ifndef _di_level_0_parameter_checking_ + if (!socketss) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_socketss_resize(length, socketss); + } +#endif // _di_f_socketss_resize_ + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/c/socket/socket.h b/level_0/f_socket/c/socket/socket.h new file mode 100644 index 0000000..31eff3b --- /dev/null +++ b/level_0/f_socket/c/socket/socket.h @@ -0,0 +1,377 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Defines socket type related functionality. + * + * This is auto-included by socket.h and should not need to be explicitly included. + */ +#ifndef _F_socket_socket_h +#define _F_socket_socket_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Resize the string sockets array. + * + * @param length + * The new size to use. + * @param sockets + * The string sockets array to resize. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_adjust(). + */ +#ifndef _di_f_sockets_adjust_ + extern f_status_t f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets); +#endif // _di_f_sockets_adjust_ + +/** + * Append the single source socket onto the destination. + * + * @param source + * The source socket to append. + * @param destination + * The destination sockets the source is appended onto. + * + * @return + * F_none on success. + * F_data_not on success, but there is nothing to append (size == 0). + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_append_ + extern f_status_t f_sockets_append(const f_socket_t source, f_sockets_t * const destination); +#endif // _di_f_sockets_append_ + +/** + * Append the source sockets onto the destination. + * + * @param source + * The source sockets to append. + * @param destination + * The destination sockets the source is appended onto. + * + * @return + * F_none on success. + * F_data_not on success, but there is nothing to append (size == 0). + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_append_all_ + extern f_status_t f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination); +#endif // _di_f_sockets_append_all_ + +/** + * Resize the string sockets array to a smaller size. + * + * This will resize making the array smaller based on (size - given length). + * If the given length is too small, then the resize will fail. + * This will not shrink the size to les than 0. + * + * @param amount + * A positive number representing how much to decimate the size by. + * @param sockets + * The string sockets array to resize. + * + * @return + * F_none on success. + * F_data_not if amount is 0. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_adjust(). + */ +#ifndef _di_f_sockets_decimate_by_ + extern f_status_t f_sockets_decimate_by(const f_number_unsigned_t amount, f_sockets_t * const sockets); +#endif // _di_f_sockets_decimate_by_ + +/** + * Resize the string sockets array to a smaller size. + * + * This will resize making the array smaller based on (size - given length). + * If the given length is too small, then the resize will fail. + * This will not shrink the size to les than 0. + * + * @param amount + * A positive number representing how much to decrease the size by. + * @param sockets + * The string sockets array to resize. + * + * @return + * F_none on success. + * F_data_not if amount is 0. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_decrease_by_ + extern f_status_t f_sockets_decrease_by(const f_number_unsigned_t amount, f_sockets_t * const sockets); +#endif // _di_f_sockets_decrease_by_ + +/** + * Increase the size of the string sockets array, but only if necesary. + * + * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d). + * If already set to the maximum buffer size, then the resize will fail. + * + * @param step + * The allocation step to use. + * Must be greater than 0. + * @param sockets + * The string sockets array to resize. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * F_array_too_large (with error bit) if the new array length is too large. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_increase_ + extern f_status_t f_sockets_increase(const f_number_unsigned_t step, f_sockets_t * const sockets); +#endif // _di_f_sockets_increase_ + +/** + * Resize the string sockets array to a larger size. + * + * This will resize making the array larger based on the given length. + * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d). + * If already set to the maximum buffer size, then the resize will fail. + * + * @param amount + * A positive number representing how much to increase the size by. + * @param sockets + * The string sockets array to resize. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + amount <= size). + * + * F_array_too_large (with error bit) if the new array length is too large. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_increase_by_ + extern f_status_t f_sockets_increase_by(const f_number_unsigned_t amount, f_sockets_t * const sockets); +#endif // _di_f_sockets_increase_by_ + +/** + * Resize the string sockets array. + * + * @param length + * The new size to use. + * @param sockets + * The string sockets array to adjust. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_sockets_resize_ + extern f_status_t f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets); +#endif // _di_f_sockets_resize_ + +/** + * Resize the string socketss array. + * + * @param length + * The new size to use. + * @param socketss + * The string socketss array to resize. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_adjust(). + * Errors (with error bit) from: f_memory_destroy(). + */ +#ifndef _di_f_socketss_adjust_ + extern f_status_t f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss); +#endif // _di_f_socketss_adjust_ + +/** + * Append the single source sockets onto the destination. + * + * @param source + * The source sockets to append. + * @param destination + * The destination ranges the source is appended onto. + * + * @return + * F_none on success. + * F_data_not on success, but there is nothing to append (size == 0). + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_append_ + extern f_status_t f_socketss_append(const f_sockets_t source, f_socketss_t * const destination); +#endif // _di_f_socketss_append_ + +/** + * Append the source socketss onto the destination. + * + * @param source + * The source socketss to append. + * @param destination + * The destination ranges the source is appended onto. + * + * @return + * F_none on success. + * F_data_not on success, but there is nothing to append (size == 0). + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_append_all_ + extern f_status_t f_socketss_append_all(const f_socketss_t source, f_socketss_t * const destination); +#endif // _di_f_socketss_append_all_ + +/** + * Resize the string socketss array to a smaller size. + * + * This will resize making the array smaller based on (size - given length). + * If the given length is too small, then the resize will fail. + * This will not shrink the size to less than 0. + * + * @param amount + * A positive number representing how much to decimate the size by. + * @param socketss + * The string socketss array to resize. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_adjust(). + * Errors (with error bit) from: f_memory_destroy(). + */ +#ifndef _di_f_socketss_decimate_by_ + extern f_status_t f_socketss_decimate_by(const f_number_unsigned_t amount, f_socketss_t * const socketss); +#endif // _di_f_socketss_decimate_by_ + +/** + * Resize the string socketss array to a smaller size. + * + * This will resize making the array smaller based on (size - given length). + * If the given length is too small, then the resize will fail. + * This will not shrink the size to less than 0. + * + * @param amount + * A positive number representing how much to decrease the size by. + * @param socketss + * The string socketss array to resize. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_delete(). + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_decrease_by_ + extern f_status_t f_socketss_decrease_by(const f_number_unsigned_t amount, f_socketss_t * const socketss); +#endif // _di_f_socketss_decrease_by_ + +/** + * Increase the size of the string socketss array, but only if necessary. + * + * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d). + * If already set to the maximum buffer size, then the resize will fail. + * + * @param step + * The allocation step to use. + * Must be greater than 0. + * @param socketss + * The string socketss array to resize. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + 1 <= size). + * + * F_array_too_large (with error bit) if the new array length is too large. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_increase_ + extern f_status_t f_socketss_increase(const f_number_unsigned_t step, f_socketss_t * const socketss); +#endif // _di_f_socketss_increase_ + +/** + * Resize the string socketss array to a larger size. + * + * This will resize making the array larger based on the given length. + * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d). + * If already set to the maximum buffer size, then the resize will fail. + * + * @param amount + * A positive number representing how much to increase the size by. + * @param socketss + * The string socketss array to resize. + * + * @return + * F_none on success. + * F_data_not on success, but there is no reason to increase size (used + amount <= size). + * + * F_array_too_large (with error bit) if the new array length is too large. + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_increase_by_ + extern f_status_t f_socketss_increase_by(const f_number_unsigned_t amount, f_socketss_t * const socketss); +#endif // _di_f_socketss_increase_by_ + +/** + * Resize the string socketss array. + * + * @param length + * The new size to use. + * @param socketss + * The string socketss array to adjust. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_memory_delete(). + * Errors (with error bit) from: f_memory_resize(). + */ +#ifndef _di_f_socketss_resize_ + extern f_status_t f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss); +#endif // _di_f_socketss_resize_ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _F_socket_socket_h diff --git a/level_0/f_socket/data/build/settings b/level_0/f_socket/data/build/settings index 6e9e1fc..0474b34 100644 --- a/level_0/f_socket/data/build/settings +++ b/level_0/f_socket/data/build/settings @@ -32,9 +32,9 @@ build_language c build_libraries -lc build_libraries-individual -lf_memory -lf_string -build_sources_library socket.c +build_sources_library socket.c socket/socket.c socket/private-socket.c -build_sources_headers socket.h socket/common.h +build_sources_headers socket.h socket/socket.h socket/common.h build_script yes build_shared yes diff --git a/level_0/f_socket/data/build/settings-mocks b/level_0/f_socket/data/build/settings-mocks index 6d0eda7..1ddf8a4 100644 --- a/level_0/f_socket/data/build/settings-mocks +++ b/level_0/f_socket/data/build/settings-mocks @@ -30,9 +30,9 @@ build_language c build_libraries -lc build_libraries-individual -lf_memory -lf_string -build_sources_library socket.c ../../tests/unit/c/mock-socket.c +build_sources_library socket.c socket/socket.c socket/private-socket.c ../../tests/unit/c/mock-socket.c -build_sources_headers socket.h socket/common.h +build_sources_headers socket.h socket/socket.h socket/common.h build_script yes build_shared yes diff --git a/level_0/f_socket/data/build/settings-tests b/level_0/f_socket/data/build/settings-tests index 8c11dc5..4b2cdbe 100644 --- a/level_0/f_socket/data/build/settings-tests +++ b/level_0/f_socket/data/build/settings-tests @@ -26,6 +26,9 @@ build_libraries -lc -lcmocka build_libraries-individual -lf_memory -lf_string -lf_type_array -lf_socket build_sources_program test-socket-accept.c test-socket-bind.c test-socket-bind_local.c test-socket-connect.c test-socket-create.c test-socket-create_pair.c test-socket-disconnect.c test-socket-listen.c test-socket-name_host.c test-socket-name_peer.c test-socket-option_get.c test-socket-option_set.c test-socket-read.c test-socket-read_message.c test-socket-read_stream.c test-socket-write.c test-socket-write_message.c test-socket-write_stream.c +build_sources_program test-socket-sockets_adjust.c test-socket-sockets_append.c test-socket-sockets_append_all.c test-socket-sockets_decimate_by.c test-socket-sockets_decrease_by.c test-socket-sockets_increase.c test-socket-sockets_increase_by.c test-socket-sockets_resize.c +build_sources_program test-socket-socketss_adjust.c test-socket-socketss_append.c test-socket-socketss_append_all.c test-socket-socketss_decimate_by.c test-socket-socketss_decrease_by.c test-socket-socketss_increase.c test-socket-socketss_increase_by.c test-socket-socketss_resize.c + build_sources_program test-socket.c build_script no diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.c new file mode 100644 index 0000000..5ba7df2 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.c @@ -0,0 +1,42 @@ +#include "test-socket.h" +#include "test-socket-sockets_adjust.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_adjust__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_adjust(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_sockets_adjust__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_adjust(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.h new file mode 100644 index 0000000..1d59f2e --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_adjust.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_adjust +#define _TEST__F_socket__sockets_adjust + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_adjust() + */ +extern void test__f_socket_sockets_adjust__parameter_checking(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_adjust() + */ +extern void test__f_socket_sockets_adjust__works(void **state); + +#endif // _TEST__F_socket__sockets_adjust diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_append.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_append.c new file mode 100644 index 0000000..edfd8c2 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_append.c @@ -0,0 +1,44 @@ +#include "test-socket.h" +#include "test-socket-sockets_append.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_append__parameter_checking(void **state) { + + const f_socket_t data = f_socket_t_initialize; + + { + const f_status_t status = f_sockets_append(data, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_socket_sockets_append__works(void **state) { + + f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4); + const f_socket_t source = macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, test); + f_sockets_t destination = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_append(source, &destination); + + assert_int_equal(status, F_none); + assert_int_equal(destination.used, 1); + assert_int_equal(destination.array[0].id, source.id); + assert_int_equal(destination.array[0].domain, source.domain); + assert_int_equal(destination.array[0].protocol, source.protocol); + assert_int_equal(destination.array[0].type, source.type); + assert_int_equal(destination.array[0].name.used, source.name.used); + + assert_string_equal(destination.array[0].name.string, source.name.string); + } + + free((void *) destination.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_append.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_append.h new file mode 100644 index 0000000..6bbfce2 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_append.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_append +#define _TEST__F_socket__sockets_append + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_append() + */ +extern void test__f_socket_sockets_append__parameter_checking(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_append() + */ +extern void test__f_socket_sockets_append__works(void **state); + +#endif // _TEST__F_socket__sockets_append diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.c new file mode 100644 index 0000000..ab6f65a --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.c @@ -0,0 +1,101 @@ +#include "test-socket.h" +#include "test-socket-sockets_append_all.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_append_all__parameter_checking(void **state) { + + const f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_append_all(data, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_socket_sockets_append_all__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t source = f_sockets_t_initialize; + f_sockets_t destination = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + { + const f_status_t status = f_sockets_append_all(source, &destination); + + assert_int_equal(status, F_data_not); + assert_int_equal(destination.used, 0); + assert_int_equal(destination.size, 0); + assert_null(destination.array); + } + + free((void *) source.array); +} + +void test__f_socket_sockets_append_all__works(void **state) { + + const int length = 5; + const int length_used = 2; + + f_string_static_t tests[] = { + macro_f_string_static_t_initialize_1("test_1", 0, 6), + macro_f_string_static_t_initialize_1("test_2", 0, 6), + }; + + f_socket_t sources[] = { + macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]), + macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]), + }; + + f_sockets_t source = f_sockets_t_initialize; + f_sockets_t destination = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + for (; source.used < length_used; ++source.used) { + source.array[source.used] = sources[source.used]; + //memcpy((void *) &source.array[source.used], (void *) &sources[source.used], sizeof(f_sockets_t)); + } // for + + { + const f_status_t status = f_sockets_append_all(source, &destination); + + assert_int_equal(status, F_none); + assert_int_equal(destination.used, source.used); + assert_int_equal(destination.size, source.used); + + for (f_number_unsigned_t i = 0; i < source.used; ++i) { + + assert_int_equal(destination.array[i].id, sources[i].id); + assert_int_equal(destination.array[i].domain, sources[i].domain); + assert_int_equal(destination.array[i].protocol, sources[i].protocol); + assert_int_equal(destination.array[i].type, sources[i].type); + assert_int_equal(destination.array[i].name.used, sources[i].name.used); + + assert_string_equal(destination.array[i].name.string, sources[i].name.string); + } // for + } + + free((void *) source.array); + free((void *) destination.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.h new file mode 100644 index 0000000..6f0649b --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_append_all.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_append_all +#define _TEST__F_socket__sockets_append_all + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_append_all() + */ +extern void test__f_socket_sockets_append_all__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_sockets_append_all() + */ +extern void test__f_socket_sockets_append_all__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_append_all() + */ +extern void test__f_socket_sockets_append_all__works(void **state); + +#endif // _TEST__F_socket__sockets_append_all diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.c new file mode 100644 index 0000000..8dcf494 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.c @@ -0,0 +1,74 @@ +#include "test-socket.h" +#include "test-socket-sockets_decimate_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_decimate_by__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_decimate_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_sockets_decimate_by__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_decimate_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_sockets_decimate_by__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_decimate_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.h new file mode 100644 index 0000000..e289854 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_decimate_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_decimate_by +#define _TEST__F_socket__sockets_decimate_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_decimate_by() + */ +extern void test__f_socket_sockets_decimate_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_sockets_decimate_by() + */ +extern void test__f_socket_sockets_decimate_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_decimate_by() + */ +extern void test__f_socket_sockets_decimate_by__works(void **state); + +#endif // _TEST__F_socket__sockets_decimate_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.c new file mode 100644 index 0000000..a3d0053 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.c @@ -0,0 +1,74 @@ +#include "test-socket.h" +#include "test-socket-sockets_decrease_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_decrease_by__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_decrease_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_sockets_decrease_by__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_decrease_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_sockets_decrease_by__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_decrease_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.h new file mode 100644 index 0000000..9d1f1f9 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_decrease_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_decrease_by +#define _TEST__F_socket__sockets_decrease_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_decrease_by() + */ +extern void test__f_socket_sockets_decrease_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_sockets_decrease_by() + */ +extern void test__f_socket_sockets_decrease_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_decrease_by() + */ +extern void test__f_socket_sockets_decrease_by__works(void **state); + +#endif // _TEST__F_socket__sockets_decrease_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.c new file mode 100644 index 0000000..95e4650 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.c @@ -0,0 +1,76 @@ +#include "test-socket.h" +#include "test-socket-sockets_increase.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_increase__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_increase(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + free((void *) data.array); +} + +void test__f_socket_sockets_increase__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_increase(length, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_sockets_increase__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + data.used = length; + + const f_status_t status = f_sockets_increase(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, length); + assert_in_range(data.size, length + 1, length + 1 + F_memory_default_allocation_small_d); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.h new file mode 100644 index 0000000..1d60619 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_increase +#define _TEST__F_socket__sockets_increase + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_increase() + */ +extern void test__f_socket_sockets_increase__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_sockets_increase() + */ +extern void test__f_socket_sockets_increase__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_increase() + */ +extern void test__f_socket_sockets_increase__works(void **state); + +#endif // _TEST__F_socket__sockets_increase diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.c new file mode 100644 index 0000000..d94e7e0 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.c @@ -0,0 +1,76 @@ +#include "test-socket.h" +#include "test-socket-sockets_increase_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_increase_by__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_increase_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_sockets_increase_by__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_sockets_increase_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_sockets_increase_by__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + data.used = length; + + const f_status_t status = f_sockets_increase_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, length); + assert_int_equal(data.size, length * 2); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.h new file mode 100644 index 0000000..4a58726 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_increase_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_increase_by +#define _TEST__F_socket__sockets_increase_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_increase_by() + */ +extern void test__f_socket_sockets_increase_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_sockets_increase_by() + */ +extern void test__f_socket_sockets_increase_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_increase_by() + */ +extern void test__f_socket_sockets_increase_by__works(void **state); + +#endif // _TEST__F_socket__sockets_increase_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.c b/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.c new file mode 100644 index 0000000..6b37f71 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.c @@ -0,0 +1,42 @@ +#include "test-socket.h" +#include "test-socket-sockets_resize.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_sockets_resize__parameter_checking(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_sockets_resize__works(void **state) { + + const int length = 5; + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.h b/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.h new file mode 100644 index 0000000..3065bc9 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-sockets_resize.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__sockets_resize +#define _TEST__F_socket__sockets_resize + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_sockets_resize() + */ +extern void test__f_socket_sockets_resize__parameter_checking(void **state); + +/** + * Test that the function works. + * + * @see f_sockets_resize() + */ +extern void test__f_socket_sockets_resize__works(void **state); + +#endif // _TEST__F_socket__sockets_resize diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.c new file mode 100644 index 0000000..6377334 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.c @@ -0,0 +1,42 @@ +#include "test-socket.h" +#include "test-socket-socketss_adjust.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_adjust__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_adjust(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_socketss_adjust__works(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_adjust(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.h new file mode 100644 index 0000000..847c212 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_adjust.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_adjust +#define _TEST__F_socket__socketss_adjust + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_adjust() + */ +extern void test__f_socket_socketss_adjust__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_increase_by() + */ +extern void test__f_socket_socketss_increase_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_adjust() + */ +extern void test__f_socket_socketss_adjust__works(void **state); + +#endif // _TEST__F_socket__socketss_adjust diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_append.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_append.c new file mode 100644 index 0000000..48f7c56 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_append.c @@ -0,0 +1,110 @@ +#include "test-socket.h" +#include "test-socket-socketss_append.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_append__parameter_checking(void **state) { + + f_sockets_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_append(data, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_socket_socketss_append__returns_data_not(void **state) { + + const int length = 5; + f_sockets_t source = f_sockets_t_initialize; + f_socketss_t destination = f_socketss_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + { + const f_status_t status = f_socketss_append(source, &destination); + + assert_int_equal(status, F_data_not); + assert_int_equal(destination.used, 0); + assert_int_equal(destination.size, 0); + assert_null(destination.array); + } + + free((void *) source.array); +} + +void test__f_socket_socketss_append__works(void **state) { + + const int length = 5; + + f_string_static_t tests[] = { + macro_f_string_static_t_initialize_1("test_1", 0, 6), + macro_f_string_static_t_initialize_1("test_2", 0, 6), + macro_f_string_static_t_initialize_1("test_3", 0, 6), + macro_f_string_static_t_initialize_1("test_4", 0, 6), + macro_f_string_static_t_initialize_1("test_5", 0, 6), + }; + + f_socket_t sources[] = { + macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]), + macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]), + macro_f_socket_t_initialize_3(9, 10, 11, 12, 0, 0, tests[2]), + macro_f_socket_t_initialize_3(13, 14, 15, 16, 0, 0, tests[3]), + macro_f_socket_t_initialize_3(17, 18, 19, 20, 0, 0, tests[4]), + }; + + f_sockets_t source = f_sockets_t_initialize; + f_socketss_t destination = f_socketss_t_initialize; + + { + const f_status_t status = f_sockets_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + for (; source.used < length; ++source.used) { + source.array[source.used] = sources[source.used]; + } // for + + { + const f_status_t status = f_socketss_append(source, &destination); + + assert_int_equal(status, F_none); + assert_int_equal(destination.used, 1); + assert_int_equal(destination.array[0].used, source.used); + assert_int_equal(destination.array[0].size, source.used); + + for (f_number_unsigned_t i = 0; i < destination.array[0].used; ++i) { + + assert_int_equal(destination.array[0].array[i].id, sources[i].id); + assert_int_equal(destination.array[0].array[i].domain, sources[i].domain); + assert_int_equal(destination.array[0].array[i].protocol, sources[i].protocol); + assert_int_equal(destination.array[0].array[i].type, sources[i].type); + assert_int_equal(destination.array[0].array[i].name.used, sources[i].name.used); + + assert_string_equal(destination.array[0].array[i].name.string, sources[i].name.string); + } // for + } + + for (f_number_unsigned_t i = 0; i < destination.used; ++i) { + free((void *) destination.array[i].array); + } // for + + free((void *) source.array); + free((void *) destination.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_append.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_append.h new file mode 100644 index 0000000..1282cd8 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_append.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_append +#define _TEST__F_socket__socketss_append + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_append() + */ +extern void test__f_socket_socketss_append__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_append() + */ +extern void test__f_socket_socketss_append__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_append() + */ +extern void test__f_socket_socketss_append__works(void **state); + +#endif // _TEST__F_socket__socketss_append diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.c new file mode 100644 index 0000000..e7fd41a --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.c @@ -0,0 +1,123 @@ +#include "test-socket.h" +#include "test-socket-socketss_append_all.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_append_all__parameter_checking(void **state) { + + const f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_append_all(data, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_socket_socketss_append_all__returns_data_not(void **state) { + + const int length = 5; + f_socketss_t source = f_socketss_t_initialize; + f_socketss_t destination = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + { + const f_status_t status = f_socketss_append_all(source, &destination); + + assert_int_equal(status, F_data_not); + assert_int_equal(destination.used, 0); + assert_int_equal(destination.size, 0); + assert_null(destination.array); + } + + free((void *) source.array); +} + +void test__f_socket_socketss_append_all__works(void **state) { + + const int length = 5; + const int length_inner = 2; + + f_string_static_t tests[] = { + macro_f_string_static_t_initialize_1("test_1", 0, 6), + macro_f_string_static_t_initialize_1("test_2", 0, 6), + }; + + f_socket_t sources[] = { + macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]), + macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]), + }; + + f_socketss_t source = f_socketss_t_initialize; + f_socketss_t destination = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &source); + + assert_int_equal(status, F_none); + assert_int_equal(source.used, 0); + assert_int_equal(source.size, length); + } + + { + for (; source.used < length; ++source.used) { + + const f_status_t status = f_sockets_resize(length_inner, &source.array[source.used]); + + assert_int_equal(status, F_none); + + for (f_number_unsigned_t i = 0; i < length_inner; ++i) { + source.array[source.used].array[source.array[source.used].used++] = sources[i]; + } // for + } // for + } + + { + const f_status_t status = f_socketss_append_all(source, &destination); + + assert_int_equal(status, F_none); + assert_int_equal(destination.used, source.used); + assert_int_equal(destination.size, source.used); + + for (f_number_unsigned_t i = 0; i < destination.used; ++i) { + + assert_int_equal(destination.array[i].used, length_inner); + assert_int_equal(destination.array[i].size, length_inner); + + for (f_number_unsigned_t j = 0; j < length_inner; ++j) { + + assert_int_equal(destination.array[i].array[j].id, sources[j].id); + assert_int_equal(destination.array[i].array[j].domain, sources[j].domain); + assert_int_equal(destination.array[i].array[j].protocol, sources[j].protocol); + assert_int_equal(destination.array[i].array[j].type, sources[j].type); + assert_int_equal(destination.array[i].array[j].name.used, sources[j].name.used); + + assert_string_equal(destination.array[i].array[j].name.string, sources[j].name.string); + } // for + } // for + } + + for (f_number_unsigned_t i = 0; i < source.used; ++i) { + free((void *) source.array[i].array); + } // for + + for (f_number_unsigned_t i = 0; i < destination.used; ++i) { + free((void *) destination.array[i].array); + } // for + + free((void *) source.array); + free((void *) destination.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.h new file mode 100644 index 0000000..c38eac9 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_append_all.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_append_all +#define _TEST__F_socket__socketss_append_all + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_append_all() + */ +extern void test__f_socket_socketss_append_all__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_append_all() + */ +extern void test__f_socket_socketss_append_all__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_append_all() + */ +extern void test__f_socket_socketss_append_all__works(void **state); + +#endif // _TEST__F_socket__socketss_append_all diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.c new file mode 100644 index 0000000..676e571 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.c @@ -0,0 +1,74 @@ +#include "test-socket.h" +#include "test-socket-socketss_decimate_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_decimate_by__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_decimate_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_socketss_decimate_by__returns_data_not(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_decimate_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_socketss_decimate_by__works(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_decimate_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.h new file mode 100644 index 0000000..f4bad75 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_decimate_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_decimate_by +#define _TEST__F_socket__socketss_decimate_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_decimate_by() + */ +extern void test__f_socket_socketss_decimate_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socket_socketss_decimate_by() + */ +extern void test__f_socket_socketss_decimate_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_decimate_by() + */ +extern void test__f_socket_socketss_decimate_by__works(void **state); + +#endif // _TEST__F_socket__socketss_decimate_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.c new file mode 100644 index 0000000..119d669 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.c @@ -0,0 +1,74 @@ +#include "test-socket.h" +#include "test-socket-socketss_decrease_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_decrease_by__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_decrease_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_socketss_decrease_by__returns_data_not(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_decrease_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_socketss_decrease_by__works(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_decrease_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.h new file mode 100644 index 0000000..9fe87f5 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_decrease_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_decrease_by +#define _TEST__F_socket__socketss_decrease_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_decrease_by() + */ +extern void test__f_socket_socketss_decrease_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_decrease_by() + */ +extern void test__f_socket_socketss_decrease_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_decrease_by() + */ +extern void test__f_socket_socketss_decrease_by__works(void **state); + +#endif // _TEST__F_socket__socketss_decrease_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.c new file mode 100644 index 0000000..752624a --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.c @@ -0,0 +1,76 @@ +#include "test-socket.h" +#include "test-socket-socketss_increase.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_increase__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_increase(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + free((void *) data.array); +} + +void test__f_socket_socketss_increase__returns_data_not(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_increase(length, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_socketss_increase__works(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + data.used = length; + + const f_status_t status = f_socketss_increase(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, length); + assert_in_range(data.size, length + 1, length + 1 + F_memory_default_allocation_small_d); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.h new file mode 100644 index 0000000..9d3eb05 --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_increase +#define _TEST__F_socket__socketss_increase + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_increase() + */ +extern void test__f_socket_socketss_increase__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_increase() + */ +extern void test__f_socket_socketss_increase__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_increase() + */ +extern void test__f_socket_socketss_increase__works(void **state); + +#endif // _TEST__F_socket__socketss_increase diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.c new file mode 100644 index 0000000..240ea5e --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.c @@ -0,0 +1,84 @@ +#include "test-socket.h" +#include "test-socket-socketss_increase_by.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_increase_by__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_increase_by(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_socketss_increase_by__returns_data_not(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_increase_by(0, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + const f_status_t status = f_socketss_increase_by(length, &data); + + assert_int_equal(status, F_data_not); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +void test__f_socket_socketss_increase_by__works(void **state) { + + const int length = 5; + f_socketss_t data = f_sockets_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + { + data.used = length; + + const f_status_t status = f_socketss_increase_by(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, length); + assert_int_equal(data.size, length * 2); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.h new file mode 100644 index 0000000..540c8ef --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_increase_by.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_increase_by +#define _TEST__F_socket__socketss_increase_by + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_increase_by() + */ +extern void test__f_socket_socketss_increase_by__parameter_checking(void **state); + +/** + * Test that the function returns F_data_not. + * + * @see f_socketss_increase_by() + */ +extern void test__f_socket_socketss_increase_by__returns_data_not(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_increase_by() + */ +extern void test__f_socket_socketss_increase_by__works(void **state); + +#endif // _TEST__F_socket__socketss_increase_by diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.c b/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.c new file mode 100644 index 0000000..0e96c1c --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.c @@ -0,0 +1,42 @@ +#include "test-socket.h" +#include "test-socket-socketss_resize.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_socket_socketss_resize__parameter_checking(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, 0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, 0); + } + + assert_null(data.array); +} + +void test__f_socket_socketss_resize__works(void **state) { + + const int length = 5; + f_socketss_t data = f_socketss_t_initialize; + + { + const f_status_t status = f_socketss_resize(length, &data); + + assert_int_equal(status, F_none); + assert_int_equal(data.used, 0); + assert_int_equal(data.size, length); + } + + free((void *) data.array); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.h b/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.h new file mode 100644 index 0000000..5613a6e --- /dev/null +++ b/level_0/f_socket/tests/unit/c/test-socket-socketss_resize.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Socket + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_socket__socketss_resize +#define _TEST__F_socket__socketss_resize + +/** + * Test that the function correctly fails on invalid parameter. + * + * @see f_socketss_resize() + */ +extern void test__f_socket_socketss_resize__parameter_checking(void **state); + +/** + * Test that the function works. + * + * @see f_socketss_resize() + */ +extern void test__f_socket_socketss_resize__works(void **state); + +#endif // _TEST__F_socket__socketss_resize diff --git a/level_0/f_socket/tests/unit/c/test-socket.c b/level_0/f_socket/tests/unit/c/test-socket.c index 0b998aa..9f8dcf1 100644 --- a/level_0/f_socket/tests/unit/c/test-socket.c +++ b/level_0/f_socket/tests/unit/c/test-socket.c @@ -79,6 +79,37 @@ int main(void) { cmocka_unit_test(test__f_socket_write_stream__fails), cmocka_unit_test(test__f_socket_write_stream__works), + cmocka_unit_test(test__f_socket_sockets_append_all__returns_data_not), + cmocka_unit_test(test__f_socket_sockets_decimate_by__returns_data_not), + cmocka_unit_test(test__f_socket_sockets_decrease_by__returns_data_not), + cmocka_unit_test(test__f_socket_sockets_increase__returns_data_not), + cmocka_unit_test(test__f_socket_sockets_increase_by__returns_data_not), + + cmocka_unit_test(test__f_socket_sockets_adjust__works), + cmocka_unit_test(test__f_socket_sockets_append__works), + cmocka_unit_test(test__f_socket_sockets_append_all__works), + cmocka_unit_test(test__f_socket_sockets_decimate_by__works), + cmocka_unit_test(test__f_socket_sockets_decrease_by__works), + cmocka_unit_test(test__f_socket_sockets_increase__works), + cmocka_unit_test(test__f_socket_sockets_increase_by__works), + cmocka_unit_test(test__f_socket_sockets_resize__works), + + cmocka_unit_test(test__f_socket_socketss_append__returns_data_not), + cmocka_unit_test(test__f_socket_socketss_append_all__returns_data_not), + cmocka_unit_test(test__f_socket_socketss_decimate_by__returns_data_not), + cmocka_unit_test(test__f_socket_socketss_decrease_by__returns_data_not), + cmocka_unit_test(test__f_socket_socketss_increase__returns_data_not), + cmocka_unit_test(test__f_socket_socketss_increase_by__returns_data_not), + + cmocka_unit_test(test__f_socket_socketss_adjust__works), + cmocka_unit_test(test__f_socket_socketss_append__works), + cmocka_unit_test(test__f_socket_socketss_append_all__works), + cmocka_unit_test(test__f_socket_socketss_decimate_by__works), + cmocka_unit_test(test__f_socket_socketss_decrease_by__works), + cmocka_unit_test(test__f_socket_socketss_increase__works), + cmocka_unit_test(test__f_socket_socketss_increase_by__works), + cmocka_unit_test(test__f_socket_socketss_resize__works), + #ifndef _di_level_0_parameter_checking_ cmocka_unit_test(test__f_socket_accept__parameter_checking), cmocka_unit_test(test__f_socket_bind__parameter_checking), @@ -97,6 +128,24 @@ int main(void) { cmocka_unit_test(test__f_socket_write__parameter_checking), cmocka_unit_test(test__f_socket_write_message__parameter_checking), cmocka_unit_test(test__f_socket_write_stream__parameter_checking), + + cmocka_unit_test(test__f_socket_sockets_adjust__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_append__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_append_all__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_decimate_by__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_decrease_by__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_increase__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_increase_by__parameter_checking), + cmocka_unit_test(test__f_socket_sockets_resize__parameter_checking), + + cmocka_unit_test(test__f_socket_socketss_adjust__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_append__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_append_all__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_decimate_by__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_decrease_by__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_increase__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_increase_by__parameter_checking), + cmocka_unit_test(test__f_socket_socketss_resize__parameter_checking), #endif // _di_level_0_parameter_checking_ }; diff --git a/level_0/f_socket/tests/unit/c/test-socket.h b/level_0/f_socket/tests/unit/c/test-socket.h index 084a75e..9205b8f 100644 --- a/level_0/f_socket/tests/unit/c/test-socket.h +++ b/level_0/f_socket/tests/unit/c/test-socket.h @@ -41,6 +41,22 @@ #include "test-socket-read.h" #include "test-socket-read_message.h" #include "test-socket-read_stream.h" +#include "test-socket-sockets_adjust.h" +#include "test-socket-sockets_append.h" +#include "test-socket-sockets_append_all.h" +#include "test-socket-sockets_decimate_by.h" +#include "test-socket-sockets_decrease_by.h" +#include "test-socket-sockets_increase.h" +#include "test-socket-sockets_increase_by.h" +#include "test-socket-sockets_resize.h" +#include "test-socket-socketss_adjust.h" +#include "test-socket-socketss_append.h" +#include "test-socket-socketss_append_all.h" +#include "test-socket-socketss_decimate_by.h" +#include "test-socket-socketss_decrease_by.h" +#include "test-socket-socketss_increase.h" +#include "test-socket-socketss_increase_by.h" +#include "test-socket-socketss_resize.h" #include "test-socket-write.h" #include "test-socket-write_message.h" #include "test-socket-write_stream.h" diff --git a/level_0/f_type_array/c/type_array/cell.c b/level_0/f_type_array/c/type_array/cell.c index f43dd5b..159d219 100644 --- a/level_0/f_type_array/c/type_array/cell.c +++ b/level_0/f_type_array/c/type_array/cell.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_cells_adjust_ - f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) { + f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_cells_adjust_ #ifndef _di_f_cells_append_ - f_status_t f_cells_append(const f_cell_t source, f_cells_t *destination) { + f_status_t f_cells_append(const f_cell_t source, f_cells_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_cells_append_ #ifndef _di_f_cells_append_all_ - f_status_t f_cells_append_all(const f_cells_t source, f_cells_t *destination) { + f_status_t f_cells_append_all(const f_cells_t source, f_cells_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_cells_append_all_ #ifndef _di_f_cells_decimate_by_ - f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t *cells) { + f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_cells_decimate_by_ #ifndef _di_f_cells_decrease_by_ - f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t *cells) { + f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_cells_decrease_by_ #ifndef _di_f_cells_increase_ - f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t *cells) { + f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_cells_increase_ #ifndef _di_f_cells_increase_by_ - f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t *cells) { + f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_cells_increase_by_ #ifndef _di_f_cells_resize_ - f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) { + f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) { #ifndef _di_level_0_parameter_checking_ if (!cells) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_cells_resize_ #ifndef _di_f_cellss_adjust_ - f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) { + f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_cellss_adjust_ #ifndef _di_f_cellss_append_ - f_status_t f_cellss_append(const f_cells_t source, f_cellss_t *destination) { + f_status_t f_cellss_append(const f_cells_t source, f_cellss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_cellss_append_ #ifndef _di_f_cellss_append_all_ - f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t *destination) { + f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_cellss_append_all_ #ifndef _di_f_cellss_decimate_by_ - f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t *cellss) { + f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_cellss_decimate_by_ #ifndef _di_f_cellss_decrease_by_ - f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t *cellss) { + f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_cellss_decrease_by_ #ifndef _di_f_cellss_increase_ - f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t *cellss) { + f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_cellss_increase_ #ifndef _di_f_cellss_increase_by_ - f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t *cellss) { + f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_cellss_increase_by_ #ifndef _di_f_cellss_resize_ - f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) { + f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) { #ifndef _di_level_0_parameter_checking_ if (!cellss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/cell.h b/level_0/f_type_array/c/type_array/cell.h index b62ac2e..d0d40a8 100644 --- a/level_0/f_type_array/c/type_array/cell.h +++ b/level_0/f_type_array/c/type_array/cell.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_cells_adjust_ - extern f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells); + extern f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells); #endif // _di_f_cells_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_append_ - extern f_status_t f_cells_append(const f_cell_t source, f_cells_t *destination); + extern f_status_t f_cells_append(const f_cell_t source, f_cells_t * const destination); #endif // _di_f_cells_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_append_all_ - extern f_status_t f_cells_append_all(const f_cells_t source, f_cells_t *destination); + extern f_status_t f_cells_append_all(const f_cells_t source, f_cells_t * const destination); #endif // _di_f_cells_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_cells_decimate_by_ - extern f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t *cells); + extern f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t * const cells); #endif // _di_f_cells_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_decrease_by_ - extern f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t *cells); + extern f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t * const cells); #endif // _di_f_cells_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_increase_ - extern f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t *cells); + extern f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t * const cells); #endif // _di_f_cells_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_increase_by_ - extern f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t *cells); + extern f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t * const cells); #endif // _di_f_cells_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_resize_ - extern f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells); + extern f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells); #endif // _di_f_cells_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_cellss_adjust_ - extern f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss); + extern f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss); #endif // _di_f_cellss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_append_ - extern f_status_t f_cellss_append(const f_cells_t source, f_cellss_t *destination); + extern f_status_t f_cellss_append(const f_cells_t source, f_cellss_t * const destination); #endif // _di_f_cellss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_append_all_ - extern f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t *destination); + extern f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t * const destination); #endif // _di_f_cellss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_cellss_decimate_by_ - extern f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t *cellss); + extern f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t * const cellss); #endif // _di_f_cellss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_decrease_by_ - extern f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t *cellss); + extern f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t * const cellss); #endif // _di_f_cellss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_increase_ - extern f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t *cellss); + extern f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t * const cellss); #endif // _di_f_cellss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_increase_by_ - extern f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t *cellss); + extern f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t * const cellss); #endif // _di_f_cellss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_resize_ - extern f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss); + extern f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss); #endif // _di_f_cellss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/file.c b/level_0/f_type_array/c/type_array/file.c index eb82e4e..e03b186 100644 --- a/level_0/f_type_array/c/type_array/file.c +++ b/level_0/f_type_array/c/type_array/file.c @@ -8,7 +8,7 @@ extern "C" { #endif #ifndef _di_f_files_adjust_ - f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t *files) { + f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -18,7 +18,7 @@ extern "C" { #endif // _di_f_files_adjust_ #ifndef _di_f_files_append_ - f_status_t f_files_append(const f_file_t source, f_files_t *destination) { + f_status_t f_files_append(const f_file_t source, f_files_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -28,7 +28,7 @@ extern "C" { #endif // _di_f_files_append_ #ifndef _di_f_files_append_all_ - f_status_t f_files_append_all(const f_files_t source, f_files_t *destination) { + f_status_t f_files_append_all(const f_files_t source, f_files_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -40,7 +40,7 @@ extern "C" { #endif // _di_f_files_append_all_ #ifndef _di_f_files_decimate_by_ - f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t *files) { + f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -56,7 +56,7 @@ extern "C" { #endif // _di_f_files_decimate_by_ #ifndef _di_f_files_decrease_by_ - f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t *files) { + f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -72,7 +72,7 @@ extern "C" { #endif // _di_f_files_decrease_by_ #ifndef _di_f_files_increase_ - f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t *files) { + f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -96,7 +96,7 @@ extern "C" { #endif // _di_f_files_increase_ #ifndef _di_f_files_increase_by_ - f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t *files) { + f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -116,7 +116,7 @@ extern "C" { #endif // _di_f_files_increase_by_ #ifndef _di_f_files_resize_ - f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t *files) { + f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t * const files) { #ifndef _di_level_0_parameter_checking_ if (!files) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -126,7 +126,7 @@ extern "C" { #endif // _di_f_files_resize_ #ifndef _di_f_filess_adjust_ - f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) { + f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -136,7 +136,7 @@ extern "C" { #endif // _di_f_filess_adjust_ #ifndef _di_f_filess_append_ - f_status_t f_filess_append(const f_files_t source, f_filess_t *destination) { + f_status_t f_filess_append(const f_files_t source, f_filess_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -160,7 +160,7 @@ extern "C" { #endif // _di_f_filess_append_ #ifndef _di_f_filess_append_all_ - f_status_t f_filess_append_all(const f_filess_t source, f_filess_t *destination) { + f_status_t f_filess_append_all(const f_filess_t source, f_filess_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -189,7 +189,7 @@ extern "C" { #endif // _di_f_filess_append_all_ #ifndef _di_f_filess_decimate_by_ - f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t *filess) { + f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -205,7 +205,7 @@ extern "C" { #endif // _di_f_filess_decimate_by_ #ifndef _di_f_filess_decrease_by_ - f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t *filess) { + f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -221,7 +221,7 @@ extern "C" { #endif // _di_f_filess_decrease_by_ #ifndef _di_f_filess_increase_ - f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t *filess) { + f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -245,7 +245,7 @@ extern "C" { #endif // _di_f_filess_increase_ #ifndef _di_f_filess_increase_by_ - f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t *filess) { + f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -265,7 +265,7 @@ extern "C" { #endif // _di_f_filess_increase_by_ #ifndef _di_f_filess_resize_ - f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) { + f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) { #ifndef _di_level_0_parameter_checking_ if (!filess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/file.h b/level_0/f_type_array/c/type_array/file.h index a829240..109b410 100644 --- a/level_0/f_type_array/c/type_array/file.h +++ b/level_0/f_type_array/c/type_array/file.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_files_adjust_ - extern f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t *files); + extern f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t * const files); #endif // _di_f_files_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_append_ - extern f_status_t f_files_append(const f_file_t source, f_files_t *destination); + extern f_status_t f_files_append(const f_file_t source, f_files_t * const destination); #endif // _di_f_files_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_append_all_ - extern f_status_t f_files_append_all(const f_files_t source, f_files_t *destination); + extern f_status_t f_files_append_all(const f_files_t source, f_files_t * const destination); #endif // _di_f_files_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_files_decimate_by_ - extern f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t *files); + extern f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t * const files); #endif // _di_f_files_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_decrease_by_ - extern f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t *files); + extern f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t * const files); #endif // _di_f_files_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_increase_ - extern f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t *files); + extern f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t * const files); #endif // _di_f_files_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_increase_by_ - extern f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t *files); + extern f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t * const files); #endif // _di_f_files_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_files_resize_ - extern f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t *files); + extern f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t * const files); #endif // _di_f_files_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_filess_adjust_ - extern f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess); + extern f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess); #endif // _di_f_filess_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_append_ - extern f_status_t f_filess_append(const f_files_t source, f_filess_t *destination); + extern f_status_t f_filess_append(const f_files_t source, f_filess_t * const destination); #endif // _di_f_filess_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_append_all_ - extern f_status_t f_filess_append_all(const f_filess_t source, f_filess_t *destination); + extern f_status_t f_filess_append_all(const f_filess_t source, f_filess_t * const destination); #endif // _di_f_filess_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_filess_decimate_by_ - extern f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t *filess); + extern f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t * const filess); #endif // _di_f_filess_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_decrease_by_ - extern f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t *filess); + extern f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t * const filess); #endif // _di_f_filess_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_increase_ - extern f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t *filess); + extern f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t * const filess); #endif // _di_f_filess_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_increase_by_ - extern f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t *filess); + extern f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t * const filess); #endif // _di_f_filess_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_filess_resize_ - extern f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess); + extern f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess); #endif // _di_f_filess_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/fll_id.c b/level_0/f_type_array/c/type_array/fll_id.c index 9d75d8f..f16ed9e 100644 --- a/level_0/f_type_array/c/type_array/fll_id.c +++ b/level_0/f_type_array/c/type_array/fll_id.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_fll_ids_adjust_ - f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids) { + f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_fll_ids_adjust_ #ifndef _di_f_fll_ids_append_ - f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) { + f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_fll_ids_append_ #ifndef _di_f_fll_ids_append_all_ - f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) { + f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_fll_ids_append_all_ #ifndef _di_f_fll_ids_decimate_by_ - f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) { + f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_fll_ids_decimate_by_ #ifndef _di_f_fll_ids_decrease_by_ - f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) { + f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_fll_ids_decrease_by_ #ifndef _di_f_fll_ids_increase_ - f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t *ids) { + f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_fll_ids_increase_ #ifndef _di_f_fll_ids_increase_by_ - f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) { + f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_fll_ids_increase_by_ #ifndef _di_f_fll_ids_resize_ - f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids) { + f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids) { #ifndef _di_level_0_parameter_checking_ if (!ids) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_fll_ids_resize_ #ifndef _di_f_fll_idss_adjust_ - f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss) { + f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_fll_idss_adjust_ #ifndef _di_f_fll_idss_append_ - f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t *destination) { + f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_fll_idss_append_ #ifndef _di_f_fll_idss_append_all_ - f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t *destination) { + f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_fll_idss_append_all_ #ifndef _di_f_fll_idss_decimate_by_ - f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) { + f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_fll_idss_decimate_by_ #ifndef _di_f_fll_idss_decrease_by_ - f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) { + f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_fll_idss_decrease_by_ #ifndef _di_f_fll_idss_increase_ - f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t *idss) { + f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_fll_idss_increase_ #ifndef _di_f_fll_idss_increase_by_ - f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) { + f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_fll_idss_increase_by_ #ifndef _di_f_fll_idss_resize_ - f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss) { + f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss) { #ifndef _di_level_0_parameter_checking_ if (!idss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/fll_id.h b/level_0/f_type_array/c/type_array/fll_id.h index 9569cd3..98a9b56 100644 --- a/level_0/f_type_array/c/type_array/fll_id.h +++ b/level_0/f_type_array/c/type_array/fll_id.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_fll_ids_adjust_ - extern f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_append_ - extern f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination); + extern f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination); #endif // _di_f_fll_ids_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_append_all_ - extern f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination); + extern f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination); #endif // _di_f_fll_ids_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_fll_ids_decimate_by_ - extern f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_decrease_by_ - extern f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_increase_ - extern f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_increase_by_ - extern f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_ids_resize_ - extern f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids); #endif // _di_f_fll_ids_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_fll_idss_adjust_ - extern f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_append_ - extern f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t *destination); + extern f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t * const destination); #endif // _di_f_fll_idss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_append_all_ - extern f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t *destination); + extern f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t * const destination); #endif // _di_f_fll_idss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_fll_idss_decimate_by_ - extern f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_decrease_by_ - extern f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_increase_ - extern f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_increase_by_ - extern f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_fll_idss_resize_ - extern f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss); #endif // _di_f_fll_idss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/int128.c b/level_0/f_type_array/c/type_array/int128.c index d444218..7444257 100644 --- a/level_0/f_type_array/c/type_array/int128.c +++ b/level_0/f_type_array/c/type_array/int128.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_int128s_adjust_ - f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) { + f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_int128s_adjust_ #ifndef _di_f_int128s_append_ - f_status_t f_int128s_append(const int128_t source, f_int128s_t *destination) { + f_status_t f_int128s_append(const int128_t source, f_int128s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_int128s_append_ #ifndef _di_f_int128s_append_all_ - f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) { + f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_int128s_append_all_ #ifndef _di_f_int128s_decimate_by_ - f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t *int128s) { + f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_int128s_decimate_by_ #ifndef _di_f_int128s_decrease_by_ - f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t *int128s) { + f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_int128s_decrease_by_ #ifndef _di_f_int128s_increase_ - f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t *int128s) { + f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_int128s_increase_ #ifndef _di_f_int128s_increase_by_ - f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t *int128s) { + f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_int128s_increase_by_ #ifndef _di_f_int128s_resize_ - f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) { + f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) { #ifndef _di_level_0_parameter_checking_ if (!int128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_int128s_resize_ #ifndef _di_f_int128ss_adjust_ - f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) { + f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_int128ss_adjust_ #ifndef _di_f_int128ss_append_ - f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t *destination) { + f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_int128ss_append_ #ifndef _di_f_int128ss_append_all_ - f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t *destination) { + f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_int128ss_append_all_ #ifndef _di_f_int128ss_decimate_by_ - f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) { + f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_int128ss_decimate_by_ #ifndef _di_f_int128ss_decrease_by_ - f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) { + f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_int128ss_decrease_by_ #ifndef _di_f_int128ss_increase_ - f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t *int128ss) { + f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_int128ss_increase_ #ifndef _di_f_int128ss_increase_by_ - f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) { + f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_int128ss_increase_by_ #ifndef _di_f_int128ss_resize_ - f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) { + f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) { #ifndef _di_level_0_parameter_checking_ if (!int128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/int128.h b/level_0/f_type_array/c/type_array/int128.h index 7acd869..cbdfb35 100644 --- a/level_0/f_type_array/c/type_array/int128.h +++ b/level_0/f_type_array/c/type_array/int128.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int128s_adjust_ - extern f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s); + extern f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s); #endif // _di_f_int128s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_append_ - extern f_status_t f_int128s_append(const int128_t source, f_int128s_t *destination); + extern f_status_t f_int128s_append(const int128_t source, f_int128s_t * const destination); #endif // _di_f_int128s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_append_all_ - extern f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination); + extern f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination); #endif // _di_f_int128s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int128s_decimate_by_ - extern f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t *int128s); + extern f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t * const int128s); #endif // _di_f_int128s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_decrease_by_ - extern f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t *int128s); + extern f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t * const int128s); #endif // _di_f_int128s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_increase_ - extern f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t *int128s); + extern f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t * const int128s); #endif // _di_f_int128s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_increase_by_ - extern f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t *int128s); + extern f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t * const int128s); #endif // _di_f_int128s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_resize_ - extern f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s); + extern f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s); #endif // _di_f_int128s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int128ss_adjust_ - extern f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_append_ - extern f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t *destination); + extern f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t * const destination); #endif // _di_f_int128ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_append_all_ - extern f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t *destination); + extern f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t * const destination); #endif // _di_f_int128ss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int128ss_decimate_by_ - extern f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_decrease_by_ - extern f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_increase_ - extern f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_increase_by_ - extern f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_resize_ - extern f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss); #endif // _di_f_int128ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/int16.c b/level_0/f_type_array/c/type_array/int16.c index 2a59e2a..783b27e 100644 --- a/level_0/f_type_array/c/type_array/int16.c +++ b/level_0/f_type_array/c/type_array/int16.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_int16s_adjust_ - f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) { + f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_int16s_adjust_ #ifndef _di_f_int16s_append_ - f_status_t f_int16s_append(const int16_t source, f_int16s_t *destination) { + f_status_t f_int16s_append(const int16_t source, f_int16s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_int16s_append_ #ifndef _di_f_int16s_append_all_ - f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) { + f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_int16s_append_all_ #ifndef _di_f_int16s_decimate_by_ - f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t *int16s) { + f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_int16s_decimate_by_ #ifndef _di_f_int16s_decrease_by_ - f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t *int16s) { + f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_int16s_decrease_by_ #ifndef _di_f_int16s_increase_ - f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t *int16s) { + f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_int16s_increase_ #ifndef _di_f_int16s_increase_by_ - f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t *int16s) { + f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_int16s_increase_by_ #ifndef _di_f_int16s_resize_ - f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) { + f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) { #ifndef _di_level_0_parameter_checking_ if (!int16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_int16s_resize_ #ifndef _di_f_int16ss_adjust_ - f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) { + f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_int16ss_adjust_ #ifndef _di_f_int16ss_append_ - f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t *destination) { + f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_int16ss_append_ #ifndef _di_f_int16ss_append_all_ - f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t *destination) { + f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_int16ss_append_all_ #ifndef _di_f_int16ss_decimate_by_ - f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) { + f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_int16ss_decimate_by_ #ifndef _di_f_int16ss_decrease_by_ - f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) { + f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_int16ss_decrease_by_ #ifndef _di_f_int16ss_increase_ - f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t *int16ss) { + f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_int16ss_increase_ #ifndef _di_f_int16ss_increase_by_ - f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) { + f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_int16ss_increase_by_ #ifndef _di_f_int16ss_resize_ - f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) { + f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) { #ifndef _di_level_0_parameter_checking_ if (!int16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/int16.h b/level_0/f_type_array/c/type_array/int16.h index fdf9c0b..481fed6 100644 --- a/level_0/f_type_array/c/type_array/int16.h +++ b/level_0/f_type_array/c/type_array/int16.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int16s_adjust_ - extern f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s); + extern f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s); #endif // _di_f_int16s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_append_ - extern f_status_t f_int16s_append(const int16_t source, f_int16s_t *destination); + extern f_status_t f_int16s_append(const int16_t source, f_int16s_t * const destination); #endif // _di_f_int16s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_append_all_ - extern f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination); + extern f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination); #endif // _di_f_int16s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int16s_decimate_by_ - extern f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t *int16s); + extern f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t * const int16s); #endif // _di_f_int16s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_decrease_by_ - extern f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t *int16s); + extern f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t * const int16s); #endif // _di_f_int16s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_increase_ - extern f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t *int16s); + extern f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t * const int16s); #endif // _di_f_int16s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_increase_by_ - extern f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t *int16s); + extern f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t * const int16s); #endif // _di_f_int16s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_resize_ - extern f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s); + extern f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s); #endif // _di_f_int16s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int16ss_adjust_ - extern f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_append_ - extern f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t *destination); + extern f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t * const destination); #endif // _di_f_int16ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_append_all_ - extern f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t *destination); + extern f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t * const destination); #endif // _di_f_int16ss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int16ss_decimate_by_ - extern f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_decrease_by_ - extern f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_increase_ - extern f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_increase_by_ - extern f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_resize_ - extern f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss); #endif // _di_f_int16ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/int32.c b/level_0/f_type_array/c/type_array/int32.c index cc9d7a0..f51c374 100644 --- a/level_0/f_type_array/c/type_array/int32.c +++ b/level_0/f_type_array/c/type_array/int32.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_int32s_adjust_ - f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) { + f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_int32s_adjust_ #ifndef _di_f_int32s_append_ - f_status_t f_int32s_append(const int32_t source, f_int32s_t *destination) { + f_status_t f_int32s_append(const int32_t source, f_int32s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_int32s_append_ #ifndef _di_f_int32s_append_all_ - f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) { + f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_int32s_append_all_ #ifndef _di_f_int32s_decimate_by_ - f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t *int32s) { + f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_int32s_decimate_by_ #ifndef _di_f_int32s_decrease_by_ - f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t *int32s) { + f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_int32s_decrease_by_ #ifndef _di_f_int32s_increase_ - f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t *int32s) { + f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_int32s_increase_ #ifndef _di_f_int32s_increase_by_ - f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t *int32s) { + f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_int32s_increase_by_ #ifndef _di_f_int32s_resize_ - f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) { + f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) { #ifndef _di_level_0_parameter_checking_ if (!int32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_int32s_resize_ #ifndef _di_f_int32ss_adjust_ - f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) { + f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_int32ss_adjust_ #ifndef _di_f_int32ss_append_ - f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t *destination) { + f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_int32ss_append_ #ifndef _di_f_int32ss_append_all_ - f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t *destination) { + f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_int32ss_append_all_ #ifndef _di_f_int32ss_decimate_by_ - f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) { + f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_int32ss_decimate_by_ #ifndef _di_f_int32ss_decrease_by_ - f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) { + f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_int32ss_decrease_by_ #ifndef _di_f_int32ss_increase_ - f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t *int32ss) { + f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_int32ss_increase_ #ifndef _di_f_int32ss_increase_by_ - f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) { + f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_int32ss_increase_by_ #ifndef _di_f_int32ss_resize_ - f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) { + f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) { #ifndef _di_level_0_parameter_checking_ if (!int32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/int32.h b/level_0/f_type_array/c/type_array/int32.h index 040147f..7773184 100644 --- a/level_0/f_type_array/c/type_array/int32.h +++ b/level_0/f_type_array/c/type_array/int32.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int32s_adjust_ - extern f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s); + extern f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s); #endif // _di_f_int32s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_append_ - extern f_status_t f_int32s_append(const int32_t source, f_int32s_t *destination); + extern f_status_t f_int32s_append(const int32_t source, f_int32s_t * const destination); #endif // _di_f_int32s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_append_all_ - extern f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination); + extern f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination); #endif // _di_f_int32s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int32s_decimate_by_ - extern f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t *int32s); + extern f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t * const int32s); #endif // _di_f_int32s_decimate_by_ /** @@ -119,7 +119,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_decrease_by_ - extern f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t *int32s); + extern f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t * const int32s); #endif // _di_f_int32s_decrease_by_ /** @@ -144,7 +144,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_increase_ - extern f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t *int32s); + extern f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t * const int32s); #endif // _di_f_int32s_increase_ /** @@ -169,7 +169,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_increase_by_ - extern f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t *int32s); + extern f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t * const int32s); #endif // _di_f_int32s_increase_by_ /** @@ -188,7 +188,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_resize_ - extern f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s); + extern f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s); #endif // _di_f_int32s_resize_ /** @@ -208,7 +208,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int32ss_adjust_ - extern f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_adjust_ /** @@ -228,7 +228,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_append_ - extern f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t *destination); + extern f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t * const destination); #endif // _di_f_int32ss_append_ /** @@ -248,7 +248,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_append_all_ - extern f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t *destination); + extern f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t * const destination); #endif // _di_f_int32ss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int32ss_decimate_by_ - extern f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_decrease_by_ - extern f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_increase_ - extern f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_increase_by_ - extern f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_resize_ - extern f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss); #endif // _di_f_int32ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/int64.c b/level_0/f_type_array/c/type_array/int64.c index 1aa1303..94f253b 100644 --- a/level_0/f_type_array/c/type_array/int64.c +++ b/level_0/f_type_array/c/type_array/int64.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_int64s_adjust_ - f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) { + f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_int64s_adjust_ #ifndef _di_f_int64s_append_ - f_status_t f_int64s_append(const int64_t source, f_int64s_t *destination) { + f_status_t f_int64s_append(const int64_t source, f_int64s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_int64s_append_ #ifndef _di_f_int64s_append_all_ - f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) { + f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_int64s_append_all_ #ifndef _di_f_int64s_decimate_by_ - f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t *int64s) { + f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_int64s_decimate_by_ #ifndef _di_f_int64s_decrease_by_ - f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t *int64s) { + f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_int64s_decrease_by_ #ifndef _di_f_int64s_increase_ - f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t *int64s) { + f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_int64s_increase_ #ifndef _di_f_int64s_increase_by_ - f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t *int64s) { + f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_int64s_increase_by_ #ifndef _di_f_int64s_resize_ - f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) { + f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) { #ifndef _di_level_0_parameter_checking_ if (!int64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_int64s_resize_ #ifndef _di_f_int64ss_adjust_ - f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) { + f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_int64ss_adjust_ #ifndef _di_f_int64ss_append_ - f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t *destination) { + f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_int64ss_append_ #ifndef _di_f_int64ss_append_all_ - f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t *destination) { + f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_int64ss_append_all_ #ifndef _di_f_int64ss_decimate_by_ - f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) { + f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_int64ss_decimate_by_ #ifndef _di_f_int64ss_decrease_by_ - f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) { + f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_int64ss_decrease_by_ #ifndef _di_f_int64ss_increase_ - f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t *int64ss) { + f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_int64ss_increase_ #ifndef _di_f_int64ss_increase_by_ - f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) { + f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_int64ss_increase_by_ #ifndef _di_f_int64ss_resize_ - f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) { + f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) { #ifndef _di_level_0_parameter_checking_ if (!int64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/int64.h b/level_0/f_type_array/c/type_array/int64.h index 1742945..12d68a9 100644 --- a/level_0/f_type_array/c/type_array/int64.h +++ b/level_0/f_type_array/c/type_array/int64.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int64s_adjust_ - extern f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s); + extern f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s); #endif // _di_f_int64s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_append_ - extern f_status_t f_int64s_append(const int64_t source, f_int64s_t *destination); + extern f_status_t f_int64s_append(const int64_t source, f_int64s_t * const destination); #endif // _di_f_int64s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_append_all_ - extern f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination); + extern f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination); #endif // _di_f_int64s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int64s_decimate_by_ - extern f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t *int64s); + extern f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t * const int64s); #endif // _di_f_int64s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_decrease_by_ - extern f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t *int64s); + extern f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t * const int64s); #endif // _di_f_int64s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_increase_ - extern f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t *int64s); + extern f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t * const int64s); #endif // _di_f_int64s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_increase_by_ - extern f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t *int64s); + extern f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t * const int64s); #endif // _di_f_int64s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_resize_ - extern f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s); + extern f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s); #endif // _di_f_int64s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int64ss_adjust_ - extern f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_append_ - extern f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t *destination); + extern f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t * const destination); #endif // _di_f_int64ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_append_all_ - extern f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t *destination); + extern f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t * const destination); #endif // _di_f_int64ss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int64ss_decimate_by_ - extern f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_decrease_by_ - extern f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_increase_ - extern f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_increase_by_ - extern f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_resize_ - extern f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss); #endif // _di_f_int64ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/int8.c b/level_0/f_type_array/c/type_array/int8.c index 7d38725..5fb81b0 100644 --- a/level_0/f_type_array/c/type_array/int8.c +++ b/level_0/f_type_array/c/type_array/int8.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_int8s_adjust_ - f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) { + f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_int8s_adjust_ #ifndef _di_f_int8s_append_ - f_status_t f_int8s_append(const int8_t source, f_int8s_t *destination) { + f_status_t f_int8s_append(const int8_t source, f_int8s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_int8s_append_ #ifndef _di_f_int8s_append_all_ - f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) { + f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_int8s_append_all_ #ifndef _di_f_int8s_decimate_by_ - f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t *int8s) { + f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_int8s_decimate_by_ #ifndef _di_f_int8s_decrease_by_ - f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t *int8s) { + f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_int8s_decrease_by_ #ifndef _di_f_int8s_increase_ - f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t *int8s) { + f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_int8s_increase_ #ifndef _di_f_int8s_increase_by_ - f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t *int8s) { + f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_int8s_increase_by_ #ifndef _di_f_int8s_resize_ - f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) { + f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) { #ifndef _di_level_0_parameter_checking_ if (!int8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_int8s_resize_ #ifndef _di_f_int8ss_adjust_ - f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) { + f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_int8ss_adjust_ #ifndef _di_f_int8ss_append_ - f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t *destination) { + f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_int8ss_append_ #ifndef _di_f_int8ss_append_all_ - f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t *destination) { + f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_int8ss_append_all_ #ifndef _di_f_int8ss_decimate_by_ - f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) { + f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_int8ss_decimate_by_ #ifndef _di_f_int8ss_decrease_by_ - f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) { + f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_int8ss_decrease_by_ #ifndef _di_f_int8ss_increase_ - f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t *int8ss) { + f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_int8ss_increase_ #ifndef _di_f_int8ss_increase_by_ - f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) { + f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_int8ss_increase_by_ #ifndef _di_f_int8ss_resize_ - f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) { + f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) { #ifndef _di_level_0_parameter_checking_ if (!int8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/int8.h b/level_0/f_type_array/c/type_array/int8.h index 01b9041..3718b65 100644 --- a/level_0/f_type_array/c/type_array/int8.h +++ b/level_0/f_type_array/c/type_array/int8.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int8s_adjust_ - extern f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s); + extern f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s); #endif // _di_f_int8s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_append_ - extern f_status_t f_int8s_append(const int8_t source, f_int8s_t *destination); + extern f_status_t f_int8s_append(const int8_t source, f_int8s_t * const destination); #endif // _di_f_int8s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_append_all_ - extern f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination); + extern f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination); #endif // _di_f_int8s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_int8s_decimate_by_ - extern f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t *int8s); + extern f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t * const int8s); #endif // _di_f_int8s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_decrease_by_ - extern f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t *int8s); + extern f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t * const int8s); #endif // _di_f_int8s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_increase_ - extern f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t *int8s); + extern f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t * const int8s); #endif // _di_f_int8s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_increase_by_ - extern f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t *int8s); + extern f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t * const int8s); #endif // _di_f_int8s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_resize_ - extern f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s); + extern f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s); #endif // _di_f_int8s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int8ss_adjust_ - extern f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_append_ - extern f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t *destination); + extern f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t * const destination); #endif // _di_f_int8ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_append_all_ - extern f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t *destination); + extern f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t * const destination); #endif // _di_f_int8ss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_int8ss_decimate_by_ - extern f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_decrease_by_ - extern f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_increase_ - extern f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_increase_by_ - extern f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_resize_ - extern f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss); #endif // _di_f_int8ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/number_unsigned.c b/level_0/f_type_array/c/type_array/number_unsigned.c index 8f0b939..e0a773f 100644 --- a/level_0/f_type_array/c/type_array/number_unsigned.c +++ b/level_0/f_type_array/c/type_array/number_unsigned.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_number_unsigneds_adjust_ - f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_number_unsigneds_adjust_ #ifndef _di_f_number_unsigneds_append_ - f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) { + f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -34,7 +34,7 @@ extern "C" { #endif // _di_f_number_unsigneds_append_ #ifndef _di_f_number_unsigneds_append_all_ - f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) { + f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -46,7 +46,7 @@ extern "C" { #endif // _di_f_number_unsigneds_append_all_ #ifndef _di_f_number_unsigneds_decimate_by_ - f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -62,7 +62,7 @@ extern "C" { #endif // _di_f_number_unsigneds_decimate_by_ #ifndef _di_f_number_unsigneds_decrease_by_ - f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -78,7 +78,7 @@ extern "C" { #endif // _di_f_number_unsigneds_decrease_by_ #ifndef _di_f_number_unsigneds_increase_ - f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -102,7 +102,7 @@ extern "C" { #endif // _di_f_number_unsigneds_increase_ #ifndef _di_f_number_unsigneds_increase_by_ - f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -122,7 +122,7 @@ extern "C" { #endif // _di_f_number_unsigneds_increase_by_ #ifndef _di_f_number_unsigneds_resize_ - f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) { + f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) { #ifndef _di_level_0_parameter_checking_ if (!lengths) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -132,7 +132,7 @@ extern "C" { #endif // _di_f_number_unsigneds_resize_ #ifndef _di_f_number_unsignedss_adjust_ - f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -142,7 +142,7 @@ extern "C" { #endif // _di_f_number_unsignedss_adjust_ #ifndef _di_f_number_unsignedss_append_ - f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t *destination) { + f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -166,7 +166,7 @@ extern "C" { #endif // _di_f_number_unsignedss_append_ #ifndef _di_f_number_unsignedss_append_all_ - f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t *destination) { + f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -195,7 +195,7 @@ extern "C" { #endif // _di_f_number_unsignedss_append_all_ #ifndef _di_f_number_unsignedss_decimate_by_ - f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -211,7 +211,7 @@ extern "C" { #endif // _di_f_number_unsignedss_decimate_by_ #ifndef _di_f_number_unsignedss_decrease_by_ - f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -227,7 +227,7 @@ extern "C" { #endif // _di_f_number_unsignedss_decrease_by_ #ifndef _di_f_number_unsignedss_increase_ - f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -251,7 +251,7 @@ extern "C" { #endif // _di_f_number_unsignedss_increase_ #ifndef _di_f_number_unsignedss_increase_by_ - f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -271,7 +271,7 @@ extern "C" { #endif // _di_f_number_unsignedss_increase_by_ #ifndef _di_f_number_unsignedss_resize_ - f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) { + f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) { #ifndef _di_level_0_parameter_checking_ if (!lengthss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/number_unsigned.h b/level_0/f_type_array/c/type_array/number_unsigned.h index 946f837..a9696b9 100644 --- a/level_0/f_type_array/c/type_array/number_unsigned.h +++ b/level_0/f_type_array/c/type_array/number_unsigned.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_number_unsigneds_adjust_ - extern f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_append_ - extern f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination); + extern f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination); #endif // _di_f_number_unsigneds_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_append_all_ - extern f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination); + extern f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination); #endif // _di_f_number_unsigneds_append_all_ /** @@ -95,7 +95,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_number_unsigneds_decimate_by_ - extern f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_decimate_by_ /** @@ -118,7 +118,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_decrease_by_ - extern f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_decrease_by_ /** @@ -143,7 +143,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_increase_ - extern f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_increase_ /** @@ -168,7 +168,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_increase_by_ - extern f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_increase_by_ /** @@ -187,7 +187,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsigneds_resize_ - extern f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths); + extern f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths); #endif // _di_f_number_unsigneds_resize_ /** @@ -207,7 +207,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_number_unsignedss_adjust_ - extern f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_adjust_ /** @@ -227,7 +227,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_append_ - extern f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t *destination); + extern f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t * const destination); #endif // _di_f_number_unsignedss_append_ /** @@ -247,7 +247,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_append_all_ - extern f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t *destination); + extern f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t * const destination); #endif // _di_f_number_unsignedss_append_all_ /** @@ -272,7 +272,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_number_unsignedss_decimate_by_ - extern f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_decrease_by_ - extern f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_increase_ - extern f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_increase_by_ - extern f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_number_unsignedss_resize_ - extern f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss); + extern f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss); #endif // _di_f_number_unsignedss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/poll.c b/level_0/f_type_array/c/type_array/poll.c index 5a5a69a..c370a99 100644 --- a/level_0/f_type_array/c/type_array/poll.c +++ b/level_0/f_type_array/c/type_array/poll.c @@ -8,7 +8,7 @@ extern "C" { #endif #ifndef _di_f_polls_adjust_ - f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) { + f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -18,7 +18,7 @@ extern "C" { #endif // _di_f_polls_adjust_ #ifndef _di_f_polls_append_ - f_status_t f_polls_append(const f_poll_t source, f_polls_t *destination) { + f_status_t f_polls_append(const f_poll_t source, f_polls_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -28,7 +28,7 @@ extern "C" { #endif // _di_f_polls_append_ #ifndef _di_f_polls_append_all_ - f_status_t f_polls_append_all(const f_polls_t source, f_polls_t *destination) { + f_status_t f_polls_append_all(const f_polls_t source, f_polls_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -40,7 +40,7 @@ extern "C" { #endif // _di_f_polls_append_all_ #ifndef _di_f_polls_decimate_by_ - f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t *polls) { + f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -53,7 +53,7 @@ extern "C" { #endif // _di_f_polls_decimate_by_ #ifndef _di_f_polls_decrease_by_ - f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t *polls) { + f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -66,7 +66,7 @@ extern "C" { #endif // _di_f_polls_decrease_by_ #ifndef _di_f_polls_increase_ - f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t *polls) { + f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -88,7 +88,7 @@ extern "C" { #endif // _di_f_polls_increase_ #ifndef _di_f_polls_increase_by_ - f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t *polls) { + f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -106,7 +106,7 @@ extern "C" { #endif // _di_f_polls_increase_by_ #ifndef _di_f_polls_resize_ - f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) { + f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) { #ifndef _di_level_0_parameter_checking_ if (!polls) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -116,7 +116,7 @@ extern "C" { #endif // _di_f_polls_resize_ #ifndef _di_f_pollss_adjust_ - f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) { + f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -126,7 +126,7 @@ extern "C" { #endif // _di_f_pollss_adjust_ #ifndef _di_f_pollss_append_ - f_status_t f_pollss_append(const f_polls_t source, f_pollss_t *destination) { + f_status_t f_pollss_append(const f_polls_t source, f_pollss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -150,7 +150,7 @@ extern "C" { #endif // _di_f_pollss_append_ #ifndef _di_f_pollss_append_all_ - f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t *destination) { + f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -179,7 +179,7 @@ extern "C" { #endif // _di_f_pollss_append_all_ #ifndef _di_f_pollss_decimate_by_ - f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t *pollss) { + f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -192,7 +192,7 @@ extern "C" { #endif // _di_f_pollss_decimate_by_ #ifndef _di_f_pollss_decrease_by_ - f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t *pollss) { + f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -205,7 +205,7 @@ extern "C" { #endif // _di_f_pollss_decrease_by_ #ifndef _di_f_pollss_increase_ - f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t *pollss) { + f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -227,7 +227,7 @@ extern "C" { #endif // _di_f_pollss_increase_ #ifndef _di_f_pollss_increase_by_ - f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t *pollss) { + f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -245,7 +245,7 @@ extern "C" { #endif // _di_f_pollss_increase_by_ #ifndef _di_f_pollss_resize_ - f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) { + f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) { #ifndef _di_level_0_parameter_checking_ if (!pollss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/poll.h b/level_0/f_type_array/c/type_array/poll.h index ee33efd..964cc02 100644 --- a/level_0/f_type_array/c/type_array/poll.h +++ b/level_0/f_type_array/c/type_array/poll.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_polls_adjust_ - extern f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls); + extern f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls); #endif // _di_f_polls_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_append_ - extern f_status_t f_polls_append(const f_poll_t source, f_polls_t *destination); + extern f_status_t f_polls_append(const f_poll_t source, f_polls_t * const destination); #endif // _di_f_polls_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_append_all_ - extern f_status_t f_polls_append_all(const f_polls_t source, f_polls_t *destination); + extern f_status_t f_polls_append_all(const f_polls_t source, f_polls_t * const destination); #endif // _di_f_polls_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_polls_decimate_by_ - extern f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t *polls); + extern f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t * const polls); #endif // _di_f_polls_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_decrease_by_ - extern f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t *polls); + extern f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t * const polls); #endif // _di_f_polls_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_increase_ - extern f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t *polls); + extern f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t * const polls); #endif // _di_f_polls_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_increase_by_ - extern f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t *polls); + extern f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t * const polls); #endif // _di_f_polls_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_polls_resize_ - extern f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls); + extern f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls); #endif // _di_f_polls_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_pollss_adjust_ - extern f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss); + extern f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss); #endif // _di_f_pollss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_append_ - extern f_status_t f_pollss_append(const f_polls_t source, f_pollss_t *destination); + extern f_status_t f_pollss_append(const f_polls_t source, f_pollss_t * const destination); #endif // _di_f_pollss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_append_all_ - extern f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t *destination); + extern f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t * const destination); #endif // _di_f_pollss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_pollss_decimate_by_ - extern f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t *pollss); + extern f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t * const pollss); #endif // _di_f_pollss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_decrease_by_ - extern f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t *pollss); + extern f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t * const pollss); #endif // _di_f_pollss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_increase_ - extern f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t *pollss); + extern f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t * const pollss); #endif // _di_f_pollss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_increase_by_ - extern f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t *pollss); + extern f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t * const pollss); #endif // _di_f_pollss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_pollss_resize_ - extern f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss); + extern f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss); #endif // _di_f_pollss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-cell.c b/level_0/f_type_array/c/type_array/private-cell.c index 6d4fee6..b581a8c 100644 --- a/level_0/f_type_array/c/type_array/private-cell.c +++ b/level_0/f_type_array/c/type_array/private-cell.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_) - f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) { + f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) { const f_status_t status = f_memory_adjust(cells->size, length, sizeof(f_cell_t), (void **) & cells->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_) #if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_) - extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t *destination) { + extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_cells_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -37,7 +37,7 @@ extern "C" { #endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_) #if !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_) - extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t *destination) { + extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_cells_resize(destination->used + source.used, destination); @@ -55,7 +55,7 @@ extern "C" { #endif // !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_) #if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_) - f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) { + f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) { const f_status_t status = f_memory_resize(cells->size, length, sizeof(f_cell_t), (void **) & cells->array); if (F_status_is_error(status)) return status; @@ -71,7 +71,7 @@ extern "C" { #endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_) #if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_) - f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) { + f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) { f_status_t status = F_none; @@ -98,7 +98,7 @@ extern "C" { #endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_) #if !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_) - f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) { + f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-cell.h b/level_0/f_type_array/c/type_array/private-cell.h index adeb1fe..466d75b 100644 --- a/level_0/f_type_array/c/type_array/private-cell.h +++ b/level_0/f_type_array/c/type_array/private-cell.h @@ -35,7 +35,7 @@ extern "C" { * @see f_cells_decimate_by() */ #if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_) - extern f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) F_attribute_visibility_internal_d; + extern f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_cellss_append() */ #if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_) - extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_cellss_append_all() */ #if !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_) - extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_cellss_append() */ #if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_) - extern f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) F_attribute_visibility_internal_d; + extern f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_cellss_decimate_by() */ #if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_) - extern f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d; + extern f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_cellss_resize() */ #if !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_) - extern f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d; + extern f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-file.c b/level_0/f_type_array/c/type_array/private-file.c index 6abb3c6..ecc5b3b 100644 --- a/level_0/f_type_array/c/type_array/private-file.c +++ b/level_0/f_type_array/c/type_array/private-file.c @@ -7,7 +7,7 @@ extern "C" { #endif #if !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_) - f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t *files) { + f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) { const f_status_t status = f_memory_adjust(files->size, length, sizeof(f_file_t), (void **) & files->array); if (F_status_is_error(status)) return status; @@ -23,7 +23,7 @@ extern "C" { #endif // !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_) #if !defined(_di_f_files_append_) || !defined(_di_f_filess_append_) - extern f_status_t private_f_files_append(const f_file_t source, f_files_t *destination) { + extern f_status_t private_f_files_append(const f_file_t source, f_files_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_files_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -37,7 +37,7 @@ extern "C" { #endif // !defined(_di_f_files_append_) || !defined(_di_f_filess_append_) #if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_) - extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t *destination) { + extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_files_resize(destination->used + source.used, destination); @@ -53,7 +53,7 @@ extern "C" { #endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_) #if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_) - f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t *files) { + f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t * const files) { const f_status_t status = f_memory_resize(files->size, length, sizeof(f_file_t), (void **) & files->array); if (F_status_is_error(status)) return status; @@ -69,7 +69,7 @@ extern "C" { #endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_) #if !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_) - f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) { + f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) { f_status_t status = F_none; @@ -96,7 +96,7 @@ extern "C" { #endif // !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_) #if !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_) - f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) { + f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-file.h b/level_0/f_type_array/c/type_array/private-file.h index 6c94fb5..b932053 100644 --- a/level_0/f_type_array/c/type_array/private-file.h +++ b/level_0/f_type_array/c/type_array/private-file.h @@ -35,7 +35,7 @@ extern "C" { * @see f_files_decimate_by() */ #if !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_) - extern f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t *files) F_attribute_visibility_internal_d; + extern f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) F_attribute_visibility_internal_d; #endif // !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_filess_append() */ #if !defined(_di_f_files_append_) || !defined(_di_f_filess_append_) - extern f_status_t private_f_files_append(const f_file_t source, f_files_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_files_append(const f_file_t source, f_files_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_files_append_) || !defined(_di_f_filess_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_filess_append_all() */ #if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_) - extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_) /** @@ -112,7 +112,7 @@ extern "C" { * */ #if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_) - extern f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t *files) F_attribute_visibility_internal_d; + extern f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t * const files) F_attribute_visibility_internal_d; #endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_) /** @@ -140,7 +140,7 @@ extern "C" { * @see f_filess_decimate_by() */ #if !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_) - extern f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) F_attribute_visibility_internal_d; + extern f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) F_attribute_visibility_internal_d; #endif // !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_) /** @@ -170,7 +170,7 @@ extern "C" { * @see f_filess_resize() */ #if !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_) - extern f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) F_attribute_visibility_internal_d; + extern f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) F_attribute_visibility_internal_d; #endif // !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-fll_id.c b/level_0/f_type_array/c/type_array/private-fll_id.c index c27880e..54467a0 100644 --- a/level_0/f_type_array/c/type_array/private-fll_id.c +++ b/level_0/f_type_array/c/type_array/private-fll_id.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_) - f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids) { + f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids) { const f_status_t status = f_memory_adjust(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_) #if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_) - extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) { + extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_fll_ids_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -39,7 +39,7 @@ extern "C" { #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_) #if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_) - extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) { + extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_fll_ids_resize(destination->used + source.used, destination); @@ -59,7 +59,7 @@ extern "C" { #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_) #if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_) - f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids) { + f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids) { const f_status_t status = f_memory_resize(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array); if (F_status_is_error(status)) return status; @@ -75,7 +75,7 @@ extern "C" { #endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_) #if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_) - f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss) { + f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss) { f_status_t status = F_none; @@ -102,7 +102,7 @@ extern "C" { #endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_) #if !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_) - f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss) { + f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-fll_id.h b/level_0/f_type_array/c/type_array/private-fll_id.h index 809e5f3..940fabd 100644 --- a/level_0/f_type_array/c/type_array/private-fll_id.h +++ b/level_0/f_type_array/c/type_array/private-fll_id.h @@ -35,7 +35,7 @@ extern "C" { * @see f_fll_ids_decimate_by() */ #if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_) - extern f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const fll_ids) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_fll_idss_append() */ #if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_) - extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_fll_idss_append_all() */ #if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_) - extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_fll_idss_append() */ #if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_) - extern f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const fll_ids) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_fll_idss_decimate_by() */ #if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_) - extern f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const fll_idss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_fll_idss_resize() */ #if !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_) - extern f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const fll_idss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-int128.c b/level_0/f_type_array/c/type_array/private-int128.c index 9b660a0..9b3757d 100644 --- a/level_0/f_type_array/c/type_array/private-int128.c +++ b/level_0/f_type_array/c/type_array/private-int128.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_) - f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) { + f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) { const f_status_t status = f_memory_adjust(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_) #if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) - extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t *destination) { + extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_int128s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) #if !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_) - extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) { + extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_int128s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_) #if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_) - f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) { + f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) { const f_status_t status = f_memory_resize(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_) #if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_) - f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) { + f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_) #if !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_) - f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) { + f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-int128.h b/level_0/f_type_array/c/type_array/private-int128.h index f7a37c9..fec9812 100644 --- a/level_0/f_type_array/c/type_array/private-int128.h +++ b/level_0/f_type_array/c/type_array/private-int128.h @@ -35,7 +35,7 @@ extern "C" { * @see f_int128s_decimate_by() */ #if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_) - extern f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_int128ss_append() */ #if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) - extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_int128ss_append_all() */ #if !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_) - extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_int128ss_append() */ #if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_) - extern f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_int128ss_decimate_by() */ #if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_) - extern f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_int128ss_resize() */ #if !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_) - extern f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-int16.c b/level_0/f_type_array/c/type_array/private-int16.c index bc17d25..30b626c 100644 --- a/level_0/f_type_array/c/type_array/private-int16.c +++ b/level_0/f_type_array/c/type_array/private-int16.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_) - f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) { + f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) { const f_status_t status = f_memory_adjust(int16s->size, length, sizeof(int16_t), (void **) & int16s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_) #if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) - extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t *destination) { + extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_int16s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) #if !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_) - extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) { + extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_int16s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_) #if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_) - f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) { + f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) { const f_status_t status = f_memory_resize(int16s->size, length, sizeof(int16_t), (void **) & int16s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_) #if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_) - f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) { + f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_) #if !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_) - f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) { + f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-int16.h b/level_0/f_type_array/c/type_array/private-int16.h index 39030fe..1758e83 100644 --- a/level_0/f_type_array/c/type_array/private-int16.h +++ b/level_0/f_type_array/c/type_array/private-int16.h @@ -35,7 +35,7 @@ extern "C" { * @see f_int16s_decimate_by() */ #if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_) - extern f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_int16ss_append() */ #if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) - extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_int16ss_append_all() */ #if !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_) - extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_int16ss_append() */ #if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_) - extern f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_int16ss_decimate_by() */ #if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_) - extern f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_int16ss_resize() */ #if !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_) - extern f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-int32.c b/level_0/f_type_array/c/type_array/private-int32.c index 9e5a5d7..9810e52 100644 --- a/level_0/f_type_array/c/type_array/private-int32.c +++ b/level_0/f_type_array/c/type_array/private-int32.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_) - f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) { + f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) { const f_status_t status = f_memory_adjust(int32s->size, length, sizeof(int32_t), (void **) & int32s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_) #if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) - extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t *destination) { + extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_int32s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) #if !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_) - extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) { + extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_int32s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_) #if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_) - f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) { + f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) { const f_status_t status = f_memory_resize(int32s->size, length, sizeof(int32_t), (void **) & int32s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_) #if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_) - f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) { + f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_) #if !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_) - f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) { + f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-int32.h b/level_0/f_type_array/c/type_array/private-int32.h index 697813d..3352d2a 100644 --- a/level_0/f_type_array/c/type_array/private-int32.h +++ b/level_0/f_type_array/c/type_array/private-int32.h @@ -35,7 +35,7 @@ extern "C" { * @see f_int32s_decimate_by() */ #if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_) - extern f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_int32ss_append() */ #if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) - extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_int32ss_append_all() */ #if !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_) - extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_int32ss_append() */ #if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_) - extern f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_int32ss_decimate_by() */ #if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_) - extern f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_int32ss_resize() */ #if !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_) - extern f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-int64.c b/level_0/f_type_array/c/type_array/private-int64.c index d4c9f3e..32a8c56 100644 --- a/level_0/f_type_array/c/type_array/private-int64.c +++ b/level_0/f_type_array/c/type_array/private-int64.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_) - f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) { + f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) { const f_status_t status = f_memory_adjust(int64s->size, length, sizeof(int64_t), (void **) & int64s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_) #if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) - extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t *destination) { + extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_int64s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) #if !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_) - extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) { + extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_int64s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_) #if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_) - f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) { + f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) { const f_status_t status = f_memory_resize(int64s->size, length, sizeof(int64_t), (void **) & int64s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_) #if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_) - f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) { + f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_) #if !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_) - f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) { + f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-int64.h b/level_0/f_type_array/c/type_array/private-int64.h index 02183c6..f9df012 100644 --- a/level_0/f_type_array/c/type_array/private-int64.h +++ b/level_0/f_type_array/c/type_array/private-int64.h @@ -35,7 +35,7 @@ extern "C" { * @see f_int64s_decimate_by() */ #if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_) - extern f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_int64ss_append() */ #if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) - extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_int64ss_append_all() */ #if !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_) - extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_int64ss_append() */ #if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_) - extern f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_int64ss_decimate_by() */ #if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_) - extern f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_int64ss_resize() */ #if !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_) - extern f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-int8.c b/level_0/f_type_array/c/type_array/private-int8.c index 75308d9..a57989b 100644 --- a/level_0/f_type_array/c/type_array/private-int8.c +++ b/level_0/f_type_array/c/type_array/private-int8.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_) - f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) { + f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) { const f_status_t status = f_memory_adjust(int8s->size, length, sizeof(int8_t), (void **) & int8s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_) #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) - extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t *destination) { + extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_int8s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_) - extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) { + extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_int8s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_) #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_) - f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) { + f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) { const f_status_t status = f_memory_resize(int8s->size, length, sizeof(int8_t), (void **) & int8s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_) #if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_) - f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) { + f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_) #if !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_) - f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) { + f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-int8.h b/level_0/f_type_array/c/type_array/private-int8.h index 361e63e..cea590a 100644 --- a/level_0/f_type_array/c/type_array/private-int8.h +++ b/level_0/f_type_array/c/type_array/private-int8.h @@ -35,7 +35,7 @@ extern "C" { * @see f_int8s_decimate_by() */ #if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_) - extern f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_int8ss_append() */ #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) - extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_int8ss_append_all() */ #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_) - extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_) /** @@ -112,7 +112,7 @@ extern "C" { * */ #if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_) - extern f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_) /** @@ -140,7 +140,7 @@ extern "C" { * @see f_int8ss_decimate_by() */ #if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_) - extern f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_) /** @@ -170,7 +170,7 @@ extern "C" { * @see f_int8ss_resize() */ #if !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_) - extern f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-number_unsigned.c b/level_0/f_type_array/c/type_array/private-number_unsigned.c index b0dca1e..44c4fbd 100644 --- a/level_0/f_type_array/c/type_array/private-number_unsigned.c +++ b/level_0/f_type_array/c/type_array/private-number_unsigned.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_) - f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *number_unsigneds) { + f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const number_unsigneds) { const f_status_t status = f_memory_adjust(number_unsigneds->size, length, sizeof(f_number_unsigned_t), (void **) & number_unsigneds->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_) #if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_) - extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) { + extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_number_unsigneds_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_) #if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_) - extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) { + extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_number_unsigneds_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_) #if !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_) - f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) { + f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) { const f_status_t status = f_memory_resize(lengths->size, length, sizeof(f_number_unsigned_t), (void **) & lengths->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_) #if !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_) - f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) { + f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_) #if !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_) - f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) { + f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-number_unsigned.h b/level_0/f_type_array/c/type_array/private-number_unsigned.h index a607e49..a945464 100644 --- a/level_0/f_type_array/c/type_array/private-number_unsigned.h +++ b/level_0/f_type_array/c/type_array/private-number_unsigned.h @@ -35,7 +35,7 @@ extern "C" { * @see f_number_unsigneds_decimate_by() */ #if !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_) - extern f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_number_unsignedss_append() */ #if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_) - extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_number_unsignedss_append_all() */ #if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_) - extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_number_unsignedss_append() */ #if !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_) - extern f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_number_unsignedss_decimate_by() */ #if !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_) - extern f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_number_unsignedss_resize() */ #if !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_) - extern f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) F_attribute_visibility_internal_d; + extern f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-poll.c b/level_0/f_type_array/c/type_array/private-poll.c index 2d27207..8d0d4eb 100644 --- a/level_0/f_type_array/c/type_array/private-poll.c +++ b/level_0/f_type_array/c/type_array/private-poll.c @@ -7,7 +7,7 @@ extern "C" { #endif #if !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_) - f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) { + f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) { const f_status_t status = f_memory_adjust(polls->size, length, sizeof(f_poll_t), (void **) & polls->array); if (F_status_is_error(status)) return status; @@ -23,7 +23,7 @@ extern "C" { #endif // !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_) #if !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_) - extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t *destination) { + extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_polls_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -37,7 +37,7 @@ extern "C" { #endif // !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_) #if !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_) - extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t *destination) { + extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_polls_resize(destination->used + source.used, destination); @@ -53,7 +53,7 @@ extern "C" { #endif // !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_) #if !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_) - f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) { + f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) { const f_status_t status = f_memory_resize(polls->size, length, sizeof(f_poll_t), (void **) & polls->array); if (F_status_is_error(status)) return status; @@ -69,7 +69,7 @@ extern "C" { #endif // !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_) #if !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_) - f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) { + f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) { f_status_t status = F_none; @@ -96,7 +96,7 @@ extern "C" { #endif // !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_) #if !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_) - f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) { + f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-poll.h b/level_0/f_type_array/c/type_array/private-poll.h index 4bdab09..934273b 100644 --- a/level_0/f_type_array/c/type_array/private-poll.h +++ b/level_0/f_type_array/c/type_array/private-poll.h @@ -35,7 +35,7 @@ extern "C" { * @see f_polls_decimate_by() */ #if !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_) - extern f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) F_attribute_visibility_internal_d; + extern f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) F_attribute_visibility_internal_d; #endif // !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_pollss_append() */ #if !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_) - extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_pollss_append_all() */ #if !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_) - extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_pollss_append() */ #if !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_) - extern f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) F_attribute_visibility_internal_d; + extern f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) F_attribute_visibility_internal_d; #endif // !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_pollss_decimate_by() */ #if !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_) - extern f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) F_attribute_visibility_internal_d; + extern f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_pollss_resize() */ #if !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_) - extern f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) F_attribute_visibility_internal_d; + extern f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-state.c b/level_0/f_type_array/c/type_array/private-state.c index 5976fae..c67e4e5 100644 --- a/level_0/f_type_array/c/type_array/private-state.c +++ b/level_0/f_type_array/c/type_array/private-state.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_) - f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t *states) { + f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) { const f_status_t status = f_memory_adjust(states->size, length, sizeof(f_state_t), (void **) & states->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_) #if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_) - extern f_status_t private_f_states_append(const f_state_t source, f_states_t *destination) { + extern f_status_t private_f_states_append(const f_state_t source, f_states_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_states_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -44,7 +44,7 @@ extern "C" { #endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_) #if !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_) - extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t *destination) { + extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_states_resize(destination->used + source.used, destination); @@ -69,7 +69,7 @@ extern "C" { #endif // !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_) #if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_) - f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t *states) { + f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t * const states) { const f_status_t status = f_memory_resize(states->size, length, sizeof(f_state_t), (void **) & states->array); if (F_status_is_error(status)) return status; @@ -85,7 +85,7 @@ extern "C" { #endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_) #if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_) - f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) { + f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) { f_status_t status = F_none; @@ -112,7 +112,7 @@ extern "C" { #endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_) #if !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_) - f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) { + f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-state.h b/level_0/f_type_array/c/type_array/private-state.h index b42fd3c..b4d13b6 100644 --- a/level_0/f_type_array/c/type_array/private-state.h +++ b/level_0/f_type_array/c/type_array/private-state.h @@ -35,7 +35,7 @@ extern "C" { * @see f_states_decimate_by() */ #if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_) - extern f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t *states) F_attribute_visibility_internal_d; + extern f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) F_attribute_visibility_internal_d; #endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_statess_append() */ #if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_) - extern f_status_t private_f_states_append(const f_state_t source, f_states_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_states_append(const f_state_t source, f_states_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_statess_append_all() */ #if !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_) - extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_statess_append() */ #if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_) - extern f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t *states) F_attribute_visibility_internal_d; + extern f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t * const states) F_attribute_visibility_internal_d; #endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_statess_decimate_by() */ #if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_) - extern f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) F_attribute_visibility_internal_d; + extern f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_statess_resize() */ #if !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_) - extern f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) F_attribute_visibility_internal_d; + extern f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-status.c b/level_0/f_type_array/c/type_array/private-status.c index f65223a..2f27be8 100644 --- a/level_0/f_type_array/c/type_array/private-status.c +++ b/level_0/f_type_array/c/type_array/private-status.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_) - f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) { + f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) { const f_status_t status = f_memory_adjust(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_) #if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_) - extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t *destination) { + extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_statuss_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_) #if !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_) - extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) { + extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_statuss_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_) #if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_) - f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) { + f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) { const f_status_t status = f_memory_resize(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_) #if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_) - f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) { + f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_) #if !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_) - f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) { + f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-status.h b/level_0/f_type_array/c/type_array/private-status.h index 35f7f5b..49bb7de 100644 --- a/level_0/f_type_array/c/type_array/private-status.h +++ b/level_0/f_type_array/c/type_array/private-status.h @@ -35,7 +35,7 @@ extern "C" { * @see f_statuss_decimate_by() */ #if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_) - extern f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d; + extern f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_statusss_append() */ #if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_) - extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_statusss_append_all() */ #if !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_) - extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_statusss_append() */ #if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_) - extern f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d; + extern f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_statusss_decimate_by() */ #if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_) - extern f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d; + extern f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_statusss_resize() */ #if !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_) - extern f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d; + extern f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-uint128.c b/level_0/f_type_array/c/type_array/private-uint128.c index e8b4f6f..2135b79 100644 --- a/level_0/f_type_array/c/type_array/private-uint128.c +++ b/level_0/f_type_array/c/type_array/private-uint128.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_) - f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) { + f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) { const f_status_t status = f_memory_adjust(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_) #if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) - extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t *destination) { + extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_uint128s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) #if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_) - extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) { + extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_uint128s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_) #if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_) - f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) { + f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) { const f_status_t status = f_memory_resize(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_) #if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_) - f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) { + f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_) #if !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_) - f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) { + f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-uint128.h b/level_0/f_type_array/c/type_array/private-uint128.h index bf77ba8..0bb1716 100644 --- a/level_0/f_type_array/c/type_array/private-uint128.h +++ b/level_0/f_type_array/c/type_array/private-uint128.h @@ -35,7 +35,7 @@ extern "C" { * @see f_uint128s_decimate_by() */ #if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_) - extern f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_uint128ss_append() */ #if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) - extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_uint128ss_append_all() */ #if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_) - extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_uint128ss_append() */ #if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_) - extern f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_uint128ss_decimate_by() */ #if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_) - extern f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_uint128ss_resize() */ #if !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_) - extern f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-uint16.c b/level_0/f_type_array/c/type_array/private-uint16.c index 095c124..31b7065 100644 --- a/level_0/f_type_array/c/type_array/private-uint16.c +++ b/level_0/f_type_array/c/type_array/private-uint16.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_) - f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) { + f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) { const f_status_t status = f_memory_adjust(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_) #if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) - extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t *destination) { + extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_uint16s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) #if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_) - extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) { + extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_uint16s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_) #if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_) - f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) { + f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) { const f_status_t status = f_memory_resize(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_) #if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_) - f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) { + f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_) #if !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_) - f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) { + f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-uint16.h b/level_0/f_type_array/c/type_array/private-uint16.h index 380254a..8997b66 100644 --- a/level_0/f_type_array/c/type_array/private-uint16.h +++ b/level_0/f_type_array/c/type_array/private-uint16.h @@ -35,7 +35,7 @@ extern "C" { * @see f_uint16s_decimate_by() */ #if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_) - extern f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_uint16ss_append() */ #if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) - extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_uint16ss_append_all() */ #if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_) - extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_uint16ss_append() */ #if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_) - extern f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_uint16ss_decimate_by() */ #if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_) - extern f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_uint16ss_resize() */ #if !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_) - extern f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-uint32.c b/level_0/f_type_array/c/type_array/private-uint32.c index cd09cbf..3e30a03 100644 --- a/level_0/f_type_array/c/type_array/private-uint32.c +++ b/level_0/f_type_array/c/type_array/private-uint32.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_) - f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) { + f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) { const f_status_t status = f_memory_adjust(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_) #if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) - extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t *destination) { + extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_uint32s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) #if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_) - extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) { + extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_uint32s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_) #if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_) - f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) { + f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) { const f_status_t status = f_memory_resize(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_) #if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_) - f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) { + f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_) #if !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_) - f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) { + f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-uint32.h b/level_0/f_type_array/c/type_array/private-uint32.h index 41f4d9a..706b05c 100644 --- a/level_0/f_type_array/c/type_array/private-uint32.h +++ b/level_0/f_type_array/c/type_array/private-uint32.h @@ -35,7 +35,7 @@ extern "C" { * @see f_uint32s_decimate_by() */ #if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_) - extern f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_uint32ss_append() */ #if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) - extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_uint32ss_append_all() */ #if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_) - extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_uint32ss_append() */ #if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_) - extern f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_uint32ss_decimate_by() */ #if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_) - extern f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_uint32ss_resize() */ #if !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_) - extern f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-uint64.c b/level_0/f_type_array/c/type_array/private-uint64.c index 8f623e8..e53aee9 100644 --- a/level_0/f_type_array/c/type_array/private-uint64.c +++ b/level_0/f_type_array/c/type_array/private-uint64.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_) - f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) { + f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) { const f_status_t status = f_memory_adjust(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_) #if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) - extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t *destination) { + extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_uint64s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) #if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_) - extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) { + extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_uint64s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_) #if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_) - f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) { + f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) { const f_status_t status = f_memory_resize(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_) #if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_) - f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) { + f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_) #if !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_) - f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) { + f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-uint64.h b/level_0/f_type_array/c/type_array/private-uint64.h index 1eea75d..b4857d5 100644 --- a/level_0/f_type_array/c/type_array/private-uint64.h +++ b/level_0/f_type_array/c/type_array/private-uint64.h @@ -35,7 +35,7 @@ extern "C" { * @see f_uint64s_decimate_by() */ #if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_) - extern f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_uint64ss_append() */ #if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) - extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_uint64ss_append_all() */ #if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_) - extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_) /** @@ -107,7 +107,7 @@ extern "C" { * @see f_uint64ss_append() */ #if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_) - extern f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_) /** @@ -135,7 +135,7 @@ extern "C" { * @see f_uint64ss_decimate_by() */ #if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_) - extern f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_) /** @@ -165,7 +165,7 @@ extern "C" { * @see f_uint64ss_resize() */ #if !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_) - extern f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/private-uint8.c b/level_0/f_type_array/c/type_array/private-uint8.c index 6350383..3b11fb9 100644 --- a/level_0/f_type_array/c/type_array/private-uint8.c +++ b/level_0/f_type_array/c/type_array/private-uint8.c @@ -6,7 +6,7 @@ extern "C" { #endif #if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_) - f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) { + f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) { const f_status_t status = f_memory_adjust(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array); if (F_status_is_error(status)) return status; @@ -22,7 +22,7 @@ extern "C" { #endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_) #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) - extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t *destination) { + extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) { if (destination->used + 1 > destination->size) { const f_status_t status = private_f_uint8s_resize(destination->used + F_memory_default_allocation_small_d, destination); @@ -36,7 +36,7 @@ extern "C" { #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_) - extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) { + extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) { if (destination->used + source.used > destination->size) { const f_status_t status = private_f_uint8s_resize(destination->used + source.used, destination); @@ -52,7 +52,7 @@ extern "C" { #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_) #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_) - f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) { + f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) { const f_status_t status = f_memory_resize(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array); if (F_status_is_error(status)) return status; @@ -68,7 +68,7 @@ extern "C" { #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_) #if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_) - f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) { + f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) { f_status_t status = F_none; @@ -95,7 +95,7 @@ extern "C" { #endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_) #if !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_) - f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) { + f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) { f_status_t status = F_none; diff --git a/level_0/f_type_array/c/type_array/private-uint8.h b/level_0/f_type_array/c/type_array/private-uint8.h index ab6ad2d..212f2f7 100644 --- a/level_0/f_type_array/c/type_array/private-uint8.h +++ b/level_0/f_type_array/c/type_array/private-uint8.h @@ -35,7 +35,7 @@ extern "C" { * @see f_uint8s_decimate_by() */ #if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_) - extern f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_) /** @@ -58,7 +58,7 @@ extern "C" { * @see f_uint8ss_append() */ #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) - extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) /** @@ -82,7 +82,7 @@ extern "C" { * @see f_uint8ss_append_all() */ #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_) - extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_) /** @@ -112,7 +112,7 @@ extern "C" { * */ #if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_) - extern f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_) /** @@ -140,7 +140,7 @@ extern "C" { * @see f_uint8ss_decimate_by() */ #if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_) - extern f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_) /** @@ -170,7 +170,7 @@ extern "C" { * @see f_uint8ss_resize() */ #if !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_) - extern f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d; + extern f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_) #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/state.c b/level_0/f_type_array/c/type_array/state.c index 55c9ea7..6aaa94e 100644 --- a/level_0/f_type_array/c/type_array/state.c +++ b/level_0/f_type_array/c/type_array/state.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_states_adjust_ - f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t *states) { + f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_states_adjust_ #ifndef _di_f_states_append_ - f_status_t f_states_append(const f_state_t source, f_states_t *destination) { + f_status_t f_states_append(const f_state_t source, f_states_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_states_append_ #ifndef _di_f_states_append_all_ - f_status_t f_states_append_all(const f_states_t source, f_states_t *destination) { + f_status_t f_states_append_all(const f_states_t source, f_states_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_states_append_all_ #ifndef _di_f_states_decimate_by_ - f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t *states) { + f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_states_decimate_by_ #ifndef _di_f_states_decrease_by_ - f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t *states) { + f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_states_decrease_by_ #ifndef _di_f_states_increase_ - f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t *states) { + f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_states_increase_ #ifndef _di_f_states_increase_by_ - f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t *states) { + f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_states_increase_by_ #ifndef _di_f_states_resize_ - f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t *states) { + f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t * const states) { #ifndef _di_level_0_parameter_checking_ if (!states) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_states_resize_ #ifndef _di_f_statess_adjust_ - f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) { + f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_statess_adjust_ #ifndef _di_f_statess_append_ - f_status_t f_statess_append(const f_states_t source, f_statess_t *destination) { + f_status_t f_statess_append(const f_states_t source, f_statess_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_statess_append_ #ifndef _di_f_statess_append_all_ - f_status_t f_statess_append_all(const f_statess_t source, f_statess_t *destination) { + f_status_t f_statess_append_all(const f_statess_t source, f_statess_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_statess_append_all_ #ifndef _di_f_statess_decimate_by_ - f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t *statess) { + f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_statess_decimate_by_ #ifndef _di_f_statess_decrease_by_ - f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t *statess) { + f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_statess_decrease_by_ #ifndef _di_f_statess_increase_ - f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t *statess) { + f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_statess_increase_ #ifndef _di_f_statess_increase_by_ - f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t *statess) { + f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_statess_increase_by_ #ifndef _di_f_statess_resize_ - f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) { + f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) { #ifndef _di_level_0_parameter_checking_ if (!statess) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/state.h b/level_0/f_type_array/c/type_array/state.h index b5df56d..0838133 100644 --- a/level_0/f_type_array/c/type_array/state.h +++ b/level_0/f_type_array/c/type_array/state.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_states_adjust_ - extern f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t *states); + extern f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t * const states); #endif // _di_f_states_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_append_ - extern f_status_t f_states_append(const f_state_t source, f_states_t *destination); + extern f_status_t f_states_append(const f_state_t source, f_states_t * const destination); #endif // _di_f_states_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_append_all_ - extern f_status_t f_states_append_all(const f_states_t source, f_states_t *destination); + extern f_status_t f_states_append_all(const f_states_t source, f_states_t * const destination); #endif // _di_f_states_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_states_decimate_by_ - extern f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t *states); + extern f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t * const states); #endif // _di_f_states_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_decrease_by_ - extern f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t *states); + extern f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t * const states); #endif // _di_f_states_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_increase_ - extern f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t *states); + extern f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t * const states); #endif // _di_f_states_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_increase_by_ - extern f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t *states); + extern f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t * const states); #endif // _di_f_states_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_resize_ - extern f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t *states); + extern f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t * const states); #endif // _di_f_states_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_statess_adjust_ - extern f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess); + extern f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess); #endif // _di_f_statess_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_append_ - extern f_status_t f_statess_append(const f_states_t source, f_statess_t *destination); + extern f_status_t f_statess_append(const f_states_t source, f_statess_t * const destination); #endif // _di_f_statess_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_append_all_ - extern f_status_t f_statess_append_all(const f_statess_t source, f_statess_t *destination); + extern f_status_t f_statess_append_all(const f_statess_t source, f_statess_t * const destination); #endif // _di_f_statess_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_statess_decimate_by_ - extern f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t *statess); + extern f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t * const statess); #endif // _di_f_statess_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_decrease_by_ - extern f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t *statess); + extern f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t * const statess); #endif // _di_f_statess_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_increase_ - extern f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t *statess); + extern f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t * const statess); #endif // _di_f_statess_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_increase_by_ - extern f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t *statess); + extern f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t * const statess); #endif // _di_f_statess_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_resize_ - extern f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess); + extern f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess); #endif // _di_f_statess_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/status.c b/level_0/f_type_array/c/type_array/status.c index fff8cc0..55da1a6 100644 --- a/level_0/f_type_array/c/type_array/status.c +++ b/level_0/f_type_array/c/type_array/status.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_statuss_adjust_ - f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) { + f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_statuss_adjust_ #ifndef _di_f_statuss_append_ - f_status_t f_statuss_append(const f_status_t source, f_statuss_t *destination) { + f_status_t f_statuss_append(const f_status_t source, f_statuss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_statuss_append_ #ifndef _di_f_statuss_append_all_ - f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) { + f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_statuss_append_all_ #ifndef _di_f_statuss_decimate_by_ - f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t *statuss) { + f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_statuss_decimate_by_ #ifndef _di_f_statuss_decrease_by_ - f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t *statuss) { + f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_statuss_decrease_by_ #ifndef _di_f_statuss_increase_ - f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t *statuss) { + f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_statuss_increase_ #ifndef _di_f_statuss_increase_by_ - f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t *statuss) { + f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_statuss_increase_by_ #ifndef _di_f_statuss_resize_ - f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) { + f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) { #ifndef _di_level_0_parameter_checking_ if (!statuss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_statuss_resize_ #ifndef _di_f_statusss_adjust_ - f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) { + f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_statusss_adjust_ #ifndef _di_f_statusss_append_ - f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t *destination) { + f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_statusss_append_ #ifndef _di_f_statusss_append_all_ - f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t *destination) { + f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_statusss_append_all_ #ifndef _di_f_statusss_decimate_by_ - f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t *statusss) { + f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_statusss_decimate_by_ #ifndef _di_f_statusss_decrease_by_ - f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t *statusss) { + f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_statusss_decrease_by_ #ifndef _di_f_statusss_increase_ - f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t *statusss) { + f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_statusss_increase_ #ifndef _di_f_statusss_increase_by_ - f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t *statusss) { + f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_statusss_increase_by_ #ifndef _di_f_statusss_resize_ - f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) { + f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) { #ifndef _di_level_0_parameter_checking_ if (!statusss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/status.h b/level_0/f_type_array/c/type_array/status.h index 92ff80e..19a4353 100644 --- a/level_0/f_type_array/c/type_array/status.h +++ b/level_0/f_type_array/c/type_array/status.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_statuss_adjust_ - extern f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss); + extern f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss); #endif // _di_f_statuss_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_append_ - extern f_status_t f_statuss_append(const f_status_t source, f_statuss_t *destination); + extern f_status_t f_statuss_append(const f_status_t source, f_statuss_t * const destination); #endif // _di_f_statuss_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_append_all_ - extern f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination); + extern f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination); #endif // _di_f_statuss_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_statuss_decimate_by_ - extern f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t *statuss); + extern f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t * const statuss); #endif // _di_f_statuss_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_decrease_by_ - extern f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t *statuss); + extern f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t * const statuss); #endif // _di_f_statuss_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_increase_ - extern f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t *statuss); + extern f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t * const statuss); #endif // _di_f_statuss_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_increase_by_ - extern f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t *statuss); + extern f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t * const statuss); #endif // _di_f_statuss_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_resize_ - extern f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss); + extern f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss); #endif // _di_f_statuss_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_statusss_adjust_ - extern f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss); + extern f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss); #endif // _di_f_statusss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_append_ - extern f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t *destination); + extern f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t * const destination); #endif // _di_f_statusss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_append_all_ - extern f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t *destination); + extern f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t * const destination); #endif // _di_f_statusss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_statusss_decimate_by_ - extern f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t *statusss); + extern f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t * const statusss); #endif // _di_f_statusss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_decrease_by_ - extern f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t *statusss); + extern f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t * const statusss); #endif // _di_f_statusss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_increase_ - extern f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t *statusss); + extern f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t * const statusss); #endif // _di_f_statusss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_increase_by_ - extern f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t *statusss); + extern f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t * const statusss); #endif // _di_f_statusss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_resize_ - extern f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss); + extern f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss); #endif // _di_f_statusss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/uint128.c b/level_0/f_type_array/c/type_array/uint128.c index 31a80b0..35b288a 100644 --- a/level_0/f_type_array/c/type_array/uint128.c +++ b/level_0/f_type_array/c/type_array/uint128.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_uint128s_adjust_ - f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) { + f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_uint128s_adjust_ #ifndef _di_f_uint128s_append_ - f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t *destination) { + f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_uint128s_append_ #ifndef _di_f_uint128s_append_all_ - f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) { + f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_uint128s_append_all_ #ifndef _di_f_uint128s_decimate_by_ - f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) { + f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_uint128s_decimate_by_ #ifndef _di_f_uint128s_decrease_by_ - f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) { + f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_uint128s_decrease_by_ #ifndef _di_f_uint128s_increase_ - f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t *uint128s) { + f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_uint128s_increase_ #ifndef _di_f_uint128s_increase_by_ - f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) { + f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_uint128s_increase_by_ #ifndef _di_f_uint128s_resize_ - f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) { + f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) { #ifndef _di_level_0_parameter_checking_ if (!uint128s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_uint128s_resize_ #ifndef _di_f_uint128ss_adjust_ - f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_uint128ss_adjust_ #ifndef _di_f_uint128ss_append_ - f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t *destination) { + f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_uint128ss_append_ #ifndef _di_f_uint128ss_append_all_ - f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t *destination) { + f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_uint128ss_append_all_ #ifndef _di_f_uint128ss_decimate_by_ - f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_uint128ss_decimate_by_ #ifndef _di_f_uint128ss_decrease_by_ - f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_uint128ss_decrease_by_ #ifndef _di_f_uint128ss_increase_ - f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_uint128ss_increase_ #ifndef _di_f_uint128ss_increase_by_ - f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_uint128ss_increase_by_ #ifndef _di_f_uint128ss_resize_ - f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!uint128ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/uint128.h b/level_0/f_type_array/c/type_array/uint128.h index 828e3f0..7f410c6 100644 --- a/level_0/f_type_array/c/type_array/uint128.h +++ b/level_0/f_type_array/c/type_array/uint128.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint128s_adjust_ - extern f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_append_ - extern f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t *destination); + extern f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t * const destination); #endif // _di_f_uint128s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_append_all_ - extern f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination); + extern f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination); #endif // _di_f_uint128s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint128s_decimate_by_ - extern f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_decrease_by_ - extern f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_increase_ - extern f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_increase_by_ - extern f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_resize_ - extern f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s); #endif // _di_f_uint128s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint128ss_adjust_ - extern f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_append_ - extern f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t *destination); + extern f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t * const destination); #endif // _di_f_uint128ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_append_all_ - extern f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t *destination); + extern f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t * const destination); #endif // _di_f_uint128ss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint128ss_decimate_by_ - extern f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_decrease_by_ - extern f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_increase_ - extern f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_increase_by_ - extern f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_resize_ - extern f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss); #endif // _di_f_uint128ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/uint16.c b/level_0/f_type_array/c/type_array/uint16.c index 1cb7f5f..9ecabe0 100644 --- a/level_0/f_type_array/c/type_array/uint16.c +++ b/level_0/f_type_array/c/type_array/uint16.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_uint16s_adjust_ - f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) { + f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_uint16s_adjust_ #ifndef _di_f_uint16s_append_ - f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t *destination) { + f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_uint16s_append_ #ifndef _di_f_uint16s_append_all_ - f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) { + f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_uint16s_append_all_ #ifndef _di_f_uint16s_decimate_by_ - f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) { + f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_uint16s_decimate_by_ #ifndef _di_f_uint16s_decrease_by_ - f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) { + f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_uint16s_decrease_by_ #ifndef _di_f_uint16s_increase_ - f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t *uint16s) { + f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_uint16s_increase_ #ifndef _di_f_uint16s_increase_by_ - f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) { + f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_uint16s_increase_by_ #ifndef _di_f_uint16s_resize_ - f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) { + f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) { #ifndef _di_level_0_parameter_checking_ if (!uint16s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_uint16s_resize_ #ifndef _di_f_uint16ss_adjust_ - f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_uint16ss_adjust_ #ifndef _di_f_uint16ss_append_ - f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t *destination) { + f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_uint16ss_append_ #ifndef _di_f_uint16ss_append_all_ - f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t *destination) { + f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_uint16ss_append_all_ #ifndef _di_f_uint16ss_decimate_by_ - f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_uint16ss_decimate_by_ #ifndef _di_f_uint16ss_decrease_by_ - f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_uint16ss_decrease_by_ #ifndef _di_f_uint16ss_increase_ - f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_uint16ss_increase_ #ifndef _di_f_uint16ss_increase_by_ - f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_uint16ss_increase_by_ #ifndef _di_f_uint16ss_resize_ - f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!uint16ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/uint16.h b/level_0/f_type_array/c/type_array/uint16.h index 88ed031..09d2341 100644 --- a/level_0/f_type_array/c/type_array/uint16.h +++ b/level_0/f_type_array/c/type_array/uint16.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint16s_adjust_ - extern f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_append_ - extern f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t *destination); + extern f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t * const destination); #endif // _di_f_uint16s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_append_all_ - extern f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination); + extern f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination); #endif // _di_f_uint16s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint16s_decimate_by_ - extern f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_decimate_by_ /** @@ -119,7 +119,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_decrease_by_ - extern f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_decrease_by_ /** @@ -144,7 +144,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_increase_ - extern f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_increase_ /** @@ -169,7 +169,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_increase_by_ - extern f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_increase_by_ /** @@ -188,7 +188,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_resize_ - extern f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s); #endif // _di_f_uint16s_resize_ /** @@ -208,7 +208,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint16ss_adjust_ - extern f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_adjust_ /** @@ -228,7 +228,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_append_ - extern f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t *destination); + extern f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t * const destination); #endif // _di_f_uint16ss_append_ /** @@ -248,7 +248,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_append_all_ - extern f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t *destination); + extern f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t * const destination); #endif // _di_f_uint16ss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint16ss_decimate_by_ - extern f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_decrease_by_ - extern f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_increase_ - extern f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_increase_by_ - extern f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_resize_ - extern f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss); #endif // _di_f_uint16ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/uint32.c b/level_0/f_type_array/c/type_array/uint32.c index a01f9dc..6f314b4 100644 --- a/level_0/f_type_array/c/type_array/uint32.c +++ b/level_0/f_type_array/c/type_array/uint32.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_uint32s_adjust_ - f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) { + f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_uint32s_adjust_ #ifndef _di_f_uint32s_append_ - f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t *destination) { + f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_uint32s_append_ #ifndef _di_f_uint32s_append_all_ - f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) { + f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_uint32s_append_all_ #ifndef _di_f_uint32s_decimate_by_ - f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) { + f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_uint32s_decimate_by_ #ifndef _di_f_uint32s_decrease_by_ - f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) { + f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_uint32s_decrease_by_ #ifndef _di_f_uint32s_increase_ - f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t *uint32s) { + f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_uint32s_increase_ #ifndef _di_f_uint32s_increase_by_ - f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) { + f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_uint32s_increase_by_ #ifndef _di_f_uint32s_resize_ - f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) { + f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) { #ifndef _di_level_0_parameter_checking_ if (!uint32s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_uint32s_resize_ #ifndef _di_f_uint32ss_adjust_ - f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_uint32ss_adjust_ #ifndef _di_f_uint32ss_append_ - f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t *destination) { + f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_uint32ss_append_ #ifndef _di_f_uint32ss_append_all_ - f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t *destination) { + f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_uint32ss_append_all_ #ifndef _di_f_uint32ss_decimate_by_ - f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_uint32ss_decimate_by_ #ifndef _di_f_uint32ss_decrease_by_ - f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_uint32ss_decrease_by_ #ifndef _di_f_uint32ss_increase_ - f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_uint32ss_increase_ #ifndef _di_f_uint32ss_increase_by_ - f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_uint32ss_increase_by_ #ifndef _di_f_uint32ss_resize_ - f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!uint32ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/uint32.h b/level_0/f_type_array/c/type_array/uint32.h index 30c2bfc..bbb6762 100644 --- a/level_0/f_type_array/c/type_array/uint32.h +++ b/level_0/f_type_array/c/type_array/uint32.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint32s_adjust_ - extern f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_append_ - extern f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t *destination); + extern f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t * const destination); #endif // _di_f_uint32s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_append_all_ - extern f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination); + extern f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination); #endif // _di_f_uint32s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint32s_decimate_by_ - extern f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_decimate_by_ /** @@ -119,7 +119,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_decrease_by_ - extern f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_decrease_by_ /** @@ -144,7 +144,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_increase_ - extern f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_increase_ /** @@ -169,7 +169,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_increase_by_ - extern f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_increase_by_ /** @@ -188,7 +188,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_resize_ - extern f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s); #endif // _di_f_uint32s_resize_ /** @@ -208,7 +208,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint32ss_adjust_ - extern f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_adjust_ /** @@ -228,7 +228,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_append_ - extern f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t *destination); + extern f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t * const destination); #endif // _di_f_uint32ss_append_ /** @@ -248,7 +248,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_append_all_ - extern f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t *destination); + extern f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t * const destination); #endif // _di_f_uint32ss_append_all_ /** @@ -273,7 +273,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint32ss_decimate_by_ - extern f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_decimate_by_ /** @@ -297,7 +297,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_decrease_by_ - extern f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_decrease_by_ /** @@ -322,7 +322,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_increase_ - extern f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_increase_ /** @@ -347,7 +347,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_increase_by_ - extern f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_increase_by_ /** @@ -367,7 +367,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_resize_ - extern f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss); #endif // _di_f_uint32ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/uint64.c b/level_0/f_type_array/c/type_array/uint64.c index 797f53f..529b063 100644 --- a/level_0/f_type_array/c/type_array/uint64.c +++ b/level_0/f_type_array/c/type_array/uint64.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_uint64s_adjust_ - f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) { + f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_uint64s_adjust_ #ifndef _di_f_uint64s_append_ - f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t *destination) { + f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_uint64s_append_ #ifndef _di_f_uint64s_append_all_ - f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) { + f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_uint64s_append_all_ #ifndef _di_f_uint64s_decimate_by_ - f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) { + f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_uint64s_decimate_by_ #ifndef _di_f_uint64s_decrease_by_ - f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) { + f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_uint64s_decrease_by_ #ifndef _di_f_uint64s_increase_ - f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t *uint64s) { + f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_uint64s_increase_ #ifndef _di_f_uint64s_increase_by_ - f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) { + f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_uint64s_increase_by_ #ifndef _di_f_uint64s_resize_ - f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) { + f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) { #ifndef _di_level_0_parameter_checking_ if (!uint64s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_uint64s_resize_ #ifndef _di_f_uint64ss_adjust_ - f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_uint64ss_adjust_ #ifndef _di_f_uint64ss_append_ - f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t *destination) { + f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_uint64ss_append_ #ifndef _di_f_uint64ss_append_all_ - f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t *destination) { + f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_uint64ss_append_all_ #ifndef _di_f_uint64ss_decimate_by_ - f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_uint64ss_decimate_by_ #ifndef _di_f_uint64ss_decrease_by_ - f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_uint64ss_decrease_by_ #ifndef _di_f_uint64ss_increase_ - f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_uint64ss_increase_ #ifndef _di_f_uint64ss_increase_by_ - f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_uint64ss_increase_by_ #ifndef _di_f_uint64ss_resize_ - f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!uint64ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/uint64.h b/level_0/f_type_array/c/type_array/uint64.h index 125096d..8780a21 100644 --- a/level_0/f_type_array/c/type_array/uint64.h +++ b/level_0/f_type_array/c/type_array/uint64.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint64s_adjust_ - extern f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_append_ - extern f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t *destination); + extern f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t * const destination); #endif // _di_f_uint64s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_append_all_ - extern f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination); + extern f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination); #endif // _di_f_uint64s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint64s_decimate_by_ - extern f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_decrease_by_ - extern f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_increase_ - extern f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_increase_by_ - extern f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_resize_ - extern f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s); #endif // _di_f_uint64s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint64ss_adjust_ - extern f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_append_ - extern f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t *destination); + extern f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t * const destination); #endif // _di_f_uint64ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_append_all_ - extern f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t *destination); + extern f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t * const destination); #endif // _di_f_uint64ss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint64ss_decimate_by_ - extern f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_decrease_by_ - extern f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_increase_ - extern f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_increase_by_ - extern f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_resize_ - extern f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss); #endif // _di_f_uint64ss_resize_ #ifdef __cplusplus diff --git a/level_0/f_type_array/c/type_array/uint8.c b/level_0/f_type_array/c/type_array/uint8.c index abf935a..9ae8a74 100644 --- a/level_0/f_type_array/c/type_array/uint8.c +++ b/level_0/f_type_array/c/type_array/uint8.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_f_uint8s_adjust_ - f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) { + f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -17,7 +17,7 @@ extern "C" { #endif // _di_f_uint8s_adjust_ #ifndef _di_f_uint8s_append_ - f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t *destination) { + f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -27,7 +27,7 @@ extern "C" { #endif // _di_f_uint8s_append_ #ifndef _di_f_uint8s_append_all_ - f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) { + f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -39,7 +39,7 @@ extern "C" { #endif // _di_f_uint8s_append_all_ #ifndef _di_f_uint8s_decimate_by_ - f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) { + f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -55,7 +55,7 @@ extern "C" { #endif // _di_f_uint8s_decimate_by_ #ifndef _di_f_uint8s_decrease_by_ - f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) { + f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -71,7 +71,7 @@ extern "C" { #endif // _di_f_uint8s_decrease_by_ #ifndef _di_f_uint8s_increase_ - f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t *uint8s) { + f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -95,7 +95,7 @@ extern "C" { #endif // _di_f_uint8s_increase_ #ifndef _di_f_uint8s_increase_by_ - f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) { + f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -115,7 +115,7 @@ extern "C" { #endif // _di_f_uint8s_increase_by_ #ifndef _di_f_uint8s_resize_ - f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) { + f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) { #ifndef _di_level_0_parameter_checking_ if (!uint8s) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -125,7 +125,7 @@ extern "C" { #endif // _di_f_uint8s_resize_ #ifndef _di_f_uint8ss_adjust_ - f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -135,7 +135,7 @@ extern "C" { #endif // _di_f_uint8ss_adjust_ #ifndef _di_f_uint8ss_append_ - f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t *destination) { + f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -159,7 +159,7 @@ extern "C" { #endif // _di_f_uint8ss_append_ #ifndef _di_f_uint8ss_append_all_ - f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t *destination) { + f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t * const destination) { #ifndef _di_level_0_parameter_checking_ if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -188,7 +188,7 @@ extern "C" { #endif // _di_f_uint8ss_append_all_ #ifndef _di_f_uint8ss_decimate_by_ - f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -204,7 +204,7 @@ extern "C" { #endif // _di_f_uint8ss_decimate_by_ #ifndef _di_f_uint8ss_decrease_by_ - f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -220,7 +220,7 @@ extern "C" { #endif // _di_f_uint8ss_decrease_by_ #ifndef _di_f_uint8ss_increase_ - f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -244,7 +244,7 @@ extern "C" { #endif // _di_f_uint8ss_increase_ #ifndef _di_f_uint8ss_increase_by_ - f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ @@ -264,7 +264,7 @@ extern "C" { #endif // _di_f_uint8ss_increase_by_ #ifndef _di_f_uint8ss_resize_ - f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!uint8ss) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ diff --git a/level_0/f_type_array/c/type_array/uint8.h b/level_0/f_type_array/c/type_array/uint8.h index e46cdfc..e7637f2 100644 --- a/level_0/f_type_array/c/type_array/uint8.h +++ b/level_0/f_type_array/c/type_array/uint8.h @@ -32,7 +32,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint8s_adjust_ - extern f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_adjust_ /** @@ -52,7 +52,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_append_ - extern f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t *destination); + extern f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t * const destination); #endif // _di_f_uint8s_append_ /** @@ -72,7 +72,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_append_all_ - extern f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination); + extern f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination); #endif // _di_f_uint8s_append_all_ /** @@ -96,7 +96,7 @@ extern "C" { * Errors (with error bit) from: f_memory_adjust(). */ #ifndef _di_f_uint8s_decimate_by_ - extern f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_decimate_by_ /** @@ -120,7 +120,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_decrease_by_ - extern f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_decrease_by_ /** @@ -145,7 +145,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_increase_ - extern f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_increase_ /** @@ -170,7 +170,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_increase_by_ - extern f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_increase_by_ /** @@ -189,7 +189,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_resize_ - extern f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s); #endif // _di_f_uint8s_resize_ /** @@ -209,7 +209,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint8ss_adjust_ - extern f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_adjust_ /** @@ -229,7 +229,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_append_ - extern f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t *destination); + extern f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t * const destination); #endif // _di_f_uint8ss_append_ /** @@ -249,7 +249,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_append_all_ - extern f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t *destination); + extern f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t * const destination); #endif // _di_f_uint8ss_append_all_ /** @@ -274,7 +274,7 @@ extern "C" { * Errors (with error bit) from: f_memory_destroy(). */ #ifndef _di_f_uint8ss_decimate_by_ - extern f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_decimate_by_ /** @@ -299,7 +299,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_decrease_by_ - extern f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_decrease_by_ /** @@ -324,7 +324,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_increase_ - extern f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_increase_ /** @@ -349,7 +349,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_increase_by_ - extern f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_increase_by_ /** @@ -369,7 +369,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_resize_ - extern f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss); #endif // _di_f_uint8ss_resize_ #ifdef __cplusplus