f_string_dynamic_t shell;
} f_account_t;
- #define f_account_t_initialize { 0, 0, f_string_dynamic_t_initialize, f_string_dynamic_t_initialize, f_string_dynamic_t_initialize, f_string_dynamic_t_initialize, f_string_dynamic_t_initialize }
+ #define f_account_t_initialize { \
+ 0, \
+ 0, \
+ f_string_dynamic_t_initialize, \
+ f_string_dynamic_t_initialize, \
+ f_string_dynamic_t_initialize, \
+ f_string_dynamic_t_initialize, \
+ f_string_dynamic_t_initialize \
+ }
#define macro_f_account_t_clear(account) \
account.id_user = 0; \
#define f_accounts_t_initialize { 0, 0, 0 }
+ #define macro_f_accounts_t_initialize(content, size, used) { array, size, used }
+ #define macro_f_accounts_t_initialize2(array, length) { array, length, length }
+
#define macro_f_accounts_t_clear(accounts) macro_f_memory_structure_clear(accounts)
#define macro_f_string_accounts_t_resize(status, accounts, length) macro_f_memory_structure_resize(status, values, sizeof(f_account_t), length)
f_color_string_medium_s \
}
+ #define macro_f_color_format_t_initialize(begin, end, medium) { begin, end, medium }
+
#define macro_f_color_format_t_clear(format) \
macro_f_string_static_t_clear(format.begin) \
macro_f_string_static_t_clear(format.end) \
typedef uint16_t f_console_parameter_id_t;
#define f_console_parameter_id_t_initialize 0
+
+ #define macro_f_console_parameter_id_t_initialize(id) id
#endif // _di_f_console_parameter_id_t_
/**
#define f_control_group_t_initialize { F_false, f_string_dynamic_t_initialize, f_string_dynamics_t_initialize }
+ #define macro_f_control_group_t_initialize(as_new, path, groups) { as_new, path, groups }
+
#define macro_f_control_group_t_clear(control) \
control.as_new = F_false; \
macro_f_string_dynamic_t_clear(control.path); \
f_string_dynamics_t_initialize, \
}
+ #define macro_f_directory_listing_t_initialize(block, character, directory, regular, link, fifo, socket, unknown) { \
+ block, \
+ character, \
+ directory, \
+ regular, \
+ link, \
+ fifo, \
+ socket, \
+ unknown, \
+ }
+
#define macro_f_directory_listing_t_delete_simple(listing) \
macro_f_string_dynamics_t_delete_simple(listing.block) \
macro_f_string_dynamics_t_delete_simple(listing.character) \
#define f_directory_status_t_initialize { 0, f_string_dynamic_t_initialize }
+ #define macro_f_directory_status_t_initialize(status, path) { status, path }
+
#define macro_f_directory_status_t_clear(directory) \
directory.status = 0; \
macro_f_string_dynamic_t_clear(directory.path);
#define f_directory_statuss_t_initialize { 0, 0, 0 }
+ #define macro_f_directory_statuss_t_initialize(content, size, used) { array, size, used }
+ #define macro_f_directory_statuss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_directory_statuss_t_clear(structures) macro_f_memory_structures_clear(structures)
#define macro_f_directory_statuss_t_resize(status, structures, new_length) \
#define macro_f_directory_statuss_t_delete_simple(structures) \
structures.used = structures.size; \
- while (structures.used > 0) { \
+ while (structures.used) { \
--structures.used; \
macro_f_directory_status_t_delete_simple(structures.array[structures.used]); \
} \
#define macro_f_directory_statuss_t_destroy_simple(structures) \
structures.used = structures.size; \
- while (structures.used > 0) { \
+ while (structures.used) { \
--structures.used; \
macro_f_directory_status_t_destroy_simple(structures.array[structures.used]); \
} \
/**
* A structure representing a scheduler and its parameters for execution.
*
- * @todo move this into a f_scheduler project.
- *
* policy: The scheduler policy.
* priority: The scheduler priority;
*/
#define f_execute_result_t_initialize { 0 }
+ #define macro_f_execute_result_t_initialize(status, pid) { status, pid }
+
#define f_execute_result_t_clear(execute_result) \
execute_result.status = 0; \
execute_result.pid = 0;
*/
#ifndef _di_f_fss_comment_t_
typedef f_string_range_t f_fss_comment_t;
+
+ #define f_fss_comment_t_initialize f_string_range_t_initialize
+
+ #define macro_f_fss_comment_t_initialize(length) macro_f_string_range_t_initialize(length)
+
+ #define macro_f_fss_comment_t_clear(comment) macro_f_string_range_t_clear(comment)
#endif // _di_f_fss_comment_t_
/**
#define f_fss_comments_t_initialize f_string_ranges_t_initialize
+ #define macro_f_fss_comments_t_initialize(array, size, used) macro_f_string_ranges_t_initialize(array, size, used)
+ #define macro_f_fss_comments_t_initialize2(array, length) macro_f_string_ranges_t_initialize2(array, length)
+
#define f_fss_comments_t_clear(comments) macro_f_string_ranges_t_clear(comments)
#define macro_f_fss_comments_t_resize(status, comments, length) macro_f_string_ranges_t_resize(status, comments, length)
#define f_fss_commentss_t_initialize f_string_rangess_t_initialize
+ #define macro_f_fss_commentss_t_initialize(array, size, used) macro_f_string_rangess_t_initialize(array, size, used)
+ #define macro_f_fss_commentss_t_initialize2(array, length) macro_f_string_rangess_t_initialize2(array, length)
+
#define macro_f_fss_commentss_t_clear(commentss) macro_f_string_rangess_t_clear(commentss)
#define macro_f_fss_commentss_t_resize(status, commentss, length) macro_f_string_rangess_t_resize(status, commentss, length)
#define f_fss_object_t_initialize f_string_range_t_initialize
+ #define macro_f_fss_object_t_initialize(length) macro_f_string_range_t_initialize(length)
+
#define macro_f_fss_object_t_clear(object) macro_f_string_range_t_clear(object)
#endif // _di_f_fss_object_t_
#define f_fss_objects_t_initialize f_string_ranges_t_initialize
+ #define macro_f_fss_objects_t_initialize(array, size, used) macro_f_string_ranges_t_initialize(array, size, used)
+ #define macro_f_fss_objects_t_initialize2(array, length) macro_f_string_ranges_t_initialize2(array, length)
+
#define macro_f_fss_objects_t_clear(objects) macro_f_string_ranges_t_clear(objects)
#define macro_f_fss_objects_t_resize(status, objects, length) macro_f_string_ranges_t_resize(status, objects, length)
#define f_fss_content_t_initialize f_string_ranges_t_initialize
+ #define macro_f_fss_content_t_initialize(array, size, used) macro_f_string_ranges_t_initialize(array, size, used)
+ #define macro_f_fss_content_t_initialize2(array, length) macro_f_string_ranges_t_initialize2(array, length)
+
#define macro_f_fss_content_t_clear(content) macro_f_string_ranges_t_clear(content)
#define macro_f_fss_content_t_resize(status, content, length) macro_f_string_ranges_t_resize(status, content, length)
#define f_fss_contents_t_initialize f_string_rangess_t_initialize
+ #define macro_f_fss_contents_t_initialize(array, size, used) macro_f_string_rangess_t_initialize(array, size, used)
+ #define macro_f_fss_contents_t_initialize2(array, length) macro_f_string_rangess_t_initialize2(array, length)
+
#define macro_f_fss_contents_t_clear(contents) macro_f_string_rangess_t_clear(contents)
#define macro_f_fss_contents_t_resize(status, contents, length) macro_f_string_rangess_t_resize(status, contents, length)
*/
#ifndef _di_f_fss_delimit_t_
typedef f_array_length_t f_fss_delimit_t;
+
+ #define macro_f_fss_object_t_initialize(length) macro_f_string_range_t_initialize(length)
#endif // _di_f_fss_delimit_t_
/**
#define f_fss_delimits_t_initialize f_array_lengths_t_initialize
+ #define macro_f_fss_delimits_t_initialize(array, size, used) macro_f_array_lengths_t_initialize(array, size, used)
+ #define macro_f_fss_delimits_t_initialize2(array, length) macro_f_array_lengths_t_initialize2(array, length)
+
#define macro_f_fss_delimits_t_clear(delimits) macro_f_array_lengths_t_clear(delimits)
#define macro_f_fss_delimits_t_resize(status, delimits, length) macro_f_array_lengths_t_resize(status, delimits, length)
#define f_fss_delimitss_t_initialize f_array_lengthss_t_initialize
+ #define macro_f_fss_delimitss_t_initialize(array, size, used) macro_f_array_lengthss_t_initialize(array, size, used)
+ #define macro_f_fss_delimitss_t_initialize2(array, length) macro_f_array_lengthss_t_initialize2(array, length)
+
#define macro_f_fss_delimitss_t_clear(delimitss) macro_f_array_lengthss_t_clear(delimitss)
#define macro_f_fss_delimitss_t_resize(status, delimitss, length) macro_f_array_lengthss_t_resize(status, delimitss, length)
#define f_fss_named_t_initialize { f_fss_object_t_initialize, f_fss_objects_t_initialize, f_fss_contents_t_initialize, f_fss_quotess_t_initialize }
+ #define macro_f_fss_named_t_initialize(name, objects, contents, quotess) macro_f_array_lengths_t_initialize(name, objects, contents, quotess)
+
#define macro_f_fss_named_t_clear(named) \
macro_f_fss_object_t_clear(named.name) \
macro_f_fss_objects_t_clear(named.objects) \
#define f_fss_nameds_t_initialize { 0, 0, 0 }
+ #define macro_f_fss_nameds_t_initialize(array, size, used) macro_f_fss_nameds_t_initialize(array, size, used)
+ #define macro_f_fss_nameds_t_initialize2(array, length) macro_f_fss_nameds_t_initialize2(array, length)
+
#define macro_f_fss_nameds_t_clear(nameds) macro_f_memory_structure_clear(nameds);
#define macro_f_fss_nameds_t_resize(status, nameds, length) status = f_fss_nameds_resize(length, &nameds);
#define f_fss_item_t_initialize { f_fss_object_t_initialize, f_fss_content_t_initialize, 0 }
+ #define macro_f_fss_item_t_initialize(object, content, parent) macro_f_array_lengths_t_initialize(object, content, parent)
+
#define macro_f_fss_item_t_clear(item) \
macro_f_fss_object_t_clear(item.object); \
macro_f_fss_content_t_clear(item.content); \
#define f_fss_items_t_initialize { 0, 0, 0 }
+ #define macro_f_fss_items_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_fss_items_t_initialize2(array, length) { array, length, length }
+
#define macro_f_fss_items_t_clear(items) macro_f_memory_structure_clear(items)
#define macro_f_fss_items_t_resize(status, items, length) status = f_fss_items_resize(length, &items);
* Each array row represents the nesting depth.
* The top-level will not have any parent, so "parent" must be ignored on anything at index 0.
* The parent identifier is expected to reference a position in the nesting depth immediately above it.
- * @todo consider instead of using a "parent", have setting set to 0 to represent no data.
*
* depth: An array of f_fss_items_t, with each index representing the depth.
* size: Total amount of allocated space.
#define f_fss_nest_t_initialize { 0, 0, 0 }
+ #define macro_f_fss_nest_t_initialize(depth, size, used) { depth, size, used }
+ #define macro_f_fss_nest_t_initialize2(depth, length) { depth, length, length }
+
#define macro_f_fss_nest_t_clear(nest) macro_f_memory_structures_clear(nest)
#define macro_f_fss_nest_t_resize(status, nest, length) status = f_fss_nest_resize(length, &nest);
#define f_fss_nests_t_initialize { 0, 0, 0 }
+ #define macro_f_fss_nests_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_fss_nests_t_initialize2(array, length) { array, length, length }
+
#define macro_f_fss_nests_t_clear(nests) macro_f_memory_structures_clear(nests)
#define macro_f_fss_nests_t_resize(status, nests, length) status = f_fss_nests_resize(length, &nests);
*/
#ifndef _di_f_fss_quote_t_
typedef uint8_t f_fss_quote_t;
+
+ #define macro_f_fss_quote_t_initialize(quote) quote
#endif // _di_f_fss_quote_t_
/**
#define f_fss_quotes_t_initialize f_uint8s_t_initialize
+ #define macro_f_fss_quotes_t_initialize(array, size, used) macro_f_uint8s_t_initialize(array, size, used)
+ #define macro_f_fss_quotes_t_initialize2(array, length) macro_f_uint8s_t_initialize2(array, length)
+
#define macro_f_fss_quotes_t_clear(quotes) macro_f_uint8s_t_clear(quotes)
#define macro_f_fss_quotes_t_resize(status, quotes, length) macro_f_uint8s_t_resize(status, quotes, length)
#define f_fss_quotess_t_initialize f_uint8ss_t_initialize
+ #define macro_f_fss_quotess_t_initialize(array, size, used) macro_f_uint8ss_t_initialize(array, size, used)
+ #define macro_f_fss_quotess_t_initialize2(array, length) macro_f_uint8ss_t_initialize2(array, length)
+
#define macro_f_fss_quotess_t_clear(quotess) macro_f_uint8ss_t_clear(quotess)
#define macro_f_fss_quotess_t_resize(status, quotess, length) macro_f_uint8ss_t_resize(status, quotess, length)
#define f_fss_set_t_initialize { f_fss_objects_t_initialize, f_fss_contents_t_initialize }
+ #define macro_f_fss_set_t_initialize(objects, contents) { objects, contents }
+
#define macro_f_fss_set_t_clear(set) \
macro_f_fss_objects_t_clear(set.objects) \
macro_f_fss_contents_t_clear(set.contents)
* The objects, contents, and quotes should each be of the same used and size.
* Any deviation to this would require implementing custom equivelents to the standard management macros.
*
- * objects: the array of objects.
- * contents: the array of contents.
- * objects_quote: the array of objects quote types.
- * contents_quote: the array of contents quote types.
+ * objects: The array of objects.
+ * contents: The array of contents.
+ * objects_quote: The array of objects quote types.
+ * contents_quote: The array of contents quote types.
*/
#ifndef _di_f_fss_set_quote_t_
typedef struct {
#define f_fss_set_quote_t_initialize { f_fss_objects_t_initialize, f_fss_contents_t_initialize, f_fss_quotes_t_initialize, f_fss_quotess_t_initialize }
+ #define macro_f_fss_set_quote_t_initialize(objects, contents, objects_quote, contents_quote) { objects, contents, objects_quote, contents_quote }
+
#define macro_f_fss_set_quote_t_clear(set) \
macro_f_fss_objects_t_clear(set.objects) \
macro_f_fss_contents_t_clear(set.contents) \
#define f_fss_set_quotes_t_initialize { 0, 0, 0 }
+ #define macro_f_fss_set_quotes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_fss_set_quotes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_fss_set_quotes_t_clear(nameds) macro_f_memory_structure_clear(nameds)
#define macro_f_fss_set_quotes_t_resize(status, set_quotes, length) status = f_fss_set_quotes_resize(length, &set_quotes);
#define f_limit_value_t_initialize { 0, 0 }
+ #define macro_f_limit_value_t_initialize(value) { value }
+
#define macro_f_limit_value_t_clear(value) \
value.rlim_cur = 0; \
value.rlim_max = 0;
#define f_limit_values_t_initialize { 0, 0, 0 }
+ #define macro_f_limit_values_t_initialize(content, size, used) { array, size, used }
+ #define macro_f_limit_values_t_initialize2(array, length) { array, length, length }
+
#define macro_f_limit_values_t_clear(values) macro_f_memory_structure_clear(values)
#define macro_f_limit_values_t_resize(status, values, length) macro_f_memory_structure_resize(status, values, f_limit_value_t, length)
#define f_limit_set_t_initialize { 0, 0 }
+ #define macro_f_limit_set_t_initialize(type, value) { type, value }
+
#define macro_f_limit_set_t_clear(set) \
set.type = 0; \
set.value = 0;
#define f_limit_sets_t_initialize { 0, 0, 0 }
+ #define macro_f_limit_sets_t_initialize(content, size, used) { array, size, used }
+ #define macro_f_limit_sets_t_initialize2(array, length) { array, length, length }
+
#define macro_f_limit_sets_t_clear(sets) macro_f_memory_structure_clear(sets)
#define macro_f_limit_sets_t_resize(status, sets, length) macro_f_memory_structure_resize(status, sets, f_limit_set_t, length)
#define f_string_t_initialize 0
+ #define macro_f_string_t_initialize(string) string
+
#define macro_f_string_t_clear(string) string = 0;
#define macro_f_string_t_resize(status, string, length_old, length_new) status = f_memory_resize(length_old, length_new, 1, (void **) & string);
#define f_string_constant_t_initialize 0
+ #define macro_f_string_constant_t_initialize(string) string
+
#define macro_f_string_constant_t_clear(string) string = 0;
#endif // _di_f_string_t_
#define f_string_dynamic_t_initialize f_string_static_t_initialize
+ #define macro_f_string_dynamic_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_dynamic_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_dynamic_t_clear(dynamic) macro_f_string_static_t_clear(dynamic)
#define macro_f_string_dynamic_t_resize(status, dynamic, length) status = f_string_dynamic_resize(length, &dynamic);
#define f_string_dynamics_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_dynamics_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_dynamics_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_dynamics_t_clear(dynamics) macro_f_string_statics_t_clear(dynamics)
#define macro_f_string_dynamics_t_resize(status, dynamics, length) status = f_string_dynamics_resize(length, &dynamics);
#define f_string_dynamicss_t_initialize f_string_staticss_t_initialize
+ #define macro_f_string_dynamicss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_dynamicss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_dynamicss_t_clear(dynamicss) macro_f_string_staticss_t_clear(dynamicss)
#define macro_f_string_dynamicss_t_resize(status, dynamicss, length) status = f_string_dynamicss_resize(length, &dynamicss);
#define f_string_map_t_initialize { f_string_dynamic_t_initialize, f_string_dynamic_t_initialize }
+ #define macro_f_string_map_t_initialize(name, value) { name, value }
+
#define macro_f_string_map_t_clear(map) \
macro_f_string_dynamic_t_clear(map.name) \
macro_f_string_dynamic_t_clear(map.value)
#define f_string_maps_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_maps_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_maps_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_maps_t_clear(maps) macro_f_memory_structure_clear(maps)
#define macro_f_string_maps_t_resize(status, maps, length) status = f_string_maps_resize(length, &maps);
#define f_string_mapss_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_mapss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_mapss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_mapss_t_clear(maps) macro_f_memory_structure_clear(maps)
#define macro_f_string_mapss_t_resize(status, maps, length) status = f_string_mapss_resize(length, &maps);
#define f_string_map_multi_t_initialize { f_string_dynamic_t_initialize, f_string_dynamics_t_initialize }
+ #define macro_f_string_map_t_initialize(name, value) { name, value }
+
#define macro_f_string_map_multi_t_clear(map) \
macro_f_string_dynamic_t_clear(map.name) \
macro_f_string_dynamics_t_clear(map.value)
#define f_string_map_multis_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_map_multis_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_map_multis_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_map_multis_t_clear(map_multis) macro_f_memory_structure_clear(map_multis)
#define macro_f_string_map_multis_t_resize(status, map_multis, length) status = f_string_map_multis_resize(length, &map_multis);
#define f_string_map_multiss_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_map_multiss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_map_multiss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_map_multiss_t_clear(map_multis) macro_f_memory_structure_clear(map_multis)
#define macro_f_string_map_multiss_t_resize(status, map_multis, length) status = f_string_map_multiss_resize(length, &map_multis);
} f_string_quantity_t;
#define f_string_quantity_t_initialize { 0, 0 }
+
+ #define macro_f_string_quantity_t_initialize(start, total) { start, total }
+
+ #define macro_f_string_quantity_t_clear(quantity) \
+ quantity.start = 0; \
+ quantity.total = 0;
#endif // _di_f_string_quantity_t_
/**
#define f_string_quantitys_t_initialize { 0, 0, 0 }
+ #define macro_f_string_quantitys_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_quantitys_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_quantitys_t_clear(quantitys) macro_f_memory_structure_clear(quantitys)
#define macro_f_string_quantitys_t_resize(status, quantitys, length) status = f_string_quantitys_resize(length, &quantitys);
#define f_string_quantityss_t_initialize { 0, 0, 0 }
+ #define macro_f_string_quantityss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_quantityss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_quantityss_t_clear(quantityss) macro_f_memory_structures_clear(quantityss)
#define macro_f_string_quantityss_t_resize(status, quantityss, length) status = f_string_quantityss_resize(length, &quantityss);
#define f_string_ranges_t_initialize { 0, 0, 0 }
+ #define macro_f_string_ranges_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_ranges_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_ranges_t_clear(ranges) macro_f_memory_structure_clear(ranges)
#define macro_f_string_ranges_t_resize(status, ranges, length) status = f_string_ranges_resize(length, &ranges);
#define f_string_rangess_t_initialize { 0, 0, 0 }
+ #define macro_f_string_rangess_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_rangess_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_rangess_t_clear(rangess) macro_f_memory_structures_clear(rangess)
#define macro_f_string_rangess_t_resize(status, rangess, length) status = f_string_rangess_resize(length, &rangess);
#define f_string_static_t_initialize { 0, 0, 0 }
+ #define macro_f_string_static_t_initialize(string, size, used) { string, size, used }
+ #define macro_f_string_static_t_initialize2(string, length) { string, length, length }
+
#define macro_f_string_static_t_clear(string_static) \
string_static.string = 0; \
string_static.size = 0; \
string_static.used = 0;
-
- #define macro_f_string_static_t_initialize(string, size, used) { string, size, used }
- #define macro_f_string_static_t_initialize2(string, length) { string, length, length }
#endif // _di_f_string_static_t_
/**
#define f_string_statics_t_initialize { 0, 0, 0 }
+ #define macro_f_string_statics_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_statics_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_statics_t_clear(statics) \
statics.array = 0; \
statics.size = 0; \
#define f_string_staticss_t_initialize { 0, 0, 0 }
+ #define macro_f_string_staticss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_staticss_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_staticss_t_clear(staticss) \
staticss.array = 0; \
staticss.size = 0; \
triple.c.size = 0; \
triple.c.used = 0;
+ #define macro_f_string_triple_t_initialize(a, b, c) { a, b, c }
+
#define macro_f_string_triple_t_delete_simple(triple) \
macro_f_string_dynamic_t_delete_simple(triple.a) \
macro_f_string_dynamic_t_delete_simple(triple.b) \
#define f_string_triples_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_triples_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_triples_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_triples_t_clear(triples) macro_f_memory_structure_clear(triples)
#define macro_f_string_triples_t_resize(status, triples, length) status = f_string_triples_resize(length, &triples);
#define f_string_tripless_t_initialize f_string_statics_t_initialize
+ #define macro_f_string_tripless_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_string_tripless_t_initialize2(array, length) { array, length, length }
+
#define macro_f_string_tripless_t_clear(tripless) macro_f_memory_structure_clear(tripless)
#define macro_f_string_tripless_t_resize(status, tripless, length) status = f_string_tripless_resize(length, &tripless);
#define f_thread_attribute_t_initialize { 0 }
+ #define macro_f_thread_attribute_t_initialize(attribute) attribute
+
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define macro_f_thread_attribute_t_clear(attribute) attribute.__align = 0;
#define f_thread_attributes_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_attributes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_attributes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_attributes_t_clear(attributes) macro_f_memory_structure_clear(attributes)
#define macro_f_thread_attributes_t_resize(status, attributes, length) status = f_thread_attributes_resize(length, &attributes);
#define f_thread_barrier_t_initialize { 0 }
+ #define macro_f_thread_barrier_t_initialize(barrier) barrier
+
#define macro_f_thread_barrier_t_clear(barrier) barrier = 0;
#define macro_f_thread_barrier_t_delete_simple(barrier) f_thread_barrier_delete(&barrier);
#define f_thread_barriers_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_barriers_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_barriers_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_barriers_t_clear(barriers) macro_f_memory_structure_clear(barriers)
#define macro_f_thread_barriers_t_resize(status, barriers, length) status = f_thread_barriers_resize(length, &barriers);
#define f_thread_barrier_attribute_t_initialize { 0 }
+ #define macro_f_thread_barrier_attribute_t_initialize(attribute) attribute
+
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define macro_f_thread_barrier_attribute_t_clear(attribute) attribute.__align = 0;
#define f_thread_barrier_attributes_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_barrier_attributes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_barrier_attributes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_barrier_attributes_t_clear(barrier_attributes) macro_f_memory_structure_clear(barrier_attributes)
#define macro_f_thread_barrier_attributes_t_resize(status, barrier_attributes, length) status = f_thread_barrier_attributes_resize(length, &barrier_attributes);
#define f_thread_condition_t_initialize PTHREAD_COND_INITIALIZER
+ #define macro_f_thread_condition_t_initialize(condition) { condition }
+
#define macro_f_thread_condition_t_delete_simple(condition) f_thread_condition_delete(&condition);
#endif // _di_f_thread_condition_t_
#define f_thread_conditions_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_conditions_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_conditions_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_conditions_t_clear(conditions) macro_f_memory_structure_clear(conditions)
#define macro_f_thread_conditions_t_resize(status, conditions, length) status = f_thread_conditions_resize(length, &conditions);
#define f_thread_condition_attribute_t_initialize { 0 };
+ #define macro_f_thread_condition_attribute_t_initialize(array, size, used) attribute
+
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define macro_f_thread_condition_attribute_t_clear(attribute) attribute.__align = 0;
#define f_thread_condition_attributes_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_condition_attributes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_condition_attributes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_condition_attributes_t_clear(attributes) macro_f_memory_structure_clear(attributes)
#define macro_f_thread_condition_attributes_t_resize(status, attributes, length) status = f_thread_condition_attributes_resize(length, &attributes);
#define f_thread_ids_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_ids_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_ids_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_ids_t_resize(status, ids, length) macro_f_memory_structure_resize(status, ids, f_thread_id_t, length)
#define macro_f_thread_ids_t_adjust(status, ids, length) macro_f_memory_structure_adjust(status, ids, f_thread_id_t, length)
#define f_thread_key_t_initialize 0
+ #define macro_f_thread_key_t_initialize(key) key
+
#define macro_f_thread_key_t_clear(key) key = 0;
#define macro_f_thread_key_t_delete_simple(key) f_thread_key_delete(&key);
#define f_thread_keys_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_keys_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_keys_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_keys_t_clear(keys) macro_f_memory_structure_clear(keys)
#define macro_f_thread_keys_t_resize(status, keys, length) status = f_thread_keys_resize(length, &keys);
#define f_thread_lock_t_initialize PTHREAD_RWLOCK_INITIALIZER
+ #define macro_f_thread_lock_t_initialize(lock) lock
+
#define macro_f_thread_lock_t_delete_simple(lock) f_thread_lock_delete(&lock);
#endif // _di_f_thread_lock_t_
#define f_thread_locks_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_locks_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_locks_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_locks_t_resize(status, locks, length) macro_f_memory_structure_resize(status, locks, f_thread_lock_t, length)
#define macro_f_thread_locks_t_adjust(status, locks, length) macro_f_memory_structure_adjust(status, locks, f_thread_lock_t, length)
#define f_thread_lock_attribute_t_initialize { 0 }
+ #define macro_f_thread_lock_attribute_t_initialize(attribute) attribute
+
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define macro_f_thread_lock_attribute_t_clear(attribute) attribute.__align = 0;
#define f_thread_lock_attributes_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_lock_attributes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_lock_attributes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_lock_attributes_t_clear(attributes) macro_f_memory_structure_clear(attributes)
#define macro_f_thread_lock_attributes_t_resize(status, attributes, length) status = f_thread_lock_attributes_resize(length, &attributes);
#define f_thread_mutex_t_initialize PTHREAD_MUTEX_INITIALIZER
+ #define macro_f_thread_mutex_t_initialize(mutex) mutex
+
#define macro_f_thread_mutex_t_delete_simple(mutex) f_thread_mutex_delete(&mutex);
#endif // _di_f_thread_mutex_t_
#define f_thread_mutexs_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_mutexs_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_mutexs_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_mutexs_t_clear(mutexs) macro_f_memory_structure_clear(mutexs)
#define macro_f_thread_mutexs_t_resize(status, mutexs, length) status = f_thread_mutexs_resize(length, &mutexs);
#define f_thread_mutex_attribute_t_initialize { 0 }
+ #define macro_f_thread_mutex_attribute_t_initialize(attribute) attribute
+
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define macro_f_thread_mutex_attribute_t_clear(attribute) attribute.__align = 0;
#define f_thread_mutex_attributes_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_mutex_attributes_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_mutex_attributes_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_mutex_attributes_t_clear(attributes) macro_f_memory_structure_clear(attributes)
#define macro_f_thread_mutex_attributes_t_resize(status, attributes, length) status = f_thread_mutex_attributes_resize(length, &attributes);
typedef pthread_once_t f_thread_once_t;
#define f_thread_once_t_initialize PTHREAD_ONCE_INIT
+
+ #define macro_f_thread_once_t_initialize(once) once
#endif // _di_f_thread_once_t_
/**
#define f_thread_onces_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_onces_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_onces_t_initialize2(array, length) { array, length, length }
+
+ #define macro_f_thread_onces_t_clear(onces) macro_f_memory_structure_clear(onces)
+
#define macro_f_thread_onces_t_resize(status, onces, length) macro_f_memory_structure_resize(status, onces, f_thread_once_t, length)
#define macro_f_thread_onces_t_adjust(status, onces, length) macro_f_memory_structure_adjust(status, onces, f_thread_once_t, length)
#define f_thread_semaphore_t_initialize 0
+ #define macro_f_thread_semaphore_t_initialize(semaphore) semaphore
+
#define macro_f_thread_semaphore_t_delete_simple(semaphore) f_thread_semaphore_delete(&semaphore);
#endif // _di_f_thread_semaphore_t_
#define f_thread_semaphores_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_semaphores_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_semaphores_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_semaphores_t_clear(semaphores) macro_f_memory_structure_clear(semaphores)
#define macro_f_thread_semaphores_t_resize(status, semaphores, length) status = f_thread_semaphores_resize(length, &semaphores);
#define f_thread_set_t_initialize { f_thread_attribute_t_initialize, f_thread_id_t_initialize, 0 }
+ #define macro_f_thread_set_t_initialize(attribute, id, result) { attribute, id, result }
+
#define macro_f_thread_set_t_clear(thread) \
macro_f_thread_attribute_t_clear(thread.attribute) \
- macro_f_thread_id_t_clear(thread.id)
+ macro_f_thread_id_t_clear(thread.id) \
+ result = 0;
#define macro_f_thread_set_t_delete_simple(set) macro_f_thread_attribute_t_delete_simple(set.attribute)
#endif // _di_f_thread_set_t_
#define f_thread_sets_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_sets_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_sets_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_sets_t_clear(sets) macro_f_memory_structure_clear(sets)
#define macro_f_thread_sets_t_resize(status, sets, length) status = f_thread_sets_resize(length, &sets);
#define f_thread_spin_t_initialize ((pthread_spinlock_t) 0xFFFFFFFF)
+ #define macro_f_thread_spin_t_initialize(spin) spin
+
#define macro_f_thread_spin_t_delete_simple(spin) f_thread_spin_delete(&spin);
#endif // _di_f_thread_spin_t_
#define f_thread_spins_t_initialize { 0, 0, 0 }
+ #define macro_f_thread_spins_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_thread_spins_t_initialize2(array, length) { array, length, length }
+
#define macro_f_thread_spins_t_clear(spins) macro_f_memory_structure_clear(spins)
#define macro_f_thread_spins_t_resize(status, spins, length) status = f_thread_spins_resize(length, &spins);
#define f_array_length_t_initialize 0
+ #define macro_f_array_length_t_initialize(length) length
+
#define F_array_length_t_size_d F_number_t_size_unsigned_d
#define F_array_length_t_size_max_d F_number_t_size_max_unsigned_d
#endif // _di_f_array_t_
/**
* A structure designating a row and column, just like a cell in a table.
*
- * row: the row position.
- * column: the column position.
+ * row: The row position.
+ * column: The column position.
*/
#ifndef _di_f_cell_t_
typedef struct {
#define f_cell_t_initialize { 0, 0 }
+ #define macro_f_cell_t_initialize(row, column) { row, column }
+
#define macro_f_cell_t_clear(cell) \
cell.row = 0; \
cell.column = 0;
} f_cells_t;
#define f_cells_t_initialize { 0, 0, 0 }
+
+ #define macro_f_cells_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_cells_t_initialize2(array, length) { array, length, length }
#endif // _di_f_cells_t_
/**
} f_cellss_t;
#define f_cellss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_cellss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_cellss_t_initialize2(array, length) { array, length, length }
#endif // _di_f_cellss_t_
/**
} f_array_lengths_t;
#define f_array_lengths_t_initialize { 0, 0, 0 }
+
+ #define macro_f_array_lengths_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_array_lengths_t_initialize2(array, length) { array, length, length }
#endif // _di_f_array_lengths_t_
/**
} f_array_lengthss_t;
#define f_array_lengthss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_array_lengthss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_array_lengthss_t_initialize2(array, length) { array, length, length }
#endif // _di_f_array_lengthss_t_
/**
} f_int8s_t;
#define f_int8s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int8s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int8s_t_initialize2(array, length) { array, length, length }
#endif // _di_int8s_t_
/**
} f_int8ss_t;
#define f_int8ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int8ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int8ss_t_initialize2(array, length) { array, length, length }
#endif // _di_int8ss_t_
/**
} f_uint8s_t;
#define f_uint8s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint8s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint8s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint8s_t_
/**
} f_uint8ss_t;
#define f_uint8ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint8ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint8ss_t_initialize2(array, length) { array, length, length }
#endif // _di_uint8ss_t_
/**
} f_int16s_t;
#define f_int16s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int16s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int16s_t_initialize2(array, length) { array, length, length }
#endif // _di_int16s_t_
/**
} f_int16ss_t;
#define f_int16ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int16ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int16ss_t_initialize2(array, length) { array, length, length }
#endif // _di_int16ss_t_
/**
} f_uint16s_t;
#define f_uint16s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint16s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint16s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint16s_t_
/**
} f_uint16ss_t;
#define f_uint16ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint16s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint16s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint16ss_t_
/**
} f_int32s_t;
#define f_int32s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int32s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int32s_t_initialize2(array, length) { array, length, length }
#endif // _di_int32s_t_
/**
} f_int32ss_t;
#define f_int32ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int32ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int32ss_t_initialize2(array, length) { array, length, length }
#endif // _di_int32ss_t_
/**
} f_uint32s_t;
#define f_uint32s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint32s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint32s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint32s_t_
/**
} f_uint32ss_t;
#define f_uint32ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint32ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint32ss_t_initialize2(array, length) { array, length, length }
#endif // _di_uint32ss_t_
/**
} f_int64s_t;
#define f_int64s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int64s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int64s_t_initialize2(array, length) { array, length, length }
#endif // _di_int64s_t_
/**
} f_int64ss_t;
#define f_int64ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int64ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int64ss_t_initialize2(array, length) { array, length, length }
#endif // _di_int64ss_t_
/**
} f_uint64s_t;
#define f_uint64s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint64s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint64s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint64s_t_
/**
} f_uint64ss_t;
#define f_uint64ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint64ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint64ss_t_initialize2(array, length) { array, length, length }
#endif // _di_uint64ss_t_
/**
} f_int128s_t;
#define f_int128s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int128s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int128s_t_initialize2(array, length) { array, length, length }
#endif // _di_int128s_t_
/**
} f_int128ss_t;
#define f_int128ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_int128ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_int128ss_t_initialize2(array, length) { array, length, length }
#endif // _di_int128ss_t_
/**
} f_uint128s_t;
#define f_uint128s_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint128s_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint128s_t_initialize2(array, length) { array, length, length }
#endif // _di_uint128s_t_
/**
} f_uint128ss_t;
#define f_uint128ss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_uint128ss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_uint128ss_t_initialize2(array, length) { array, length, length }
#endif // _di_uint128ss_t_
/**
} f_statuss_t;
#define f_statuss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_statuss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_statuss_t_initialize2(array, length) { array, length, length }
#endif // _di_f_statuss_t_
/**
} f_statusss_t;
#define f_statusss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_statusss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_statusss_t_initialize2(array, length) { array, length, length }
#endif // _di_f_statusss_t_
/**
} f_states_t;
#define f_states_t_initialize { 0, 0, 0 }
+
+ #define macro_f_states_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_states_t_initialize2(array, length) { array, length, length }
#endif // _di_f_states_t_
/**
} f_statess_t;
#define f_statess_t_initialize { 0, 0, 0 }
+
+ #define macro_f_statess_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_statess_t_initialize2(array, length) { array, length, length }
#endif // _di_f_statess_t_
/**
0, \
}
+ #define macro_f_fll_id_t_initialize(name, type, used) { name, type, used }
+
#define macro_f_fll_id_t_clear(id) \
id.name[0] = 0; \
id.type = 0; \
} f_fll_ids_t;
#define f_fll_ids_t_initialize { 0, 0, 0 }
+
+ #define macro_f_fll_ids_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_fll_ids_t_initialize2(array, length) { array, length, length }
#endif // _di_f_fll_ids_t_
/**
} f_fll_idss_t;
#define f_fll_idss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_fll_idss_t_initialize(array, size, used) { array, size, used }
+ #define macro_f_fll_idss_t_initialize2(array, length) { array, length, length }
#endif // _di_f_fll_idss_t_
#ifdef __cplusplus
} fl_directory_recurse_t;
#define fl_directory_recurse_t_initialize { FL_directory_recurse_depth_max_d, F_file_default_read_size_d, F_false, macro_f_file_t_initialize2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d), 0, 0 }
+
+ #define macro_fl_directory_recurse_t_initialize(depth_max, size_block, exclusive, output, verbose, failures) { \
+ depth_max, \
+ size_block, \
+ exclusive, \
+ output, \
+ verbose, \
+ failures \
+ }
#endif // _di_fl_directory_recurse_t_
#ifdef __cplusplus
build_indexer_arguments rcs
build_language c
build_libraries -lc
-build_libraries-individual -lf_iki -lf_memory -lf_string -lf_utf
+build_libraries-individual -lf_iki -lf_memory -lf_string -lf_type_array -lf_utf
build_libraries_shared
build_libraries_static
build_objects_library
#define fl_signal_interrupt_t_initialize { f_int32s_t_initialize, f_signal_t_initialize, 0 }
#define macro_fl_signal_interrupt_t_initialize(interrupts, signal) { interrupts, signal, 0 }
+ #define macro_fl_signal_interrupt_t_initialize2(interrupts, signal, trigger) { interrupts, signal, trigger }
#define macro_fl_signal_interrupt_t_clear(structure) \
macro_f_int32s_t_clear(structure.interrupts) \
build_indexer_arguments rcs
build_language c
build_libraries -lc
-build_libraries-individual -lfl_iki -lf_iki -lf_memory -lf_string -lf_utf
+build_libraries-individual -lfl_iki -lf_iki -lf_memory -lf_string -lf_type_array -lf_utf
build_libraries_shared
build_libraries_static
build_objects_library
f_signal_t_initialize, \
f_color_context_t_initialize, \
}
+
+ #define macro_fll_program_data_t_initialize(parameters, signal_check, process_pipe, output, error, warning, signal, context) { \
+ parameters, \
+ signal_check, \
+ process_pipe, \
+ output, \
+ error, \
+ warning, \
+ signal, \
+ context, \
+ }
#endif // _di_fll_program_data_t_
/**
projects / fll / commitdiff