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.
/**
* 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.
* 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
#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.
* 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
#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.
#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);
#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);
* 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;
#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.
* 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_
/**
* 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_
/**
#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);
#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);
#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);
* 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;
#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.
* 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;
#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.
* 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;
#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.
* 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;
#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.
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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;
#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.
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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) {
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;
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;
}
} // while
if (F_status_is_error(status)) {
- delimits->used = delimits_used;
+ data->delimits.used = delimits_used;
return status;
}
// 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;
++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;
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;
}
// 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;
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;
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;
}
if (F_status_is_error(status)) {
- delimits->used = delimits_used;
+ data->delimits.used = delimits_used;
return status;
}
* 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.
* 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
#include "../iki.h"
+#include "../private-iki.h"
#ifdef __cplusplus
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);
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"
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"
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"
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.
* 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
#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.
* 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
#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.
* 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
#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.
* 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
#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.
* 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
#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.
#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
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) {
#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.
#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);
* @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_
/**
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
* 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_
/**
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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);
#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);
#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);
#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);
* 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_
/**
* 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_
/**
* 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_
/**
* 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_
/**
#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.
* @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_)
/**
* 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.
#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.
* @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.
* @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.
* @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"
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
#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);
* 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_
/**
* 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_
/**
#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);
* 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_
/**
#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);
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) {
* 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.
* @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
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);
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) {
}
// 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]);
}
}
- 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;
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]);
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;
}
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;
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);
}
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);
}
}
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);
}
// 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]);
} // 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]);
++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_
#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
#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;
* 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
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);
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;
}
}
}
- 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;
{
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)) {
#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;
{
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)) {
#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);
{
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)) {
* 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_
/**
* 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_
/**
* 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_
/**
projects / fll / commitdiff