From f191f458949a3ee733a44d23fb80df5ecc854e58 Mon Sep 17 00:00:00 2001 From: Kevin Day Date: Tue, 22 Feb 2022 22:04:15 -0600 Subject: [PATCH] Update: IKI Improvements and some cleanups. The _di_X_t_ where "X" is something like f_fss_object, is missing the leading "f_" in several cases. Make the *_increase() step variable an f_array_length_t. Rather than trying to optimize, just guarantee whatever step size is desired is available. Move the iki_read programs practice of defining an iki_data_t structure into the level_0 iki project. This then allows simplifying the arguments passed to the iki read functions. --- level_0/f_fss/c/fss/common.h | 12 +- level_0/f_fss/c/fss/named.c | 4 +- level_0/f_fss/c/fss/named.h | 8 +- level_0/f_fss/c/fss/nest.c | 6 +- level_0/f_fss/c/fss/nest.h | 22 +- level_0/f_fss/c/fss/set.c | 8 +- level_0/f_fss/c/fss/set.h | 12 +- level_0/f_iki/c/iki.c | 70 +- level_0/f_iki/c/iki.h | 12 +- level_0/f_iki/c/iki/common.c | 181 +- level_0/f_iki/c/iki/common.h | 290 +++- level_0/f_iki/c/private-iki.c | 76 + level_0/f_iki/c/private-iki.h | 52 + level_0/f_memory/c/memory/structure.c | 2 +- level_0/f_memory/c/memory/structure.h | 2 +- level_0/f_string/c/string/dynamic.c | 6 +- level_0/f_string/c/string/dynamic.h | 6 +- level_0/f_string/c/string/map.c | 8 +- level_0/f_string/c/string/map.h | 6 +- level_0/f_string/c/string/quantity.c | 4 +- level_0/f_string/c/string/quantity.h | 4 +- level_0/f_string/c/string/range.c | 4 +- level_0/f_string/c/string/range.h | 4 +- level_0/f_string/c/string/triple.c | 2 +- level_0/f_string/c/string/triple.h | 2 +- level_0/f_thread/c/thread.c | 26 +- level_0/f_thread/c/thread.h | 26 +- level_0/f_type_array/c/type_array/array_length.c | 4 +- level_0/f_type_array/c/type_array/array_length.h | 4 +- level_0/f_type_array/c/type_array/cell.c | 4 +- level_0/f_type_array/c/type_array/cell.h | 4 +- level_0/f_type_array/c/type_array/fll_id.c | 4 +- level_0/f_type_array/c/type_array/fll_id.h | 4 +- level_0/f_type_array/c/type_array/int128.c | 8 +- level_0/f_type_array/c/type_array/int128.h | 8 +- level_0/f_type_array/c/type_array/int16.c | 8 +- level_0/f_type_array/c/type_array/int16.h | 8 +- level_0/f_type_array/c/type_array/int32.c | 8 +- level_0/f_type_array/c/type_array/int32.h | 8 +- level_0/f_type_array/c/type_array/int64.c | 8 +- level_0/f_type_array/c/type_array/int64.h | 8 +- level_0/f_type_array/c/type_array/int8.c | 8 +- level_0/f_type_array/c/type_array/int8.h | 8 +- level_0/f_type_array/c/type_array/private-fll_id.h | 1827 +------------------- level_0/f_type_array/c/type_array/state.c | 4 +- level_0/f_type_array/c/type_array/state.h | 4 +- level_0/f_type_array/c/type_array/status.c | 4 +- level_0/f_type_array/c/type_array/status.h | 4 +- level_0/f_utf/c/utf/dynamic.c | 4 +- level_0/f_utf/c/utf/dynamic.h | 4 +- level_0/f_utf/c/utf/map.c | 4 +- level_0/f_utf/c/utf/map.h | 4 +- level_0/f_utf/c/utf/triple.c | 2 +- level_0/f_utf/c/utf/triple.h | 2 +- level_1/fl_iki/c/iki.c | 4 +- level_1/fl_iki/c/iki.h | 12 +- level_3/fake/c/private-make-operate.c | 59 +- level_3/iki_read/c/private-common.h | 32 - level_3/iki_read/c/private-print.c | 2 +- level_3/iki_read/c/private-print.h | 2 +- level_3/iki_read/c/private-read.c | 18 +- level_3/iki_read/c/private-read.h | 6 +- 62 files changed, 834 insertions(+), 2123 deletions(-) diff --git a/level_0/f_fss/c/fss/common.h b/level_0/f_fss/c/fss/common.h index b232360..d56af4d 100644 --- a/level_0/f_fss/c/fss/common.h +++ b/level_0/f_fss/c/fss/common.h @@ -255,13 +255,13 @@ enum { /** * This is a range that represents an object. */ -#ifndef _di_fss_object_t_ +#ifndef _di_f_fss_object_t_ typedef f_string_range_t f_fss_object_t; #define f_fss_object_t_initialize f_string_range_t_initialize #define macro_f_fss_object_t_clear(object) macro_f_string_range_t_clear(object) -#endif // _di_fss_object_t_ +#endif // _di_f_fss_object_t_ /** * This holds an array of fss_object. @@ -270,7 +270,7 @@ enum { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_objects_t_ +#ifndef _di_f_fss_objects_t_ typedef f_string_ranges_t f_fss_objects_t; #define f_fss_objects_t_initialize f_string_ranges_t_initialize @@ -287,7 +287,7 @@ enum { #define macro_f_fss_objects_t_increase_by(status, objects, amount) macro_f_string_ranges_t_increase_by(status, objects, amount) #define macro_f_fss_objects_t_decrease_by(status, objects, amount) macro_f_string_ranges_t_decrease_by(status, objects, amount) #define macro_f_fss_objects_t_decimate_by(status, objects, amount) macro_f_string_ranges_t_decimate_by(status, objects, amount) -#endif // _di_fss_objects_t_ +#endif // _di_f_fss_objects_t_ /** * This holds an array of string ranges that represent the content. @@ -298,7 +298,7 @@ enum { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_content_ +#ifndef _di_f_fss_content_ typedef f_string_ranges_t f_fss_content_t; #define f_fss_content_t_initialize f_string_ranges_t_initialize @@ -315,7 +315,7 @@ enum { #define macro_f_fss_content_t_increase_by(status, content, amount) macro_f_string_ranges_t_increase_by(status, content, amount) #define macro_f_fss_content_t_decrease_by(status, content, amount) macro_f_string_ranges_t_decrease_by(status, content, amount) #define macro_f_fss_content_t_decimate_by(status, content, amount) macro_f_string_ranges_t_decimate_by(status, content, amount) -#endif // _di_fss_content_ +#endif // _di_f_fss_content_ /** * This holds an array of fss_content. diff --git a/level_0/f_fss/c/fss/named.c b/level_0/f_fss/c/fss/named.c index af2cdcf..3070c5e 100644 --- a/level_0/f_fss/c/fss/named.c +++ b/level_0/f_fss/c/fss/named.c @@ -46,7 +46,7 @@ extern "C" { #endif // _di_f_fss_named_decrease_by_ #ifndef _di_f_fss_named_increase_ - f_status_t f_fss_named_increase(const uint16_t step, f_fss_named_t * const named) { + f_status_t f_fss_named_increase(const f_array_length_t step, f_fss_named_t * const named) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!named) return F_status_set_error(F_parameter); @@ -140,7 +140,7 @@ extern "C" { #endif // _di_f_fss_nameds_decrease_by_ #ifndef _di_f_fss_nameds_increase_ - f_status_t f_fss_nameds_increase(const uint16_t step, f_fss_nameds_t * const nameds) { + f_status_t f_fss_nameds_increase(const f_array_length_t step, f_fss_nameds_t * const nameds) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!nameds) return F_status_set_error(F_parameter); diff --git a/level_0/f_fss/c/fss/named.h b/level_0/f_fss/c/fss/named.h index 792922e..b505175 100644 --- a/level_0/f_fss/c/fss/named.h +++ b/level_0/f_fss/c/fss/named.h @@ -63,7 +63,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_nameds_t_ +#ifndef _di_f_fss_nameds_t_ typedef struct { f_fss_named_t *array; @@ -85,7 +85,7 @@ extern "C" { #define macro_f_fss_nameds_t_increase_by(status, nameds, amount) status = f_fss_nameds_increase_by(amount, &nameds); #define macro_f_fss_nameds_t_decrease_by(status, nameds, amount) status = f_fss_nameds_decrease_by(amount, &nameds); #define macro_f_fss_nameds_t_decimate_by(status, nameds, amount) status = f_fss_nameds_decimate_by(amount, &nameds); -#endif // _di_fss_nameds_t_ +#endif // _di_f_fss_nameds_t_ /** * Resize all parts of the named structure using the same length. @@ -170,7 +170,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_named_increase_ - extern f_status_t f_fss_named_increase(const uint16_t step, f_fss_named_t * const named); + extern f_status_t f_fss_named_increase(const f_array_length_t step, f_fss_named_t * const named); #endif // _di_f_fss_named_increase_ /** @@ -298,7 +298,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_nameds_increase_ - extern f_status_t f_fss_nameds_increase(const uint16_t step, f_fss_nameds_t * const nameds); + extern f_status_t f_fss_nameds_increase(const f_array_length_t step, f_fss_nameds_t * const nameds); #endif // _di_f_fss_nameds_increase_ /** diff --git a/level_0/f_fss/c/fss/nest.c b/level_0/f_fss/c/fss/nest.c index 04da6a8..c760ec7 100644 --- a/level_0/f_fss/c/fss/nest.c +++ b/level_0/f_fss/c/fss/nest.c @@ -46,7 +46,7 @@ extern "C" { #endif // _di_f_fss_items_decrease_by_ #ifndef _di_f_fss_items_increase_ - f_status_t f_fss_items_increase(const uint16_t step, f_fss_items_t * const items) { + f_status_t f_fss_items_increase(const f_array_length_t step, f_fss_items_t * const items) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!items) return F_status_set_error(F_parameter); @@ -140,7 +140,7 @@ extern "C" { #endif // _di_f_fss_nest_decrease_by_ #ifndef _di_f_fss_nest_increase_ - f_status_t f_fss_nest_increase(const uint16_t step, f_fss_nest_t * const nest) { + f_status_t f_fss_nest_increase(const f_array_length_t step, f_fss_nest_t * const nest) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!nest) return F_status_set_error(F_parameter); @@ -234,7 +234,7 @@ extern "C" { #endif // _di_f_fss_nests_decrease_by_ #ifndef _di_f_fss_nests_increase_ - f_status_t f_fss_nests_increase(const uint16_t step, f_fss_nests_t * const nests) { + f_status_t f_fss_nests_increase(const f_array_length_t step, f_fss_nests_t * const nests) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!nests) return F_status_set_error(F_parameter); diff --git a/level_0/f_fss/c/fss/nest.h b/level_0/f_fss/c/fss/nest.h index ce38da1..c89c857 100644 --- a/level_0/f_fss/c/fss/nest.h +++ b/level_0/f_fss/c/fss/nest.h @@ -31,7 +31,7 @@ extern "C" { * content: The content associated with the object. * parent: A location referencing a parrent object or content that this object content is nested under. */ -#ifndef _di_fss_item_t_ +#ifndef _di_f_fss_item_t_ typedef struct { f_fss_object_t object; f_fss_content_t content; @@ -56,7 +56,7 @@ extern "C" { #define macro_f_fss_item_t_increase_by(status, item, amount) macro_f_fss_content_t_increase_by(status, item.content, amount) #define macro_f_fss_item_t_decrease_by(status, item, amount) macro_f_fss_content_t_decrease_by(status, item.content, amount) #define macro_f_fss_item_t_decimate_by(status, item, amount) macro_f_fss_content_t_decimate_by(status, item.content, amount) -#endif // _di_fss_item_t_ +#endif // _di_f_fss_item_t_ /** * This holds an array of fss_item. @@ -86,7 +86,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_items_t_ +#ifndef _di_f_fss_items_t_ typedef struct { f_fss_item_t *array; @@ -108,7 +108,7 @@ extern "C" { #define macro_f_fss_items_t_increase_by(status, items, amount) status = f_fss_items_increase_by(amount, &items); #define macro_f_fss_items_t_decrease_by(status, items, amount) status = f_fss_items_decrease_by(amount, &items); #define macro_f_fss_items_t_decimate_by(status, items, amount) status = f_fss_items_decimate_by(amount, &items); -#endif // _di_fss_items_t_ +#endif // _di_f_fss_items_t_ /** * This holds an array of f_fss_items_t. @@ -122,7 +122,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_nest_t_ +#ifndef _di_f_fss_nest_t_ typedef struct { f_fss_items_t *depth; @@ -144,7 +144,7 @@ extern "C" { #define macro_f_fss_nest_t_increase_by(status, nest, amount) status = f_fss_nest_increase_by(amount, &nest); #define macro_f_fss_nest_t_decrease_by(status, nest, amount) status = f_fss_nest_decrease_by(amount, &nest); #define macro_f_fss_nest_t_decimate_by(status, nest, amount) status = f_fss_nest_decimate_by(amount, &nest); -#endif // _di_fss_nest_t_ +#endif // _di_f_fss_nest_t_ /** * This holds an array of f_fss_nest_t. @@ -153,7 +153,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_fss_nests_t_ +#ifndef _di_f_fss_nests_t_ typedef struct { f_fss_nest_t *array; @@ -175,7 +175,7 @@ extern "C" { #define macro_f_fss_nests_t_increase_by(status, nests, amount) status = f_fss_nests_increase_by(amount, &nests); #define macro_f_fss_nests_t_decrease_by(status, nests, amount) status = f_fss_nests_decrease_by(amount, &nests); #define macro_f_fss_nests_t_decimate_by(status, nests, amount) status = f_fss_nests_decimate_by(amount, &nests); -#endif // _di_fss_nests_t_ +#endif // _di_f_fss_nests_t_ /** * Resize the nest array. @@ -260,7 +260,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_items_increase_ - extern f_status_t f_fss_items_increase(const uint16_t step, f_fss_items_t * const items); + extern f_status_t f_fss_items_increase(const f_array_length_t step, f_fss_items_t * const items); #endif // _di_f_fss_items_increase_ /** @@ -388,7 +388,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_nest_increase_ - extern f_status_t f_fss_nest_increase(const uint16_t step, f_fss_nest_t * const nest); + extern f_status_t f_fss_nest_increase(const f_array_length_t step, f_fss_nest_t * const nest); #endif // _di_f_fss_nest_increase_ /** @@ -516,7 +516,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_nests_increase_ - extern f_status_t f_fss_nests_increase(const uint16_t step, f_fss_nests_t * const nests); + extern f_status_t f_fss_nests_increase(const f_array_length_t step, f_fss_nests_t * const nests); #endif // _di_f_fss_nests_increase_ /** diff --git a/level_0/f_fss/c/fss/set.c b/level_0/f_fss/c/fss/set.c index 2ec0998..09f524d 100644 --- a/level_0/f_fss/c/fss/set.c +++ b/level_0/f_fss/c/fss/set.c @@ -46,7 +46,7 @@ extern "C" { #endif // _di_f_fss_set_decrease_by_ #ifndef _di_f_fss_set_increase_ - f_status_t f_fss_set_increase(const uint16_t step, f_fss_set_t * const set) { + f_status_t f_fss_set_increase(const f_array_length_t step, f_fss_set_t * const set) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!set) return F_status_set_error(F_parameter); @@ -140,7 +140,7 @@ extern "C" { #endif // _di_f_fss_set_quote_decrease_by_ #ifndef _di_f_fss_set_quote_increase_ - f_status_t f_fss_set_quote_increase(const uint16_t step, f_fss_set_quote_t * const set_quote) { + f_status_t f_fss_set_quote_increase(const f_array_length_t step, f_fss_set_quote_t * const set_quote) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!set_quote) return F_status_set_error(F_parameter); @@ -234,7 +234,7 @@ extern "C" { #endif // _di_f_fss_set_quotes_decrease_by_ #ifndef _di_f_fss_set_quotes_increase_ - f_status_t f_fss_set_quotes_increase(const uint16_t step, f_fss_set_quotes_t * const set_quotes) { + f_status_t f_fss_set_quotes_increase(const f_array_length_t step, f_fss_set_quotes_t * const set_quotes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!set_quotes) return F_status_set_error(F_parameter); @@ -328,7 +328,7 @@ extern "C" { #endif // _di_f_fss_sets_decrease_by_ #ifndef _di_f_fss_sets_increase_ - f_status_t f_fss_sets_increase(const uint16_t step, f_fss_sets_t * const sets) { + f_status_t f_fss_sets_increase(const f_array_length_t step, f_fss_sets_t * const sets) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!sets) return F_status_set_error(F_parameter); diff --git a/level_0/f_fss/c/fss/set.h b/level_0/f_fss/c/fss/set.h index 451056e..7533165 100644 --- a/level_0/f_fss/c/fss/set.h +++ b/level_0/f_fss/c/fss/set.h @@ -127,7 +127,7 @@ extern "C" { * size: total amount of allocated space. * used: total number of allocated spaces used. */ -#ifndef _di_fss_set_quotes_t_ +#ifndef _di_f_fss_set_quotes_t_ typedef struct { f_fss_set_quote_t *array; @@ -149,7 +149,7 @@ extern "C" { #define macro_f_fss_set_quotes_t_increase_by(status, set_quotes, amount) status = f_fss_set_quotes_increase_by(amount, &set_quotes); #define macro_f_fss_set_quotes_t_decrease_by(status, set_quotes, amount) status = f_fss_set_quotes_decrease_by(amount, &set_quotes); #define macro_f_fss_set_quotes_t_decimate_by(status, set_quotes, amount) status = f_fss_set_quotes_decimate_by(amount, &set_quotes); -#endif // _di_fss_set_quotes_t_ +#endif // _di_f_fss_set_quotes_t_ /** * Resize the set array. @@ -234,7 +234,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_set_increase_ - extern f_status_t f_fss_set_increase(const uint16_t step, f_fss_set_t * const set); + extern f_status_t f_fss_set_increase(const f_array_length_t step, f_fss_set_t * const set); #endif // _di_f_fss_set_increase_ /** @@ -362,7 +362,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_set_quote_increase_ - extern f_status_t f_fss_set_quote_increase(const uint16_t step, f_fss_set_quote_t * const set_quote); + extern f_status_t f_fss_set_quote_increase(const f_array_length_t step, f_fss_set_quote_t * const set_quote); #endif // _di_f_fss_set_quote_increase_ /** @@ -490,7 +490,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_set_quotes_increase_ - extern f_status_t f_fss_set_quotes_increase(const uint16_t step, f_fss_set_quotes_t * const set_quotes); + extern f_status_t f_fss_set_quotes_increase(const f_array_length_t step, f_fss_set_quotes_t * const set_quotes); #endif // _di_f_fss_set_quotes_increase_ /** @@ -618,7 +618,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_fss_sets_increase_ - extern f_status_t f_fss_sets_increase(const uint16_t step, f_fss_sets_t * const sets); + extern f_status_t f_fss_sets_increase(const f_array_length_t step, f_fss_sets_t * const sets); #endif // _di_f_fss_sets_increase_ /** diff --git a/level_0/f_iki/c/iki.c b/level_0/f_iki/c/iki.c index 58cc96d..ce3d5d1 100644 --- a/level_0/f_iki/c/iki.c +++ b/level_0/f_iki/c/iki.c @@ -52,14 +52,11 @@ extern "C" { #endif // _di_f_iki_object_partial_is_ #ifndef _di_f_iki_read_ - f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits) { + f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data) { #ifndef _di_level_0_parameter_checking_ if (!buffer) return F_status_set_error(F_parameter); if (!range) return F_status_set_error(F_parameter); - if (!variable) return F_status_set_error(F_parameter); - if (!vocabulary) return F_status_set_error(F_parameter); - if (!content) return F_status_set_error(F_parameter); - if (!delimits) return F_status_set_error(F_parameter); + if (!data) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ if (!buffer->used) { @@ -98,7 +95,7 @@ extern "C" { f_string_range_t found_vocabulary = f_string_range_t_initialize; f_array_length_t found_content = 0; f_array_length_t vocabulary_slash_first = range->start; - const f_array_length_t delimits_used = delimits->used; + const f_array_length_t delimits_used = data->delimits.used; uint8_t quote = 0; @@ -212,13 +209,13 @@ extern "C" { if (F_status_is_error(status)) break; if (range->start > range->stop) { - delimits->used = delimits_used; + data->delimits.used = delimits_used; return F_data_not_stop; } if (range->start >= buffer->used) { - delimits->used = delimits_used; + data->delimits.used = delimits_used; return F_data_not_eos; } @@ -231,7 +228,7 @@ extern "C" { } // while if (F_status_is_error(status)) { - delimits->used = delimits_used; + data->delimits.used = delimits_used; return status; } @@ -262,36 +259,37 @@ extern "C" { // This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore. if (vocabulary_delimited) { - status = f_array_lengths_increase(state.step_small, delimits); + status = f_array_lengths_increase(state.step_small, &data->delimits); if (F_status_is_error(status)) break; - delimits->array[delimits->used++] = vocabulary_slash_first; + data->delimits.array[data->delimits.used++] = vocabulary_slash_first; find_next = F_true; vocabulary_delimited = F_false; quote = 0; ++range->start; + break; } - status = f_string_ranges_increase(state.step_small, variable); + status = f_string_ranges_increase(state.step_small, &data->variable); if (F_status_is_error(status)) break; - status = f_string_ranges_increase(state.step_small, vocabulary); + status = f_string_ranges_increase(state.step_small, &data->vocabulary); if (F_status_is_error(status)) break; - status = f_string_ranges_increase(state.step_small, content); + status = f_string_ranges_increase(state.step_small, &data->content); if (F_status_is_error(status)) break; - variable->array[variable->used].start = found_vocabulary.start; - variable->array[variable->used++].stop = range->start; + data->variable.array[data->variable.used].start = found_vocabulary.start; + data->variable.array[data->variable.used++].stop = range->start; - vocabulary->array[vocabulary->used].start = found_vocabulary.start; - vocabulary->array[vocabulary->used++].stop = found_vocabulary.stop; + data->vocabulary.array[data->vocabulary.used].start = found_vocabulary.start; + data->vocabulary.array[data->vocabulary.used++].stop = found_vocabulary.stop; - content->array[content->used].start = found_content; - content->array[content->used++].stop = range->start - 1; + data->content.array[data->content.used].start = found_content; + data->content.array[data->content.used++].stop = range->start - 1; if (++range->start > range->stop) { return F_none_stop; @@ -324,7 +322,7 @@ extern "C" { ++content_slash_delimits; } - status = f_array_lengths_increase_by(content_slash_delimits, delimits); + status = f_array_lengths_increase_by(content_slash_delimits, &data->delimits); if (F_status_is_error(status)) break; content_range.start = content_slash_first; @@ -333,7 +331,7 @@ extern "C" { while (i < content_slash_delimits) { if (buffer->string[content_range.start] == f_iki_syntax_slash_s.string[0]) { - delimits->array[delimits->used++] = content_range.start; + data->delimits.array[data->delimits.used++] = content_range.start; ++i; } @@ -348,10 +346,10 @@ extern "C" { // This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore. if (vocabulary_delimited) { - status = f_array_lengths_increase(state.step_small, delimits); + status = f_array_lengths_increase(state.step_small, &data->delimits); if (F_status_is_error(status)) break; - delimits->array[delimits->used++] = vocabulary_slash_first; + data->delimits.array[data->delimits.used++] = vocabulary_slash_first; vocabulary_delimited = F_false; quote = 0; @@ -364,23 +362,23 @@ extern "C" { found_vocabulary.start = range->start; } else { - status = f_string_ranges_increase(state.step_small, variable); + status = f_string_ranges_increase(state.step_small, &data->variable); if (F_status_is_error(status)) break; - status = f_string_ranges_increase(state.step_small, vocabulary); + status = f_string_ranges_increase(state.step_small, &data->vocabulary); if (F_status_is_error(status)) break; - status = f_string_ranges_increase(state.step_small, content); + status = f_string_ranges_increase(state.step_small, &data->content); if (F_status_is_error(status)) break; - variable->array[variable->used].start = found_vocabulary.start; - variable->array[variable->used++].stop = range->start; + data->variable.array[data->variable.used].start = found_vocabulary.start; + data->variable.array[data->variable.used++].stop = range->start; - vocabulary->array[vocabulary->used].start = found_vocabulary.start; - vocabulary->array[vocabulary->used++].stop = found_vocabulary.stop; + data->vocabulary.array[data->vocabulary.used].start = found_vocabulary.start; + data->vocabulary.array[data->vocabulary.used++].stop = found_vocabulary.stop; - content->array[content->used].start = found_content; - content->array[content->used++].stop = range->start - 1; + data->content.array[data->content.used].start = found_content; + data->content.array[data->content.used++].stop = range->start - 1; if (++range->start > range->stop) { return F_none_stop; @@ -397,9 +395,7 @@ extern "C" { break; } - if (buffer->string[range->start] != f_iki_syntax_slash_s.string[0]) { - break; - } + if (buffer->string[range->start] != f_iki_syntax_slash_s.string[0]) break; ++content_slash_total; @@ -420,7 +416,7 @@ extern "C" { } if (F_status_is_error(status)) { - delimits->used = delimits_used; + data->delimits.used = delimits_used; return status; } diff --git a/level_0/f_iki/c/iki.h b/level_0/f_iki/c/iki.h index f087342..9e4ea02 100644 --- a/level_0/f_iki/c/iki.h +++ b/level_0/f_iki/c/iki.h @@ -136,14 +136,8 @@ extern "C" { * The start location will be updated as the buffer is being processed. * The start location will represent where the read stopped on return. * A start location past the stop location or buffer used means that the entire range was processed. - * @param variable - * The entire vocabulary name, content, and syntax. - * @param vocabulary - * The vocabulary name list to store the found vocabulary name. - * @param content - * The content list to store the content associated with the found vocabulary name. - * @param delimits - * A delimits array representing where delimits exist within the buffer. + * @param data + * The IKI variable data. * * @return * F_none on success and an IKI vocabulary name was found. @@ -159,7 +153,7 @@ extern "C" { * F_string_too_large (with error bit) if a string length is too large to store in the buffer. */ #ifndef _di_f_iki_read_ - extern f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits); + extern f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data); #endif // _di_f_iki_read_ #ifdef __cplusplus diff --git a/level_0/f_iki/c/iki/common.c b/level_0/f_iki/c/iki/common.c index 5af824e..2bfc0cc 100644 --- a/level_0/f_iki/c/iki/common.c +++ b/level_0/f_iki/c/iki/common.c @@ -1,4 +1,5 @@ #include "../iki.h" +#include "../private-iki.h" #ifdef __cplusplus extern "C" { @@ -12,7 +13,7 @@ extern "C" { const f_string_static_t f_iki_syntax_slash_s = macro_f_string_static_t_initialize(F_iki_syntax_slash_s, 0, F_iki_syntax_slash_s_length); #endif //_di_f_iki_syntax_ -#ifndef _di_iki_vocabulary_0001_s_ +#ifndef _di_f_iki_vocabulary_0001_s_ const f_string_static_t f_iki_vocabulary_0001_address_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_address_s, 0, F_iki_vocabulary_0001_address_s_length); const f_string_static_t f_iki_vocabulary_0001_code_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_code_s, 0, F_iki_vocabulary_0001_code_s_length); const f_string_static_t f_iki_vocabulary_0001_email_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_email_s, 0, F_iki_vocabulary_0001_email_s_length); @@ -23,13 +24,185 @@ extern "C" { const f_string_static_t f_iki_vocabulary_0001_url_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_url_s, 0, F_iki_vocabulary_0001_url_s_length); const f_string_static_t f_iki_vocabulary_0001_urn_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_urn_s, 0, F_iki_vocabulary_0001_urn_s_length); const f_string_static_t f_iki_vocabulary_0001_variable_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_variable_s, 0, F_iki_vocabulary_0001_variable_s_length); -#endif // _di_iki_vocabulary_0001_s_ +#endif // _di_f_iki_vocabulary_0001_s_ -#ifndef _di_iki_vocabulary_0002_s_ +#ifndef _di_f_iki_vocabulary_0002_s_ const f_string_static_t f_iki_vocabulary_0002_context_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_context_s, 0, F_iki_vocabulary_0002_context_s_length); const f_string_static_t f_iki_vocabulary_0002_define_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_define_s, 0, F_iki_vocabulary_0002_define_s_length); const f_string_static_t f_iki_vocabulary_0002_parameter_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_parameter_s, 0, F_iki_vocabulary_0002_parameter_s_length); -#endif // _di_iki_vocabulary_0002_s_ +#endif // _di_f_iki_vocabulary_0002_s_ + +#ifndef _di_f_iki_data_delete_ + f_status_t f_iki_data_delete(f_iki_data_t *data) { + #ifndef _di_level_0_parameter_checking_ + if (!data) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + f_status_t status = f_string_ranges_resize(0, &data->content); + if (F_status_is_error(status)) return status; + + status = f_array_lengths_resize(0, &data->delimits); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_resize(0, &data->variable); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_resize(0, &data->vocabulary); + if (F_status_is_error(status)) return status; + + return F_none; + } +#endif // _di_f_iki_data_delete_ + +#ifndef _di_f_iki_data_destroy_ + f_status_t f_iki_data_destroy(f_iki_data_t *data) { + #ifndef _di_level_0_parameter_checking_ + if (!data) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + f_status_t status = f_string_ranges_adjust(0, &data->content); + if (F_status_is_error(status)) return status; + + status = f_array_lengths_adjust(0, &data->delimits); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_adjust(0, &data->variable); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_adjust(0, &data->vocabulary); + if (F_status_is_error(status)) return status; + + return F_none; + } +#endif // _di_f_iki_data_destroy_ + +#ifndef _di_f_iki_datas_adjust_ + f_status_t f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_iki_datas_adjust(length, datas); + } +#endif // _di_f_iki_datas_adjust_ + +#ifndef _di_f_iki_datas_append_ + f_status_t f_iki_datas_append(const f_iki_datas_t source, f_iki_datas_t *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_iki_datas_resize(destination->used + source.used, destination); + if (F_status_is_error(status)) return status; + } + + for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) { + + status = f_string_ranges_append(source.array[i].content, &destination->array[destination->used].content); + if (F_status_is_error(status)) return status; + + status = f_array_lengths_append(source.array[i].delimits, &destination->array[destination->used].delimits); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_append(source.array[i].variable, &destination->array[destination->used].variable); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_append(source.array[i].vocabulary, &destination->array[destination->used].vocabulary); + if (F_status_is_error(status)) return status; + } // for + + return F_none; + } +#endif // _di_f_iki_datas_append_ + +#ifndef _di_f_iki_datas_decimate_by_ + f_status_t f_iki_datas_decimate_by(const f_array_length_t amount, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!amount) return F_status_set_error(F_parameter); + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (datas->size - amount > 0) { + return private_f_iki_datas_adjust(datas->size - amount, datas); + } + + return private_f_iki_datas_adjust(0, datas); + } +#endif // _di_f_iki_datas_decimate_by_ + +#ifndef _di_f_iki_datas_decrease_by_ + f_status_t f_iki_datas_decrease_by(const f_array_length_t amount, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!amount) return F_status_set_error(F_parameter); + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (datas->size - amount > 0) { + return private_f_iki_datas_resize(datas->size - amount, datas); + } + + return private_f_iki_datas_resize(0, datas); + } +#endif // _di_f_iki_datas_decrease_by_ + +#ifndef _di_f_iki_datas_increase_ + f_status_t f_iki_datas_increase(const f_array_length_t step, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!step) return F_status_set_error(F_parameter); + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (datas->used + 1 > datas->size) { + f_array_length_t size = datas->used + step; + + if (size > F_array_length_t_size_d) { + if (datas->used + 1 > F_array_length_t_size_d) { + return F_status_set_error(F_array_too_large); + } + + size = F_array_length_t_size_d; + } + + return private_f_iki_datas_resize(size, datas); + } + + return F_data_not; + } +#endif // _di_f_iki_datas_increase_ + +#ifndef _di_f_iki_datas_increase_by_ + f_status_t f_iki_datas_increase_by(const f_array_length_t amount, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!amount) return F_status_set_error(F_parameter); + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + if (datas->used + amount > datas->size) { + if (datas->used + amount > F_array_length_t_size_d) { + return F_status_set_error(F_array_too_large); + } + + return private_f_iki_datas_resize(datas->used + amount, datas); + } + + return F_data_not; + } +#endif // _di_f_iki_datas_increase_by_ + +#ifndef _di_f_iki_datas_resize_ + f_status_t f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) { + #ifndef _di_level_0_parameter_checking_ + if (!datas) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + return private_f_iki_datas_resize(length, datas); + } +#endif // _di_f_iki_datas_resize_ #ifdef __cplusplus } // extern "C" diff --git a/level_0/f_iki/c/iki/common.h b/level_0/f_iki/c/iki/common.h index 3f74b0f..387f00b 100644 --- a/level_0/f_iki/c/iki/common.h +++ b/level_0/f_iki/c/iki/common.h @@ -39,7 +39,7 @@ extern "C" { extern const f_string_static_t f_iki_syntax_slash_s; #endif //_di_f_iki_syntax_ -#ifndef _di_iki_vocabulary_0001_ +#ifndef _di_f_iki_vocabulary_0001_ #define F_iki_vocabulary_0001_address_s "address" #define F_iki_vocabulary_0001_code_s "code" #define F_iki_vocabulary_0001_email_s "email" @@ -72,9 +72,9 @@ extern "C" { extern const f_string_static_t f_iki_vocabulary_0001_url_s; extern const f_string_static_t f_iki_vocabulary_0001_urn_s; extern const f_string_static_t f_iki_vocabulary_0001_variable_s; -#endif // _di_iki_vocabulary_0001_ +#endif // _di_f_iki_vocabulary_0001_ -#ifndef _di_iki_vocabulary_0002_ +#ifndef _di_f_iki_vocabulary_0002_ #define F_iki_vocabulary_0002_context_s "context" #define F_iki_vocabulary_0002_define_s "define" #define F_iki_vocabulary_0002_parameter_s "parameter" @@ -86,9 +86,7 @@ extern "C" { extern const f_string_static_t f_iki_vocabulary_0002_context_s; extern const f_string_static_t f_iki_vocabulary_0002_define_s; extern const f_string_static_t f_iki_vocabulary_0002_parameter_s; -#endif // _di_iki_vocabulary_0002_ - -// @todo consider IKI-0003 = vocabulary based on context from HTML5 and accessibility-related? +#endif // _di_f_iki_vocabulary_0002_ /** * Designate an iki delimit location. @@ -157,7 +155,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_iki_variable_t_ +#ifndef _di_f_iki_variable_t_ typedef f_string_ranges_t f_iki_variable_t; #define f_iki_variable_t_initialize f_string_ranges_t_initialize @@ -170,7 +168,7 @@ extern "C" { #define macro_f_iki_variable_t_delete_simple(variable) macro_f_string_ranges_t_delete_simple(variable) #define macro_f_iki_variable_t_destroy_simple(variable) macro_f_string_ranges_t_destroy_simple(variable) -#endif // _di_iki_variable_t_ +#endif // _di_f_iki_variable_t_ /** * This holds an array of string ranges that represent the vocabulary names. @@ -179,7 +177,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_iki_vocabulary_t_ +#ifndef _di_f_iki_vocabulary_t_ typedef f_string_ranges_t f_iki_vocabulary_t; #define f_iki_vocabulary_t_initialize f_string_ranges_t_initialize @@ -191,7 +189,7 @@ extern "C" { #define macro_f_iki_vocabulary_t_delete_simple(vocabulary) macro_f_string_ranges_t_delete_simple(vocabulary) #define macro_f_iki_vocabulary_t_destroy_simple(vocabulary) macro_f_string_ranges_t_destroy_simple(vocabulary) -#endif // _di_iki_vocabulary_t_ +#endif // _di_f_iki_vocabulary_t_ /** * This holds an array of f_iki_vocabulary_t. @@ -200,7 +198,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_iki_vocabularys_t_ +#ifndef _di_f_iki_vocabularys_t_ typedef f_string_rangess_t f_iki_vocabularys_t; #define f_iki_vocabularys_t_initialize f_string_rangess_t_initialize @@ -212,7 +210,7 @@ extern "C" { #define macro_f_iki_vocabularys_t_delete_simple(content) macro_f_string_rangess_t_delete_simple(content) #define macro_f_iki_vocabularys_t_destroy_simple(content) macro_f_string_rangess_t_destroy_simple(content) -#endif // _di_iki_vocabularys_t_ +#endif // _di_f_iki_vocabularys_t_ /** * This holds an array of string ranges that represent the content. @@ -223,7 +221,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_iki_content_t_ +#ifndef _di_f_iki_content_t_ typedef f_string_ranges_t f_iki_content_t; #define f_iki_content_t_initialize f_string_ranges_t_initialize @@ -235,7 +233,7 @@ extern "C" { #define macro_f_iki_content_t_delete_simple(content) macro_f_string_ranges_t_delete_simple(content) #define macro_f_iki_content_t_destroy_simple(content) macro_f_string_ranges_t_destroy_simple(content) -#endif // _di_iki_content_t_ +#endif // _di_f_iki_content_t_ /** * This holds an array of f_iki_content_t. @@ -244,7 +242,7 @@ extern "C" { * size: Total amount of allocated space. * used: Total number of allocated spaces used. */ -#ifndef _di_iki_contents_t_ +#ifndef _di_f_iki_contents_t_ typedef f_string_rangess_t f_iki_contents_t; #define f_iki_contents_t_initialize f_string_rangess_t_initialize @@ -256,7 +254,71 @@ extern "C" { #define macro_f_iki_contents_t_delete_simple(content) macro_f_string_rangess_t_delete_simple(content) #define macro_f_iki_contents_t_destroy_simple(content) macro_f_string_rangess_t_destroy_simple(content) -#endif // _di_iki_contents_t_ +#endif // _di_f_iki_contents_t_ + +/** + * This containg all of the IKI data. + * + * content: A set of ranges representing the content list to store the content associated with the found vocabulary name. + * delimits: A delimits array representing where delimits exist within the buffer. + * variable: A set of ranges representing the entire vocabulary name, content, and syntax. + * vocabulary: A set of ranges representing the vocabulary name list to store the found vocabulary name. + */ +#ifndef _di_f_iki_data_t_ + typedef struct { + f_iki_content_t content; + f_iki_delimits_t delimits; + f_iki_variable_t variable; + f_iki_vocabulary_t vocabulary; + } f_iki_data_t; + + #define f_iki_data_t_initialize { \ + f_iki_content_t_initialize, \ + f_iki_delimits_t_initialize, \ + f_iki_variable_t_initialize, \ + f_iki_vocabulary_t_initialize, \ + } + + #define macro_f_iki_data_t_clear(data) \ + f_iki_content_t_clear(data.content) \ + f_iki_delimits_t_clear(data.delimits) \ + f_iki_variable_t_clear(data.variable) \ + f_iki_vocabulary_t_clear(data.vocabulary) + + #define macro_f_iki_data_t_delete_simple(data) status = f_iki_data_delete(data); + #define macro_f_iki_data_t_destroy_simple(data) status = f_iki_data_destroy(data); +#endif // _di_f_iki_data_t_ + +/** + * An array of f_iki_data_t. + * + * array: The array of fss quotes. + * size: Total amount of allocated space. + * used: Total number of allocated spaces used. + */ +#ifndef _di_f_iki_datas_t_ + typedef struct { + f_iki_data_t *array; + + f_array_length_t size; + f_array_length_t used; + } f_iki_datas_t; + + #define f_fss_iki_datas_t_initialize { 0, 0, 0 } + + #define macro_f_fss_iki_datas_t_clear(datas) macro_f_memory_structure_clear(datas) + + #define macro_f_fss_iki_datas_t_resize(status, datas, length) status = f_iki_datas_resize(length, &datas); + #define macro_f_fss_iki_datas_t_adjust(status, datas, length) status = f_iki_datas_adjust(length, &datas); + + #define macro_f_fss_iki_datas_t_delete_simple(datas) status = f_iki_datas_resize(0, &datas); + #define macro_f_fss_iki_datas_t_destroy_simple(datas) status = f_iki_datas_adjust(0, &datas); + + #define macro_f_fss_iki_datas_t_increase(status, step, datas) status = f_iki_datas_increase(step, &datas); + #define macro_f_fss_iki_datas_t_increase_by(status, datas, amount) status = f_iki_datas_increase_by(amount, &datas); + #define macro_f_fss_iki_datas_t_decrease_by(status, datas, amount) status = f_iki_datas_decrease_by(amount, &datas); + #define macro_f_fss_iki_datas_t_decimate_by(status, datas, amount) status = f_iki_datas_decimate_by(amount, &datas); +#endif // _di_f_iki_datas_t_ /** * Provide a default allocation step. @@ -267,6 +329,202 @@ extern "C" { #define F_iki_default_allocation_step_d 4 #endif // _di_f_iki_default_allocation_step_ +/** + * Delete the IKI data. + * + * @param data + * The IKI data to delete. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_array_lengths_resize(). + * Errors (with error bit) from: f_string_ranges_resize(). + * + * @see f_array_lengths_resize() + * @see f_string_ranges_resize() + */ +#ifndef _di_f_iki_data_delete_ + extern f_status_t f_iki_data_delete(f_iki_data_t *data); +#endif // _di_f_iki_data_delete_ + +/** + * Destroy the IKI data. + * + * @param data + * The IKI data to destroy. + * + * @return + * F_none on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_array_lengths_adjust(). + * Errors (with error bit) from: f_string_ranges_adjust(). + * + * @see f_array_lengths_adjust() + * @see f_string_ranges_adjust() + */ +#ifndef _di_f_iki_data_destroy_ + extern f_status_t f_iki_data_destroy(f_iki_data_t *data); +#endif // _di_f_iki_data_destroy_ + +/** + * Resize the string lengths array. + * + * @param length + * The new size to use. + * @param lengths + * The string lengths 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_iki_datas_adjust_ + extern f_status_t f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_adjust_ + +/** + * Append the source lengths onto the destination. + * + * @param source + * The source lengths to append. + * @param destination + * The destination lengths 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_iki_datas_append_ + extern f_status_t f_iki_datas_append(const f_iki_datas_t source, f_iki_datas_t *destination); +#endif // _di_f_iki_datas_append_ + +/** + * Resize the string lengths 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 lengths + * The string lengths 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_iki_datas_decimate_by_ + extern f_status_t f_iki_datas_decimate_by(const f_array_length_t amount, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_decimate_by_ + +/** + * Resize the string lengths 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 lengths + * The string lengths 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_resize(). + */ +#ifndef _di_f_iki_datas_decrease_by_ + extern f_status_t f_iki_datas_decrease_by(const f_array_length_t amount, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_decrease_by_ + +/** + * Increase the size of the string lengths array, but only if necesary. + * + * If the given length is too large for the buffer, then attempt to set max buffer size (F_array_length_t_size_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 lengths + * The string lengths 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_iki_datas_increase_ + extern f_status_t f_iki_datas_increase(const f_array_length_t step, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_increase_ + +/** + * Resize the string lengths array to a larger size. + * + * This will resize making the string larger based on the given length. + * If the given length is too large for the buffer, then attempt to set max buffer size (F_array_length_t_size_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 lengths + * The string lengths 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_iki_datas_increase_by_ + extern f_status_t f_iki_datas_increase_by(const f_array_length_t amount, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_increase_by_ + +/** + * Resize the string lengths array. + * + * @param length + * The new size to use. + * @param lengths + * The string lengths 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_iki_datas_resize_ + extern f_status_t f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas); +#endif // _di_f_iki_datas_resize_ + #ifdef __cplusplus } // extern "C" #endif diff --git a/level_0/f_iki/c/private-iki.c b/level_0/f_iki/c/private-iki.c index 8970b49..0a4727e 100644 --- a/level_0/f_iki/c/private-iki.c +++ b/level_0/f_iki/c/private-iki.c @@ -5,6 +5,82 @@ extern "C" { #endif +#if !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_) + f_status_t private_f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) { + + if (datas->used + length > F_array_length_t_size_d) { + return F_status_set_error(F_array_too_large); + } + + f_status_t status = F_none; + + for (f_array_length_t i = length; i < datas->size; ++i) { + + status = f_string_ranges_adjust(0, &datas->array[i].content); + if (F_status_is_error(status)) return status; + + status = f_array_lengths_adjust(0, &datas->array[i].delimits); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_adjust(0, &datas->array[i].variable); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_adjust(0, &datas->array[i].vocabulary); + if (F_status_is_error(status)) return status; + } // for + + status = f_memory_adjust(datas->size, length, sizeof(f_iki_data_t), (void **) & datas->array); + + if (F_status_is_error_not(status)) { + datas->size = length; + + if (datas->used > datas->size) { + datas->used = length; + } + } + + return status; + } +#endif // !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_) + +#if !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_) + f_status_t private_f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) { + + if (datas->used + length > F_array_length_t_size_d) { + return F_status_set_error(F_array_too_large); + } + + f_status_t status = F_none; + + for (f_array_length_t i = length; i < datas->size; ++i) { + + status = f_string_ranges_resize(0, &datas->array[i].content); + if (F_status_is_error(status)) return status; + + status = f_array_lengths_resize(0, &datas->array[i].delimits); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_resize(0, &datas->array[i].variable); + if (F_status_is_error(status)) return status; + + status = f_string_ranges_resize(0, &datas->array[i].vocabulary); + if (F_status_is_error(status)) return status; + } // for + + status = f_memory_resize(datas->size, length, sizeof(f_iki_data_t), (void **) & datas->array); + + if (F_status_is_error_not(status)) { + datas->size = length; + + if (datas->used > datas->size) { + datas->used = length; + } + } + + return status; + } +#endif // !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_) + #if !defined(_di_f_iki_read_) f_status_t private_f_iki_seek_special(const f_string_static_t buffer, f_string_range_t * const range) { diff --git a/level_0/f_iki/c/private-iki.h b/level_0/f_iki/c/private-iki.h index b98ab16..24c2664 100644 --- a/level_0/f_iki/c/private-iki.h +++ b/level_0/f_iki/c/private-iki.h @@ -16,6 +16,58 @@ extern "C" { #endif /** + * Private implementation for resizing the iki_datas array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to adjust to. + * @param datas + * The IKI datas 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_array_lengths_adjust(). + * Errors (with error bit) from: f_memory_adjust(). + * Errors (with error bit) from: f_string_ranges_adjust(). + * + * @see f_array_lengths_adjust() + * @see f_memory_adjust() + * @see f_string_ranges_adjust() + */ +#if !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_) + extern f_status_t private_f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_) + +/** + * Private implementation for resizing the iki_datas array. + * + * Intended to be shared to each of the different implementation variations. + * + * @param length + * The length to adjust to. + * @param datas + * The IKI datas 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_array_lengths_resize(). + * Errors (with error bit) from: f_memory_resize(). + * Errors (with error bit) from: f_string_ranges_resize(). + * + * @see f_array_lengths_resize() + * @see f_memory_resize() + * @see f_string_ranges_resize() + */ +#if !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_) + extern f_status_t private_f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_) + +/** * Private implementation of f_iki_content_partial_is(). * * Intended to be shared to each of the different implementation variations. diff --git a/level_0/f_memory/c/memory/structure.c b/level_0/f_memory/c/memory/structure.c index c617b78..22dc263 100644 --- a/level_0/f_memory/c/memory/structure.c +++ b/level_0/f_memory/c/memory/structure.c @@ -53,7 +53,7 @@ extern "C" { #endif // _di_f_memory_structure_decrease_by_ #ifndef _di_f_memory_structure_increase_ - f_status_t f_memory_structure_increase(const uint16_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size) { + f_status_t f_memory_structure_increase(const f_array_length_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!type_size) return F_status_set_error(F_parameter); diff --git a/level_0/f_memory/c/memory/structure.h b/level_0/f_memory/c/memory/structure.h index 99bda4f..5600a57 100644 --- a/level_0/f_memory/c/memory/structure.h +++ b/level_0/f_memory/c/memory/structure.h @@ -142,7 +142,7 @@ extern "C" { * @see memset() */ #ifndef _di_f_memory_structure_increase_ - extern f_status_t f_memory_structure_increase(const uint16_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size); + extern f_status_t f_memory_structure_increase(const f_array_length_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size); #endif // _di_f_memory_structure_increase_ /** diff --git a/level_0/f_string/c/string/dynamic.c b/level_0/f_string/c/string/dynamic.c index 8ad6380..c0ed0bb 100644 --- a/level_0/f_string/c/string/dynamic.c +++ b/level_0/f_string/c/string/dynamic.c @@ -160,7 +160,7 @@ extern "C" { #endif // _di_f_string_dynamic_decrease_by_ #ifndef _di_f_string_dynamic_increase_ - f_status_t f_string_dynamic_increase(const uint16_t step, f_string_dynamic_t * const dynamic) { + f_status_t f_string_dynamic_increase(const f_array_length_t step, f_string_dynamic_t * const dynamic) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!dynamic) return F_status_set_error(F_parameter); @@ -936,7 +936,7 @@ extern "C" { #endif // _di_f_string_dynamics_decrease_by_ #ifndef _di_f_string_dynamics_increase_ - f_status_t f_string_dynamics_increase(const uint16_t step, f_string_dynamics_t * const dynamics) { + f_status_t f_string_dynamics_increase(const f_array_length_t step, f_string_dynamics_t * const dynamics) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!dynamics) return F_status_set_error(F_parameter); @@ -1043,7 +1043,7 @@ extern "C" { #endif // _di_f_string_dynamicss_decrease_by_ #ifndef _di_f_string_dynamicss_increase_ - f_status_t f_string_dynamicss_increase(const uint16_t step, f_string_dynamicss_t * const dynamicss) { + f_status_t f_string_dynamicss_increase(const f_array_length_t step, f_string_dynamicss_t * const dynamicss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!dynamicss) return F_status_set_error(F_parameter); diff --git a/level_0/f_string/c/string/dynamic.h b/level_0/f_string/c/string/dynamic.h index ca50835..ffd5097 100644 --- a/level_0/f_string/c/string/dynamic.h +++ b/level_0/f_string/c/string/dynamic.h @@ -252,7 +252,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_dynamic_increase_ - extern f_status_t f_string_dynamic_increase(const uint16_t step, f_string_dynamic_t * const dynamic); + extern f_status_t f_string_dynamic_increase(const f_array_length_t step, f_string_dynamic_t * const dynamic); #endif // _di_f_string_dynamic_increase_ /** @@ -1065,7 +1065,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_dynamics_increase_ - extern f_status_t f_string_dynamics_increase(const uint16_t step, f_string_dynamics_t * const dynamics); + extern f_status_t f_string_dynamics_increase(const f_array_length_t step, f_string_dynamics_t * const dynamics); #endif // _di_f_string_dynamics_increase_ /** @@ -1222,7 +1222,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_dynamicss_increase_ - extern f_status_t f_string_dynamicss_increase(const uint16_t step, f_string_dynamicss_t * const dynamicss); + extern f_status_t f_string_dynamicss_increase(const f_array_length_t step, f_string_dynamicss_t * const dynamicss); #endif // _di_f_string_dynamicss_increase_ /** diff --git a/level_0/f_string/c/string/map.c b/level_0/f_string/c/string/map.c index 1aac93b..8e9eae3 100644 --- a/level_0/f_string/c/string/map.c +++ b/level_0/f_string/c/string/map.c @@ -79,7 +79,7 @@ extern "C" { #endif // _di_f_string_map_multis_decrease_by_ #ifndef _di_f_string_map_multis_increase_ - f_status_t f_string_map_multis_increase(const uint16_t step, f_string_map_multis_t * const map_multis) { + f_status_t f_string_map_multis_increase(const f_array_length_t step, f_string_map_multis_t * const map_multis) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!map_multis) return F_status_set_error(F_parameter); @@ -200,7 +200,7 @@ extern "C" { #endif // _di_f_string_map_multiss_decrease_by_ #ifndef _di_f_string_map_multiss_increase_ - f_status_t f_string_map_multiss_increase(const uint16_t step, f_string_map_multiss_t * const map_multiss) { + f_status_t f_string_map_multiss_increase(const f_array_length_t step, f_string_map_multiss_t * const map_multiss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!map_multiss) return F_status_set_error(F_parameter); @@ -306,7 +306,7 @@ extern "C" { #endif // _di_f_string_maps_decrease_by_ #ifndef _di_f_string_maps_increase_ - f_status_t f_string_maps_increase(const uint16_t step, f_string_maps_t * const maps) { + f_status_t f_string_maps_increase(const f_array_length_t step, f_string_maps_t * const maps) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!maps) return F_status_set_error(F_parameter); @@ -429,7 +429,7 @@ extern "C" { #endif // _di_f_string_mapss_decrease_by_ #ifndef _di_f_string_mapss_increase_ - f_status_t f_string_mapss_increase(const uint16_t step, f_string_mapss_t * const mapss) { + f_status_t f_string_mapss_increase(const f_array_length_t step, f_string_mapss_t * const mapss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!mapss) return F_status_set_error(F_parameter); diff --git a/level_0/f_string/c/string/map.h b/level_0/f_string/c/string/map.h index ee156de..452dd6b 100644 --- a/level_0/f_string/c/string/map.h +++ b/level_0/f_string/c/string/map.h @@ -302,7 +302,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_map_multis_increase_ - extern f_status_t f_string_map_multis_increase(const uint16_t step, f_string_map_multis_t * const map_multis); + extern f_status_t f_string_map_multis_increase(const f_array_length_t step, f_string_map_multis_t * const map_multis); #endif // _di_f_string_map_multis_increase_ /** @@ -457,7 +457,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_maps_increase_ - extern f_status_t f_string_maps_increase(const uint16_t step, f_string_maps_t * const maps); + extern f_status_t f_string_maps_increase(const f_array_length_t step, f_string_maps_t * const maps); #endif // _di_f_string_maps_increase_ /** @@ -612,7 +612,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_mapss_increase_ - extern f_status_t f_string_mapss_increase(const uint16_t step, f_string_mapss_t * const mapss); + extern f_status_t f_string_mapss_increase(const f_array_length_t step, f_string_mapss_t * const mapss); #endif // _di_f_string_mapss_increase_ /** diff --git a/level_0/f_string/c/string/quantity.c b/level_0/f_string/c/string/quantity.c index 3624b12..573a6d8 100644 --- a/level_0/f_string/c/string/quantity.c +++ b/level_0/f_string/c/string/quantity.c @@ -73,7 +73,7 @@ extern "C" { #endif // _di_f_string_quantitys_decrease_by_ #ifndef _di_f_string_quantitys_increase_ - f_status_t f_string_quantitys_increase(const uint16_t step, f_string_quantitys_t * const quantitys) { + f_status_t f_string_quantitys_increase(const f_array_length_t step, f_string_quantitys_t * const quantitys) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!quantitys) return F_status_set_error(F_parameter); @@ -167,7 +167,7 @@ extern "C" { #endif // _di_f_string_quantityss_decrease_by_ #ifndef _di_f_string_quantityss_increase_ - f_status_t f_string_quantityss_increase(const uint16_t step, f_string_quantityss_t * const quantityss) { + f_status_t f_string_quantityss_increase(const f_array_length_t step, f_string_quantityss_t * const quantityss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!quantityss) return F_status_set_error(F_parameter); diff --git a/level_0/f_string/c/string/quantity.h b/level_0/f_string/c/string/quantity.h index 19bce66..94346d0 100644 --- a/level_0/f_string/c/string/quantity.h +++ b/level_0/f_string/c/string/quantity.h @@ -205,7 +205,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_quantitys_increase_ - extern f_status_t f_string_quantitys_increase(const uint16_t step, f_string_quantitys_t * const quantitys); + extern f_status_t f_string_quantitys_increase(const f_array_length_t step, f_string_quantitys_t * const quantitys); #endif // _di_f_string_quantitys_increase_ /** @@ -338,7 +338,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_quantityss_increase_ - extern f_status_t f_string_quantityss_increase(const uint16_t step, f_string_quantityss_t * const quantityss); + extern f_status_t f_string_quantityss_increase(const f_array_length_t step, f_string_quantityss_t * const quantityss); #endif // _di_f_string_quantityss_increase_ /** diff --git a/level_0/f_string/c/string/range.c b/level_0/f_string/c/string/range.c index 0cb06c9..79aa751 100644 --- a/level_0/f_string/c/string/range.c +++ b/level_0/f_string/c/string/range.c @@ -73,7 +73,7 @@ extern "C" { #endif // _di_f_string_ranges_decrease_by_ #ifndef _di_f_string_ranges_increase_ - f_status_t f_string_ranges_increase(const uint16_t step, f_string_ranges_t * const ranges) { + f_status_t f_string_ranges_increase(const f_array_length_t step, f_string_ranges_t * const ranges) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!ranges) return F_status_set_error(F_parameter); @@ -167,7 +167,7 @@ extern "C" { #endif // _di_f_string_rangess_decrease_by_ #ifndef _di_f_string_rangess_increase_ - f_status_t f_string_rangess_increase(const uint16_t step, f_string_rangess_t * const rangess) { + f_status_t f_string_rangess_increase(const f_array_length_t step, f_string_rangess_t * const rangess) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!rangess) return F_status_set_error(F_parameter); diff --git a/level_0/f_string/c/string/range.h b/level_0/f_string/c/string/range.h index 82420d0..1ae647c 100644 --- a/level_0/f_string/c/string/range.h +++ b/level_0/f_string/c/string/range.h @@ -210,7 +210,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_ranges_increase_ - extern f_status_t f_string_ranges_increase(const uint16_t step, f_string_ranges_t * const ranges); + extern f_status_t f_string_ranges_increase(const f_array_length_t step, f_string_ranges_t * const ranges); #endif // _di_f_string_ranges_increase_ /** @@ -344,7 +344,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_rangess_increase_ - extern f_status_t f_string_rangess_increase(const uint16_t step, f_string_rangess_t * const rangess); + extern f_status_t f_string_rangess_increase(const f_array_length_t step, f_string_rangess_t * const rangess); #endif // _di_f_string_rangess_increase_ /** diff --git a/level_0/f_string/c/string/triple.c b/level_0/f_string/c/string/triple.c index 497a581..eac16b8 100644 --- a/level_0/f_string/c/string/triple.c +++ b/level_0/f_string/c/string/triple.c @@ -89,7 +89,7 @@ extern "C" { #endif // _di_f_string_triples_decrease_by_ #ifndef _di_f_string_triples_increase_ - f_status_t f_string_triples_increase(const uint16_t step, f_string_triples_t * const triples) { + f_status_t f_string_triples_increase(const f_array_length_t step, f_string_triples_t * const triples) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!triples) return F_status_set_error(F_parameter); diff --git a/level_0/f_string/c/string/triple.h b/level_0/f_string/c/string/triple.h index 322cf29..b5c2570 100644 --- a/level_0/f_string/c/string/triple.h +++ b/level_0/f_string/c/string/triple.h @@ -192,7 +192,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_string_triples_increase_ - extern f_status_t f_string_triples_increase(const uint16_t step, f_string_triples_t * const triples); + extern f_status_t f_string_triples_increase(const f_array_length_t step, f_string_triples_t * const triples); #endif // _di_f_string_triples_increase_ /** diff --git a/level_0/f_thread/c/thread.c b/level_0/f_thread/c/thread.c index 6c49a98..2e58960 100644 --- a/level_0/f_thread/c/thread.c +++ b/level_0/f_thread/c/thread.c @@ -536,7 +536,7 @@ extern "C" { #endif // _di_f_thread_attributes_decrease_by_ #ifndef _di_f_thread_attributes_increase_ - f_status_t f_thread_attributes_increase(const uint16_t step, f_thread_attributes_t * const attributes) { + f_status_t f_thread_attributes_increase(const f_array_length_t step, f_thread_attributes_t * const attributes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!attributes) return F_status_set_error(F_parameter); @@ -688,7 +688,7 @@ extern "C" { #endif // _di_f_thread_barrier_attributes_decrease_by_ #ifndef _di_f_thread_barrier_attributes_increase_ - f_status_t f_thread_barrier_attributes_increase(const uint16_t step, f_thread_barrier_attributes_t * const attributes) { + f_status_t f_thread_barrier_attributes_increase(const f_array_length_t step, f_thread_barrier_attributes_t * const attributes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!attributes) return F_status_set_error(F_parameter); @@ -824,7 +824,7 @@ extern "C" { #endif // _di_f_thread_barriers_decrease_by_ #ifndef _di_f_thread_barriers_increase_ - f_status_t f_thread_barriers_increase(const uint16_t step, f_thread_barriers_t * const barriers) { + f_status_t f_thread_barriers_increase(const f_array_length_t step, f_thread_barriers_t * const barriers) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!barriers) return F_status_set_error(F_parameter); @@ -1072,7 +1072,7 @@ extern "C" { #endif // _di_f_thread_condition_attributes_decrease_by_ #ifndef _di_f_thread_condition_attributes_increase_ - f_status_t f_thread_condition_attributes_increase(const uint16_t step, f_thread_condition_attributes_t * const attributes) { + f_status_t f_thread_condition_attributes_increase(const f_array_length_t step, f_thread_condition_attributes_t * const attributes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!attributes) return F_status_set_error(F_parameter); @@ -1278,7 +1278,7 @@ extern "C" { #endif // _di_f_thread_conditions_decrease_by_ #ifndef _di_f_thread_conditions_increase_ - f_status_t f_thread_conditions_increase(const uint16_t step, f_thread_conditions_t * const conditions) { + f_status_t f_thread_conditions_increase(const f_array_length_t step, f_thread_conditions_t * const conditions) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!conditions) return F_status_set_error(F_parameter); @@ -1538,7 +1538,7 @@ extern "C" { #endif // _di_f_thread_keys_decrease_by_ #ifndef _di_f_thread_keys_increase_ - f_status_t f_thread_keys_increase(const uint16_t step, f_thread_keys_t * const keys) { + f_status_t f_thread_keys_increase(const f_array_length_t step, f_thread_keys_t * const keys) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!keys) return F_status_set_error(F_parameter); @@ -1698,7 +1698,7 @@ extern "C" { #endif // _di_f_thread_lock_attributes_decrease_by_ #ifndef _di_f_thread_lock_attributes_increase_ - f_status_t f_thread_lock_attributes_increase(const uint16_t step, f_thread_lock_attributes_t * const attributes) { + f_status_t f_thread_lock_attributes_increase(const f_array_length_t step, f_thread_lock_attributes_t * const attributes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!attributes) return F_status_set_error(F_parameter); @@ -1945,7 +1945,7 @@ extern "C" { #endif // _di_f_thread_locks_decrease_by_ #ifndef _di_f_thread_locks_increase_ - f_status_t f_thread_locks_increase(const uint16_t step, f_thread_locks_t * const locks) { + f_status_t f_thread_locks_increase(const f_array_length_t step, f_thread_locks_t * const locks) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!locks) return F_status_set_error(F_parameter); @@ -2217,7 +2217,7 @@ extern "C" { #endif // _di_f_thread_mutex_attributes_decrease_by_ #ifndef _di_f_thread_mutex_attributes_increase_ - f_status_t f_thread_mutex_attributes_increase(const uint16_t step, f_thread_mutex_attributes_t * const attributes) { + f_status_t f_thread_mutex_attributes_increase(const f_array_length_t step, f_thread_mutex_attributes_t * const attributes) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!attributes) return F_status_set_error(F_parameter); @@ -2648,7 +2648,7 @@ extern "C" { #endif // _di_f_thread_mutexs_decrease_by_ #ifndef _di_f_thread_mutexs_increase_ - f_status_t f_thread_mutexs_increase(const uint16_t step, f_thread_mutexs_t * const mutexs) { + f_status_t f_thread_mutexs_increase(const f_array_length_t step, f_thread_mutexs_t * const mutexs) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!mutexs) return F_status_set_error(F_parameter); @@ -2817,7 +2817,7 @@ extern "C" { #endif // _di_f_thread_semaphores_decrease_by_ #ifndef _di_f_thread_semaphores_increase_ - f_status_t f_thread_semaphores_increase(const uint16_t step, f_thread_semaphores_t * const semaphores) { + f_status_t f_thread_semaphores_increase(const f_array_length_t step, f_thread_semaphores_t * const semaphores) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!semaphores) return F_status_set_error(F_parameter); @@ -2911,7 +2911,7 @@ extern "C" { #endif // _di_f_thread_sets_decrease_by_ #ifndef _di_f_thread_sets_increase_ - f_status_t f_thread_sets_increase(const uint16_t step, f_thread_sets_t * const sets) { + f_status_t f_thread_sets_increase(const f_array_length_t step, f_thread_sets_t * const sets) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!sets) return F_status_set_error(F_parameter); @@ -3160,7 +3160,7 @@ extern "C" { #endif // _di_f_thread_spins_decrease_by_ #ifndef _di_f_thread_spins_increase_ - f_status_t f_thread_spins_increase(const uint16_t step, f_thread_spins_t * const spins) { + f_status_t f_thread_spins_increase(const f_array_length_t step, f_thread_spins_t * const spins) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!spins) return F_status_set_error(F_parameter); diff --git a/level_0/f_thread/c/thread.h b/level_0/f_thread/c/thread.h index f2c299c..86247ab 100644 --- a/level_0/f_thread/c/thread.h +++ b/level_0/f_thread/c/thread.h @@ -700,7 +700,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_attributes_increase_ - extern f_status_t f_thread_attributes_increase(const uint16_t step, f_thread_attributes_t * const attributes); + extern f_status_t f_thread_attributes_increase(const f_array_length_t step, f_thread_attributes_t * const attributes); #endif // _di_f_thread_attributes_increase_ /** @@ -915,7 +915,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_barrier_attributes_increase_ - extern f_status_t f_thread_barrier_attributes_increase(const uint16_t step, f_thread_barrier_attributes_t * const attributes); + extern f_status_t f_thread_barrier_attributes_increase(const f_array_length_t step, f_thread_barrier_attributes_t * const attributes); #endif // _di_f_thread_barrier_attributes_increase_ /** @@ -1108,7 +1108,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_barriers_increase_ - extern f_status_t f_thread_barriers_increase(const uint16_t step, f_thread_barriers_t * const barriers); + extern f_status_t f_thread_barriers_increase(const f_array_length_t step, f_thread_barriers_t * const barriers); #endif // _di_f_thread_barriers_increase_ /** @@ -1453,7 +1453,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_condition_attributes_increase_ - extern f_status_t f_thread_condition_attributes_increase(const uint16_t step, f_thread_condition_attributes_t * const attributes); + extern f_status_t f_thread_condition_attributes_increase(const f_array_length_t step, f_thread_condition_attributes_t * const attributes); #endif // _di_f_thread_condition_attributes_increase_ /** @@ -1722,7 +1722,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_conditions_increase_ - extern f_status_t f_thread_conditions_increase(const uint16_t step, f_thread_conditions_t * const conditions); + extern f_status_t f_thread_conditions_increase(const f_array_length_t step, f_thread_conditions_t * const conditions); #endif // _di_f_thread_conditions_increase_ /** @@ -2099,7 +2099,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_keys_increase_ - extern f_status_t f_thread_keys_increase(const uint16_t step, f_thread_keys_t * const keys); + extern f_status_t f_thread_keys_increase(const f_array_length_t step, f_thread_keys_t * const keys); #endif // _di_f_thread_keys_increase_ /** @@ -2315,7 +2315,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_lock_attributes_increase_ - extern f_status_t f_thread_lock_attributes_increase(const uint16_t step, f_thread_lock_attributes_t * const attributes); + extern f_status_t f_thread_lock_attributes_increase(const f_array_length_t step, f_thread_lock_attributes_t * const attributes); #endif // _di_f_thread_lock_attributes_increase_ /** @@ -2640,7 +2640,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_locks_increase_ - extern f_status_t f_thread_locks_increase(const uint16_t step, f_thread_locks_t * const locks); + extern f_status_t f_thread_locks_increase(const f_array_length_t step, f_thread_locks_t * const locks); #endif // _di_f_thread_locks_increase_ /** @@ -2981,7 +2981,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_mutex_attributes_increase_ - extern f_status_t f_thread_mutex_attributes_increase(const uint16_t step, f_thread_mutex_attributes_t * const attributes); + extern f_status_t f_thread_mutex_attributes_increase(const f_array_length_t step, f_thread_mutex_attributes_t * const attributes); #endif // _di_f_thread_mutex_attributes_increase_ /** @@ -3309,7 +3309,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_mutexs_increase_ - extern f_status_t f_thread_mutexs_increase(const uint16_t step, f_thread_mutexs_t * const mutexs); + extern f_status_t f_thread_mutexs_increase(const f_array_length_t step, f_thread_mutexs_t * const mutexs); #endif // _di_f_thread_mutexs_increase_ /** @@ -3785,7 +3785,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_semaphores_increase_ - extern f_status_t f_thread_semaphores_increase(const uint16_t step, f_thread_semaphores_t * const semaphores); + extern f_status_t f_thread_semaphores_increase(const f_array_length_t step, f_thread_semaphores_t * const semaphores); #endif // _di_f_thread_semaphores_increase_ /** @@ -3913,7 +3913,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_sets_increase_ - extern f_status_t f_thread_sets_increase(const uint16_t step, f_thread_sets_t * const sets); + extern f_status_t f_thread_sets_increase(const f_array_length_t step, f_thread_sets_t * const sets); #endif // _di_f_thread_sets_increase_ /** @@ -4233,7 +4233,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. */ #ifndef _di_f_thread_spins_increase_ - extern f_status_t f_thread_spins_increase(const uint16_t step, f_thread_spins_t * const spins); + extern f_status_t f_thread_spins_increase(const f_array_length_t step, f_thread_spins_t * const spins); #endif // _di_f_thread_spins_increase_ /** diff --git a/level_0/f_type_array/c/type_array/array_length.c b/level_0/f_type_array/c/type_array/array_length.c index 0316dc1..7697406 100644 --- a/level_0/f_type_array/c/type_array/array_length.c +++ b/level_0/f_type_array/c/type_array/array_length.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_array_lengths_decrease_by_ #ifndef _di_f_array_lengths_increase_ - f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths) { + f_status_t f_array_lengths_increase(const f_array_length_t step, f_array_lengths_t *lengths) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!lengths) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_array_lengthss_decrease_by_ #ifndef _di_f_array_lengthss_increase_ - f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss) { + f_status_t f_array_lengthss_increase(const f_array_length_t step, f_array_lengthss_t *lengthss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!lengthss) return F_status_set_error(F_parameter); diff --git a/level_0/f_type_array/c/type_array/array_length.h b/level_0/f_type_array/c/type_array/array_length.h index b735f62..013182d 100644 --- a/level_0/f_type_array/c/type_array/array_length.h +++ b/level_0/f_type_array/c/type_array/array_length.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_array_lengths_increase_ - extern f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths); + extern f_status_t f_array_lengths_increase(const f_array_length_t step, f_array_lengths_t *lengths); #endif // _di_f_array_lengths_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_array_lengthss_increase_ - extern f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss); + extern f_status_t f_array_lengthss_increase(const f_array_length_t step, f_array_lengthss_t *lengthss); #endif // _di_f_array_lengthss_increase_ /** 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 d47f130..75938dd 100644 --- a/level_0/f_type_array/c/type_array/cell.c +++ b/level_0/f_type_array/c/type_array/cell.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_cells_decrease_by_ #ifndef _di_f_cells_increase_ - f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells) { + f_status_t f_cells_increase(const f_array_length_t step, f_cells_t *cells) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!cells) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_cellss_decrease_by_ #ifndef _di_f_cellss_increase_ - f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss) { + f_status_t f_cellss_increase(const f_array_length_t step, f_cellss_t *cellss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!cellss) return F_status_set_error(F_parameter); 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 16b7232..8323e63 100644 --- a/level_0/f_type_array/c/type_array/cell.h +++ b/level_0/f_type_array/c/type_array/cell.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cells_increase_ - extern f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells); + extern f_status_t f_cells_increase(const f_array_length_t step, f_cells_t *cells); #endif // _di_f_cells_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_cellss_increase_ - extern f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss); + extern f_status_t f_cellss_increase(const f_array_length_t step, f_cellss_t *cellss); #endif // _di_f_cellss_increase_ /** 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 fa5c6c5..fa3cf8b 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 @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_fll_ids_decrease_by_ #ifndef _di_f_fll_ids_increase_ - f_status_t f_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids) { + f_status_t f_fll_ids_increase(const f_array_length_t step, f_fll_ids_t *ids) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!ids) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_fll_idss_decrease_by_ #ifndef _di_f_fll_idss_increase_ - f_status_t f_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss) { + f_status_t f_fll_idss_increase(const f_array_length_t step, f_fll_idss_t *idss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!idss) return F_status_set_error(F_parameter); 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 129e8cb..14cf1bd 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 @@ -123,7 +123,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 uint16_t step, f_fll_ids_t *ids); + extern f_status_t f_fll_ids_increase(const f_array_length_t step, f_fll_ids_t *ids); #endif // _di_f_fll_ids_increase_ /** @@ -300,7 +300,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 uint16_t step, f_fll_idss_t *idss); + extern f_status_t f_fll_idss_increase(const f_array_length_t step, f_fll_idss_t *idss); #endif // _di_f_fll_idss_increase_ /** 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 5f0b801..d2f2f26 100644 --- a/level_0/f_type_array/c/type_array/int128.c +++ b/level_0/f_type_array/c/type_array/int128.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_int128s_decrease_by_ #ifndef _di_f_int128s_increase_ - f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s) { + f_status_t f_int128s_increase(const f_array_length_t step, f_int128s_t *int128s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int128s) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_int128ss_decrease_by_ #ifndef _di_f_int128ss_increase_ - f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss) { + f_status_t f_int128ss_increase(const f_array_length_t step, f_int128ss_t *int128ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int128ss) return F_status_set_error(F_parameter); @@ -283,7 +283,7 @@ extern "C" { #endif // _di_f_uint128s_decrease_by_ #ifndef _di_f_uint128s_increase_ - f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s) { + f_status_t f_uint128s_increase(const f_array_length_t step, f_uint128s_t *uint128s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint128s) return F_status_set_error(F_parameter); @@ -401,7 +401,7 @@ extern "C" { #endif // _di_f_uint128ss_decrease_by_ #ifndef _di_f_uint128ss_increase_ - f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss) { + f_status_t f_uint128ss_increase(const f_array_length_t step, f_uint128ss_t *uint128ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint128ss) return F_status_set_error(F_parameter); 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 7c1527f..843773b 100644 --- a/level_0/f_type_array/c/type_array/int128.h +++ b/level_0/f_type_array/c/type_array/int128.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128s_increase_ - extern f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s); + extern f_status_t f_int128s_increase(const f_array_length_t step, f_int128s_t *int128s); #endif // _di_f_int128s_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int128ss_increase_ - extern f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss); + extern f_status_t f_int128ss_increase(const f_array_length_t step, f_int128ss_t *int128ss); #endif // _di_f_int128ss_increase_ /** @@ -455,7 +455,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128s_increase_ - extern f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s); + extern f_status_t f_uint128s_increase(const f_array_length_t step, f_uint128s_t *uint128s); #endif // _di_f_uint128s_increase_ /** @@ -632,7 +632,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint128ss_increase_ - extern f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss); + extern f_status_t f_uint128ss_increase(const f_array_length_t step, f_uint128ss_t *uint128ss); #endif // _di_f_uint128ss_increase_ /** 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 ab7d74f..d5f8857 100644 --- a/level_0/f_type_array/c/type_array/int16.c +++ b/level_0/f_type_array/c/type_array/int16.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_int16s_decrease_by_ #ifndef _di_f_int16s_increase_ - f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s) { + f_status_t f_int16s_increase(const f_array_length_t step, f_int16s_t *int16s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int16s) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_int16ss_decrease_by_ #ifndef _di_f_int16ss_increase_ - f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss) { + f_status_t f_int16ss_increase(const f_array_length_t step, f_int16ss_t *int16ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int16ss) return F_status_set_error(F_parameter); @@ -283,7 +283,7 @@ extern "C" { #endif // _di_f_uint16s_decrease_by_ #ifndef _di_f_uint16s_increase_ - f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s) { + f_status_t f_uint16s_increase(const f_array_length_t step, f_uint16s_t *uint16s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint16s) return F_status_set_error(F_parameter); @@ -401,7 +401,7 @@ extern "C" { #endif // _di_f_uint16ss_decrease_by_ #ifndef _di_f_uint16ss_increase_ - f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss) { + f_status_t f_uint16ss_increase(const f_array_length_t step, f_uint16ss_t *uint16ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint16ss) return F_status_set_error(F_parameter); 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 01ecf8b..dfb00af 100644 --- a/level_0/f_type_array/c/type_array/int16.h +++ b/level_0/f_type_array/c/type_array/int16.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16s_increase_ - extern f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s); + extern f_status_t f_int16s_increase(const f_array_length_t step, f_int16s_t *int16s); #endif // _di_f_int16s_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int16ss_increase_ - extern f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss); + extern f_status_t f_int16ss_increase(const f_array_length_t step, f_int16ss_t *int16ss); #endif // _di_f_int16ss_increase_ /** @@ -455,7 +455,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16s_increase_ - extern f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s); + extern f_status_t f_uint16s_increase(const f_array_length_t step, f_uint16s_t *uint16s); #endif // _di_f_uint16s_increase_ /** @@ -632,7 +632,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint16ss_increase_ - extern f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss); + extern f_status_t f_uint16ss_increase(const f_array_length_t step, f_uint16ss_t *uint16ss); #endif // _di_f_uint16ss_increase_ /** 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 1cc48dd..e1a98d6 100644 --- a/level_0/f_type_array/c/type_array/int32.c +++ b/level_0/f_type_array/c/type_array/int32.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_int32s_decrease_by_ #ifndef _di_f_int32s_increase_ - f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s) { + f_status_t f_int32s_increase(const f_array_length_t step, f_int32s_t *int32s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int32s) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_int32ss_decrease_by_ #ifndef _di_f_int32ss_increase_ - f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss) { + f_status_t f_int32ss_increase(const f_array_length_t step, f_int32ss_t *int32ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int32ss) return F_status_set_error(F_parameter); @@ -283,7 +283,7 @@ extern "C" { #endif // _di_f_uint32s_decrease_by_ #ifndef _di_f_uint32s_increase_ - f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s) { + f_status_t f_uint32s_increase(const f_array_length_t step, f_uint32s_t *uint32s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint32s) return F_status_set_error(F_parameter); @@ -401,7 +401,7 @@ extern "C" { #endif // _di_f_uint32ss_decrease_by_ #ifndef _di_f_uint32ss_increase_ - f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss) { + f_status_t f_uint32ss_increase(const f_array_length_t step, f_uint32ss_t *uint32ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint32ss) return F_status_set_error(F_parameter); 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 5e1fe91..ea6aa1d 100644 --- a/level_0/f_type_array/c/type_array/int32.h +++ b/level_0/f_type_array/c/type_array/int32.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32s_increase_ - extern f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s); + extern f_status_t f_int32s_increase(const f_array_length_t step, f_int32s_t *int32s); #endif // _di_f_int32s_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int32ss_increase_ - extern f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss); + extern f_status_t f_int32ss_increase(const f_array_length_t step, f_int32ss_t *int32ss); #endif // _di_f_int32ss_increase_ /** @@ -455,7 +455,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32s_increase_ - extern f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s); + extern f_status_t f_uint32s_increase(const f_array_length_t step, f_uint32s_t *uint32s); #endif // _di_f_uint32s_increase_ /** @@ -632,7 +632,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint32ss_increase_ - extern f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss); + extern f_status_t f_uint32ss_increase(const f_array_length_t step, f_uint32ss_t *uint32ss); #endif // _di_f_uint32ss_increase_ /** 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 a5bab9d..3568eb6 100644 --- a/level_0/f_type_array/c/type_array/int64.c +++ b/level_0/f_type_array/c/type_array/int64.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_int64s_decrease_by_ #ifndef _di_f_int64s_increase_ - f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s) { + f_status_t f_int64s_increase(const f_array_length_t step, f_int64s_t *int64s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int64s) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_int64ss_decrease_by_ #ifndef _di_f_int64ss_increase_ - f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss) { + f_status_t f_int64ss_increase(const f_array_length_t step, f_int64ss_t *int64ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int64ss) return F_status_set_error(F_parameter); @@ -283,7 +283,7 @@ extern "C" { #endif // _di_f_uint64s_decrease_by_ #ifndef _di_f_uint64s_increase_ - f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s) { + f_status_t f_uint64s_increase(const f_array_length_t step, f_uint64s_t *uint64s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint64s) return F_status_set_error(F_parameter); @@ -401,7 +401,7 @@ extern "C" { #endif // _di_f_uint64ss_decrease_by_ #ifndef _di_f_uint64ss_increase_ - f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss) { + f_status_t f_uint64ss_increase(const f_array_length_t step, f_uint64ss_t *uint64ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint64ss) return F_status_set_error(F_parameter); 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 0290d5b..5bcacc3 100644 --- a/level_0/f_type_array/c/type_array/int64.h +++ b/level_0/f_type_array/c/type_array/int64.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64s_increase_ - extern f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s); + extern f_status_t f_int64s_increase(const f_array_length_t step, f_int64s_t *int64s); #endif // _di_f_int64s_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int64ss_increase_ - extern f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss); + extern f_status_t f_int64ss_increase(const f_array_length_t step, f_int64ss_t *int64ss); #endif // _di_f_int64ss_increase_ /** @@ -455,7 +455,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64s_increase_ - extern f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s); + extern f_status_t f_uint64s_increase(const f_array_length_t step, f_uint64s_t *uint64s); #endif // _di_f_uint64s_increase_ /** @@ -632,7 +632,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint64ss_increase_ - extern f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss); + extern f_status_t f_uint64ss_increase(const f_array_length_t step, f_uint64ss_t *uint64ss); #endif // _di_f_uint64ss_increase_ /** 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 109f9a8..735d319 100644 --- a/level_0/f_type_array/c/type_array/int8.c +++ b/level_0/f_type_array/c/type_array/int8.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_int8s_decrease_by_ #ifndef _di_f_int8s_increase_ - f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s) { + f_status_t f_int8s_increase(const f_array_length_t step, f_int8s_t *int8s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int8s) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_int8ss_decrease_by_ #ifndef _di_f_int8ss_increase_ - f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss) { + f_status_t f_int8ss_increase(const f_array_length_t step, f_int8ss_t *int8ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!int8ss) return F_status_set_error(F_parameter); @@ -283,7 +283,7 @@ extern "C" { #endif // _di_f_uint8s_decrease_by_ #ifndef _di_f_uint8s_increase_ - f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s) { + f_status_t f_uint8s_increase(const f_array_length_t step, f_uint8s_t *uint8s) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint8s) return F_status_set_error(F_parameter); @@ -401,7 +401,7 @@ extern "C" { #endif // _di_f_uint8ss_decrease_by_ #ifndef _di_f_uint8ss_increase_ - f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss) { + f_status_t f_uint8ss_increase(const f_array_length_t step, f_uint8ss_t *uint8ss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!uint8ss) return F_status_set_error(F_parameter); 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 36bdf73..6163da3 100644 --- a/level_0/f_type_array/c/type_array/int8.h +++ b/level_0/f_type_array/c/type_array/int8.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8s_increase_ - extern f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s); + extern f_status_t f_int8s_increase(const f_array_length_t step, f_int8s_t *int8s); #endif // _di_f_int8s_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_int8ss_increase_ - extern f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss); + extern f_status_t f_int8ss_increase(const f_array_length_t step, f_int8ss_t *int8ss); #endif // _di_f_int8ss_increase_ /** @@ -455,7 +455,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8s_increase_ - extern f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s); + extern f_status_t f_uint8s_increase(const f_array_length_t step, f_uint8s_t *uint8s); #endif // _di_f_uint8s_increase_ /** @@ -632,7 +632,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_uint8ss_increase_ - extern f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss); + extern f_status_t f_uint8ss_increase(const f_array_length_t step, f_uint8ss_t *uint8ss); #endif // _di_f_uint8ss_increase_ /** 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 2e98e15..c6db12e 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 @@ -16,398 +16,14 @@ extern "C" { #endif /** - * Private implementation for resizing the statuss array. + * Private implementation for resizing the fll_ids array. * * Intended to be shared to each of the different implementation variations. * * @param length * The length to adjust to. - * @param statuss - * The statuss 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_statuss_adjust() - * @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_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_) - -/** - * Private implementation for appending the status array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source statuss to append. - * @param destination - * The destination statuss the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_statuss_append() - * @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_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_) - -/** - * Private implementation for resizing the statuss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param statuss - * The statuss 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_statuss_resize() - * @see f_statuss_append() - * @see f_statuss_decimate_by() - * @see f_statusss_append() - */ -#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_) - extern f_status_t private_f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_) - -/** - * Private implementation for resizing the statusss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param statusss - * The statusss 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_statusss_adjust() - * @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_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_) - -/** - * Private implementation for resizing the statusss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param statusss - * The statusss 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_statusss_decrease_by() - * @see f_statusss_increase() - * @see f_statusss_increase_by() - * @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_array_length_t length, f_statusss_t *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_) - -/** - * Private implementation for resizing the states array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param states - * The states 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_states_adjust() - * @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_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_) - -/** - * Private implementation for appending the state array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source states to append. - * @param destination - * The destination states the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_states_append() - * @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_states_t source, f_states_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_) - -/** - * Private implementation for resizing the states array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param states - * The states 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_states_resize() - * @see f_states_append() - * @see f_states_decimate_by() - * @see f_statess_append() - */ -#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_) - extern f_status_t private_f_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_) - -/** - * Private implementation for resizing the statess array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param statess - * The statess 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_statess_adjust() - * @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_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_) - -/** - * Private implementation for resizing the statess array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param statess - * The statess 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_statess_decrease_by() - * @see f_statess_increase() - * @see f_statess_increase_by() - * @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_array_length_t length, f_statess_t *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_) - -/** - * Private implementation for resizing the cells array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param cells - * The cells 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_cells_adjust() - * @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_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_) - -/** - * Private implementation for appending the cell array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source cells to append. - * @param destination - * The destination cells the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_cells_append() - * @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_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_) - -/** - * Private implementation for resizing the cells array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param cells - * The cells 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_cells_resize() - * @see f_cells_append() - * @see f_cells_decimate_by() - * @see f_cellss_append() - */ -#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_) - extern f_status_t private_f_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_) - -/** - * Private implementation for resizing the cellss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param cellss - * The cellss 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_cellss_adjust() - * @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_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_) - -/** - * Private implementation for resizing the cellss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param cellss - * The cellss 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_cellss_decrease_by() - * @see f_cellss_increase() - * @see f_cellss_increase_by() - * @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_array_length_t length, f_cellss_t *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_) - -/** - * Private implementation for resizing the ids array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param ids - * The ids array to adjust. + * @param fll_ids + * The fll_ids array to adjust. * * @return * F_none on success. @@ -419,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_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_) /** @@ -428,9 +44,9 @@ extern "C" { * Intended to be shared to each of the different implementation variations. * * @param source - * The source ids to append. + * The source fll_ids to append. * @param destination - * The destination ids the source is appended onto. + * The destination fll_ids the source is appended onto. * * @return * F_none on success. @@ -445,14 +61,14 @@ extern "C" { #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_) /** - * Private implementation for resizing the ids array. + * Private implementation for resizing the fll_ids array. * * Intended to be shared to each of the different implementation variations. * * @param length * The length to adjust to. - * @param ids - * The ids array to adjust. + * @param fll_ids + * The fll_ids array to adjust. * * @return * F_none on success. @@ -466,18 +82,18 @@ 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_decimate_by_) || !defined(_di_f_fll_idss_append_) - extern f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *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_decimate_by_) || !defined(_di_f_fll_idss_append_) /** - * Private implementation for resizing the idss array. + * Private implementation for resizing the fll_idss array. * * Intended to be shared to each of the different implementation variations. * * @param length * The length to adjust to. - * @param idss - * The idss array to adjust. + * @param fll_idss + * The fll_idss array to adjust. * * @return * F_none on success. @@ -494,18 +110,18 @@ 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_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d; #endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_) /** - * Private implementation for resizing the idss array. + * Private implementation for resizing the fll_idss array. * * Intended to be shared to each of the different implementation variations. * * @param length * The length to resize to. - * @param idss - * The idss array to resize. + * @param fll_idss + * The fll_idss array to resize. * * @return * F_none on success. @@ -524,1415 +140,8 @@ 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_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d; + extern f_status_t private_f_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *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_) -/** - * Private implementation for resizing the array_lengths array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param lengths - * The lengths 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_array_lengths_adjust() - * @see f_array_lengths_decimate_by() - */ -#if !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_) - extern f_status_t private_f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_) - -/** - * Private implementation for appending the array_length array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source array_lengths 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_array_lengths_append() - * @see f_array_lengthss_append() - */ -#if !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_) - extern f_status_t private_f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_) - -/** - * Private implementation for resizing the array_lengths array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param lengths - * The lengths 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_array_lengths_resize() - * @see f_array_lengths_append() - * @see f_array_lengths_decimate_by() - * @see f_array_lengthss_append() - */ -#if !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_) - extern f_status_t private_f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_) - -/** - * Private implementation for resizing the lengthss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param lengthss - * The lengthss 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_array_lengthss_adjust() - * @see f_array_lengthss_decimate_by() - */ -#if !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_) - extern f_status_t private_f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_) - -/** - * Private implementation for resizing the lengthss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param lengthss - * The lengthss 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_array_lengthss_decrease_by() - * @see f_array_lengthss_increase() - * @see f_array_lengthss_increase_by() - * @see f_array_lengthss_resize() - */ -#if !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_) - extern f_status_t private_f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_) - -/** - * Private implementation for resizing the int8s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int8s - * The int8s 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_int8s_adjust() - * @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_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_) - -/** - * Private implementation for appending the int8 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source int8s to append. - * @param destination - * The destination int8s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_int8s_append() - * @see f_int8ss_append() - */ -#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) - extern f_status_t private_f_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_) - -/** - * Private implementation for resizing the int8s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int8s - * The int8s 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_int8s_resize() - * @see f_int8s_append() - * @see f_int8s_decimate_by() - * @see f_int8ss_append() - */ -#if !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_) - extern f_status_t private_f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_) - -/** - * Private implementation for resizing the int8ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int8ss - * The int8ss 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_int8ss_adjust() - * @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_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_) - -/** - * Private implementation for resizing the int8ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param int8ss - * The int8ss 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_int8ss_decrease_by() - * @see f_int8ss_increase() - * @see f_int8ss_increase_by() - * @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_array_length_t length, f_int8ss_t *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_) - -/** - * Private implementation for resizing the uint8s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint8s - * The uint8s 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_uint8s_adjust() - * @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_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_) - -/** - * Private implementation for appending the uint8 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source uint8s to append. - * @param destination - * The destination uint8s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_uint8s_append() - * @see f_uint8ss_append() - */ -#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) - extern f_status_t private_f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_) - -/** - * Private implementation for resizing the uint8s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint8s - * The uint8s 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_uint8s_resize() - * @see f_uint8s_append() - * @see f_uint8s_decimate_by() - * @see f_uint8ss_append() - */ -#if !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_) - extern f_status_t private_f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_) - -/** - * Private implementation for resizing the uint8ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint8ss - * The uint8ss 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_uint8ss_adjust() - * @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_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_) - -/** - * Private implementation for resizing the uint8ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param uint8ss - * The uint8ss 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_uint8ss_decrease_by() - * @see f_uint8ss_increase() - * @see f_uint8ss_increase_by() - * @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_array_length_t length, f_uint8ss_t *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_) - -/** - * Private implementation for resizing the int16s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int16s - * The int16s 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_int16s_adjust() - * @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_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_) - -/** - * Private implementation for appending the int16 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source int16s to append. - * @param destination - * The destination int16s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_int16s_append() - * @see f_int16ss_append() - */ -#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) - extern f_status_t private_f_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_) - -/** - * Private implementation for resizing the int16s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int16s - * The int16s 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_int16s_resize() - * @see f_int16s_append() - * @see f_int16s_decimate_by() - * @see f_int16ss_append() - */ -#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_) - extern f_status_t private_f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_) - -/** - * Private implementation for resizing the int16ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int16ss - * The int16ss 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_int16ss_adjust() - * @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_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_) - -/** - * Private implementation for resizing the int16ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param int16ss - * The int16ss 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_int16ss_decrease_by() - * @see f_int16ss_increase() - * @see f_int16ss_increase_by() - * @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_array_length_t length, f_int16ss_t *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_) - -/** - * Private implementation for resizing the uint16s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint16s - * The uint16s 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_uint16s_adjust() - * @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_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_) - -/** - * Private implementation for appending the uint16 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source uint16s to append. - * @param destination - * The destination uint16s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_uint16s_append() - * @see f_uint16ss_append() - */ -#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) - extern f_status_t private_f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_) - -/** - * Private implementation for resizing the uint16s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint16s - * The uint16s 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_uint16s_resize() - * @see f_uint16s_append() - * @see f_uint16s_decimate_by() - * @see f_uint16ss_append() - */ -#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_) - extern f_status_t private_f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_) - -/** - * Private implementation for resizing the uint16ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint16ss - * The uint16ss 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_uint16ss_adjust() - * @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_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_) - -/** - * Private implementation for resizing the uint16ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param uint16ss - * The uint16ss 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_uint16ss_decrease_by() - * @see f_uint16ss_increase() - * @see f_uint16ss_increase_by() - * @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_array_length_t length, f_uint16ss_t *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_) - -/** - * Private implementation for resizing the int32s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int32s - * The int32s 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_int32s_adjust() - * @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_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_) - -/** - * Private implementation for appending the int32 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source int32s to append. - * @param destination - * The destination int32s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_int32s_append() - * @see f_int32ss_append() - */ -#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) - extern f_status_t private_f_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_) - -/** - * Private implementation for resizing the int32s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int32s - * The int32s 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_int32s_resize() - * @see f_int32s_append() - * @see f_int32s_decimate_by() - * @see f_int32ss_append() - */ -#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_) - extern f_status_t private_f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_) - -/** - * Private implementation for resizing the int32ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int32ss - * The int32ss 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_int32ss_adjust() - * @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_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_) - -/** - * Private implementation for resizing the int32ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param int32ss - * The int32ss 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_int32ss_decrease_by() - * @see f_int32ss_increase() - * @see f_int32ss_increase_by() - * @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_array_length_t length, f_int32ss_t *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_) - -/** - * Private implementation for resizing the uint32s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint32s - * The uint32s 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_uint32s_adjust() - * @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_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_) - -/** - * Private implementation for appending the uint32 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source uint32s to append. - * @param destination - * The destination uint32s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_uint32s_append() - * @see f_uint32ss_append() - */ -#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) - extern f_status_t private_f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_) - -/** - * Private implementation for resizing the uint32s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint32s - * The uint32s 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_uint32s_resize() - * @see f_uint32s_append() - * @see f_uint32s_decimate_by() - * @see f_uint32ss_append() - */ -#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_) - extern f_status_t private_f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_) - -/** - * Private implementation for resizing the uint32ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint32ss - * The uint32ss 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_uint32ss_adjust() - * @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_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_) - -/** - * Private implementation for resizing the uint32ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param uint32ss - * The uint32ss 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_uint32ss_decrease_by() - * @see f_uint32ss_increase() - * @see f_uint32ss_increase_by() - * @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_array_length_t length, f_uint32ss_t *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_) - -/** - * Private implementation for resizing the int64s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int64s - * The int64s 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_int64s_adjust() - * @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_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_) - -/** - * Private implementation for appending the int64 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source int64s to append. - * @param destination - * The destination int64s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_int64s_append() - * @see f_int64ss_append() - */ -#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) - extern f_status_t private_f_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_) - -/** - * Private implementation for resizing the int64s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int64s - * The int64s 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_int64s_resize() - * @see f_int64s_append() - * @see f_int64s_decimate_by() - * @see f_int64ss_append() - */ -#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_) - extern f_status_t private_f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_) - -/** - * Private implementation for resizing the int64ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int64ss - * The int64ss 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_int64ss_adjust() - * @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_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_) - -/** - * Private implementation for resizing the int64ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param int64ss - * The int64ss 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_int64ss_decrease_by() - * @see f_int64ss_increase() - * @see f_int64ss_increase_by() - * @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_array_length_t length, f_int64ss_t *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_) - -/** - * Private implementation for resizing the uint64s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint64s - * The uint64s 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_uint64s_adjust() - * @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_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_) - -/** - * Private implementation for appending the uint64 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source uint64s to append. - * @param destination - * The destination uint64s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_uint64s_append() - * @see f_uint64ss_append() - */ -#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) - extern f_status_t private_f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_) - -/** - * Private implementation for resizing the uint64s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint64s - * The uint64s 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_uint64s_resize() - * @see f_uint64s_append() - * @see f_uint64s_decimate_by() - * @see f_uint64ss_append() - */ -#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_) - extern f_status_t private_f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_) - -/** - * Private implementation for resizing the uint64ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint64ss - * The uint64ss 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_uint64ss_adjust() - * @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_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_) - -/** - * Private implementation for resizing the uint64ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param uint64ss - * The uint64ss 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_uint64ss_decrease_by() - * @see f_uint64ss_increase() - * @see f_uint64ss_increase_by() - * @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_array_length_t length, f_uint64ss_t *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_) - -/** - * Private implementation for resizing the int128s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int128s - * The int128s 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_int128s_adjust() - * @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_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_) - -/** - * Private implementation for appending the int128 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source int128s to append. - * @param destination - * The destination int128s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_int128s_append() - * @see f_int128ss_append() - */ -#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) - extern f_status_t private_f_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_) - -/** - * Private implementation for resizing the int128s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int128s - * The int128s 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_int128s_resize() - * @see f_int128s_append() - * @see f_int128s_decimate_by() - * @see f_int128ss_append() - */ -#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_) - extern f_status_t private_f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_) - -/** - * Private implementation for resizing the int128ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param int128ss - * The int128ss 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_int128ss_adjust() - * @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_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_) - -/** - * Private implementation for resizing the int128ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param int128ss - * The int128ss 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_int128ss_decrease_by() - * @see f_int128ss_increase() - * @see f_int128ss_increase_by() - * @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_array_length_t length, f_int128ss_t *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_) - -/** - * Private implementation for resizing the uint128s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint128s - * The uint128s 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_uint128s_adjust() - * @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_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_) - -/** - * Private implementation for appending the uint128 array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param source - * The source uint128s to append. - * @param destination - * The destination uint128s the source is appended onto. - * - * @return - * F_none on success. - * - * Errors (with error bit) from: f_memory_resize(). - * - * @see f_uint128s_append() - * @see f_uint128ss_append() - */ -#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) - extern f_status_t private_f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_) - -/** - * Private implementation for resizing the uint128s array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint128s - * The uint128s 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_uint128s_resize() - * @see f_uint128s_append() - * @see f_uint128s_decimate_by() - * @see f_uint128ss_append() - */ -#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_) - extern f_status_t private_f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_) - -/** - * Private implementation for resizing the uint128ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to adjust to. - * @param uint128ss - * The uint128ss 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_uint128ss_adjust() - * @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_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_) - -/** - * Private implementation for resizing the uint128ss array. - * - * Intended to be shared to each of the different implementation variations. - * - * @param length - * The length to resize to. - * @param uint128ss - * The uint128ss 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_uint128ss_decrease_by() - * @see f_uint128ss_increase() - * @see f_uint128ss_increase_by() - * @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_array_length_t length, f_uint128ss_t *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 } // extern "C" 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 2273223..9aa700e 100644 --- a/level_0/f_type_array/c/type_array/state.c +++ b/level_0/f_type_array/c/type_array/state.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_states_decrease_by_ #ifndef _di_f_states_increase_ - f_status_t f_states_increase(const uint16_t step, f_states_t *states) { + f_status_t f_states_increase(const f_array_length_t step, f_states_t *states) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!states) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_statess_decrease_by_ #ifndef _di_f_statess_increase_ - f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess) { + f_status_t f_statess_increase(const f_array_length_t step, f_statess_t *statess) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!statess) return F_status_set_error(F_parameter); 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 223fd80..ddd1cb1 100644 --- a/level_0/f_type_array/c/type_array/state.h +++ b/level_0/f_type_array/c/type_array/state.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_states_increase_ - extern f_status_t f_states_increase(const uint16_t step, f_states_t *states); + extern f_status_t f_states_increase(const f_array_length_t step, f_states_t *states); #endif // _di_f_states_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statess_increase_ - extern f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess); + extern f_status_t f_statess_increase(const f_array_length_t step, f_statess_t *statess); #endif // _di_f_statess_increase_ /** 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 4c911d1..d5ed45b 100644 --- a/level_0/f_type_array/c/type_array/status.c +++ b/level_0/f_type_array/c/type_array/status.c @@ -59,7 +59,7 @@ extern "C" { #endif // _di_f_statuss_decrease_by_ #ifndef _di_f_statuss_increase_ - f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss) { + f_status_t f_statuss_increase(const f_array_length_t step, f_statuss_t *statuss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!statuss) return F_status_set_error(F_parameter); @@ -177,7 +177,7 @@ extern "C" { #endif // _di_f_statusss_decrease_by_ #ifndef _di_f_statusss_increase_ - f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss) { + f_status_t f_statusss_increase(const f_array_length_t step, f_statusss_t *statusss) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!statusss) return F_status_set_error(F_parameter); 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 7f743e3..ff25306 100644 --- a/level_0/f_type_array/c/type_array/status.h +++ b/level_0/f_type_array/c/type_array/status.h @@ -123,7 +123,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statuss_increase_ - extern f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss); + extern f_status_t f_statuss_increase(const f_array_length_t step, f_statuss_t *statuss); #endif // _di_f_statuss_increase_ /** @@ -300,7 +300,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_statusss_increase_ - extern f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss); + extern f_status_t f_statusss_increase(const f_array_length_t step, f_statusss_t *statusss); #endif // _di_f_statusss_increase_ /** diff --git a/level_0/f_utf/c/utf/dynamic.c b/level_0/f_utf/c/utf/dynamic.c index 672fe3f..c856ccb 100644 --- a/level_0/f_utf/c/utf/dynamic.c +++ b/level_0/f_utf/c/utf/dynamic.c @@ -158,7 +158,7 @@ extern "C" { #endif // _di_f_utf_string_dynamic_decrease_by_ #ifndef _di_f_utf_string_dynamic_increase_ - f_status_t f_utf_string_dynamic_increase(const uint16_t step, f_utf_string_dynamic_t *dynamic) { + f_status_t f_utf_string_dynamic_increase(const f_array_length_t step, f_utf_string_dynamic_t *dynamic) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!dynamic) return F_status_set_error(F_parameter); @@ -938,7 +938,7 @@ extern "C" { #endif // _di_f_utf_string_dynamics_decrease_by_ #ifndef _di_f_utf_string_dynamics_increase_ - f_status_t f_utf_string_dynamics_increase(const uint16_t step, f_utf_string_dynamics_t *dynamics) { + f_status_t f_utf_string_dynamics_increase(const f_array_length_t step, f_utf_string_dynamics_t *dynamics) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!dynamics) return F_status_set_error(F_parameter); diff --git a/level_0/f_utf/c/utf/dynamic.h b/level_0/f_utf/c/utf/dynamic.h index eb44ac2b6..d29e4d7 100644 --- a/level_0/f_utf/c/utf/dynamic.h +++ b/level_0/f_utf/c/utf/dynamic.h @@ -303,7 +303,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_utf_string_dynamic_increase_ - extern f_status_t f_utf_string_dynamic_increase(const uint16_t step, f_utf_string_dynamic_t *dynamic); + extern f_status_t f_utf_string_dynamic_increase(const f_array_length_t step, f_utf_string_dynamic_t *dynamic); #endif // _di_f_utf_string_dynamic_increase_ /** @@ -1135,7 +1135,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_utf_string_dynamics_increase_ - extern f_status_t f_utf_string_dynamics_increase(const uint16_t step, f_utf_string_dynamics_t *dynamics); + extern f_status_t f_utf_string_dynamics_increase(const f_array_length_t step, f_utf_string_dynamics_t *dynamics); #endif // _di_f_utf_string_dynamics_increase_ /** diff --git a/level_0/f_utf/c/utf/map.c b/level_0/f_utf/c/utf/map.c index 16bc6d8..9f71496 100644 --- a/level_0/f_utf/c/utf/map.c +++ b/level_0/f_utf/c/utf/map.c @@ -80,7 +80,7 @@ extern "C" { #endif // _di_f_utf_string_map_multis_decrease_by_ #ifndef _di_f_utf_string_map_multis_increase_ - f_status_t f_utf_string_map_multis_increase(const uint16_t step, f_utf_string_map_multis_t *map_multis) { + f_status_t f_utf_string_map_multis_increase(const f_array_length_t step, f_utf_string_map_multis_t *map_multis) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!map_multis) return F_status_set_error(F_parameter); @@ -209,7 +209,7 @@ extern "C" { #endif // _di_f_utf_string_maps_decrease_by_ #ifndef _di_f_utf_string_maps_increase_ - f_status_t f_utf_string_maps_increase(const uint16_t step, f_utf_string_maps_t *maps) { + f_status_t f_utf_string_maps_increase(const f_array_length_t step, f_utf_string_maps_t *maps) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!maps) return F_status_set_error(F_parameter); diff --git a/level_0/f_utf/c/utf/map.h b/level_0/f_utf/c/utf/map.h index 0961346..6456177 100644 --- a/level_0/f_utf/c/utf/map.h +++ b/level_0/f_utf/c/utf/map.h @@ -240,7 +240,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_utf_string_map_multis_increase_ - extern f_status_t f_utf_string_map_multis_increase(const uint16_t step, f_utf_string_map_multis_t *map_multis); + extern f_status_t f_utf_string_map_multis_increase(const f_array_length_t step, f_utf_string_map_multis_t *map_multis); #endif // _di_f_utf_string_map_multis_increase_ /** @@ -395,7 +395,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_utf_string_maps_increase_ - extern f_status_t f_utf_string_maps_increase(const uint16_t step, f_utf_string_maps_t *maps); + extern f_status_t f_utf_string_maps_increase(const f_array_length_t step, f_utf_string_maps_t *maps); #endif // _di_f_utf_string_maps_increase_ /** diff --git a/level_0/f_utf/c/utf/triple.c b/level_0/f_utf/c/utf/triple.c index 0be2923..ddcd5b7 100644 --- a/level_0/f_utf/c/utf/triple.c +++ b/level_0/f_utf/c/utf/triple.c @@ -90,7 +90,7 @@ extern "C" { #endif // _di_f_utf_string_triples_decrease_by_ #ifndef _di_f_utf_string_triples_increase_ - f_status_t f_utf_string_triples_increase(const uint16_t step, f_utf_string_triples_t *triples) { + f_status_t f_utf_string_triples_increase(const f_array_length_t step, f_utf_string_triples_t *triples) { #ifndef _di_level_0_parameter_checking_ if (!step) return F_status_set_error(F_parameter); if (!triples) return F_status_set_error(F_parameter); diff --git a/level_0/f_utf/c/utf/triple.h b/level_0/f_utf/c/utf/triple.h index 77e1355..5871a57 100644 --- a/level_0/f_utf/c/utf/triple.h +++ b/level_0/f_utf/c/utf/triple.h @@ -192,7 +192,7 @@ extern "C" { * Errors (with error bit) from: f_memory_resize(). */ #ifndef _di_f_utf_string_triples_increase_ - extern f_status_t f_utf_string_triples_increase(const uint16_t step, f_utf_string_triples_t *triples); + extern f_status_t f_utf_string_triples_increase(const f_array_length_t step, f_utf_string_triples_t *triples); #endif // _di_f_utf_string_triples_increase_ /** diff --git a/level_1/fl_iki/c/iki.c b/level_1/fl_iki/c/iki.c index 676d7b8..08ffd6f 100644 --- a/level_1/fl_iki/c/iki.c +++ b/level_1/fl_iki/c/iki.c @@ -5,7 +5,7 @@ extern "C" { #endif #ifndef _di_fl_iki_read_ - f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits) { + f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data) { #ifndef _di_level_1_parameter_checking_ if (!buffer) return F_status_set_error(F_parameter); if (!range) return F_status_set_error(F_parameter); @@ -14,7 +14,7 @@ extern "C" { f_status_t status = F_none; do { - status = f_iki_read(state, buffer, range, variable, vocabulary, content, delimits); + status = f_iki_read(state, buffer, range, data); if (F_status_is_error(status)) return status; if (status == F_data_not_eos || status == F_data_not_stop) { diff --git a/level_1/fl_iki/c/iki.h b/level_1/fl_iki/c/iki.h index 09c8aae..385f2f2 100644 --- a/level_1/fl_iki/c/iki.h +++ b/level_1/fl_iki/c/iki.h @@ -51,14 +51,8 @@ extern "C" { * The start location will be updated as the buffer is being processed. * The start location will represent where the read stopped on return. * A start location past the stop location or buffer used means that the entire range was processed. - * @param variable - * The entire vocabulary name, content, and syntax. - * @param vocabulary - * The vocabulary name list to store the found vocabulary names. - * @param content - * The content list to store the content associated with the found vocabulary names. - * @param delimits - * A delimits array representing where delimits exist within the buffer. + * @param data + * The IKI data. * * @return * F_none on success and an IKI vocabulary name was found. @@ -75,7 +69,7 @@ extern "C" { * @see f_iki_read() */ #ifndef _di_fl_iki_read_ - extern f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits); + extern f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data); #endif // _di_fl_iki_read_ #ifdef __cplusplus diff --git a/level_3/fake/c/private-make-operate.c b/level_3/fake/c/private-make-operate.c index 95d76e0..2abbe5a 100644 --- a/level_3/fake/c/private-make-operate.c +++ b/level_3/fake/c/private-make-operate.c @@ -160,10 +160,7 @@ extern "C" { const f_string_range_t range_define = macro_f_string_range_t_initialize(F_iki_vocabulary_0002_define_s_length); const f_string_range_t range_parameter = macro_f_string_range_t_initialize(F_iki_vocabulary_0002_parameter_s_length); - f_iki_variable_t iki_variable = f_iki_variable_t_initialize; - f_iki_vocabulary_t iki_vocabulary = f_iki_vocabulary_t_initialize; - f_iki_content_t iki_content = f_iki_content_t_initialize; - f_iki_delimits_t iki_delimits = f_iki_delimits_t_initialize; + f_iki_data_t iki_data = f_iki_data_t_initialize; f_state_t state = macro_f_state_t_initialize(fake_common_allocation_large_d, fake_common_allocation_small_d, 0, &fake_signal_state_interrupt_iki, 0, (void *) data_make->main, 0); @@ -260,7 +257,7 @@ extern "C" { range = content.array[i]; - *status = fl_iki_read(state, &data_make->buffer, &range, &iki_variable, &iki_vocabulary, &iki_content, &iki_delimits); + *status = fl_iki_read(state, &data_make->buffer, &range, &iki_data); if (F_status_is_error(*status)) { if (F_status_set_fine(*status) != F_interrupt) { @@ -271,17 +268,17 @@ extern "C" { } // Apply the IKI delimits to the buffer. - for (j = 0; j < iki_delimits.used; ++j) { - data_make->buffer.string[iki_delimits.array[j]] = f_iki_syntax_placeholder_s.string[0]; + for (j = 0; j < iki_data.delimits.used; ++j) { + data_make->buffer.string[iki_data.delimits.array[j]] = f_iki_syntax_placeholder_s.string[0]; } // for - if (iki_variable.used) { + if (iki_data.variable.used) { used_content = arguments->array[arguments->used].used; // Copy everything up to the start of the first IKI variable. - if (iki_variable.array[0].start && content.array[i].start < iki_variable.array[0].start) { + if (iki_data.variable.array[0].start && content.array[i].start < iki_data.variable.array[0].start) { range.start = content.array[i].start; - range.stop = iki_variable.array[0].start - 1; + range.stop = iki_data.variable.array[0].start - 1; *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]); @@ -292,23 +289,23 @@ extern "C" { } } - for (j = 0; j < iki_variable.used; ++j) { + for (j = 0; j < iki_data.variable.used; ++j) { is = 0; - *status = fl_string_dynamic_partial_compare(vocabulary_define, data_make->buffer, range_define, iki_vocabulary.array[j]); + *status = fl_string_dynamic_partial_compare(vocabulary_define, data_make->buffer, range_define, iki_data.vocabulary.array[j]); if (*status == F_equal_to) { is = 2; } else if (*status == F_equal_to_not) { - *status = fl_string_dynamic_partial_compare(vocabulary_parameter, data_make->buffer, range_parameter, iki_vocabulary.array[j]); + *status = fl_string_dynamic_partial_compare(vocabulary_parameter, data_make->buffer, range_parameter, iki_data.vocabulary.array[j]); if (*status == F_equal_to) { is = 1; } else if (*status == F_equal_to_not) { - *status = fl_string_dynamic_partial_compare(vocabulary_context, data_make->buffer, range_context, iki_vocabulary.array[j]); + *status = fl_string_dynamic_partial_compare(vocabulary_context, data_make->buffer, range_context, iki_data.vocabulary.array[j]); if (*status == F_equal_to) { is = 3; @@ -326,7 +323,7 @@ extern "C" { unmatched = F_true; // Check against reserved parameter names and if matches use them instead. - if (fl_string_dynamic_partial_compare_string(fake_make_parameter_variable_return_s.string, data_make->buffer, fake_make_parameter_variable_return_s.used, iki_content.array[j]) == F_equal_to) { + if (fl_string_dynamic_partial_compare_string(fake_make_parameter_variable_return_s.string, data_make->buffer, fake_make_parameter_variable_return_s.used, iki_data.content.array[j]) == F_equal_to) { if (data_make->setting_make.parameter.array[0].value.array[0].used) { *status = f_string_dynamic_append_nulless(data_make->setting_make.parameter.array[0].value.array[0], &arguments->array[arguments->used]); @@ -351,7 +348,7 @@ extern "C" { else { for (k = 0; k < 33; ++k) { - if (fl_string_dynamic_partial_compare_string(reserved_name[k].string, data_make->buffer, reserved_name[k].used, iki_content.array[j]) != F_equal_to) { + if (fl_string_dynamic_partial_compare_string(reserved_name[k].string, data_make->buffer, reserved_name[k].used, iki_data.content.array[j]) != F_equal_to) { continue; } @@ -398,7 +395,7 @@ extern "C" { for (k = 0; k < parameter->used; ++k) { // Check against IKI variable list. - *status = fl_string_dynamic_partial_compare_dynamic(parameter->array[k].name, data_make->buffer, iki_content.array[j]); + *status = fl_string_dynamic_partial_compare_dynamic(parameter->array[k].name, data_make->buffer, iki_data.content.array[j]); if (*status == F_equal_to) { unmatched = F_false; @@ -461,7 +458,7 @@ extern "C" { if (F_status_is_error(*status)) break; if (unmatched) { - *status = fake_make_operate_expand_build(data_make, quotes.array[i], iki_content.array[j], arguments); + *status = fake_make_operate_expand_build(data_make, quotes.array[i], iki_data.content.array[j], arguments); if (F_status_is_error(*status)) { fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_build", F_true); @@ -472,7 +469,7 @@ extern "C" { } else if (is == 2) { if (data_make->setting_make.load_build) { - *status = fake_make_operate_expand_environment(data_make, quotes.array[i], iki_content.array[j], arguments); + *status = fake_make_operate_expand_environment(data_make, quotes.array[i], iki_data.content.array[j], arguments); if (F_status_is_error(*status)) { fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_environment", F_true); @@ -482,7 +479,7 @@ extern "C" { } } else if (is == 3) { - *status = fake_make_operate_expand_context(data_make, quotes.array[i], iki_content.array[j], arguments); + *status = fake_make_operate_expand_context(data_make, quotes.array[i], iki_data.content.array[j], arguments); if (F_status_is_error(*status)) { fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_context", F_true); @@ -492,10 +489,10 @@ extern "C" { } // Make sure to copy and content between multiple IKI variables within the same content. - if (j + 1 < iki_variable.used) { - if (iki_variable.array[j].stop + 1 < iki_variable.array[j + 1].start && iki_variable.array[j + 1].stop <= content.array[i].stop) { - range.start = iki_variable.array[j].stop + 1; - range.stop = iki_variable.array[j + 1].start - 1; + if (j + 1 < iki_data.variable.used) { + if (iki_data.variable.array[j].stop + 1 < iki_data.variable.array[j + 1].start && iki_data.variable.array[j + 1].stop <= content.array[i].stop) { + range.start = iki_data.variable.array[j].stop + 1; + range.stop = iki_data.variable.array[j + 1].start - 1; *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]); @@ -509,8 +506,8 @@ extern "C" { } // for // Copy everything after the last IKI variable to the end of the content. - if (iki_variable.used && content.array[i].stop > iki_variable.array[iki_variable.used - 1].stop) { - range.start = iki_variable.array[iki_variable.used - 1].stop + 1; + if (iki_data.variable.used && content.array[i].stop > iki_data.variable.array[iki_data.variable.used - 1].stop) { + range.start = iki_data.variable.array[iki_data.variable.used - 1].stop + 1; range.stop = content.array[i].stop; *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]); @@ -539,16 +536,10 @@ extern "C" { ++arguments->used; } - macro_f_iki_variable_t_delete_simple(iki_variable); - macro_f_iki_vocabulary_t_delete_simple(iki_vocabulary); - macro_f_iki_content_t_delete_simple(iki_content); - macro_f_iki_delimits_t_delete_simple(iki_delimits); + f_iki_data_delete(&iki_data); } // for - macro_f_iki_variable_t_delete_simple(iki_variable); - macro_f_iki_vocabulary_t_delete_simple(iki_vocabulary); - macro_f_iki_content_t_delete_simple(iki_content); - macro_f_iki_delimits_t_delete_simple(iki_delimits); + f_iki_data_delete(&iki_data); } #endif // _di_fake_make_operate_expand_ diff --git a/level_3/iki_read/c/private-common.h b/level_3/iki_read/c/private-common.h index 3ca90d2..97a8d17 100644 --- a/level_3/iki_read/c/private-common.h +++ b/level_3/iki_read/c/private-common.h @@ -25,38 +25,6 @@ extern "C" { #endif // _di_iki_read_common_ /** - * Provide a structure for containing processed IKI data. - * - * variable: The variable ranges. - * vocabulary: The vocabulary ranges. - * content: The content ranges. - * delimits: The delimited locations. - */ -#ifndef _di_iki_data_ - typedef struct { - f_iki_variable_t variable; - f_iki_vocabulary_t vocabulary; - f_iki_content_t content; - f_iki_delimits_t delimits; - } iki_data_t; - - #define iki_data_t_initialize \ - { \ - f_iki_variable_t_initialize, \ - f_iki_vocabulary_t_initialize, \ - f_iki_content_t_initialize, \ - f_iki_delimits_t_initialize, \ - } - - #define macro_iki_data_t_delete_simple(data) \ - macro_f_iki_variable_t_delete_simple(data.variable) \ - macro_f_iki_vocabulary_t_delete_simple(data.vocabulary) \ - macro_f_iki_content_t_delete_simple(data.content) \ - macro_f_iki_delimits_t_delete_simple(data.delimits) - -#endif // _di_iki_data_ - -/** * Print a message about a process signal being recieved, such as an interrupt signal. * * @param main diff --git a/level_3/iki_read/c/private-print.c b/level_3/iki_read/c/private-print.c index a268364..eabeb71 100644 --- a/level_3/iki_read/c/private-print.c +++ b/level_3/iki_read/c/private-print.c @@ -7,7 +7,7 @@ extern "C" { #endif #ifndef _di_iki_read_substitutions_print_ - void iki_read_substitutions_print(iki_read_main_t * const main, const iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) { + void iki_read_substitutions_print(iki_read_main_t * const main, const f_iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) { f_status_t status = F_none; f_array_length_t i = 0; diff --git a/level_3/iki_read/c/private-print.h b/level_3/iki_read/c/private-print.h index bda54fb..205ffe8 100644 --- a/level_3/iki_read/c/private-print.h +++ b/level_3/iki_read/c/private-print.h @@ -30,7 +30,7 @@ extern "C" { * Set to FALSE to print the entire variable when printing substituted text. */ #ifndef _di_iki_read_substitutions_print_ - extern void iki_read_substitutions_print(iki_read_main_t * const main, const iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) F_attribute_visibility_internal_d; + extern void iki_read_substitutions_print(iki_read_main_t * const main, const f_iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) F_attribute_visibility_internal_d; #endif // _di_iki_read_substitutions_print_ #ifdef __cplusplus diff --git a/level_3/iki_read/c/private-read.c b/level_3/iki_read/c/private-read.c index 7e3b3a8..f126463 100644 --- a/level_3/iki_read/c/private-read.c +++ b/level_3/iki_read/c/private-read.c @@ -39,7 +39,7 @@ extern "C" { f_status_t iki_read_process_buffer(iki_read_main_t * const main) { f_status_t status = F_none; - iki_data_t iki_data = iki_data_t_initialize; + f_iki_data_t iki_data = f_iki_data_t_initialize; if (main->parameters.array[iki_read_parameter_whole_e].result == f_console_result_found_e) { f_string_range_t buffer_range = macro_f_string_range_t_initialize(main->buffer.used); @@ -74,7 +74,7 @@ extern "C" { status = iki_read_process_at(main, &buffer_range); if (status == F_true && buffer_range.start > main->buffer.used || status == F_data_not) { - macro_iki_data_t_delete_simple(iki_data); + f_iki_data_delete(&iki_data); return F_data_not; } @@ -90,14 +90,14 @@ extern "C" { } } - macro_iki_data_t_delete_simple(iki_data); + f_iki_data_delete(&iki_data); return status; } #endif // _di_iki_read_process_buffer_ #ifndef _di_iki_read_process_buffer_ranges_ - f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) { + f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) { f_status_t status = F_none; @@ -106,7 +106,7 @@ extern "C" { { f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0); - status = fl_iki_read(state, &main->buffer, buffer_range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits); + status = fl_iki_read(state, &main->buffer, buffer_range, iki_data); } if (F_status_is_error(status)) { @@ -259,7 +259,7 @@ extern "C" { #endif // _di_iki_read_process_buffer_ranges_ #ifndef _di_iki_read_process_buffer_ranges_whole_ - f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) { + f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) { f_status_t status = F_none; f_string_range_t range = buffer_range; @@ -267,7 +267,7 @@ extern "C" { { f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0); - status = fl_iki_read(state, &main->buffer, &range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits); + status = fl_iki_read(state, &main->buffer, &range, iki_data); } if (F_status_is_error(status)) { @@ -451,7 +451,7 @@ extern "C" { #endif // _di_iki_read_process_buffer_ranges_whole_ #ifndef _di_iki_read_process_buffer_total_ - f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, iki_data_t *iki_data) { + f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, f_iki_data_t *iki_data) { f_status_t status = F_none; f_string_range_t range = macro_f_string_range_t_initialize(main->buffer.used); @@ -474,7 +474,7 @@ extern "C" { { f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0); - status = fl_iki_read(state, &main->buffer, &range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits); + status = fl_iki_read(state, &main->buffer, &range, iki_data); } if (F_status_is_error(status)) { diff --git a/level_3/iki_read/c/private-read.h b/level_3/iki_read/c/private-read.h index 71348e5..1c87a43 100644 --- a/level_3/iki_read/c/private-read.h +++ b/level_3/iki_read/c/private-read.h @@ -70,7 +70,7 @@ extern "C" { * Status codes (with error bit) are returned on any problem. */ #ifndef _di_iki_read_process_buffer_ranges_ - extern f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d; + extern f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d; #endif // _di_iki_read_process_buffer_ranges_ /** @@ -95,7 +95,7 @@ extern "C" { * Status codes (with error bit) are returned on any problem. */ #ifndef _di_iki_read_process_buffer_ranges_whole_ - extern f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d; + extern f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d; #endif // _di_iki_read_process_buffer_ranges_whole_ /** @@ -112,7 +112,7 @@ extern "C" { * Status codes (with error bit) are returned on any problem. */ #ifndef _di_iki_read_process_buffer_total_ - extern f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, iki_data_t *iki_data) F_attribute_visibility_internal_d; + extern f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, f_iki_data_t *iki_data) F_attribute_visibility_internal_d; #endif // _di_iki_read_process_buffer_total_ /** -- 1.8.3.1