These were being removed at one point in time, resulting in an inconsistent declaration of these macros.
The memory clear macros were also removed, but some of the uses still (incorrectly) remained.
Ensure that these `*_t_clear()` macros are encased in a brace defined block.
Do not use semi-colons at the end of the `*_t_clear()` uses.
Do use semi-colons at the end of `*_t_clear()` direct property assignments.
#define macro_f_abstruse_t_initialize_1(type, is) { type, is }
#define macro_f_abstruse_t_initialize_2(type) { type, f_abstruse_type_t_initialize }
- #define macro_f_abstruse_t_clear(abstruse) \
+ #define macro_f_abstruse_t_clear(abstruse) { \
abstruse.type = 0; \
- macro_f_abstruse_type_t_clear(abstruse.is);
+ macro_f_abstruse_type_t_clear(abstruse.is); \
+ }
#endif // _di_f_abstruse_t_
/**
#define macro_f_abstruses_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_abstruses_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_abstruses_t_clear(abstruses) { \
+ abstruses.array = 0; \
+ abstruses.used = 0; \
+ abstruses.size = 0; \
+ }
#endif // _di_f_abstruses_t_
/**
#define macro_f_abstrusess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_abstrusess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_abstrusess_t_clear(abstrusess) { \
+ abstrusess.array = 0; \
+ abstrusess.used = 0; \
+ abstrusess.size = 0; \
+ }
#endif // _di_f_abstrusess_t_
/**
#define macro_f_abstruse_map_t_initialize_1(key, value) { key, value }
- #define macro_f_abstruse_map_t_clear(map) \
- macro_f_string_dynamic_t_clear(map.key); \
- macro_f_abstruse_t_clear(map.value);
+ #define macro_f_abstruse_map_t_clear(map) { \
+ macro_f_string_dynamic_t_clear(map.key) \
+ macro_f_abstruse_t_clear(map.value) \
+ }
#endif // _di_f_abstruse_map_t_
/**
#define macro_f_abstruse_maps_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_abstruse_maps_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_abstruse_maps_t_clear(abstruse_maps) { \
+ abstruse_maps.array = 0; \
+ abstruse_maps.used = 0; \
+ abstruse_maps.size = 0; \
+ }
#endif // _di_f_abstruse_maps_t_
/**
#define macro_f_abstruse_mapss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_abstruse_mapss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_abstruse_mapss_t_clear(abstruse_mapss) { \
+ abstruse_mapss.array = 0; \
+ abstruse_mapss.used = 0; \
+ abstruse_mapss.size = 0; \
+ }
#endif // _di_f_abstruse_mapss_t_
/**
f_string_dynamic_t_initialize \
}
- #define macro_f_account_t_clear(account) \
- macro_f_uid_t_clear(account.id_user); \
- macro_f_gid_t_clear(account.id_group); \
- macro_f_string_dynamic_t_clear(account.home); \
- macro_f_string_dynamic_t_clear(account.label); \
- macro_f_string_dynamic_t_clear(account.name); \
- macro_f_string_dynamic_t_clear(account.password); \
- macro_f_string_dynamic_t_clear(account.shell);
+ #define macro_f_account_t_clear(account) { \
+ macro_f_uid_t_clear(account.id_user) \
+ macro_f_gid_t_clear(account.id_group) \
+ macro_f_string_dynamic_t_clear(account.home) \
+ macro_f_string_dynamic_t_clear(account.label) \
+ macro_f_string_dynamic_t_clear(account.name) \
+ macro_f_string_dynamic_t_clear(account.password) \
+ macro_f_string_dynamic_t_clear(account.shell) \
+ }
#define macro_f_account_t_delete_simple(accounts) f_account_delete(&accounts);
#define macro_f_account_t_destroy_simple(accounts) f_account_destroy(&accounts);
#define macro_f_accounts_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_accounts_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_accounts_t_clear(accounts) macro_f_memory_structures_clear(accounts)
+ #define macro_f_accounts_t_clear(accounts) { \
+ accounts.array = 0; \
+ accounts.used = 0; \
+ accounts.size = 0; \
+ }
#endif // _di_f_accounts_t_
/**
#define macro_f_accountss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_accountss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_accountss_t_clear(accountss) macro_f_memory_structures_clear(accountss)
+ #define macro_f_accountss_t_clear(accountss) { \
+ accountss.array = 0; \
+ accountss.used = 0; \
+ accountss.size = 0; \
+ }
#endif // _di_f_accountss_t_
#ifdef __cplusplus
#define macro_f_color_format_t_initialize_1(begin, end, medium) { begin, end, medium }
- #define macro_f_color_format_t_clear(format) \
+ #define macro_f_color_format_t_clear(format) { \
macro_f_string_static_t_clear(format.begin) \
macro_f_string_static_t_clear(format.end) \
- macro_f_string_static_t_clear(format.medium)
+ macro_f_string_static_t_clear(format.medium) \
+ }
- #define macro_f_color_format_t_set_linux(format) \
+ #define macro_f_color_format_t_set_linux(format) { \
format.begin = f_color_begin_s; \
format.end = f_color_end_s; \
- format.medium = f_color_medium_s;
+ format.medium = f_color_medium_s; \
+ }
- #define macro_f_color_format_t_set_xterminal(format) \
+ #define macro_f_color_format_t_set_xterminal(format) { \
format.begin = f_color_begin_s; \
format.end = f_color_end_s; \
- format.medium = f_color_medium_s;
+ format.medium = f_color_medium_s; \
+ }
#endif // _di_f_color_format_t_
/**
f_string_dynamic_t warning;
} f_color_context_t;
- // @todo create allocate/clear/etc... functions.
#define f_color_context_t_initialize { \
f_color_t_initialize_linux, \
f_color_format_t_initialize_linux, \
f_number_unsigneds_t_initialize, \
f_number_unsigneds_t_initialize, \
}
+
+ #define macro_f_console_parameter_t_clear(console_parameter) { \
+ macro_f_string_static_t_clear(console_parameter.match_short) \
+ macro_f_string_static_t_clear(console_parameter.match_long) \
+ macro_f_string_static_t_clear(console_parameter.match_simple) \
+ console_parameter.values_total = 0; \
+ console_parameter.flag = 0; \
+ console_parameter.result = f_console_result_none_d; \
+ console_parameter.location = 0; \
+ console_parameter.location_sub = 0; \
+ macro_f_number_unsigneds_t_clear(console_parameter.locations) \
+ macro_f_number_unsigneds_t_clear(console_parameter.locations_sub) \
+ macro_f_number_unsigneds_t_clear(console_parameter.values) \
+ }
#endif // _di_f_console_parameter_t_
/**
used, \
on_match \
}
+
+ #define macro_f_console_parameters_t_clear(console_parameters) { \
+ console_parameters.before = 0; \
+ macro_f_string_dynamics_t_clear(console_parameters.arguments) \
+ macro_f_number_unsigneds_t_clear(console_parameters.remaining) \
+ console_parameters.used = 0; \
+ macro_f_console_parameters_t_clear(console_parameters.on_match) \
+ }
#endif // _di_f_console_parameters_t_
/**
#define macro_f_control_group_t_initialize_1(as_new, path, groups) { as_new, path, groups }
- #define macro_f_control_group_t_clear(control) \
+ #define macro_f_control_group_t_clear(control) { \
control.as_new = F_false; \
- macro_f_string_dynamic_t_clear(control.path); \
- macro_f_string_dynamics_t_clear(control.groups);
+ macro_f_string_dynamic_t_clear(control.path) \
+ macro_f_string_dynamics_t_clear(control.groups) \
+ }
#endif // _di_f_control_group_t_
#ifdef __cplusplus
#define macro_f_conversion_data_t_initialize_1(base, flag, width) { base, flag, width }
- #define macro_f_conversion_data_t_clear(data) \
+ #define macro_f_conversion_data_t_clear(data) { \
data.base = 0; \
data.flag = 0; \
- data.width = 0;
+ data.width = 0; \
+ }
#endif // _di_f_conversion_data_t_
/**
socket, \
unknown, \
}
+
+ #define macro_f_directory_listing_t_clear(directory_listing) { \
+ macro_f_string_dynamics_t_clear(directory_listing.block) \
+ macro_f_string_dynamics_t_clear(directory_listing.character) \
+ macro_f_string_dynamics_t_clear(directory_listing.directory) \
+ macro_f_string_dynamics_t_clear(directory_listing.regular) \
+ macro_f_string_dynamics_t_clear(directory_listing.link) \
+ macro_f_string_dynamics_t_clear(directory_listing.fifo) \
+ macro_f_string_dynamics_t_clear(directory_listing.socket) \
+ macro_f_string_dynamics_t_clear(directory_listing.unknown) \
+ }
#endif // _di_f_directory_listing_t_
/**
#define macro_f_directory_listings_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_listings_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_listings_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_listings_t_clear(directory_listings) { \
+ directory_listings.array = 0; \
+ directory_listings.used = 0; \
+ directory_listings.size = 0; \
+ }
#endif // _di_f_directory_listings_t_
/**
#define macro_f_directory_listingss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_listingss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_listingss_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_listingss_t_clear(directory_listingss) { \
+ directory_listingss.array = 0; \
+ directory_listingss.used = 0; \
+ directory_listingss.size = 0; \
+ }
#endif // _di_f_directory_listingss_t_
/**
#define macro_f_directory_recurse_dos_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_recurse_dos_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_recurse_dos_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_recurse_dos_t_clear(directory_recurse_dos) { \
+ directory_recurse_dos.array = 0; \
+ directory_recurse_dos.used = 0; \
+ directory_recurse_dos.size = 0; \
+ }
#endif // _di_f_directory_recurse_dos_t_
/**
#define macro_f_directory_recurse_doss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_recurse_doss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_recurse_doss_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_recurse_doss_t_clear(directory_recurse_doss) { \
+ directory_recurse_doss.array = 0; \
+ directory_recurse_doss.used = 0; \
+ directory_recurse_doss.size = 0; \
+ }
#endif // _di_f_directory_recurse_doss_t_
/**
#define macro_f_directory_status_t_initialize_1(status, path) { status, path }
- #define macro_f_directory_status_t_clear(directory) \
+ #define macro_f_directory_status_t_clear(directory) { \
directory.status = 0; \
- macro_f_string_dynamic_t_clear(directory.path);
+ macro_f_string_dynamic_t_clear(directory.path) \
+ }
#endif // _di_f_directory_status_t_
/**
#define macro_f_directory_statuss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_statuss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_statuss_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_statuss_t_clear(directory_statuss) { \
+ directory_statuss.array = 0; \
+ directory_statuss.used = 0; \
+ directory_statuss.size = 0; \
+ }
#endif // _di_f_directory_statuss_t_
/**
#define macro_f_directory_statusss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_directory_statusss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_directory_statusss_t_clear(structures) macro_f_memory_structures_clear(structures)
+ #define macro_f_directory_statusss_t_clear(directory_statusss) { \
+ directory_statusss.array = 0; \
+ directory_statusss.used = 0; \
+ directory_statusss.size = 0; \
+ }
#endif // _di_f_directory_statusss_t_
/**
#define macro_f_execute_scheduler_t_initialize_1(policy, priority) { policy, priority }
- #define f_execute_scheduler_t_clear(scheduler) \
+ #define f_execute_scheduler_t_clear(scheduler) { \
scheduler.policy = 0; \
- scheduler.priority = 0;
+ scheduler.priority = 0; \
+ }
#endif // _di_f_execute_scheduler_t_
/**
#define macro_f_fss_item_t_initialize_1(object, close, content, parent) macro_f_number_unsigneds_t_initialize_1(object, close, content, parent)
- #define macro_f_fss_item_t_clear(item) \
- macro_f_range_t_clear(item.object); \
- macro_f_range_t_clear(item.close); \
- macro_f_ranges_t_clear(item.content); \
- item.parent = 0;
+ #define macro_f_fss_item_t_clear(item) { \
+ macro_f_range_t_clear(item.object) \
+ macro_f_range_t_clear(item.close) \
+ macro_f_ranges_t_clear(item.content) \
+ item.parent = 0; \
+ }
#endif // _di_f_fss_item_t_
/**
#define macro_f_fss_items_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_items_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_fss_items_t_clear(fss_items) { \
+ fss_items.array = 0; \
+ fss_items.used = 0; \
+ fss_items.size = 0; \
+ }
#endif // _di_f_fss_items_t_
/**
#define macro_f_fss_itemss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_itemss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_fss_itemss_t_clear(fss_itemss) { \
+ fss_itemss.array = 0; \
+ fss_itemss.used = 0; \
+ fss_itemss.size = 0; \
+ }
#endif // _di_f_fss_itemss_t_
/**
#define macro_f_fss_named_t_initialize_1(name, objects, contents, quotess) macro_f_number_unsigneds_t_initialize_1(name, objects, contents, quotess)
#define macro_f_fss_named_t_initialize_2(name) macro_f_number_unsigneds_t_initialize_1(name, f_ranges_t_initialize, f_rangess_t_initialize, f_uint8ss_t_initialize)
- #define macro_f_fss_named_t_clear(named) \
+ #define macro_f_fss_named_t_clear(named) { \
macro_f_range_t_clear(named.name) \
macro_f_ranges_t_clear(named.objects) \
macro_f_rangess_t_clear(named.contents) \
- macro_f_uint8ss_t_clear(named.quotess)
+ macro_f_uint8ss_t_clear(named.quotess) \
+ }
#endif // _di_f_fss_named_t_
/**
#define macro_f_fss_nameds_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_nameds_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_nameds_t_clear(nameds) macro_f_memory_structures_clear(nameds)
+ #define macro_f_fss_nameds_t_clear(fss_nameds) { \
+ fss_nameds.array = 0; \
+ fss_nameds.used = 0; \
+ fss_nameds.size = 0; \
+ }
#endif // _di_f_fss_nameds_t_
/**
#define macro_f_fss_namedss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_namedss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_namedss_t_clear(nameds) macro_f_memory_structures_clear(nameds)
+ #define macro_f_fss_namedss_t_clear(fss_namedss) { \
+ fss_namedss.array = 0; \
+ fss_namedss.used = 0; \
+ fss_namedss.size = 0; \
+ }
#endif // _di_f_fss_namedss_t_
/**
#define macro_f_fss_nest_t_initialize_1(depth_value, used_value, size_value) { .depth = depth_value, .used = used_value, .size = size_value }
#define macro_f_fss_nest_t_initialize_2(depth_value, length_value) { .depth = depth_value, .used = length_value, .size = length_value }
- #define macro_f_fss_nest_t_clear(nest) macro_f_memory_structures_clear(nest)
+ #define macro_f_fss_nest_t_clear(fss_nest) { \
+ fss_nest.array = 0; \
+ fss_nest.used = 0; \
+ fss_nest.size = 0; \
+ }
#endif // _di_f_fss_nest_t_
/**
#define macro_f_fss_nests_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_nests_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_nests_t_clear(nests) macro_f_memory_structures_clear(nests)
+ #define macro_f_fss_nests_t_clear(fss_nests) { \
+ fss_nests.array = 0; \
+ fss_nests.used = 0; \
+ fss_nests.size = 0; \
+ }
#endif // _di_f_fss_nests_t_
/**
#define macro_f_fss_nestss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_nestss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_nestss_t_clear(nests) macro_f_memory_structures_clear(nests)
+ #define macro_f_fss_nestss_t_clear(fss_nestss) { \
+ fss_nestss.array = 0; \
+ fss_nestss.used = 0; \
+ fss_nestss.size = 0; \
+ }
#endif // _di_f_fss_nestss_t_
/**
#define macro_f_fss_set_t_initialize_1(objects, contents) { objects, contents }
- #define macro_f_fss_set_t_clear(set) \
+ #define macro_f_fss_set_t_clear(set) { \
macro_f_ranges_t_clear(set.objects) \
- macro_f_rangess_t_clear(set.contents)
+ macro_f_rangess_t_clear(set.contents) \
+ }
#endif // _di_f_fss_set_t_
/**
#define macro_f_fss_sets_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_sets_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_sets_t_clear(sets) macro_f_memory_structures_clear(sets)
+ #define macro_f_fss_sets_t_clear(fss_sets) { \
+ fss_sets.array = 0; \
+ fss_sets.used = 0; \
+ fss_sets.size = 0; \
+ }
#endif // _di_f_fss_sets_t_
/**
#define macro_f_fss_setss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_setss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_setss_t_clear(sets) macro_f_memory_structures_clear(sets)
+ #define macro_f_fss_setss_t_clear(fss_setss) { \
+ fss_setss.array = 0; \
+ fss_setss.used = 0; \
+ fss_setss.size = 0; \
+ }
#endif // _di_f_fss_setss_t_
/**
#define macro_f_fss_set_quote_t_initialize_1(objects, contents, objects_quote, contents_quote) { objects, contents, objects_quote, contents_quote }
- #define macro_f_fss_set_quote_t_clear(set) \
+ #define macro_f_fss_set_quote_t_clear(set) { \
macro_f_ranges_t_clear(set.objects) \
macro_f_rangess_t_clear(set.contents) \
macro_f_uint8s_t_clear(set.objects_quote) \
- macro_f_uint8ss_t_clear(set.contents_quote)
+ macro_f_uint8ss_t_clear(set.contents_quote) \
+ }
#endif // _di_f_fss_set_quote_t_
/**
#define macro_f_fss_set_quotes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_set_quotes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_set_quotes_t_clear(set_quotes) macro_f_memory_structures_clear(set_quotes)
+ #define macro_f_fss_set_quotes_t_clear(fss_set_quotes) { \
+ fss_set_quotes.array = 0; \
+ fss_set_quotes.used = 0; \
+ fss_set_quotes.size = 0; \
+ }
#endif // _di_f_fss_set_quotes_t_
/**
#define macro_f_fss_set_quotess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_set_quotess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_set_quotess_t_clear(set_quotes) macro_f_memory_structures_clear(set_quotes)
+ #define macro_f_fss_set_quotess_t_clear(fss_set_quotess) { \
+ fss_set_quotess.array = 0; \
+ fss_set_quotess.used = 0; \
+ fss_set_quotess.size = 0; \
+ }
#endif // _di_f_fss_set_quotess_t_
/**
f_string_dynamic_t payload;
} f_fss_simple_packet_t;
- #define f_fss_simple_packet_t_initialize { \
- 0, \
- 0, \
- f_string_dynamic_t_initialize, \
- }
+ #define f_fss_simple_packet_t_initialize { 0, 0, f_string_dynamic_t_initialize }
- #define macro_f_fss_simple_packet_t_initialize_1(control, size, payload) { \
- control, \
- size, \
- payload, \
- }
+ #define macro_f_fss_simple_packet_t_initialize_1(control, size, payload) { control, size, payload }
+ #define macro_f_fss_simple_packet_t_initialize_2(payload) { 0, 0, payload }
- #define macro_f_fss_simple_packet_t_initialize_2(payload) { \
- 0, \
- 0, \
- payload, \
+ #define macro_f_fss_simple_packet_t_clear(fss_simple_packet) { \
+ fss_simple_packet.array = 0; \
+ fss_simple_packet.used = 0; \
+ fss_simple_packet.size = 0; \
}
#endif // _di_f_fss_simple_packet_t_
#define macro_f_fss_simple_packets_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_simple_packets_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_simple_packets_t_clear(simple_packets) macro_f_memory_structures_clear(simple_packets)
+ #define macro_f_fss_simple_packets_t_clear(fss_simple_packets) { \
+ fss_simple_packets.array = 0; \
+ fss_simple_packets.used = 0; \
+ fss_simple_packets.size = 0; \
+ }
#endif // _di_f_fss_simple_packets_t_
/**
#define macro_f_fss_simple_packetss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_simple_packetss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_simple_packetss_t_clear(simple_packetss) macro_f_memory_structures_clear(simple_packetss)
+ #define macro_f_fss_simple_packetss_t_clear(fss_simple_packetss) { \
+ fss_simple_packetss.array = 0; \
+ fss_simple_packetss.used = 0; \
+ fss_simple_packetss.size = 0; \
+ }
#endif // _di_f_fss_simple_packetss_t_
/**
f_range_t payload;
} f_fss_simple_packet_range_t;
- #define f_fss_simple_packet_range_t_initialize { \
- 0, \
- 0, \
- f_range_t_initialize, \
- }
+ #define f_fss_simple_packet_range_t_initialize { 0, 0, f_range_t_initialize }
- #define macro_f_fss_simple_packet_range_t_initialize_1(control, size, payload) { \
- control, \
- size, \
- payload, \
- }
+ #define macro_f_fss_simple_packet_range_t_initialize_1(control, size, payload) { control, size, payload }
+ #define macro_f_fss_simple_packet_range_t_initialize_2(payload) { 0, 0, payload }
- #define macro_f_fss_simple_packet_range_t_initialize_2(payload) { \
- 0, \
- 0, \
- payload, \
+ #define macro_f_fss_simple_packet_range_t_clear(fss_simple_packet_range) { \
+ fss_simple_packet_range.control = 0; \
+ fss_simple_packet_range.size = 0; \
+ macro_f_range_t_clear(fss_simple_packet_range.payload) \
}
#endif // _di_f_fss_simple_packet_range_t_
#define macro_f_fss_simple_packet_ranges_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_simple_packet_ranges_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_simple_packet_ranges_t_clear(simple_packet_ranges) macro_f_memory_structures_clear(simple_packet_ranges)
+ #define macro_f_fss_simple_packet_ranges_t_clear(fss_simple_packet_ranges) { \
+ fss_simple_packet_ranges.array = 0; \
+ fss_simple_packet_ranges.used = 0; \
+ fss_simple_packet_ranges.size = 0; \
+ }
#endif // _di_f_fss_simple_packet_ranges_t_
/**
#define macro_f_fss_simple_packet_rangess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fss_simple_packet_rangess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_fss_simple_packet_rangess_t_clear(simple_packet_rangess) macro_f_memory_structures_clear(simple_packet_rangess)
+ #define macro_f_fss_simple_packet_rangess_t_clear(fss_simple_packet_rangess) { \
+ fss_simple_packet_rangess.array = 0; \
+ fss_simple_packet_rangess.used = 0; \
+ fss_simple_packet_rangess.size = 0; \
+ }
#endif // _di_f_fss_simple_packet_rangess_t_
/**
#define macro_f_iki_data_t_initialize_1(content, delimits, variable, vocabulary) { content, delimits, variable, vocabulary }
- #define macro_f_iki_data_t_clear(data) \
- f_ranges_t_clear(data.content) \
- f_number_unsigneds_t_clear(data.delimits) \
- f_ranges_t_clear(data.variable) \
- f_ranges_t_clear(data.vocabulary)
+ #define macro_f_iki_data_t_clear(data) { \
+ macro_f_ranges_t_clear(data.content) \
+ macro_f_number_unsigneds_t_clear(data.delimits) \
+ macro_f_ranges_t_clear(data.variable) \
+ macro_f_ranges_t_clear(data.vocabulary) \
+ }
#endif // _di_f_iki_data_t_
/**
#define macro_f_iki_datas_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_iki_datas_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_iki_datas_t_clear(iki_datas) { \
+ iki_datas.array = 0; \
+ iki_datas.used = 0; \
+ iki_datas.size = 0; \
+ }
#endif // _di_f_iki_datas_t_
/**
#define macro_f_iki_datass_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_iki_datass_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_iki_datass_t_clear(iki_datass) { \
+ iki_datass.array = 0; \
+ iki_datass.used = 0; \
+ iki_datass.size = 0; \
+ }
#endif // _di_f_iki_datass_t_
/**
#define macro_f_iki_eki_t_initialize_1(content, delimits, variable, vocabularys) { content, delimits, variable, vocabularys }
- #define macro_f_iki_eki_t_clear(data) \
- f_ranges_t_clear(data.content) \
- f_number_unsigneds_t_clear(data.delimits) \
- f_ranges_t_clear(data.variable) \
- f_ranges_t_clear(data.vocabulary)
+ #define macro_f_iki_eki_t_clear(data) { \
+ macro_f_ranges_t_clear(data.content) \
+ macro_f_number_unsigneds_t_clear(data.delimits) \
+ macro_f_ranges_t_clear(data.variable) \
+ macro_f_ranges_t_clear(data.vocabulary) \
+ }
#endif // _di_f_iki_eki_t_
/**
#define macro_f_iki_ekis_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_iki_ekis_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_iki_ekis_t_clear(iki_ekis) { \
+ iki_ekis.array = 0; \
+ iki_ekis.used = 0; \
+ iki_ekis.size = 0; \
+ }
#endif // _di_f_iki_ekis_t_
/**
#define macro_f_iki_ekiss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_iki_ekiss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_iki_ekiss_t_clear(iki_ekiss) { \
+ iki_ekiss.array = 0; \
+ iki_ekiss.used = 0; \
+ iki_ekiss.size = 0; \
+ }
#endif // _di_f_iki_ekiss_t_
#ifdef __cplusplus
#define macro_f_limit_set_t_initialize_1(type, value) { type, value }
- #define macro_f_limit_set_t_clear(set) \
+ #define macro_f_limit_set_t_clear(set) { \
set.type = 0; \
- macro_f_limit_value_t_clear(set.value);
+ macro_f_limit_value_t_clear(set.value) \
+ }
#endif // _di_f_limit_set_t_
/**
#define macro_f_limit_sets_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_limit_sets_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_limit_sets_t_clear(limit_sets) { \
+ limit_sets.array = 0; \
+ limit_sets.used = 0; \
+ limit_sets.size = 0; \
+ }
#endif // _di_f_limit_sets_t_
/**
#define macro_f_limit_setss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_limit_setss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_limit_setss_t_clear(limit_setss) { \
+ limit_setss.array = 0; \
+ limit_setss.used = 0; \
+ limit_setss.size = 0; \
+ }
#endif // _di_f_limit_setss_t_
/**
#define macro_f_limit_values_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_limit_values_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_limit_values_t_clear(limit_values) { \
+ limit_values.array = 0; \
+ limit_values.used = 0; \
+ limit_values.size = 0; \
+ }
#endif // _di_f_limit_values_t_
/**
#define macro_f_limit_valuess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_limit_valuess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_limit_valuess_t_clear(limit_valuess) { \
+ limit_valuess.array = 0; \
+ limit_valuess.used = 0; \
+ limit_valuess.size = 0; \
+ }
#endif // _di_f_limit_valuess_t_
/**
#define macro_f_network_family_ip_t_initialize_1(v4) { f_network_family_ip_4_e, macro_f_network_family_ip_4_or_6_t_initialize_1(v4) }
#define macro_f_network_family_ip_t_initialize_2(v6) { f_network_family_ip_6_e, macro_f_network_family_ip_4_or_6_t_initialize_2(v6) }
- #define f_network_family_ip_t_clear(family_ip) \
+ #define f_network_family_ip_t_clear(family_ip) { \
family_ip.type = f_network_family_none_e; \
- f_network_family_ip_t_clear(family_ip.address)
+ f_network_family_ip_t_clear(family_ip.address) \
+ }
#endif // _di_f_network_family_ip_t_
#ifdef __cplusplus
deadline, \
period, \
}
+
+ #define macro_f_schedule_attribute_t_clear(schedule_attribute) { \
+ schedule_attribute.array = 0; \
+ schedule_attribute.used = 0; \
+ schedule_attribute.size = 0; \
+ }
#endif // _di_f_schedule_attribute_t_
/**
#define macro_f_signal_t_initialize_1(flags, id, set) { flags, id, set }
- #define macro_f_signal_t_clear(signal) \
+ #define macro_f_signal_t_clear(signal) { \
signal.flags = 0; \
signal.id = -1; \
- signal.set[0] = 0;
+ signal.set[0] = 0; \
+ }
#endif // _di_f_signal_t_
/**
#define f_signal_how_t_initialize { { 0 } , { 0 } }
#define macro_f_signal_how_t_initialize_1(block, block_not) { block, block_not }
+
+ #define macro_f_signal_how_t_clear(signal_how) { \
+ signal_how.block[0] = 0; \
+ signal_how.block_not[0] = 0; \
+ }
#endif // _di_f_signal_how_t_
#ifdef __cplusplus
#define macro_f_socket_addresss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_socket_addresss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_socket_addresss_t_clear(socket_addresss) { \
+ socket_addresss.array = 0; \
+ socket_addresss.used = 0; \
+ socket_addresss.size = 0; \
+ }
#endif // _di_f_socket_addresss_t_
/**
#define macro_f_socket_addressss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_socket_addressss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_socket_addressss_t_clear(socket_addressss) { \
+ socket_addressss.array = 0; \
+ socket_addressss.used = 0; \
+ socket_addressss.size = 0; \
+ }
#endif // _di_f_socket_addressss_t_
/**
* Commonly used socket related properties, loosely based off of f_file_t.
*
* Properties:
- * - id: Socket file descriptor, used for binding and listening.
- * - id_data: Data file descriptor, used for reading and writing data from or to the socket.
+ * - id: Socket file descriptor, used for binding and listening (set to -1 to designate not used).
+ * - id_data: Data file descriptor, used for reading and writing data from or to the socket (set to -1 to designate not used).
* - domain: The socket domain (protocol family, such as f_socket_protocol_family_local_e).
* - protocol: The socket protocol (such as f_socket_protocol_tcp_e).
* - type: The socket type (address family, such as f_socket_address_family_local_e).
f_string_static_t name;
} f_socket_t;
- #define f_socket_t_initialize { -1, -1, 0, 0, 0, f_socket_address_form_generic_e, F_socket_default_read_size_d, F_socket_default_write_size_d, f_socket_address_t_initialize, 0, f_string_static_t_initialize }
+ #define f_socket_t_initialize { \
+ -1, \
+ -1, \
+ 0, \
+ 0, \
+ 0, \
+ f_socket_address_form_generic_e, \
+ F_socket_default_read_size_d, \
+ F_socket_default_write_size_d, \
+ f_socket_address_t_initialize, \
+ 0, \
+ f_string_static_t_initialize \
+ }
#define macro_f_socket_t_initialize_1(form, address, length) { \
-1, \
name \
}
- #define macro_f_socket_t_clear(file) \
+ #define macro_f_socket_t_clear(file) { \
file.id = -1; \
file.id_data = -1; \
file.domain = 0; \
file.size_read = 0; \
file.size_write = 0; \
file.length = 0; \
- macro_f_string_static_t_clear(file);
+ macro_f_string_static_t_clear(file) \
+ }
- #define macro_f_socket_t_reset(file) \
+ #define macro_f_socket_t_reset(file) { \
file.id = -1; \
file.id_data = -1; \
file.domain = 0; \
file.size_read = F_socket_default_read_size_d; \
file.size_write = F_socket_default_write_size_d; \
file.length = 0; \
- macro_f_string_static_t_clear(file);
+ macro_f_string_static_t_clear(file) \
+ }
#endif // _di_f_socket_t_
/**
#define macro_f_sockets_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_sockets_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_sockets_t_clear(sockets) { \
+ sockets.array = 0; \
+ sockets.used = 0; \
+ sockets.size = 0; \
+ }
#endif // _di_f_sockets_t_
/**
#define macro_f_socketss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_socketss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_socketss_t_clear(socketss) { \
+ socketss.array = 0; \
+ socketss.used = 0; \
+ socketss.size = 0; \
+ }
#endif // _di_f_socketss_t_
/**
#define macro_f_string_map_t_initialize_1(key, value) { key, value }
- #define macro_f_string_map_t_clear(map) \
+ #define macro_f_string_map_t_clear(map) { \
macro_f_string_dynamic_t_clear(map.key) \
- macro_f_string_dynamic_t_clear(map.value)
+ macro_f_string_dynamic_t_clear(map.value) \
+ }
#endif // _di_f_string_map_t_
#ifdef __cplusplus
#define macro_f_string_map_multi_t_initialize_1(key, value) { key, value }
- #define macro_f_string_map_multi_t_clear(key) \
+ #define macro_f_string_map_multi_t_clear(key) { \
macro_f_string_dynamic_t_clear(key.name) \
- macro_f_string_dynamics_t_clear(key.value)
+ macro_f_string_dynamics_t_clear(key.value) \
+ }
#endif // _di_f_string_map_multi_t_
#ifdef __cplusplus
#define macro_f_string_map_multis_t_initialize_1(array, size, used) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_map_multis_t_initialize_2(array, length) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_map_multis_t_clear(map_multis) \
+ #define macro_f_string_map_multis_t_clear(map_multis) { \
map_multis.array = 0; \
map_multis.used = 0; \
- map_multis.size = 0;
+ map_multis.size = 0; \
+ }
#endif // _di_f_string_map_multis_t_
/**
#define macro_f_string_map_multiss_t_initialize_1(array, size, used) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_map_multiss_t_initialize_2(array, length) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_map_multiss_t_clear(map_multiss) \
+ #define macro_f_string_map_multiss_t_clear(map_multiss) { \
map_multiss.array = 0; \
map_multiss.used = 0; \
- map_multiss.size = 0;
+ map_multiss.size = 0; \
+ }
#endif // _di_f_string_map_multiss_t_
/**
#define macro_f_string_maps_t_initialize_1(array, size, used) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_maps_t_initialize_2(array, length) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_maps_t_clear(maps) \
+ #define macro_f_string_maps_t_clear(maps) { \
maps.array = 0; \
maps.used = 0; \
- maps.size = 0;
+ maps.size = 0; \
+ }
#endif // _di_f_string_maps_t_
/**
#define macro_f_string_mapss_t_initialize_1(array, size, used) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_mapss_t_initialize_2(array, length) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_mapss_t_clear(mapss) \
+ #define macro_f_string_mapss_t_clear(mapss) { \
mapss.array = 0; \
mapss.used = 0; \
- mapss.size = 0;
+ mapss.size = 0; \
+ }
#endif // _di_f_string_mapss_t_
/**
#define macro_f_string_statics_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_statics_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_statics_t_clear(statics) \
+ #define macro_f_string_statics_t_clear(statics) { \
statics.array = 0; \
statics.used = 0; \
- statics.size = 0;
+ statics.size = 0; \
+ }
#endif // _di_f_string_statics_t_
#ifdef __cplusplus
#define macro_f_string_staticss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_staticss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_staticss_t_clear(staticss) \
+ #define macro_f_string_staticss_t_clear(staticss) { \
staticss.array = 0; \
staticss.used = 0; \
- staticss.size = 0;
+ staticss.size = 0; \
+ }
#endif // _di_f_string_staticss_t_
#ifdef __cplusplus
#define macro_f_string_triple_t_initialize_1(a, b, c) { a, b, c }
- #define macro_f_string_triple_t_clear(triple) \
- triple.a.array = 0; \
- triple.a.size = 0; \
- triple.a.used = 0; \
- triple.b.array = 0; \
- triple.b.size = 0; \
- triple.b.used = 0; \
- triple.c.array = 0; \
- triple.c.size = 0; \
- triple.c.used = 0;
+ #define macro_f_string_triple_t_clear(triple) { \
+ macro_f_string_dynamic_t_clear(triple.a) \
+ macro_f_string_dynamic_t_clear(triple.b) \
+ macro_f_string_dynamic_t_clear(triple.c) \
+ }
#endif // _di_f_string_triple_t_
#ifdef __cplusplus
#define macro_f_string_triples_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_triples_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_triples_t_clear(triples) \
+ #define macro_f_string_triples_t_clear(triples) { \
triples.array = 0; \
triples.used = 0; \
- triples.size = 0;
+ triples.size = 0; \
+ }
#endif // _di_f_string_triples_t_
/**
#define macro_f_string_tripless_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_string_tripless_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_string_tripless_t_clear(tripless) \
+ #define macro_f_string_tripless_t_clear(tripless) { \
tripless.array = 0; \
tripless.used = 0; \
- tripless.size = 0;
+ tripless.size = 0; \
+ }
#endif // _di_f_string_tripless_t_
/**
#define macro_f_thread_attributes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_attributes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_attributes_t_clear(thread_attributes) { \
+ thread_attributes.array = 0; \
+ thread_attributes.used = 0; \
+ thread_attributes.size = 0; \
+ }
#endif // _di_f_thread_attributes_t_
/**
#endif
/**
- * An array of an array of f_thread_attributes_t.
+ * An array of an array of f_thread_attribute_t.
*
* Properties:
* - array: The array of f_thread_attributes_t.
#define macro_f_thread_attributess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_attributess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_attributess_t_clear(thread_attributess) { \
+ thread_attributess.array = 0; \
+ thread_attributess.used = 0; \
+ thread_attributess.size = 0; \
+ }
#endif // _di_f_thread_attributess_t_
/**
/**
* A typedef representing pthread_barrierattr_t.
+ *
+ * This does not provide a clear macro because pthread_cond_t requires special functions to perform a clear.
*/
#ifndef _di_f_thread_barrier_attribute_t_
typedef pthread_barrierattr_t f_thread_barrier_attribute_t;
#define macro_f_thread_barrier_attributes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_barrier_attributes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_barrier_attributes_t_clear(thread_barrier_attributes) { \
+ thread_barrier_attributes.array = 0; \
+ thread_barrier_attributes.used = 0; \
+ thread_barrier_attributes.size = 0; \
+ }
#endif // _di_f_thread_barrier_attributes_t_
/**
#define macro_f_thread_barrier_attributess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_barrier_attributess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_barrier_attributess_t_clear(thread_barrier_attributess) { \
+ thread_barrier_attributess.array = 0; \
+ thread_barrier_attributess.used = 0; \
+ thread_barrier_attributess.size = 0; \
+ }
#endif // _di_f_thread_barrier_attributess_t_
/**
* A structure of the barrier and its associated attribute.
*
* Properties:
- * - barrier: The barrier.
+ * - barrier: The barrier (cannot be cleared using the clear macro).
* - attribute: The associated attribute.
*/
#ifndef _di_f_thread_barrier_full_t_
#define f_thread_barrier_full_t_initialize { f_thread_barrier_t_initialize, f_thread_barrier_attribute_t_initialize }
#define macro_f_thread_barrier_full_t_initialize_1(barrier, attribute) { barrier, attribute }
+
+ #define macro_f_thread_barrier_full_t_clear(thread_barrier_full) { \
+ macro_f_thread_barrier_attribute_t_clear(thread_barrier_full.attribute) \
+ }
#endif // _di_f_thread_barrier_full_t_
/**
#define macro_f_thread_barrier_fulls_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_barrier_fulls_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_barrier_fulls_t_clear(thread_barrier_fulls) { \
+ thread_barrier_fulls.array = 0; \
+ thread_barrier_fulls.used = 0; \
+ thread_barrier_fulls.size = 0; \
+ }
#endif // _di_f_thread_barrier_fulls_t_
/**
#define macro_f_thread_barrier_fullss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_barrier_fullss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_barrier_fullss_t_clear(thread_barrier_fullss) { \
+ thread_barrier_fullss.array = 0; \
+ thread_barrier_fullss.used = 0; \
+ thread_barrier_fullss.size = 0; \
+ }
#endif // _di_f_thread_barrier_fullss_t_
/**
#define macro_f_thread_barriers_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_barriers_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_barriers_t_clear(thread_barriers) { \
+ thread_barriers.array = 0; \
+ thread_barriers.used = 0; \
+ thread_barriers.size = 0; \
+ }
#endif // _di_f_thread_barriers_t_
/**
* A callback intended to be passed to f_memory_arrays_resize() for an f_thread_barriers_t structure.
*
* This must be dynamically initialized using f_thread_condition_create().
* In some cases, they can be utilized statically, in which case only f_thread_condition_t_initialize is needed.
+ *
+ * This does not provide a clear maco because pthread_cond_t requires special functions to perform a clear.
*/
#ifndef _di_f_thread_condition_t_
typedef pthread_cond_t f_thread_condition_t;
#define macro_f_thread_condition_attributes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_condition_attributes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_condition_attributes_t_clear(thread_condition_attributes) { \
+ thread_condition_attributes.array = 0; \
+ thread_condition_attributes.used = 0; \
+ thread_condition_attributes.size = 0; \
+ }
#endif // _di_f_thread_condition_attributes_t_
/**
#define macro_f_thread_condition_attributess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_condition_attributess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_condition_attributess_t_clear(thread_condition_attributess) { \
+ thread_condition_attributess.array = 0; \
+ thread_condition_attributess.used = 0; \
+ thread_condition_attributess.size = 0; \
+ }
#endif // _di_f_thread_condition_attributess_t_
/**
* A structure of the condition and its associated attribute.
*
* Properties:
- * - condition: The condition.
+ * - condition: The condition (cannot be cleared using the clear macro).
* - attribute: The associated attribute.
*/
#ifndef _di_f_thread_condition_full_t_
#define f_thread_condition_full_t_initialize { f_thread_condition_t_initialize, f_thread_condition_attribute_t_initialize }
#define macro_f_thread_condition_full_t_initialize_1(condition, attribute) { condition, attribute }
+
+ #define macro_f_thread_condition_full_t_clear(thread_condition_full) { \
+ macro_f_thread_condition_attribute_t_clear(thread_condition_full.condition_attribute) \
+ }
#endif // _di_f_thread_condition_full_t_
/**
#define macro_f_thread_condition_fulls_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_condition_fulls_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_condition_fulls_t_clear(thread_condition_fulls) { \
+ thread_condition_fulls.array = 0; \
+ thread_condition_fulls.used = 0; \
+ thread_condition_fulls.size = 0; \
+ }
#endif // _di_f_thread_condition_fulls_t_
/**
#define macro_f_thread_condition_fullss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_condition_fullss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_condition_fullss_t_clear(thread_condition_fullss) { \
+ thread_condition_fullss.array = 0; \
+ thread_condition_fullss.used = 0; \
+ thread_condition_fullss.size = 0; \
+ }
#endif // _di_f_thread_condition_fullss_t_
/**
#define macro_f_thread_conditions_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_conditions_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_conditions_t_clear(thread_conditions) { \
+ thread_conditions.array = 0; \
+ thread_conditions.used = 0; \
+ thread_conditions.size = 0; \
+ }
#endif // _di_f_thread_conditions_t_
/**
#define macro_f_thread_conditionss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_conditionss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_conditionss_t_clear(thread_conditionss) { \
+ thread_conditionss.array = 0; \
+ thread_conditionss.used = 0; \
+ thread_conditionss.size = 0; \
+ }
#endif // _di_f_thread_conditionss_t_
/**
#define macro_f_thread_ids_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_ids_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_ids_t_clear(thread_ids) { \
+ thread_ids.array = 0; \
+ thread_ids.used = 0; \
+ thread_ids.size = 0; \
+ }
#endif // _di_f_thread_ids_t_
/**
#define macro_f_thread_idss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_idss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_idss_t_clear(thread_idss) { \
+ thread_idss.array = 0; \
+ thread_idss.used = 0; \
+ thread_idss.size = 0; \
+ }
#endif // _di_f_thread_idss_t_
/**
#define macro_f_thread_keys_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_keys_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_keys_t_clear(thread_keys) { \
+ thread_keys.array = 0; \
+ thread_keys.used = 0; \
+ thread_keys.size = 0; \
+ }
#endif // _di_f_thread_keys_t_
/**
#define macro_f_thread_keyss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_keyss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_keyss_t_clear(thread_keyss) { \
+ thread_keyss.array = 0; \
+ thread_keyss.used = 0; \
+ thread_keyss.size = 0; \
+ }
#endif // _di_f_thread_keyss_t_
/**
*
* This must be dynamically initialized using f_thread_lock_create().
* In some cases, they can be utilized statically, in which case only f_thread_lock_t_initialize is needed.
+ *
+ * This does not provide a clear macro because pthread_rwlock_t requires special functions to perform a clear.
*/
#ifndef _di_f_thread_lock_t_
typedef pthread_rwlock_t f_thread_lock_t;
#define macro_f_thread_lock_attributes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_lock_attributes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_lock_attributes_t_clear(lock_attributes) { \
+ lock_attributes.array = 0; \
+ lock_attributes.used = 0; \
+ lock_attributes.size = 0; \
+ }
#endif // _di_f_thread_lock_attributes_t_
/**
#define macro_f_thread_lock_attributess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_lock_attributess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_lock_attributess_t_clear(lock_attributess) { \
+ lock_attributess.array = 0; \
+ lock_attributess.used = 0; \
+ lock_attributess.size = 0; \
+ }
#endif // _di_f_thread_lock_attributess_t_
/**
* A structure of the lock and its associated attribute.
*
* Properties:
- * - lock: The lock.
+ * - lock: The lock (cannot be cleared using the clear macro).
* - attribute: The associated attribute.
*/
#ifndef _di_f_thread_lock_full_t_
#define f_thread_lock_full_t_initialize { f_thread_lock_t_initialize, f_thread_lock_attribute_t_initialize }
#define macro_f_thread_lock_full_t_initialize_1(lock, attribute) { lock, attribute }
+
+ #define macro_f_thread_lock_full_t_clear(thread_lock_full) { \
+ macro_f_thread_lock_attribute_t_clear(thread_lock_full.attribute) \
+ }
#endif // _di_f_thread_lock_full_t_
/**
#define macro_f_thread_lock_fulls_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_lock_fulls_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_lock_fulls_t_clear(thread_lock_fulls) { \
+ thread_lock_fulls.array = 0; \
+ thread_lock_fulls.used = 0; \
+ thread_lock_fulls.size = 0; \
+ }
#endif // _di_f_thread_lock_fulls_t_
/**
#define macro_f_thread_lock_fullss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_lock_fullss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_lock_fullss_t_clear(thread_lock_fullss) { \
+ thread_lock_fullss.array = 0; \
+ thread_lock_fullss.used = 0; \
+ thread_lock_fullss.size = 0; \
+ }
#endif // _di_f_thread_lock_fullss_t_
/**
#define macro_f_thread_locks_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_locks_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_locks_t_clear(thread_locks) { \
+ thread_locks.array = 0; \
+ thread_locks.used = 0; \
+ thread_locks.size = 0; \
+ }
#endif // _di_f_thread_locks_t_
/**
#define macro_f_thread_lockss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_lockss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_lockss_t_clear(thread_lockss) { \
+ thread_lockss.array = 0; \
+ thread_lockss.used = 0; \
+ thread_lockss.size = 0; \
+ }
#endif // _di_f_thread_lockss_t_
/**
*
* This must be dynamically initialized using f_thread_mutex_create().
* In some cases, they can be utilized statically, in which case only f_thread_mutex_t_initialize is needed.
+ *
+ * This does not provide a clear macro because pthread_mutex_t requires special functions to perform a clear.
*/
#ifndef _di_f_thread_mutex_t_
typedef pthread_mutex_t f_thread_mutex_t;
#define macro_f_thread_mutex_attributes_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutex_attributes_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutex_attributes_t_clear(thread_mutex_attributes) { \
+ thread_mutex_attributes.array = 0; \
+ thread_mutex_attributes.used = 0; \
+ thread_mutex_attributes.size = 0; \
+ }
#endif // _di_f_thread_mutex_attributes_t_
/**
#define macro_f_thread_mutex_attributess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutex_attributess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutex_attributess_t_clear(thread_mutex_attributess) { \
+ thread_mutex_attributess.array = 0; \
+ thread_mutex_attributess.used = 0; \
+ thread_mutex_attributess.size = 0; \
+ }
#endif // _di_f_thread_mutex_attributess_t_
/**
* A structure of the mutex and its associated attribute.
*
* Properties:
- * - mutex: The mutex.
+ * - mutex: The mutex (cannot be cleared using the clear macro).
* - attribute: The associated attribute.
*/
#ifndef _di_f_thread_mutex_full_t_
#define f_thread_mutex_full_t_initialize { f_thread_mutex_t_initialize, f_thread_mutex_attribute_t_initialize }
#define macro_f_thread_mutex_full_t_initialize_1(mutex, attribute) { mutex, attribute }
+
+ #define macro_f_thread_mutex_full_t_clear(thread_mutex_full) { \
+ macro_f_thread_mutex_attribute_t_clear(thread_mutex_full.attribute)\
+ }
#endif // _di_f_thread_mutex_full_t_
/**
#define macro_f_thread_mutex_fulls_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutex_fulls_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutex_fulls_t_clear(thread_mutex_fulls) { \
+ thread_mutex_fulls.array = 0; \
+ thread_mutex_fulls.used = 0; \
+ thread_mutex_fulls.size = 0; \
+ }
#endif // _di_f_thread_mutex_fulls_t_
/**
#define macro_f_thread_mutex_fullss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutex_fullss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutex_fullss_t_clear(thread_mutex_fullss) { \
+ thread_mutex_fullss.array = 0; \
+ thread_mutex_fullss.used = 0; \
+ thread_mutex_fullss.size = 0; \
+ }
#endif // _di_f_thread_mutex_fullss_t_
/**
#define macro_f_thread_mutexs_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutexs_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutexs_t_clear(thread_mutexs) { \
+ thread_mutexs.array = 0; \
+ thread_mutexs.used = 0; \
+ thread_mutexs.size = 0; \
+ }
#endif // _di_f_thread_mutexs_t_
/**
#define macro_f_thread_mutexss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_mutexss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_mutexss_t_clear(thread_mutexss) { \
+ thread_mutexss.array = 0; \
+ thread_mutexss.used = 0; \
+ thread_mutexss.size = 0; \
+ }
#endif // _di_f_thread_mutexss_t_
/**
#define macro_f_thread_onces_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_onces_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_onces_t_clear(thread_onces) { \
+ thread_onces.array = 0; \
+ thread_onces.used = 0; \
+ thread_onces.size = 0; \
+ }
#endif // _di_f_thread_onces_t_
// @todo add delete & destroy callbacks.
#define macro_f_thread_oncess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_oncess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_oncess_t_clear(thread_oncess) { \
+ thread_oncess.array = 0; \
+ thread_oncess.used = 0; \
+ thread_oncess.size = 0; \
+ }
#endif // _di_f_thread_oncess_t_
// @todo add delete & destroy callbacks.
#define macro_f_thread_semaphores_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_semaphores_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_semaphores_t_clear(thread_semaphores) { \
+ thread_semaphores.array = 0; \
+ thread_semaphores.used = 0; \
+ thread_semaphores.size = 0; \
+ }
#endif // _di_f_thread_semaphores_t_
/**
#define macro_f_thread_semaphoress_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_semaphoress_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_semaphoress_t_clear(thread_semaphoress) { \
+ thread_semaphoress.array = 0; \
+ thread_semaphoress.used = 0; \
+ thread_semaphoress.size = 0; \
+ }
#endif // _di_f_thread_semaphoress_t_
/**
#define macro_f_thread_spins_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_spins_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_spins_t_clear(thread_spins) { \
+ thread_spins.array = 0; \
+ thread_spins.used = 0; \
+ thread_spins.size = 0; \
+ }
#endif // _di_f_thread_spins_t_
/**
#define macro_f_thread_spinss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_thread_spinss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_thread_spinss_t_clear(thread_spinss) { \
+ thread_spinss.array = 0; \
+ thread_spinss.used = 0; \
+ thread_spinss.size = 0; \
+ }
#endif // _di_f_thread_spinss_t_
/**
#define f_cell_t_initialize { 0, 0 }
#define macro_f_cell_t_initialize_1(row, column) { row, column }
+
+ #define macro_f_cell_t_clear(cell) { \
+ cell.row = 0; \
+ cell.column = 0; \
+ }
#endif // _di_f_cell_t_
/**
#define macro_f_cells_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_cells_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_cells_t_clear(cells) { \
+ cells.array = 0; \
+ cells.used = 0; \
+ cells.size = 0; \
+ }
#endif // _di_f_cells_t_
/**
#define macro_f_cellss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_cellss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_cellss_t_clear(cellss) { \
+ cellss.array = 0; \
+ cellss.used = 0; \
+ cellss.size = 0; \
+ }
#endif // _di_f_cellss_t_
#ifdef __cplusplus
#define macro_f_file_t_initialize_id(id) { 0, id, O_RDONLY, F_file_default_size_read_d, F_file_default_size_write_d }
#define macro_f_file_t_initialize_stream(stream) { stream, -1, O_RDONLY, F_file_default_size_read_d, F_file_default_size_write_d }
- #define macro_f_file_t_clear(file) \
+ #define macro_f_file_t_clear(file) { \
file.stream = 0; \
file.id = -1; \
file.flag = 0; \
file.size_read = 0; \
- file.size_write = 0;
+ file.size_write = 0; \
+ }
- #define macro_f_file_t_reset(file) \
+ #define macro_f_file_t_reset(file) { \
file.stream = 0; \
file.id = -1; \
file.flag = F_file_flag_read_only_d; \
file.size_read = F_file_default_size_read_d; \
- file.size_write = F_file_default_size_write_d;
+ file.size_write = F_file_default_size_write_d; \
+ }
#endif // _di_f_file_t_
/**
#define macro_f_files_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_files_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_files_t_clear(files) { \
+ files.array = 0; \
+ files.used = 0; \
+ files.size = 0; \
+ }
#endif // _di_f_files_t_
/**
#define macro_f_filess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_filess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_filess_t_clear(filess) { \
+ filess.array = 0; \
+ filess.used = 0; \
+ filess.size = 0; \
+ }
#endif // _di_f_filess_t_
/**
#ifndef _di_f_poll_t_
typedef struct pollfd f_poll_t;
- #define f_poll_t_initialize { 0 }
+ #define f_poll_t_initialize { .fd = -1, .events = 0, .revents = 0 }
#define macro_f_poll_t_initialize_1(fd, events, revents) { fd, events, revents }
#define macro_f_poll_t_initialize_2(fd, events) { fd, events, 0 }
#define macro_f_poll_t_initialize_3(fd) { fd, 0, 0 }
#define macro_f_poll_t_initialize_4(events) { 0, events, 0 }
+
+ #define macro_f_poll_t_clear(files) { \
+ files.fd = -1; \
+ files.events = 0; \
+ files.revents = 0; \
+ }
#endif // _di_f_poll_t_
/**
#define macro_f_polls_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_polls_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_polls_t_clear(polls) { \
+ polls.array = 0; \
+ polls.used = 0; \
+ polls.size = 0; \
+ }
#endif // _di_f_polls_t_
/**
#define macro_f_pollss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_pollss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_pollss_t_clear(pollss) { \
+ pollss.array = 0; \
+ pollss.used = 0; \
+ pollss.size = 0; \
+ }
#endif // _di_f_pollss_t_
#ifdef __cplusplus
}
#define macro_f_fll_id_t_initialize_1(name, type, used) { name, type, used }
+
+ #define macro_f_fll_id_t_clear(states) { \
+ states.name[0] = 0; \
+ states.name[1] = 0; \
+ states.name[2] = 0; \
+ states.name[3] = 0; \
+ states.name[4] = 0; \
+ states.name[5] = 0; \
+ states.name[6] = 0; \
+ states.name[7] = 0; \
+ states.name[8] = 0; \
+ states.name[9] = 0; \
+ states.name[0] = 0; \
+ states.name[11] = 0; \
+ states.name[12] = 0; \
+ states.name[13] = 0; \
+ states.name[14] = 0; \
+ states.name[15] = 0; \
+ states.name[16] = 0; \
+ states.name[17] = 0; \
+ states.name[18] = 0; \
+ states.name[19] = 0; \
+ states.name[20] = 0; \
+ states.name[21] = 0; \
+ states.name[22] = 0; \
+ states.name[23] = 0; \
+ states.name[24] = 0; \
+ states.name[25] = 0; \
+ states.name[26] = 0; \
+ states.name[27] = 0; \
+ states.name[28] = 0; \
+ states.name[29] = 0; \
+ states.name[30] = 0; \
+ states.name[31] = 0; \
+ states.name[32] = 0; \
+ states.name[33] = 0; \
+ states.name[34] = 0; \
+ states.name[35] = 0; \
+ states.name[36] = 0; \
+ states.name[37] = 0; \
+ states.name[38] = 0; \
+ states.name[39] = 0; \
+ states.name[40] = 0; \
+ states.name[41] = 0; \
+ states.name[42] = 0; \
+ states.name[43] = 0; \
+ states.name[44] = 0; \
+ states.name[45] = 0; \
+ states.name[46] = 0; \
+ states.name[47] = 0; \
+ states.name[48] = 0; \
+ states.name[49] = 0; \
+ states.name[50] = 0; \
+ states.name[51] = 0; \
+ states.name[52] = 0; \
+ states.name[53] = 0; \
+ states.name[54] = 0; \
+ states.name[55] = 0; \
+ states.name[56] = 0; \
+ states.name[57] = 0; \
+ states.name[58] = 0; \
+ states.name[59] = 0; \
+ states.name[60] = 0; \
+ states.name[61] = 0; \
+ states.name[62] = 0; \
+ states.name[63] = 0; \
+ states.type = 0; \
+ states.used = 0; \
+ }
#endif // _di_f_fll_id_t_
/**
#define macro_f_fll_ids_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fll_ids_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_fll_ids_t_clear(fll_ids) { \
+ fll_ids.array = 0; \
+ fll_ids.used = 0; \
+ fll_ids.size = 0; \
+ }
#endif // _di_f_fll_ids_t_
/**
#define macro_f_fll_idss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_fll_idss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_fll_idss_t_clear(fll_idss) { \
+ fll_idss.array = 0; \
+ fll_idss.used = 0; \
+ fll_idss.size = 0; \
+ }
#endif // _di_f_fll_idss_t_
#ifdef __cplusplus
mode.fifo = value_fifo; \
mode.socket = value_socket; \
mode.unknown = value_unknown;
+
+ #define macro_f_mode_t_clear(mode) { \
+ mode.block = 0; \
+ mode.character = 0; \
+ mode.directory = 0; \
+ mode.fifo = 0; \
+ mode.regular = 0; \
+ mode.link = 0; \
+ mode.socket = 0; \
+ mode.unknown = 0; \
+ }
#endif // _di_f_mode_t_
#ifdef __cplusplus
#define macro_f_number_signeds_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_number_signeds_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_number_signeds_t_clear(number_signeds) { \
+ number_signeds.array = 0; \
+ number_signeds.used = 0; \
+ number_signeds.size = 0; \
+ }
#endif // _di_f_number_signeds_t_
/**
#define macro_f_number_signedss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_number_signedss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_number_signedss_t_clear(number_signedss) { \
+ number_signedss.array = 0; \
+ number_signedss.used = 0; \
+ number_signedss.size = 0; \
+ }
#endif // _di_f_number_signedss_t_
/**
#define macro_f_number_unsigneds_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_number_unsigneds_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_number_unsigneds_t_clear(number_unsigneds) { \
+ number_unsigneds.array = 0; \
+ number_unsigneds.used = 0; \
+ number_unsigneds.size = 0; \
+ }
#endif // _di_f_number_unsigneds_t_
/**
#define macro_f_number_unsignedss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_number_unsignedss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_number_unsignedss_t_clear(number_unsignedss) { \
+ number_unsignedss.array = 0; \
+ number_unsignedss.used = 0; \
+ number_unsignedss.size = 0; \
+ }
#endif // _di_f_number_unsignedss_t_
/**
#define macro_f_int8s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int8s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int8s_t_clear(int8s) { \
+ int8s.array = 0; \
+ int8s.used = 0; \
+ int8s.size = 0; \
+ }
#endif // _di_f_int8s_t_
/**
#define macro_f_int8ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int8ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int8ss_t_clear(int8ss) { \
+ int8ss.array = 0; \
+ int8ss.used = 0; \
+ int8ss.size = 0; \
+ }
#endif // _di_f_int8ss_t_
/**
#define macro_f_uint8s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint8s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint8s_t_clear(uint8s) { \
+ uint8s.array = 0; \
+ uint8s.used = 0; \
+ uint8s.size = 0; \
+ }
#endif // _di_f_uint8s_t_
/**
#define macro_f_uint8ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint8ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint8ss_t_clear(uint8ss) { \
+ uint8ss.array = 0; \
+ uint8ss.used = 0; \
+ uint8ss.size = 0; \
+ }
#endif // _di_f_uint8ss_t_
/**
#define macro_f_int16s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int16s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int16s_t_clear(int16s) { \
+ int16s.array = 0; \
+ int16s.used = 0; \
+ int16s.size = 0; \
+ }
#endif // _di_f_int16s_t_
/**
#define macro_f_int16ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int16ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int16ss_t_clear(int16ss) { \
+ int16ss.array = 0; \
+ int16ss.used = 0; \
+ int16ss.size = 0; \
+ }
#endif // _di_f_int16ss_t_
/**
#define macro_f_uint16s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint16s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint16s_t_clear(uint16s) { \
+ uint16s.array = 0; \
+ uint16s.used = 0; \
+ uint16s.size = 0; \
+ }
#endif // _di_f_uint16s_t_
/**
#define macro_f_uint16s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint16s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint16ss_t_clear(uint16ss) { \
+ uint16ss.array = 0; \
+ uint16ss.used = 0; \
+ uint16ss.size = 0; \
+ }
#endif // _di_f_uint16ss_t_
/**
#define macro_f_int32s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int32s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int32s_t_clear(int32s) { \
+ int32s.array = 0; \
+ int32s.used = 0; \
+ int32s.size = 0; \
+ }
#endif // _di_f_int32s_t_
/**
#define macro_f_int32ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int32ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int32ss_t_clear(int32ss) { \
+ int32ss.array = 0; \
+ int32ss.used = 0; \
+ int32ss.size = 0; \
+ }
#endif // _di_f_int32ss_t_
/**
#define macro_f_uint32s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint32s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint32s_t_clear(uint32s) { \
+ uint32s.array = 0; \
+ uint32s.used = 0; \
+ uint32s.size = 0; \
+ }
#endif // _di_f_uint32s_t_
/**
#define macro_f_uint32ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint32ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint32ss_t_clear(uint32ss) { \
+ uint32ss.array = 0; \
+ uint32ss.used = 0; \
+ uint32ss.size = 0; \
+ }
#endif // _di_f_uint32ss_t_
/**
#define macro_f_int64s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int64s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int64s_t_clear(int64s) { \
+ int64s.array = 0; \
+ int64s.used = 0; \
+ int64s.size = 0; \
+ }
#endif // _di_f_int64s_t_
/**
#define macro_f_int64ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int64ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int64ss_t_clear(int64ss) { \
+ int64ss.array = 0; \
+ int64ss.used = 0; \
+ int64ss.size = 0; \
+ }
#endif // _di_f_int64ss_t_
/**
#define macro_f_uint64s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint64s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint64s_t_clear(uint64s) { \
+ uint64s.array = 0; \
+ uint64s.used = 0; \
+ uint64s.size = 0; \
+ }
#endif // _di_f_uint64s_t_
/**
#define macro_f_uint64ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint64ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint64ss_t_clear(int64s) { \
+ uint64ss.array = 0; \
+ uint64ss.used = 0; \
+ uint64ss.size = 0; \
+ }
#endif // _di_f_uint64ss_t_
/**
#define macro_f_int128s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int128s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int128s_t_clear(int128s) { \
+ int128s.array = 0; \
+ int128s.used = 0; \
+ int128s.size = 0; \
+ }
#endif // _di_f_int128s_t_
/**
#define macro_f_int128ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_int128ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_int128ss_t_clear(int128ss) { \
+ int128ss.array = 0; \
+ int128ss.used = 0; \
+ int128ss.size = 0; \
+ }
#endif // _di_f_int128ss_t_
/**
#define macro_f_uint128s_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint128s_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint128s_t_clear(uint128s) { \
+ uint128s.array = 0; \
+ uint128s.used = 0; \
+ uint128s.size = 0; \
+ }
#endif // _di_f_uint128s_t_
/**
#define macro_f_uint128ss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_uint128ss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_uint128ss_t_clear(uint128ss) { \
+ uint128ss.array = 0; \
+ uint128ss.used = 0; \
+ uint128ss.size = 0; \
+ }
#endif // _di_f_uint128ss_t_
/**
#define f_id_t_initialize -1
- #define macro_f_id_t_clear(id) id = -1;
+ #define macro_f_id_t_clear(id) { id = -1; }
/**
* The f_gid_t type, see f_id_t documentation.
#define f_gid_t_initialize -1
- #define macro_f_gid_t_clear(id) id = -1;
+ #define macro_f_gid_t_clear(id) { id = -1; }
#endif // _di_f_gid_t_
/**
#define f_uid_t_initialize -1
- #define macro_f_uid_t_clear(id) id = -1;
+ #define macro_f_uid_t_clear(id) { id = -1; }
#endif // _di_f_uid_t_
#endif // _di_f_id_t_
#define macro_f_ids_t_initialize_1(array, used, size) macro_f_uint32s_t_initialize_1(array, used, size)
#define macro_f_ids_t_initialize_2(array, length) macro_f_uint32s_t_initialize_2(array, length)
+ #define macro_f_ids_t_clear(ids) macro_f_uint32s_t_clear(ids)
+
/**
* The f_gids_t type, see f_ids_t documentation.
*/
#define macro_f_gids_t_initialize_1(array, used, size) macro_f_ids_t_initialize_1(array, used, size)
#define macro_f_gids_t_initialize_2(array, length) macro_f_ids_t_initialize_2(array, length)
+
+ #define macro_f_gids_t_clear(gids) macro_f_ids_t_clear(gids)
#endif // _di_f_gids_t_
/**
#define macro_f_uids_t_initialize_1(array, used, size) macro_f_ids_t_initialize_1(array, used, size)
#define macro_f_uids_t_initialize_2(array, length) macro_f_ids_t_initialize_2(array, length)
+
+ #define macro_f_uids_t_clear(uids) macro_f_ids_t_clear(uids)
#endif // _di_f_uids_t_
#endif // _di_f_ids_t_
#define macro_f_idss_t_initialize_1(array, used, size) macro_f_uint32ss_t_initialize_1(array, used, size)
#define macro_f_idss_t_initialize_2(array, length) macro_f_uint32ss_t_initialize_2(array, length)
+ #define macro_f_idss_t_clear(idss) macro_f_uint32ss_t_clear(idss)
+
/**
* The f_gidss_t type, see f_idss_t documentation.
*/
#define macro_f_gidss_t_initialize_1(array, used, size) macro_f_idss_t_initialize_1(array, used, size)
#define macro_f_gidss_t_initialize_2(array, length) macro_f_idss_t_initialize_2(array, length)
+
+ #define macro_f_gidss_t_clear(gidss) macro_f_idss_t_clear(gidss)
#endif // _di_f_gids_t_
/**
#define macro_f_uidss_t_initialize_1(array, used, size) macro_f_idss_t_initialize_1(array, used, size)
#define macro_f_uidss_t_initialize_2(array, length) macro_f_idss_t_initialize_2(array, length)
+
+ #define macro_f_uidss_t_clear(gidss) macro_f_idss_t_clear(uidss)
#endif // _di_f_uidss_t_
#endif // _di_f_idss_t_
#define macro_f_pids_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_pids_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_pids_t_clear(pids) { \
+ pids.array = 0; \
+ pids.used = 0; \
+ pids.size = 0; \
+ }
#endif // _di_f_pids_t_
/**
#define macro_f_pidss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_pidss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_pidss_t_clear(pidss) { \
+ pidss.array = 0; \
+ pidss.used = 0; \
+ pidss.size = 0; \
+ }
#endif // _di_f_pidss_t_
#ifdef __cplusplus
#define f_quantity_t_initialize { 0, 0 }
#define macro_f_quantity_t_initialize_1(start, total) { start, total }
+
+ #define macro_f_quantity_t_clear(quantity) { \
+ quantity.start = 0; \
+ quantity.total = 0; \
+ }
#endif // _di_f_quantity_t_
/**
#define macro_f_quantitys_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_quantitys_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_quantitys_t_clear(quantitys) { \
+ quantitys.array = 0; \
+ quantitys.used = 0; \
+ quantitys.size = 0; \
+ }
#endif // _di_f_quantitys_t_
/**
#define macro_f_quantityss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_quantityss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_quantityss_t_clear(quantityss) { \
+ quantityss.array = 0; \
+ quantityss.used = 0; \
+ quantityss.size = 0; \
+ }
#endif // _di_f_quantityss_t_
#ifdef __cplusplus
#define macro_f_range_t_initialize_1(start, stop) { start, stop }
#define macro_f_range_t_initialize_2(length) { length ? 0 : 1, length ? length - 1 : 0 }
+
+ #define macro_f_range_t_clear(range) { \
+ range.start = 1; \
+ range.stop = 0; \
+ }
#endif // _di_f_range_t_
/**
#define macro_f_ranges_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_ranges_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_ranges_t_clear(ranges) { \
+ ranges.array = 0; \
+ ranges.used = 0; \
+ ranges.size = 0; \
+ }
#endif // _di_f_ranges_t_
/**
#define macro_f_rangess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_rangess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_rangess_t_clear(rangess) { \
+ rangess.array = 0; \
+ rangess.used = 0; \
+ rangess.size = 0; \
+ }
#endif // _di_f_rangess_t_
#ifdef __cplusplus
typedef struct {
f_number_unsigned_t start_1;
f_number_unsigned_t stop_1;
+
f_number_unsigned_t start_2;
f_number_unsigned_t stop_2;
} f_range_double_t;
#define macro_f_range_double_t_initialize_1(start_1, stop_1, start_2, stop_2) { start_1, stop_1, start_2, stop_2 }
#define macro_f_range_double_t_initialize_2(length_1, length_2) { length_1 ? 0 : 1, length_1 ? length_1 - 1 : 0, length_2 ? 0 : 1, length_2 ? length_2 - 1 : 0 }
+
+ #define macro_f_range_double_t_clear(range_double) { \
+ range_double.start_1 = 1; \
+ range_double.stop_1 = 0; \
+ range_double.start_2 = 1; \
+ range_double.stop_2 = 0; \
+ }
#endif // _di_f_range_double_t_
/**
#define macro_f_range_doubles_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_range_doubles_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_range_doubles_t_clear(range_doubles) { \
+ range_doubles.array = 0; \
+ range_doubles.used = 0; \
+ range_doubles.size = 0; \
+ }
#endif // _di_f_range_doubles_t_
/**
#define macro_f_range_doubless_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_range_doubless_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_range_doubless_t_clear(range_doubless) { \
+ range_doubless.array = 0; \
+ range_doubless.used = 0; \
+ range_doubless.size = 0; \
+ }
#endif // _di_f_range_doubless_t_
#ifdef __cplusplus
#define macro_f_states_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_states_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_states_t_clear(states) { \
+ states.array = 0; \
+ states.used = 0; \
+ states.size = 0; \
+ }
#endif // _di_f_states_t_
/**
#define macro_f_statess_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_statess_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_states_t_clear(states) { \
+ states.array = 0; \
+ states.used = 0; \
+ states.size = 0; \
+ }
#endif // _di_f_statess_t_
#ifdef __cplusplus
#define macro_f_statuss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_statuss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_statuss_t_clear(statuss) { \
+ statuss.array = 0; \
+ statuss.used = 0; \
+ statuss.size = 0; \
+ }
#endif // _di_f_statuss_t_
/**
#define macro_f_statusss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_statusss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_statusss_t_clear(statusss) { \
+ statusss.array = 0; \
+ statusss.used = 0; \
+ statusss.size = 0; \
+ }
#endif // _di_f_statusss_t_
#ifdef __cplusplus
#define f_time_simple_t_initialize { f_time_t_initialize, f_time_t_initialize }
#define macro_f_time_simple_t_initialize_1(seconds, nanoseconds) { .seconds = seconds, .seconds_nano = nanoseconds };
+
+ #define macro_f_time_simple_t_clear(time_simple) { \
+ time_simple.seconds = 0; \
+ time_simple.seconds_nano = 0; \
+ }
#endif // _di_f_time_simple_t_
/**
#define f_date_t_initialize { f_number_signed_t_initialize, f_time_t_initialize }
#define macro_f_date_t_initialize_1(year, time) { .year = year, .time = time };
+
+ #define macro_f_date_t_clear(date) { \
+ date.year = 0; \
+ date.time = 0; \
+ }
#endif // _di_f_date_t_
/**
#define f_date_simple_t_initialize { f_time_t_initialize, f_time_simple_t_initialize }
#define macro_f_date_simple_t_initialize_1(year, time) { .year = year, .time = time };
+
+ #define macro_f_date_simple_t_clear(date_simple) { \
+ date_simple.year = 0; \
+ date_simple.time = 0; \
+ }
#endif // _di_f_date_simple_t_
#ifdef __cplusplus
#define macro_f_utf_string_dynamic_t_initialize_1(array, used, value) macro_f_utf_string_static_t_initialize_1(array, used, value)
#define macro_f_utf_string_dynamic_t_initialize_2(array, length) macro_f_utf_string_static_t_initialize_2(array, length)
- #define macro_f_utf_string_dynamic_t_clear(dynamic) macro_f_utf_string_static_t_clear(dynamic)
+ #define macro_f_utf_string_dynamic_t_clear(utf_string_dynamic) macro_f_utf_string_static_t_clear(utf_string_dynamic)
#endif // _di_f_utf_string_dynamic_t_
/**
#define macro_f_utf_string_dynamics_t_initialize_1(array, used, value) macro_f_utf_string_statics_t_initialize_1(array, used, value)
#define macro_f_utf_string_dynamics_t_initialize_2(array, length) macro_f_utf_string_statics_t_initialize_2(array, length)
- #define macro_f_utf_string_dynamics_t_clear(dynamics) macro_f_utf_string_statics_t_clear(dynamics)
+ #define macro_f_utf_string_dynamics_t_clear(utf_string_dynamics) macro_f_utf_string_statics_t_clear(utf_string_dynamics)
#endif // _di_f_utf_string_dynamics_t_
/**
#define macro_f_utf_string_dynamicss_t_initialize_1(array, used, value) macro_f_utf_string_staticss_t_initialize_1(array, used, value)
#define macro_f_utf_string_dynamicss_t_initialize_2(array, length) macro_f_utf_string_staticss_t_initialize_2(array, length)
- #define macro_f_utf_string_dynamicss_t_clear(dynamicss) macro_f_utf_string_staticss_t_clear(dynamicss)
+ #define macro_f_utf_string_dynamicss_t_clear(utf_string_dynamicss) macro_f_utf_string_staticss_t_clear(utf_string_dynamicss)
#endif // _di_f_utf_string_dynamicss_t_
/**
#define macro_f_utf_string_map_t_initialize_1(key, value) { key, value }
- #define macro_f_utf_string_map_t_clear(map) \
- macro_f_utf_string_dynamic_t_clear(map.key) \
- macro_f_utf_string_dynamic_t_clear(map.value)
+ #define macro_f_utf_string_map_t_clear(utf_string_map) { \
+ macro_f_utf_string_dynamic_t_clear(utf_string_map.key) \
+ macro_f_utf_string_dynamic_t_clear(utf_string_map.value) \
+ }
#endif // _di_f_utf_string_map_t_
#ifdef __cplusplus
#define macro_f_utf_string_map_multi_t_initialize_1(key, value) { key, value }
- #define macro_f_utf_string_map_multi_t_clear(map) \
+ #define macro_f_utf_string_map_multi_t_clear(map) { \
macro_f_utf_string_dynamic_t_clear(map.key) \
- macro_f_utf_string_dynamics_t_clear(map.value)
+ macro_f_utf_string_dynamics_t_clear(map.value) \
+ }
#endif // _di_f_utf_string_map_multi_t_
#ifdef __cplusplus
#define macro_f_utf_string_map_multis_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_map_multis_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_map_multis_t_clear(utf_string_map_multis) { \
+ utf_string_map_multis.array = 0; \
+ utf_string_map_multis.used = 0; \
+ utf_string_map_multis.size = 0; \
+ }
#endif // _di_f_utf_string_map_multis_t_
/**
#define macro_f_utf_string_map_multiss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_map_multiss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_map_multiss_t_clear(utf_string_map_multiss) { \
+ utf_string_map_multiss.array = 0; \
+ utf_string_map_multiss.used = 0; \
+ utf_string_map_multiss.size = 0; \
+ }
#endif // _di_f_utf_string_map_multiss_t_
/**
#define macro_f_utf_string_maps_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_maps_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_maps_t_clear(utf_string_maps) { \
+ utf_string_maps.array = 0; \
+ utf_string_maps.used = 0; \
+ utf_string_maps.size = 0; \
+ }
#endif // _di_f_utf_string_maps_t_
/**
#define macro_f_utf_string_mapss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_mapss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_mapss_t_clear(utf_string_mapss) { \
+ utf_string_mapss.array = 0; \
+ utf_string_mapss.used = 0; \
+ utf_string_mapss.size = 0; \
+ }
#endif // _di_f_utf_string_mapss_t_
/**
#define macro_f_utf_string_static_t_initialize_1(string_value, used_value, size_value) { .string = string_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_static_t_initialize_2(string_value, length_value) { .string = string_value, .used = length_value, .size = length_value }
- #define macro_f_utf_string_static_t_clear(string_static) \
- string_static.string = 0; \
- string_static.used = 0; \
- string_static.size = 0;
+ #define macro_f_utf_string_static_t_clear(utf_string_static) { \
+ utf_string_static.string = 0; \
+ utf_string_static.used = 0; \
+ utf_string_static.size = 0; \
+ }
#endif // _di_f_utf_string_static_t_
/**
#define macro_f_utf_string_statics_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_statics_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_utf_string_statics_t_clear(statics) \
+ #define macro_f_utf_string_statics_t_clear(statics) { \
statics.array = 0; \
statics.used = 0; \
- statics.size = 0;
+ statics.size = 0; \
+ }
#endif // _di_f_utf_string_statics_t_
#ifdef __cplusplus
#define macro_f_utf_string_staticss_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_staticss_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
- #define macro_f_utf_string_staticss_t_clear(staticss) \
+ #define macro_f_utf_string_staticss_t_clear(staticss) { \
staticss.array = 0; \
staticss.used = 0; \
- staticss.size = 0;
+ staticss.size = 0; \
+ }
#endif // _di_f_utf_string_staticss_t_
#ifdef __cplusplus
#define f_utf_string_triple_t_initialize { f_utf_string_dynamic_t_initialize, f_utf_string_dynamic_t_initialize, f_utf_string_dynamic_t_initialize }
- #define macro_f_utf_string_triple_t_clear(triple) \
- triple.a.array = 0; \
- triple.a.size = 0; \
- triple.a.used = 0; \
- triple.b.array = 0; \
- triple.b.size = 0; \
- triple.b.used = 0; \
- triple.c.array = 0; \
- triple.c.size = 0; \
- triple.c.used = 0;
-
#define macro_f_utf_string_triple_t_initialize_1(a, b, c) { a, b, c }
+
+ #define macro_f_utf_string_triple_t_clear(triple) { \
+ macrro_f_utf_string_dynamic_t_clear(triple.a) \
+ macrro_f_utf_string_dynamic_t_clear(triple.b) \
+ macrro_f_utf_string_dynamic_t_clear(triple.c) \
+ }
#endif // _di_f_utf_string_triple_t_
#ifdef __cplusplus
#define macro_f_utf_string_triples_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_triples_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_triples_t_clear(utf_string_triples) { \
+ utf_string_triples.array = 0; \
+ utf_string_triples.used = 0; \
+ utf_string_triples.size = 0; \
+ }
#endif // _di_f_utf_string_triples_t_
/**
#define macro_f_utf_string_tripless_t_initialize_1(array_value, used_value, size_value) { .array = array_value, .used = used_value, .size = size_value }
#define macro_f_utf_string_tripless_t_initialize_2(array_value, length_value) { .array = array_value, .used = length_value, .size = length_value }
+
+ #define macro_f_utf_string_tripless_t_clear(utf_string_tripless) { \
+ utf_string_tripless.array = 0; \
+ utf_string_tripless.used = 0; \
+ utf_string_tripless.size = 0; \
+ }
#endif // _di_f_utf_string_tripless_t_
/**
#define macro_fl_conversion_data_t_initialize_1(base, flag) { base, flag }
- #define macro_fl_conversion_data_t_clear(data) \
- data.base = 0; \
- data.flag = 0;
+ #define macro_fl_conversion_data_t_clear(conversion_data) { \
+ conversion_data.base = 0; \
+ conversion_data.flag = 0; \
+ }
#endif // _di_fl_conversion_data_t_
/**
#define macro_fl_execute_parameter_t_initialize_1(option, wait, environment, signals, data) { option, wait, environment, signals, data }
- #define macro_fl_execute_parameter_t_clear(set) \
- set.option = 0; \
- set.wait = 0; \
- set.environment = 0; \
- set.signals = 0; \
- set.data = 0;
+ #define macro_fl_execute_parameter_t_clear(execute_parameter) { \
+ execute_parameter.option = 0; \
+ execute_parameter.wait = 0; \
+ execute_parameter.environment = 0; \
+ execute_parameter.signals = 0; \
+ execute_parameter.data = 0; \
+ }
#endif // _di_fl_execute_parameter_t_
/**
#define macro_fl_execute_as_t_initialize_1(nice, id_user, id_group, affinity, capability, control_group, id_groups, limits, scheduler) { nice, id_user, id_group, affinity, capability, control_group, id_groups, limits, scheduler }
- #define macro_fl_execute_as_t_clear(as) \
+ #define macro_fl_execute_as_t_clear(as) { \
as.nice = 0; \
as.id_user = 0; \
as.id_group = 0; \
as.control_group = 0; \
as.id_groups = 0; \
as.limits = 0; \
- as.scheduler = 0;
+ as.scheduler = 0; \
+ }
#endif // _di_fl_execute_as_t_
#ifdef __cplusplus
#define macro_fl_fss_data_embedded_list_t_initialize_1(objects, positions, slashes) { objects, positions, slashes }
- #define macro_fl_fss_data_embedded_list_t_clear(data) \
+ #define macro_fl_fss_data_embedded_list_t_clear(data) { \
data.objects = 0; \
data.positions = 0; \
- data.slashes = 0;
+ data.slashes = 0; \
+ }
#endif // _di_fl_fss_data_embedded_list_t_
/**
* - range: Used for passing a given string range to the FSS write functions.
* - conversion: The conversion data.
* - quote_null: The string representing an empty, aka NULL, Content. This is generally double-quotes.
- * - destinations: The destinations map being appended to.
- * - original: The original destination used length.
+ * - destinations: The destinations map being appended to (This cannot be cleared due to being a constant).
+ * - original: The original destination used length (This cannot be cleared due to being a constant).
*/
#ifndef _di_fl_fss_payload_header_internal_t_
typedef struct {
destinations, \
original, \
}
+
+ #define macro_f_fss_payload_header_internal_t_clear(fss_payload_header_internal) { \
+ fss_payload_header_internal.quote = 0; \
+ fss_payload_header_internal.step = 0; \
+ fss_payload_header_internal.size = 0; \
+ fss_payload_header_internal.i = 0; \
+ fss_payload_header_internal.j = 0; \
+ fss_payload_header_internal.k = 0; \
+ fss_payload_header_internal.l = 0; \
+ fss_payload_header_internal.m = 0; \
+ macro_f_range_t_clear(fss_payload_header_internal.range) \
+ macro_f_conversion_data_t_clear(fss_payload_header_internal.conversion) \
+ macro_f_string_static_t_clear(fss_payload_header_internal.quote_null) \
+ }
#endif // _di_fl_fss_payload_header_internal_t_
/**
f_conversion_data_base_10_c, \
cache, \
}
+
+ #define macro_f_fss_payload_header_state_t_clear(fss_payload_header_state) { \
+ fss_payload_header_state.flag = 0; \
+ macro_f_conversion_data_t_clear(fss_payload_header_state.conversion) \
+ fss_payload_header_state.cache = 0; \
+ }
#endif // _di_fl_fss_payload_header_state_t_
#ifdef __cplusplus
#define macro_fl_print_t_initialize_error_2(suffix, set) macro_fl_print_t_initialize_1(macro_f_file_t_initialize_2(F_type_error_d, F_type_descriptor_error_d, F_file_flag_write_only_d), f_console_verbosity_normal_e, 0, fl_print_error_s, suffix, f_color_set_t_initialize, f_color_set_t_initialize, set, 0)
#define macro_fl_print_t_initialize_warning_1() macro_fl_print_t_initialize_1(macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d), f_console_verbosity_normal_e, 0, fl_print_warning_s, f_string_static_t_initialize, f_color_set_t_initialize, f_color_set_t_initialize, 0, 0)
#define macro_fl_print_t_initialize_warning_2(suffix, set) macro_fl_print_t_initialize_1(macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d), f_console_verbosity_normal_e, 0, fl_print_warning_s, suffix, f_color_set_t_initialize, f_color_set_t_initialize, set, 0)
+
+ #define macro_fl_print_t_clear(print) { \
+ macro_f_file_t_clear(print.to) \
+ print.verbosity = 0; \
+ print.flag = 0; \
+ macro_f_string_static_t_clear(print.prefix) \
+ macro_f_string_static_t_clear(print.suffix) \
+ macro_f_color_set_t_clear(print.context) \
+ macro_f_color_set_t_clear(print.notable) \
+ print.set = 0; \
+ print.custom = 0; \
+ }
#endif // _di_fl_print_t_
/**
macro_f_console_parameter_t_initialize_3(f_console_standard_short_verbose_s, f_console_standard_long_verbose_s, 0, f_console_flag_inverse_d), \
macro_f_console_parameter_t_initialize_3(f_console_standard_short_debug_s, f_console_standard_long_debug_s, 0, f_console_flag_inverse_d), \
macro_f_console_parameter_t_initialize_3(f_console_standard_short_version_s, f_console_standard_long_version_s, 0, f_console_flag_inverse_d)
+
+ #define macro_fll_program_data_t_clear(program_data) { \
+ macro_f_console_parameters_t_clear(program_data.parameters) \
+ program_data.environment = 0; \
+ program_data.umask = 0; \
+ program_data.pid = 0; \
+ program_data.child = 0; \
+ program_data.pipe = 0; \
+ program_data.signal_received = 0; \
+ program_data.signal_check = 0; \
+ macro_f_signal_t_clear(program_data.signal) \
+ program_data.signal_status = F_false; \
+ macro_f_file_t_clear(program_data.input) \
+ macro_fl_print_t_clear(program_data.message) \
+ macro_fl_print_t_clear(program_data.output) \
+ macro_fl_print_t_clear(program_data.error) \
+ macro_fl_print_t_clear(program_data.warning) \
+ macro_fl_print_t_clear(program_data.debug) \
+ macro_f_color_context_t_clear(program_data.context) \
+ }
#endif // _di_fll_program_data_t_
/**
projects / fll / commitdiff