Change the code to pre-process and load all of the Rules during the Entry/Exit load.
The existing dynamic Rule file loading still happens, but only when not using a `controlfile`/`initfile`.
This, however, is unlikely to be used and that code might be gutted in the future.
Add new `F_load_not` status error for when the loading fails.
Update the error and debug printing functions to not use `debug` instead of `line_file`.
This brings the functions in line with the FLL debug printing functionality.
This still does not load the `controlfile`/`initfile` just yet.
#defines -D_di_libcap_
defines -D_libcap_legacy_only_
-defines -D_support_controller_controlfile_ -D_support_controller_initfile_
+defines -D_support_controller_controlfile_
defines-android -D_di_f_thread_attribute_affinity_get_ -D_di_f_thread_attribute_affinity_set_ -D_di_f_thread_attribute_concurrency_get_ -D_di_f_thread_attribute_concurrency_set_ -D_di_f_thread_attribute_default_get_ -D_di_f_thread_attribute_default_set_ -D_di_f_thread_cancel_ -D_di_f_thread_cancel_state_set_ -D_di_f_thread_cancel_test_ -D_di_f_thread_join_try_ -D_di_f_thread_join_timed_ -D_pthread_mutex_prioceiling_unsupported_ -D_di_f_thread_semaphore_file_close_ -D_di_f_thread_semaphore_file_open_ -D_di_f_thread_semaphore_file_delete_ -D_di_f_thread_cancel_type_set_
defines-debug -D_en_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
#define _di_f_string_format_s_double_s_
#define _di_f_string_format_s_s_
#define _di_f_string_format_s_single_s_
-#define _di_f_string_format_sentence_end_basic_s_
+//#define _di_f_string_format_sentence_end_basic_s_
#define _di_f_string_format_sentence_end_double_basic_s_
#define _di_f_string_format_sentence_end_double_quote_s_
#define _di_f_string_format_sentence_end_double_quote_basic_s_
//#define _di_fll_error_file_type_socket_s_
#define _di_fll_error_parameter_integer_print_
//#define _di_fll_error_print_
-#define _di_fll_error_print_debug_
+//#define _di_fll_error_print_debug_
//#define _di_fll_error_s_a_
//#define _di_fll_error_s_e_
#define _di_fll_execute_arguments_add_
defines -include sources/c/config.h -I sources/c/
#defines -D_di_libcap_
defines -D_libcap_legacy_only_
+defines -D_support_controller_controlfile_
defines-android -D_di_f_thread_attribute_affinity_get_ -D_di_f_thread_attribute_affinity_set_ -D_di_f_thread_attribute_concurrency_get_ -D_di_f_thread_attribute_concurrency_set_ -D_di_f_thread_attribute_default_get_ -D_di_f_thread_attribute_default_set_ -D_di_f_thread_cancel_ -D_di_f_thread_cancel_state_set_ -D_di_f_thread_cancel_test_ -D_di_f_thread_join_try_ -D_di_f_thread_join_timed_ -D_pthread_mutex_prioceiling_unsupported_ -D_di_f_thread_semaphore_file_close_ -D_di_f_thread_semaphore_file_open_ -D_di_f_thread_semaphore_file_delete_ -D_di_f_thread_cancel_type_set_
defines-debug -D_en_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines -include sources/c/config.h -I sources/c/
#defines -D_di_libcap_
defines -D_libcap_legacy_only_
+defines -D_support_controller_controlfile_
defines-android -D_di_f_thread_attribute_affinity_get_ -D_di_f_thread_attribute_affinity_set_ -D_di_f_thread_attribute_concurrency_get_ -D_di_f_thread_attribute_concurrency_set_ -D_di_f_thread_attribute_default_get_ -D_di_f_thread_attribute_default_set_ -D_di_f_thread_cancel_ -D_di_f_thread_cancel_state_set_ -D_di_f_thread_cancel_test_ -D_di_f_thread_join_try_ -D_di_f_thread_join_timed_ -D_pthread_mutex_prioceiling_unsupported_ -D_di_f_thread_semaphore_file_close_ -D_di_f_thread_semaphore_file_open_ -D_di_f_thread_semaphore_file_delete_ -D_di_f_thread_cancel_type_set_
defines-debug -D_en_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
case F_valid_not:
return F_status_set_error(F_valid_not);
+
+ case F_load_not:
+ return F_status_set_error(F_load_not);
}
return F_status_set_error(F_failure);
const f_string_static_t controller_program_version_s = macro_f_string_static_t_initialize_1(CONTROLLER_program_version_s, 0, CONTROLLER_program_version_s_length);
#endif // _di_controller_program_version_s_
-#if !defined(_di_controller_controlfile_s_) && defined(_support_controller_controlfile_)
+#ifndef _di_controller_controlfile_s_
const f_string_static_t controller_prefix_entry_s = macro_f_string_static_t_initialize_1(CONTROLLER_prefix_entry_s, 0, CONTROLLER_prefix_entry_s_length);
const f_string_static_t controller_prefix_exit_s = macro_f_string_static_t_initialize_1(CONTROLLER_prefix_exit_s, 0, CONTROLLER_prefix_exit_s_length);
const f_string_static_t controller_prefix_rule_s = macro_f_string_static_t_initialize_1(CONTROLLER_prefix_rule_s, 0, CONTROLLER_prefix_rule_s_length);
-#endif // !defined(_di_controller_controlfile_s_) && defined(_support_controller_controlfile_)
+#endif // _di_controller_controlfile_s_
#ifndef _di_controller_parameter_s_
const f_string_static_t controller_short_cgroup_s = macro_f_string_static_t_initialize_1(CONTROLLER_short_cgroup_s, 0, CONTROLLER_short_cgroup_s_length);
*
* The controller_controlfile_s implementation is defined within the individual programs.
*/
-#if !defined(_di_controller_controlfile_s_) && defined(_support_controller_controlfile_)
+#ifndef _di_controller_controlfile_s_
#define CONTROLLER_prefix_entry_s "entry_"
#define CONTROLLER_prefix_exit_s "exit_"
#define CONTROLLER_prefix_rule_s "rule_"
extern const f_string_static_t controller_prefix_entry_s;
extern const f_string_static_t controller_prefix_exit_s;
extern const f_string_static_t controller_prefix_rule_s;
-#endif // !defined(_di_controller_controlfile_s_) && defined(_support_controller_controlfile_)
+#endif // _di_controller_controlfile_s_
/**
* The main program parameters.
state.status = f_memory_array_increase_by(main->thread.cache.object_items.used, sizeof(f_range_t), (void **) &main->thread.cache.object_items.array, &main->thread.cache.object_items.used, &main->thread.cache.object_items.size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
}
else {
f_range_t *range = 0;
+ f_range_t offset = f_range_t_initialize;
f_number_unsigned_t at = 0;
f_number_unsigned_t i = 0;
f_number_unsigned_t j = 0;
// 0x1 = main found, 0x2 = found existing.
uint8_t code = 0;
- #ifdef _support_controller_controlfile_
- const f_string_static_t prefix = is_entry ? controller_prefix_entry_s : controller_prefix_exit_s;
- const f_range_t prefix_range = macro_f_range_t_initialize_2(prefix.used);
-
- f_range_t offset = f_range_t_initialize;
- #endif // _support_controller_controlfile_
+ const f_string_static_t prefix = is_entry ? controller_prefix_entry_s : controller_prefix_exit_s;
+ const f_range_t prefix_range = macro_f_range_t_initialize_2(prefix.used);
for (i = 0; i < main->thread.cache.object_items.used && controller_thread_enable_is_normal(&main->thread, is_entry); ++i) {
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_entry_item_t), (void **) &entry->items.array, &entry->items.used, &entry->items.size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_string_dynamic_partial_append(main->thread.cache.buffer_file, offset, &main->thread.cache.action.name_item);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
f_fss_count_lines(main->thread.cache.buffer_file, main->thread.cache.object_items.array[i].start, &main->thread.cache.action.line_item, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_memory_array_increase(at, sizeof(controller_entry_item_t), (void **) &entry->items.array, &entry->items.used, &entry->items.size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_memory_array_resize(2, sizeof(controller_entry_item_t), (void **) &entry->items.array, &entry->items.used, &entry->items.size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
status = controller_entry_extract(main, is_entry);
}
+ if (F_status_is_error_not(status)) {
+ status = controller_entry_load_rules(main, is_entry);
+ }
+
f_thread_mutex_unlock(&main->thread.lock.entry.mutex);
return status;
f_fss_apply_delimit(main->thread.cache.delimits, &main->thread.cache.buffer_file, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
}
}
}
}
#endif // _di_controller_entry_load_
+#ifndef _di_controller_entry_load_rules_
+ f_status_t controller_entry_load_rules(controller_t * const main, const uint8_t is_entry) {
+
+ if (!main) return F_status_set_error(F_parameter);
+
+ f_status_t status = F_okay;
+
+ controller_entry_t * const entry = is_entry ? &main->process.entry : &main->process.exit;
+
+ controller_entry_action_t *entry_action = 0;
+ controller_entry_actions_t *entry_actions = 0;
+
+ f_number_unsigned_t i = 0;
+ f_number_unsigned_t j = 0;
+ f_number_unsigned_t total = 0;
+ f_number_unsigned_t used = 0;
+
+ // Pre-process items to allow pre-allocating all of the necessary memory for each rule in as few allocations as possible.
+ for (i = 0; i < entry->items.used; ++i) {
+
+ entry_actions = &entry->items.array[i].actions;
+
+ for (j = 0; j < entry_actions->used; ++j) {
+
+ entry_action = &entry_actions->array[j];
+
+ if (entry_action->type != controller_entry_action_type_consider_e && !controller_entry_action_type_is_rule(entry_action->type)) continue;
+
+ ++total;
+ } // for
+ } // for
+
+ if (!controller_thread_enable_is_normal(&main->thread, is_entry)) return F_status_set_error(F_interrupt);
+
+ controller_rule_t *rules[total];
+
+ memset(rules, 0, sizeof(controller_rule_t *) * total);
+
+ for (i = 0; i < entry->items.used && F_status_is_error_not(status); ++i) {
+
+ entry_actions = &entry->items.array[i].actions;
+
+ for (j = 0; j < entry_actions->used; ++j) {
+
+ entry_action = &entry_actions->array[j];
+
+ if (entry_action->type != controller_entry_action_type_consider_e && !controller_entry_action_type_is_rule(entry_action->type)) continue;
+
+ main->thread.cache.action.line_action = 0;
+ main->thread.cache.action.line_item = entry->items.array[i].line;
+ main->thread.cache.action.name_action.used = 0;
+ main->thread.cache.action.name_item.used = 0;
+
+ status = f_string_dynamic_append_nulless(entry->items.array[i].name, &main->thread.cache.action.name_item);
+
+ if (F_status_is_error(status)) {
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
+
+ break;
+ }
+
+ const f_number_unsigned_t id_rule_length = entry_action->parameters.array[0].used + entry_action->parameters.array[1].used + 1;
+ f_char_t id_rule_name[id_rule_length + 1];
+ const f_string_static_t alias_rule = macro_f_string_static_t_initialize_1(id_rule_name, 0, id_rule_length);
+
+ memcpy(id_rule_name, entry_action->parameters.array[0].string, sizeof(f_char_t) * entry_action->parameters.array[0].used);
+ memcpy(id_rule_name + entry_action->parameters.array[0].used + 1, entry_action->parameters.array[1].string, sizeof(f_char_t) * entry_action->parameters.array[1].used);
+
+ id_rule_name[entry_action->parameters.array[0].used] = f_path_separator_s.string[0];
+ id_rule_name[id_rule_length] = 0;
+
+ status = controller_rule_find(main, is_entry, alias_rule, main->process.rules, 0);
+ if (F_status_is_error(status)) break;
+
+ // Rule is already loaded.
+ if (status == F_true) continue;
+
+ if (!controller_thread_enable_is_normal(&main->thread, is_entry)) {
+ status = F_status_set_error(F_interrupt);
+
+ break;
+ }
+
+ rules[used] = 0;
+
+ status = f_memory_new(1, sizeof(controller_rule_t), (void **) &rules[used]);
+
+ if (F_status_is_error(status)) {
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
+
+ // Load as much as possible, even if one fails.
+ entry_action->status = controller_status_simplify_error(F_load_not);
+
+ continue;
+ }
+
+ ++used;
+
+ status = controller_rule_read(main, &main->thread.cache, is_entry, alias_rule, entry, rules[used - 1]);
+ if (F_status_set_fine(status) == F_interrupt) break;
+
+ if (F_status_is_error(status)) {
+ if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
+ controller_lock_print(main->program.error.to, &main->thread);
+
+ controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry, F_status_debug_source_d);
+
+ controller_unlock_print_flush(main->program.error.to, &main->thread);
+ }
+
+ // Designate the Action as failed.
+ entry_action->status = controller_status_simplify_error(F_load_not);
+
+ if (used) {
+ f_memory_delete(1, sizeof(controller_rule_t), (void **) &rules[--used]);
+
+ rules[used] = 0;
+ }
+
+ // Load as much as possible, even if one fails.
+ continue;
+ }
+ } // for
+ } // for
+
+ // Save all of the allocated rules at the end to reduce the amount of write locks needed for adding rules.
+ if (used && F_status_is_error_not(status)) {
+ status = controller_lock_write_standard(is_entry, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.rule);
+
+ if (status != F_okay) {
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
+ }
+ else {
+ status = f_memory_array_increase_by(used, sizeof(controller_rule_t), (void **) &main->process.rules.array, &main->process.rules.used, &main->process.rules.size);
+
+ if (F_status_is_error(status)) {
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
+ }
+ else {
+ for (i = 0; i < used; ++i) {
+ main->process.rules.array[main->process.rules.used++] = rules[i];
+ } // for
+
+ used = 0;
+ }
+
+ f_thread_unlock(&main->thread.lock.rule);
+ }
+ }
+
+ if (F_status_is_error(status)) {
+ for (i = 0; i < used; ++i) {
+ if (rules[i]) f_memory_delete(1, sizeof(controller_rule_t), (void **) &rules[i]);
+ } // for
+
+ return status;
+ }
+
+ return F_okay;
+ }
+#endif // _di_controller_entry_load_rules_
+
#ifndef _di_controller_entry_setup_
f_status_t controller_entry_setup(controller_t * const main, controller_entry_t * const entry) {
*
* F_parameter (with error bit) if a parameter is invalid.
*
- * Errors (with error bit) from: controller_entry_action_read().
* Errors (with error bit) from: controller_file_load().
* Errors (with error bit) from: controller_status_simplify_error().
*
#endif // _di_controller_entry_load_
/**
+ * Load the rules from the entry or exit file.
+ *
+ * @param main
+ * The main program data.
+ *
+ * This does not alter main.setting.state.status.
+ *
+ * Must not be NULL.
+ * @param is_entry
+ * If TRUE, then this operates as an Entry.
+ * If FALSE, then this operates as an Exit.
+ *
+ * @return
+ * F_okay on success.
+ * F_file_found_not on file not found for an Exit file (is_entry is FALSE).
+ *
+ * F_parameter (with error bit) if a parameter is invalid..
+ *
+ * Errors (with error bit) from: f_fss_apply_delimit().
+ * Errors (with error bit) from: fll_fss_basic_list_read().
+ *
+ * @see controller_file_load()
+ * @see controller_status_simplify_error()
+ *
+ * @see f_fss_apply_delimit()
+ * @see fll_fss_basic_list_read()
+ */
+#ifndef _di_controller_entry_load_rules_
+ extern f_status_t controller_entry_load_rules(controller_t * const main, const uint8_t is_entry);
+#endif // _di_controller_entry_load_rules_
+
+/**
* Read the entry or exit, extracting all lists, with locking.
*
* This utilizes a mutex lock to prevent double execution.
}
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
return state.status;
}
f_fss_apply_delimit(main->thread.cache.delimits, &main->thread.cache.buffer_file, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
return state.status;
}
state.status = f_memory_array_increase_by(main->thread.cache.object_actions.used, sizeof(controller_entry_action_t), (void **) &actions->array, &actions->used, &actions->size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
return state.status;
}
f_fss_count_lines(main->thread.cache.buffer_file, main->thread.cache.object_actions.array[i].start, &main->thread.cache.action.line_action, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_rip_dynamic_partial_nulless(main->thread.cache.buffer_file, main->thread.cache.object_actions.array[i], &main->thread.cache.action.name_action);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_memory_array_increase_by(allocate, sizeof(f_string_dynamic_t), (void **) &action->parameters.array, &action->parameters.used, &action->parameters.size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
action->status = state.status;
state.status = f_memory_array_increase_by((main->thread.cache.content_actions.array[i].array[j].stop - main->thread.cache.content_actions.array[i].array[j].start) + 1, sizeof(f_char_t), (void **) &action->parameters.array[j].string, &action->parameters.array[j].used, &action->parameters.array[j].size);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_string_dynamic_partial_append_nulless(main->thread.cache.buffer_file, main->thread.cache.content_actions.array[i].array[j], &action->parameters.array[j]);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = controller_path_canonical_relative(main, main->process.path_current, action->parameters.array[0], &main->thread.cache.buffer_path);
if (F_status_is_error(state.status)) {
- controller_print_error_entry_file(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, main->thread.cache.action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, F_status_debug_source_d);
+ controller_print_error_entry_file(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, main->thread.cache.action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e);
action->status = state.status;
state.status = f_file_name_base(action->parameters.array[1], &main->thread.cache.buffer_path);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
if (F_status_set_fine(state.status) == F_memory_not) {
status_action = controller_status_simplify_error(state.status);
}
if (F_status_set_fine(state.status) == F_memory_not) {
- controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
status_action = state.status;
status = f_memory_array_resize(2, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status = f_string_dynamic_append_nulless(entry->items.array[0].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status2 = f_string_dynamic_append_nulless(controller_entry_action_type_name(actions->array[cache->ats.array[at_j]].type), &cache->action.name_action);
if (F_status_is_error(status2)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true);
return status2;
}
status2 = f_memory_array_increase(controller_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status2)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true);
return status2;
}
status2 = f_string_dynamic_append_nulless(entry->items.array[i].name, &cache->action.name_item);
if (F_status_is_error(status2)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true);
return status2;
}
status2 = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status2)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true);
return status2;
}
status = f_memory_array_resize(2, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[0]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status = f_string_dynamic_append_nulless(controller_entry_action_type_name(entry_action->type), &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status = f_memory_array_increase_by(2, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
return status;
}
if (!controller_thread_enable_is_normal(&main->thread, is_entry)) break;
- // The Rule is not yet loaded, ensure that it is loaded.
+ // The Rule is not yet loaded, ensure that it is loaded (but not when using controlfile/initfile).
if (status != F_true) {
+ if (main->setting.flag & controller_main_flag_loaded_d) {
+ status = F_status_set_error(F_load_not);
- controller_rule_t *rule = 0;
+ controller_print_error_entry_action_missing_rule(&main->program.error, &main->thread.cache.action, is_entry, alias_rule, F_status_debug_source_d);
+ }
+ else {
+ controller_rule_t *rule = 0;
- status = f_memory_new(1, sizeof(controller_rule_t), (void **) &rule);
+ status = f_memory_new(1, sizeof(controller_rule_t), (void **) &rule);
- if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ if (F_status_is_error(status)) {
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
- return status;
- }
+ return status;
+ }
- // Rule execution will re-use the existing cache, so save the current cache.
- const f_number_unsigned_t cache_line_action = cache->action.line_action;
- const f_number_unsigned_t cache_line_item = cache->action.line_item;
+ // Rule execution will re-use the existing cache, so save the current cache.
+ const f_number_unsigned_t cache_line_action = cache->action.line_action;
+ const f_number_unsigned_t cache_line_item = cache->action.line_item;
- const f_number_unsigned_t cache_name_action_used = cache->action.name_action.used;
- const f_number_unsigned_t cache_name_item_used = cache->action.name_item.used;
- const f_number_unsigned_t cache_name_file_used = cache->action.name_file.used;
+ const f_number_unsigned_t cache_name_action_used = cache->action.name_action.used;
+ const f_number_unsigned_t cache_name_item_used = cache->action.name_item.used;
+ const f_number_unsigned_t cache_name_file_used = cache->action.name_file.used;
- f_char_t cache_name_action[cache_name_action_used];
- f_char_t cache_name_item[cache_name_item_used];
- f_char_t cache_name_file[cache_name_file_used];
+ f_char_t cache_name_action[cache_name_action_used];
+ f_char_t cache_name_item[cache_name_item_used];
+ f_char_t cache_name_file[cache_name_file_used];
- memcpy(cache_name_action, cache->action.name_action.string, sizeof(f_char_t) * cache->action.name_action.used);
- memcpy(cache_name_item, cache->action.name_item.string, sizeof(f_char_t) * cache->action.name_item.used);
- memcpy(cache_name_file, cache->action.name_file.string, sizeof(f_char_t) * cache->action.name_file.used);
+ memcpy(cache_name_action, cache->action.name_action.string, sizeof(f_char_t) * cache->action.name_action.used);
+ memcpy(cache_name_item, cache->action.name_item.string, sizeof(f_char_t) * cache->action.name_item.used);
+ memcpy(cache_name_file, cache->action.name_file.string, sizeof(f_char_t) * cache->action.name_file.used);
- status = controller_rule_read(main, cache, is_entry, alias_rule, entry, rule); // @fixme this re-uses the buffer_file, which may be a problem for entry reading.
+ status = controller_rule_read(main, cache, is_entry, alias_rule, entry, rule);
- // Restore cache.
- memcpy(cache->action.name_action.string, cache_name_action, sizeof(f_char_t) * cache_name_action_used);
- memcpy(cache->action.name_item.string, cache_name_item, sizeof(f_char_t) * cache_name_item_used);
- memcpy(cache->action.name_file.string, cache_name_file, sizeof(f_char_t) * cache_name_file_used);
+ // Restore cache.
+ memcpy(cache->action.name_action.string, cache_name_action, sizeof(f_char_t) * cache_name_action_used);
+ memcpy(cache->action.name_item.string, cache_name_item, sizeof(f_char_t) * cache_name_item_used);
+ memcpy(cache->action.name_file.string, cache_name_file, sizeof(f_char_t) * cache_name_file_used);
- cache->action.name_action.string[cache_name_action_used] = 0;
- cache->action.name_item.string[cache_name_item_used] = 0;
- cache->action.name_file.string[cache_name_file_used] = 0;
+ cache->action.name_action.string[cache_name_action_used] = 0;
+ cache->action.name_item.string[cache_name_item_used] = 0;
+ cache->action.name_file.string[cache_name_file_used] = 0;
- cache->action.name_action.used = cache_name_action_used;
- cache->action.name_item.used = cache_name_item_used;
- cache->action.name_file.used = cache_name_file_used;
+ cache->action.name_action.used = cache_name_action_used;
+ cache->action.name_item.used = cache_name_item_used;
+ cache->action.name_file.used = cache_name_file_used;
- cache->action.line_action = cache_line_action;
- cache->action.line_item = cache_line_item;
+ cache->action.line_action = cache_line_action;
+ cache->action.line_item = cache_line_item;
- if (F_status_set_fine(status) == F_interrupt || !controller_thread_enable_is_normal(&main->thread, is_entry)) break;
+ if (F_status_set_fine(status) == F_interrupt || !controller_thread_enable_is_normal(&main->thread, is_entry)) break;
- if (F_status_is_error(status)) {
- if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
- controller_lock_print(main->program.error.to, &main->thread);
+ if (F_status_is_error(status)) {
+ if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
+ controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_entry_cache(&main->program.error, &cache->action, is_entry, F_status_debug_source_d);
+ controller_print_error_entry_cache(&main->program.error, &cache->action, is_entry, F_status_debug_source_d);
- controller_unlock_print_flush(main->program.error.to, &main->thread);
- }
+ controller_unlock_print_flush(main->program.error.to, &main->thread);
+ }
- // Designate the Action as failed.
- entry_action->status = controller_status_simplify_error(F_failure);
+ // Designate the Action as failed.
+ entry_action->status = controller_status_simplify_error(F_failure);
- if (!(main->setting.flag & controller_main_flag_simulate_d)) {
- if (rule) {
- f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
- }
+ if (!(main->setting.flag & controller_main_flag_simulate_d)) {
+ if (rule) {
+ f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
+ }
- f_thread_unlock(&main->thread.lock.rule);
+ f_thread_unlock(&main->thread.lock.rule);
- if (entry_action->code & controller_entry_rule_code_require_d) return F_status_set_error(F_require);
+ if (entry_action->code & controller_entry_rule_code_require_d) return F_status_set_error(F_require);
- ++cache->ats.array[at_j];
+ ++cache->ats.array[at_j];
- break;
+ break;
+ }
}
- }
- else {
- status_lock = controller_lock_write_standard(is_entry, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.rule);
+ else {
+ status_lock = controller_lock_write_standard(is_entry, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.rule);
- if (status_lock != F_okay) {
- if (rule) {
- f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
- }
+ if (status_lock != F_okay) {
+ if (rule) {
+ f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
+ }
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_d);
- break;
- }
+ break;
+ }
- status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_rule_t), (void **) &main->process.rules.array, &main->process.rules.used, &main->process.rules.size);
+ status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_rule_t), (void **) &main->process.rules.array, &main->process.rules.used, &main->process.rules.size);
- if (F_status_is_error(status)) {
- if (rule) {
- f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
- }
+ if (F_status_is_error(status)) {
+ if (rule) {
+ f_memory_delete(1, sizeof(controller_rule_t), (void **) &rule);
+ }
- f_thread_unlock(&main->thread.lock.rule);
+ f_thread_unlock(&main->thread.lock.rule);
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
- return status;
- }
+ return status;
+ }
- main->process.rules.array[main->process.rules.used++] = rule;
+ main->process.rules.array[main->process.rules.used++] = rule;
- f_thread_unlock(&main->thread.lock.rule);
+ f_thread_unlock(&main->thread.lock.rule);
+ }
}
}
controller_print_error_entry_action_execution_missing(&main->program.error, &cache->action, is_entry, entry_action->parameters.array[0], F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
}
return F_status_set_error(F_execute);
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true);
break;
}
}
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
return state.status;
}
f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
return state.status;
}
f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->action.line_action, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->object_actions.array[i], &cache->action.name_action);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = controller_path_canonical_relative(main, main->process.path_current, cache->action.generic, &main->process.path_control);
if (F_status_is_error(state.status)) {
- controller_print_error_entry_file(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, F_status_debug_source_d);
+ controller_print_error_entry_file(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e);
continue;
}
controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
}
continue;
state.status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
break;
}
state.status = f_file_mode_to_mode(mode_file, &mode);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
}
continue;
state.status = controller_entry_setting_read_map(cache->buffer_file, cache->content_actions.array[i], &entry->define);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
state.status = controller_entry_setting_read_map(cache->buffer_file, cache->content_actions.array[i], &entry->parameter);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
state.status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
state.status = controller_path_canonical_relative(main, main->process.path_current, cache->action.generic, &main->process.path_pid);
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
*time = time_previous;
if (F_status_set_fine(state.status) == F_memory_not) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true);
continue;
}
}
#endif // _di_controller_file_load_
+#if defined(_support_controller_controlfile_) && !defined(_di_controller_file_load_controlfile_)
+ f_status_t controller_file_load_controlfile(controller_t * const main) {
+
+ if (!main) return F_status_set_error(F_parameter);
+
+ f_file_t file = f_file_t_initialize;
+
+ f_status_t status = f_file_stream_open(controller_controlfile_s, f_string_empty_s, &file);
+
+ if (F_status_is_error(status)) {
+ if (F_status_set_fine(status) == F_file_found_not) {
+ f_file_stream_flush(file);
+ f_file_stream_close(&file);
+
+ return F_file_found_not;
+ }
+
+ if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
+ controller_print_error_file_status(&main->program.error, F_status_debug_source_d, controller_controlfile_s, f_file_operation_open_s, fll_error_file_type_file_e, F_status_set_fine(status));
+ }
+ }
+ else {
+ main->thread.cache.buffer_file.used = 0;
+
+ status = f_file_stream_read(file, &main->thread.cache.buffer_file);
+
+ if (F_status_is_error(status)) {
+ controller_print_error_file_status(&main->program.error, F_status_debug_source_d, controller_controlfile_s, f_file_operation_read_s, fll_error_file_type_file_e, F_status_set_fine(status));
+ }
+ }
+
+ f_file_stream_flush(file);
+ f_file_stream_close(&file);
+
+ return F_status_is_error(status) ? status : F_okay;
+ }
+#endif // defined(_support_controller_controlfile_) && !defined(_di_controller_file_load_controlfile_)
+
#ifndef _di_controller_file_pid_create_
f_status_t controller_file_pid_create(const pid_t pid, const f_string_static_t path) {
#endif // _di_controller_file_load_
/**
+ * Load the controlfile/initfile, if it exists at the current path.
+ *
+ * @param main
+ * The main program data.
+ *
+ * The following within the main.thread.cache is changed:
+ * - action.name_file: The partial path of the file is inserted.
+ * - buffer_file: The contents of the file is inserted.
+ * - timestamp: This is updated to reflect the last changed timestamp.
+ *
+ * Must not be NULL.
+ *
+ * @return
+ * F_okay on success.
+ * F_file_found_not if required is FALSE and the file is not found.
+ *
+ * Errors (with error bit) from: f_file_stream_open().
+ * Errors (with error bit) from: f_file_stream_read().
+ *
+ * @see f_file_stream_open()
+ * @see f_file_stream_read()
+ */
+#if defined(_support_controller_controlfile_) && !defined(_di_controller_file_load_controlfile_)
+ extern f_status_t controller_file_load_controlfile(controller_t * const main);
+#endif // defined(_support_controller_controlfile_) && !defined(_di_controller_file_load_controlfile_)
+
+/**
* Create the pid file, if possible.
*
* @param pid
// Always return immediately on memory errors.
if (F_status_set_fine(status) == F_memory_not) {
- controller_print_error_perform_pid_file_create(&main->program.error, F_status_set_fine(status), F_status_debug_source_d, is_entry, F_status_debug_source_d);
+ controller_print_error_perform_pid_file_create(&main->program.error, F_status_set_fine(status), F_status_debug_source_d, is_entry);
return status;
}
#endif
#ifndef _di_controller_print_debug_rule_action_empty_
- f_status_t controller_print_debug_rule_action_empty(fl_print_t * const print, controller_cache_t * const cache, const f_string_t line_file) {
+ f_status_t controller_print_debug_rule_action_empty(fl_print_t * const print, controller_cache_t * const cache, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format("%r%[%QAction is empty, nothing to do.%]%r", print->to, f_string_eol_s, print->context, print->prefix, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, &cache->action, F_true, line_file);
+ controller_print_error_rule_cache(print, &cache->action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* A structure for containing and caching relevant data.
*
* Must not be NULL.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_debug_rule_action_empty_
- extern f_status_t controller_print_debug_rule_action_empty(fl_print_t * const print, controller_cache_t * const cache, const f_string_t line_file);
+ extern f_status_t controller_print_debug_rule_action_empty(fl_print_t * const print, controller_cache_t * const cache, const f_string_t debug);
#endif // _di_controller_print_debug_rule_action_empty_
#ifdef __cplusplus
#endif
#ifndef _di_controller_main_print_debug_rule_execute_rerun_
- f_status_t controller_main_print_debug_rule_execute_rerun(fl_print_t * const print, controller_instance_t * const instance, controller_rule_rerun_item_t * const rerun, const uint8_t action, const f_string_t line_file) {
+ f_status_t controller_main_print_debug_rule_execute_rerun(fl_print_t * const print, controller_instance_t * const instance, controller_rule_rerun_item_t * const rerun, const uint8_t action, const f_string_t debug) {
if (!print || !print->custom || !instance || !rerun) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(" for %[%ul%]", print->to, print->set->notable, rerun->count, print->set->notable);
fl_print_format(" of %[%r%] ", print->to, print->set->notable, controller_max_s, print->set->notable);
fl_print_format(f_string_format_un_single_s.string, print->to, print->set->notable, rerun->max, print->set->notable);
-
- if (line_file) {
- fl_print_format(" (file: %s)", print->to, line_file);
- }
-
- fl_print_format(f_string_format_sentence_end_s.string, print->to, f_string_eol_s);
}
else {
- fl_print_format(" with no %[%r%].%r", print->to, print->set->notable, controller_max_s, print->set->notable, f_string_eol_s);
+ fl_print_format(" with no %[%r%]", print->to, print->set->notable, controller_max_s, print->set->notable);
}
+ if (debug) {
+ fl_print_format(" (%S)", print->to, debug);
+ }
+
+ fl_print_format(f_string_format_sentence_end_s.string, print->to, f_string_eol_s);
+
controller_unlock_print_flush(print->to, &main->thread);
return F_okay;
* Must not be NULL.
* @param action
* The ID of the Action being re-run.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_main_print_debug_rule_execute_rerun_
- extern f_status_t controller_main_print_debug_rule_execute_rerun(fl_print_t * const print, controller_instance_t * const instance, controller_rule_rerun_item_t * const rerun, const uint8_t action, const f_string_t line_file);
+ extern f_status_t controller_main_print_debug_rule_execute_rerun(fl_print_t * const print, controller_instance_t * const instance, controller_rule_rerun_item_t * const rerun, const uint8_t action, const f_string_t debug);
#endif // _di_controller_main_print_debug_rule_execute_rerun_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_debug_rule_instance_need_want_wish_
- f_status_t controller_print_debug_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file) {
+ f_status_t controller_print_debug_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug) {
if (!print || !print->custom || !instance) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
controller_lock_print(print->to, &main->thread);
- controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, line_file);
+ controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, debug);
- controller_print_error_rule_cache(print, &instance->cache.action, F_true, line_file);
+ controller_print_error_rule_cache(print, &instance->cache.action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* The value that is the error or warning.
* @param why
* A short explanation on why this is an error or warning.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_debug_rule_instance_need_want_wish_
- extern f_status_t controller_print_debug_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file);
+ extern f_status_t controller_print_debug_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug);
#endif // #ifndef _di_controller_print_debug_rule_instance_need_want_wish_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_entry_
- f_status_t controller_print_error_entry(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_t line_file) {
+ f_status_t controller_print_error_entry(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
f_file_stream_lock(print->to);
- controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_
#ifndef _di_controller_print_error_entry_cache_
- f_status_t controller_print_error_entry_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t debug) {
if (!print || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("%r file '%]%[%Q%]%['", print->to, is_entry ? controller_entry_s : controller_exit_s, print->context, print->notable, action->name_file, print->notable, print->context);
}
- fl_print_format(".%]%r", print->to, print->context, f_string_eol_s);
+ fll_error_print_debug(print, debug);
+
+ //fl_print_format(f_string_format_sentence_end_basic_s.string, print->to, print->context, f_string_eol_s);
+ fl_print_format(".%]%r", print->to, print->context, f_string_eol_s); // @todo remove this and use above line once FLL has bug fixed where f_string_format_sentence_end_basic_s is missing.
return F_okay;
}
#endif // _di_controller_print_error_entry_cache_
#ifndef _di_controller_print_error_entry_file_
- f_status_t controller_print_error_entry_file(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_file(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
f_file_stream_lock(print->to);
- controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
* Set to F_true to print the fallback error message for unknown errors.
* @param thread
* The thread data.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
- *
- * Set to NULL to disable.
*
* @return
* F_okay on success.
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_
- extern f_status_t controller_print_error_entry(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback);
#endif // _di_controller_print_error_entry_
/**
* @param is_entry
* If TRUE, then this loads as an Entry.
* If FALSE, then this loads as an Exit.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_cache_
- extern f_status_t controller_print_error_entry_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t debug);
#endif // _di_controller_print_error_entry_cache_
/**
* The operation that fails, such as 'create' or 'access'.
* @param type
* A valid file type code from the fll_error_file_type enum.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
- *
- * Set to NULL to disable.
*
* @return
* F_okay on success.
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_file_
- extern f_status_t controller_print_error_entry_file(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_file(fl_print_t * const print, const uint8_t is_entry, const f_status_t status, const f_string_t debug, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type);
#endif // _di_controller_print_error_entry_file_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_entry_action_execution_failure_
- f_status_t controller_print_error_entry_action_execution_failure(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const int code, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_execution_failure(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const int code, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_i_single_s.string, print->to, print->notable, code, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_execution_failure_
#ifndef _di_controller_print_error_entry_action_execution_missing_
- f_status_t controller_print_error_entry_action_execution_missing(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_execution_missing(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_execution_missing_
#ifndef _di_controller_print_error_entry_action_invalid_allow_1_
- f_status_t controller_print_error_entry_action_invalid_allow_1(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_invalid_allow_1(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, has, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_invalid_allow_1_
#ifndef _di_controller_print_error_entry_action_invalid_allow_3_
- f_status_t controller_print_error_entry_action_invalid_allow_3(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow_1, const f_string_static_t allow_2, const f_string_static_t allow_3, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_invalid_allow_3(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow_1, const f_string_static_t allow_2, const f_string_static_t allow_3, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, has, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
}
#endif // _di_controller_print_error_entry_action_invalid_allow_3_
+#ifndef _di_controller_print_error_entry_action_missing_rule_
+ f_status_t controller_print_error_entry_action_missing_rule(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
+
+ if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
+ if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
+
+ controller_t * const main = (controller_t *) print->custom;
+
+ controller_lock_print(print->to, &main->thread);
+
+ fl_print_format("%r%[%QCannot execute item action rule '%]", print->to, f_string_eol_s, print->context, print->prefix, print->context);
+ fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
+ fl_print_format("%[', could not load", print->to, print->context);
+ //fl_print_format(f_string_format_sentence_end_basic_s.string, print->to, print->context, f_string_eol_s);
+ fl_print_format(".%]%r", print->to, print->context, f_string_eol_s); // @todo remove this and use above line once FLL has bug fixed where f_string_format_sentence_end_basic_s is missing.
+
+ controller_print_error_entry_cache(print, action, is_entry, debug);
+
+ controller_unlock_print_flush(print->to, &main->thread);
+
+ return F_okay;
+ }
+#endif // _di_controller_print_error_entry_action_missing_rule_
+
#ifndef _di_controller_print_error_entry_action_parameter_empty_
- f_status_t controller_print_error_entry_action_parameter_empty(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_parameter_empty(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("%r%[%QThe %r Item Action %S must not be an empty string.%]", print->to, f_string_eol_s, print->context, print->prefix, is_entry ? controller_entry_s : controller_exit_s, message, print->context);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_parameter_empty_
#ifndef _di_controller_print_error_entry_action_parameter_second_base_
- f_status_t controller_print_error_entry_action_parameter_second_base(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_static_t example, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_parameter_second_base(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_static_t example, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, example, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_parameter_second_base_
#ifndef _di_controller_print_error_entry_action_requires_range_
- f_status_t controller_print_error_entry_action_requires_range(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_number_unsigned_t at_least, const f_number_unsigned_t at_most, const uint8_t type, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_requires_range(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_number_unsigned_t at_least, const f_number_unsigned_t at_most, const uint8_t type, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
}
}
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_requires_range_
#ifndef _di_controller_print_error_entry_action_unsupported_number_
- f_status_t controller_print_error_entry_action_unsupported_number(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_unsupported_number(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, has, print->notable);
fl_print_format("%[' is not a valid supported number.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_action_unsupported_number_
#ifndef _di_controller_print_error_entry_action_unsupported_reserve_
- f_status_t controller_print_error_entry_action_unsupported_reserve(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t item, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_action_unsupported_reserve(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t item, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_r_single_s.string, print->to, print->notable, item, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, action, is_entry, line_file);
+ controller_print_error_entry_cache(print, action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
* If FALSE, then this loads as an Exit.
* @param code
* The return code.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_execution_failure_
- extern f_status_t controller_print_error_entry_action_execution_failure(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const int code, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_execution_failure(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const int code, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_execution_failure_
/**
* If FALSE, then this loads as an Exit.
* @param name
* The program or script name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_execution_missing_
- extern f_status_t controller_print_error_entry_action_execution_missing(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_execution_missing(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_execution_missing_
/**
* The invalid value that is not supported.
* @param allow
* The allowed value that is supported.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_invalid_allow_1_
- extern f_status_t controller_print_error_entry_action_invalid_allow_1(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_invalid_allow_1(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_invalid_allow_1_
/**
* The second allowed value that is supported.
* @param allow_3
* The third allowed value that is supported.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_invalid_allow_3_
- extern f_status_t controller_print_error_entry_action_invalid_allow_3(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow_1, const f_string_static_t allow_2, const f_string_static_t allow_3, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_invalid_allow_3(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_static_t has, const f_string_static_t allow_1, const f_string_static_t allow_2, const f_string_static_t allow_3, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_invalid_allow_3_
/**
+ * Print an error when an Item Action Rule could not be loaded.
+ *
+ * @param print
+ * The output structure to print to.
+ *
+ * This requires print.custom to be controller_t.
+ *
+ * This does not alter print.custom.setting.state.status.
+ *
+ * Must not be NULL.
+ * @param action
+ * The Action cache.
+ *
+ * Must not be NULL.
+ * @param is_entry
+ * If TRUE, then this loads as an Entry.
+ * If FALSE, then this loads as an Exit.
+ * @param name
+ * The Item Action Rule name.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
+ *
+ * Set to NULL to disable.
+ *
+ * @return
+ * F_okay on success.
+ * F_output_not on success, but no printing is performed.
+ *
+ * F_output_not (with error bit) if setting is NULL.
+ */
+#ifndef _di_controller_print_error_entry_action_missing_rule_
+ extern f_status_t controller_print_error_entry_action_missing_rule(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
+#endif // _di_controller_print_error_entry_action_missing_rule_
+
+/**
* Print an error when an Item Action parameter is empty.
*
* @param print
* If FALSE, then this loads as an Exit.
* @param message
* A message describing which parameter is empty.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_parameter_empty_
- extern f_status_t controller_print_error_entry_action_parameter_empty(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_parameter_empty(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_t message, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_parameter_empty_
/**
* The second parameter value.
* @param example
* An example of a valid base path name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_parameter_second_base_
- extern f_status_t controller_print_error_entry_action_parameter_second_base(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_static_t example, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_parameter_second_base(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_static_t example, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_parameter_second_base_
/**
* The maximum number that is allowed.
* @param type
* The Action type code.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_requires_range_
- extern f_status_t controller_print_error_entry_action_requires_range(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_number_unsigned_t at_least, const f_number_unsigned_t at_most, const uint8_t type, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_requires_range(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_number_unsigned_t at_least, const f_number_unsigned_t at_most, const uint8_t type, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_requires_range_
/**
* If FALSE, then this loads as an Exit.
* @param has
* The invalid value that is not supported.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_unsupported_number_
- extern f_status_t controller_print_error_entry_action_unsupported_number(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_unsupported_number(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t has, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_unsupported_number_
/**
* If FALSE, then this loads as an Exit.
* @param item
* The reserved item that is not allowed to be used.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_action_unsupported_reserve_
- extern f_status_t controller_print_error_entry_action_unsupported_reserve(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t item, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_action_unsupported_reserve(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t item, const f_string_t debug);
#endif // _di_controller_print_error_entry_action_unsupported_reserve_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_entry_item_failure_
- f_status_t controller_print_error_entry_item_failure(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t message, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_item_failure(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t message, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format("%[' %S.%]%r", print->to, print->context, message, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_item_failure_
#ifndef _di_controller_print_error_entry_item_invalid_
- f_status_t controller_print_error_entry_item_invalid(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t number, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_item_invalid(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t number, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_un_single_s.string, print->to, print->notable, number, print->notable);
fl_print_format("%[' detected.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_item_invalid_
#ifndef _di_controller_print_error_entry_item_setting_support_not_option_
- f_status_t controller_print_error_entry_item_setting_support_not_option(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_item_setting_support_not_option(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
* The item name.
* @param message
* A short message describing the reason for the failure.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_item_failure_
- extern f_status_t controller_print_error_entry_item_failure(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t message, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_item_failure(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t message, const f_string_t debug);
#endif // _di_controller_print_error_entry_item_failure_
/**
* If FALSE, then this loads as an Exit.
* @param number
* The index position of the invalid item.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_item_invalid_
- extern f_status_t controller_print_error_entry_item_invalid(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t number, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_item_invalid(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t number, const f_string_t debug);
#endif // _di_controller_print_error_entry_item_invalid_
/**
* The buffer containing the setting name.
* @param range
* The range within the buffer representing the setting name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_item_setting_support_not_option_
- extern f_status_t controller_print_error_entry_item_setting_support_not_option(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_item_setting_support_not_option(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_entry_item_setting_support_not_option_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_entry_setting_with_range_
- f_status_t controller_print_error_entry_setting_with_range(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t before, const f_range_t range, const f_string_t after, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_setting_with_range(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t before, const f_range_t range, const f_string_t after, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("%[%/Q%]", print->to, print->notable, cache->buffer_file, range, print->notable);
fl_print_format("%['%S.%]%r", print->to, print->context, after, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_setting_with_range_
#ifndef _di_controller_print_error_entry_setting_ignored_
- f_status_t controller_print_error_entry_setting_ignored(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_setting_ignored(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, cache->action.name_action, print->notable);
fl_print_format("%[' is being ignored.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_setting_ignored_
#ifndef _di_controller_print_error_entry_setting_requires_between_
- f_status_t controller_print_error_entry_setting_requires_between(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t minimum, const f_number_unsigned_t maximum, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_setting_requires_between(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t minimum, const f_number_unsigned_t maximum, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_un_single_s.string, print->to, print->notable, maximum, print->notable);
fl_print_format("%[ Content.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_setting_requires_between_
#ifndef _di_controller_print_error_entry_setting_requires_exactly_
- f_status_t controller_print_error_entry_setting_requires_exactly(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t total, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_setting_requires_exactly(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t total, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_un_single_s.string, print->to, print->notable, total, print->notable);
fl_print_format("%[ Content.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_entry_setting_requires_exactly_
#ifndef _di_controller_print_error_entry_setting_support_not_number_
- f_status_t controller_print_error_entry_setting_support_not_number(fl_print_t * const print, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_entry_setting_support_not_number(fl_print_t * const print, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("%r%[%QThe %r setting '%]", print->to, f_string_eol_s, print->context, print->prefix, is_entry ? controller_entry_s : controller_exit_s, print->context);
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
- fl_print_format("%[' is not a valid supported number.%]", print->to, print->context, print->context, f_string_eol_s);
+ fl_print_format("%[' is not a valid supported number", print->to, print->context, print->context);
+
+ fll_error_print_debug(print, debug);
+
+ fl_print_format(".%]%r", print->to, print->context, f_string_eol_s);
controller_unlock_print_flush(print->to, &main->thread);
* The range within the cache item buffer representing the value.
* @param after
* The string to add to the message being printed (after the value).
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_setting_with_range_
- extern f_status_t controller_print_error_entry_setting_with_range(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t before, const f_range_t range, const f_string_t after, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_setting_with_range(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t before, const f_range_t range, const f_string_t after, const f_string_t debug);
#endif // _di_controller_print_error_entry_setting_with_range_
/**
* @param is_entry
* If TRUE, then this loads as an Entry.
* If FALSE, then this loads as an Exit.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_setting_ignored_
- extern f_status_t controller_print_error_entry_setting_ignored(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_setting_ignored(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t debug);
#endif // _di_controller_print_error_entry_setting_ignored_
/**
* The expected minimum number of arguments.
* @param maximum
* The expected maximum number of arguments.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_setting_requires_between_
- extern f_status_t controller_print_error_entry_setting_requires_between(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t minimum, const f_number_unsigned_t maximum, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_setting_requires_between(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t minimum, const f_number_unsigned_t maximum, const f_string_t debug);
#endif // _di_controller_print_error_entry_setting_requires_between_
/**
* If FALSE, then this loads as an Exit.
* @param total
* The expected number of arguments.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_setting_requires_exactly_
- extern f_status_t controller_print_error_entry_setting_requires_exactly(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t total, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_setting_requires_exactly(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_number_unsigned_t total, const f_string_t debug);
#endif // _di_controller_print_error_entry_setting_requires_exactly_
/**
* The buffer containing the settings.
* @param range
* The range within the buffer representing the unsupported number.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_entry_setting_support_not_number_
- extern f_status_t controller_print_error_entry_setting_support_not_number(fl_print_t * const print, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_entry_setting_support_not_number(fl_print_t * const print, const uint8_t is_entry, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_entry_setting_support_not_number_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_lock_critical_
- f_status_t controller_print_error_lock_critical(fl_print_t * const print, const f_status_t status, const uint8_t is_read, const f_string_t line_file) {
+ f_status_t controller_print_error_lock_critical(fl_print_t * const print, const f_status_t status, const uint8_t is_read, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e || status == F_interrupt) return F_output_not;
}
}
- fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
+ if (debug) {
+ fll_error_print_debug(print, debug);
+
+ //fl_print_format(f_string_format_sentence_end_basic_s.string, print->to, print->context, f_string_eol_s);
+ fl_print_format(".%]%r", print->to, print->context, f_string_eol_s); // @todo remove this and use above line once FLL has bug fixed where f_string_format_sentence_end_basic_s is missing.
+ }
+ else {
+ fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
+ }
controller_unlock_print_flush(print->to, &main->thread);
* @param is_read
* If TRUE, then this is for a read lock.
* If FALSE, then this is for a write lock.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_lock_critical_
- extern f_status_t controller_print_error_lock_critical(fl_print_t * const print, const f_status_t status, const uint8_t is_read, const f_string_t line_file);
+ extern f_status_t controller_print_error_lock_critical(fl_print_t * const print, const f_status_t status, const uint8_t is_read, const f_string_t debug);
#endif // _di_controller_print_error_lock_critical_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_perform_pid_file_create_
- f_status_t controller_print_error_perform_pid_file_create(fl_print_t * const print, const f_status_t status, const f_string_t debug, const uint8_t is_entry, const f_string_t line_file) {
+ f_status_t controller_print_error_perform_pid_file_create(fl_print_t * const print, const f_status_t status, const f_string_t debug, const uint8_t is_entry) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
f_file_stream_lock(print->to);
- controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
}
* @param is_entry
* If TRUE, then this operates as an Entry.
* If FALSE, then this operates as an Exit.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
- *
- * Set to NULL to disable.
*
* @return
* F_okay on success.
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_perform_pid_file_create_
- extern f_status_t controller_print_error_perform_pid_file_create(fl_print_t * const print, const f_status_t status, const f_string_t debug, const uint8_t is_entry, const f_string_t line_file);
+ extern f_status_t controller_print_error_perform_pid_file_create(fl_print_t * const print, const f_status_t status, const f_string_t debug, const uint8_t is_entry);
#endif // _di_controller_print_error_perform_pid_file_create_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_rule_
- f_status_t controller_print_error_rule(fl_print_t * const print, controller_cache_action_t * const action, const f_status_t status, const f_string_t debug, const uint8_t fallback, const uint8_t item, const f_string_t line_file) {
+ f_status_t controller_print_error_rule(fl_print_t * const print, controller_cache_action_t * const action, const f_status_t status, const f_string_t debug, const uint8_t fallback, const uint8_t item) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
f_file_stream_lock(print->to);
- controller_print_error_rule_cache(print, action, item, line_file);
+ controller_print_error_rule_cache(print, action, item, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_
#ifndef _di_controller_print_error_rule_cache_
- f_status_t controller_print_error_rule_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_string_t debug) {
if (!print || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("Rule file '%]%[%Q%]%['", print->to, print->context, print->notable, action->name_file, print->notable, print->context);
}
- if (line_file) {
- fl_print_format(" (file: %s)", print->to, line_file);
- }
+ fll_error_print_debug(print, debug);
- fl_print_format(".%]%r", print->to, print->context, f_string_eol_s);
+ //fl_print_format(f_string_format_sentence_end_basic_s.string, print->to, print->context, f_string_eol_s);
+ fl_print_format(".%]%r", print->to, print->context, f_string_eol_s); // @todo remove this and use above line once FLL has bug fixed where f_string_format_sentence_end_basic_s is missing.
return F_okay;
}
#endif // _di_controller_print_error_rule_cache_
#ifndef _di_controller_print_error_rule_stack_already_
- f_status_t controller_print_error_rule_stack_already(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const uint8_t item, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_stack_already(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const uint8_t item, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format("%[' is already on the execution dependency stack, this recursion is prohibited.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, item, line_file);
+ controller_print_error_rule_cache(print, action, item, debug);
controller_unlock_print_flush(print->to, &main->thread);
* @param item
* If TRUE, then this error is associated with an item.
* If FALSE, then this error is associated with a Rule setting.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
- *
- * Set to NULL to disable.
*
* @return
* F_okay on success.
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_
- extern f_status_t controller_print_error_rule(fl_print_t * const print, controller_cache_action_t * const action, const f_status_t status, const f_string_t debug, const uint8_t fallback, const uint8_t item, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule(fl_print_t * const print, controller_cache_action_t * const action, const f_status_t status, const f_string_t debug, const uint8_t fallback, const uint8_t item);
#endif // _di_controller_print_error_rule_
/**
* @param item
* If TRUE, then this error is associated with an item.
* If FALSE, then this error is associated with a Rule setting.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_cache_
- extern f_status_t controller_print_error_rule_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_cache(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_string_t debug);
#endif // _di_controller_print_error_rule_cache_
/**
* @param item
* If TRUE, then this error is associated with an item.
* If FALSE, then this error is associated with a Rule setting.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_stack_already_
- extern f_status_t controller_print_error_rule_stack_already(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const uint8_t item, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_stack_already(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const uint8_t item, const f_string_t debug);
#endif // _di_controller_print_error_rule_stack_already_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_rule_action_first_
- f_status_t controller_print_error_rule_action_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_r_single_s.string, print->to, print->notable, controller_thaw_s, print->notable, print->context);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_first_
#ifndef _di_controller_print_error_rule_action_fss_0003_unsupported_
- f_status_t controller_print_error_rule_action_fss_0003_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_fss_0003_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_fss_0003_unsupported_
#ifndef _di_controller_print_error_rule_action_missing_pid_
- f_status_t controller_print_error_rule_action_missing_pid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_missing_pid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, alias, print->notable);
fl_print_format("%[' is not designating a PID file.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_missing_pid_
#ifndef _di_controller_print_error_rule_action_positive_number_not_
- f_status_t controller_print_error_rule_action_positive_number_not(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_ranges_t contents, const f_number_unsigned_t index, const f_status_t status, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_positive_number_not(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_ranges_t contents, const f_number_unsigned_t index, const f_status_t status, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
}
}
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_positive_number_not_
#ifndef _di_controller_print_error_rule_action_second_
- f_status_t controller_print_error_rule_action_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_r_single_s.string, print->to, print->notable, controller_thaw_s, print->notable, print->context);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_second_
#ifndef _di_controller_print_error_rule_action_type_unsupported_
- f_status_t controller_print_error_rule_action_type_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t type, const f_string_t message, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_type_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t type, const f_string_t message, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, type, print->notable);
fl_print_format("%[' while attempting to %S.%]%r", print->to, print->context, message, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_type_unsupported_
#ifndef _di_controller_print_error_rule_action_unknown_
- f_status_t controller_print_error_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_action_unknown_
#ifndef _di_controller_print_error_rule_action_unknown_execute_
- f_status_t controller_print_error_rule_action_unknown_execute(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t type, const f_number_unsigned_t total, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_action_unknown_execute(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t type, const f_number_unsigned_t total, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format("%[') to execute.%]%r", print->to, print->context, print->context, f_string_eol_s);
}
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* The buffer containing the setting name.
* @param range
* The range within the buffer representing the unknown Action name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_first_
- extern f_status_t controller_print_error_rule_action_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_first_
/**
* Must not be NULL.
* @param alias
* The Rule alias of the Rule that is missing the pid file designation.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_fss_0003_unsupported_
- extern f_status_t controller_print_error_rule_action_fss_0003_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_fss_0003_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_fss_0003_unsupported_
/**
* Must not be NULL.
* @param alias
* The Rule alias of the Rule that is missing the pid file designation.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_missing_pid_
- extern f_status_t controller_print_error_rule_action_missing_pid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_missing_pid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_missing_pid_
/**
* The index position in content representing the Content range for the buffer.
* @param status
* The status code of the error.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_positive_number_not_
- extern f_status_t controller_print_error_rule_action_positive_number_not(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_ranges_t contents, const f_number_unsigned_t index, const f_status_t status, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_positive_number_not(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_ranges_t contents, const f_number_unsigned_t index, const f_status_t status, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_positive_number_not_
/**
* The buffer containing the second Action.
* @param range
* The range within the buffer representing the second Action.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_second_
- extern f_status_t controller_print_error_rule_action_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_second_
/**
* The Action type name.
* @param message
* A specific message on what is being attempted by the Action.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_type_unsupported_
- extern f_status_t controller_print_error_rule_action_type_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t type, const f_string_t message, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_type_unsupported(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t type, const f_string_t message, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_type_unsupported_
/**
* The buffer containing the setting name.
* @param range
* The range within the buffer representing the unknown Action name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_unknown_
- extern f_status_t controller_print_error_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_unknown_
/**
* The Rule name.
* @param type
* The Action type name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_action_unknown_execute_
- extern f_status_t controller_print_error_rule_action_unknown_execute(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t type, const f_number_unsigned_t total, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_action_unknown_execute(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_static_t type, const f_number_unsigned_t total, const f_string_t debug);
#endif // _di_controller_print_error_rule_action_unknown_execute_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_rule_instance_need_want_wish_
- f_status_t controller_print_error_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug) {
if (!print || !print->custom || !instance) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
controller_lock_print(print->to, &main->thread);
- controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, line_file);
+ controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, debug);
- controller_print_error_rule_cache(print, &instance->cache.action, F_true, line_file);
+ controller_print_error_rule_cache(print, &instance->cache.action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* The value that is the error or warning.
* @param why
* A short explanation on why this is an error or warning.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_instance_need_want_wish_
- extern f_status_t controller_print_error_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_instance_need_want_wish(fl_print_t * const print, controller_instance_t * const instance, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug);
#endif // _di_controller_print_error_rule_instance_need_want_wish_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_rule_item_
- f_status_t controller_print_error_rule_item(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_status_t status, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_item(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_status_t status, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e || status == F_interrupt) return F_output_not;
controller_lock_print(print->to, &main->thread);
- controller_print_error_rule_cache(print, action, item, line_file);
+ controller_print_error_rule_cache(print, action, item, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_item_
#ifndef _di_controller_print_error_rule_item_execute_
- f_status_t controller_print_error_rule_item_execute(fl_print_t * const print, const uint8_t script_is, const f_string_static_t name, const f_status_t status, const int result, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_item_execute(fl_print_t * const print, const uint8_t script_is, const f_string_static_t name, const f_status_t status, const int result, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
#endif // _di_controller_print_error_rule_item_execute_
#ifndef _di_controller_print_error_rule_item_execute_none_
- f_status_t controller_print_error_rule_item_execute_none(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const uint8_t no_action, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_item_execute_none(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const uint8_t no_action, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
#endif // _di_controller_print_error_rule_item_execute_none_
#ifndef _di_controller_print_error_rule_item_need_want_wish_
- f_status_t controller_print_error_rule_item_need_want_wish(fl_print_t * const print, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_item_need_want_wish(fl_print_t * const print, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
#endif // _di_controller_print_error_rule_item_need_want_wish_
#ifndef _di_controller_print_error_rule_item_rule_not_loaded_
- f_status_t controller_print_error_rule_item_rule_not_loaded(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_item_rule_not_loaded(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, alias, print->notable);
fl_print_format("%[' is no longer loaded.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
* If FALSE, then this error is associated with a Rule setting.
* @param status
* The status code representing the failure (without the error bit set).
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_item_
- extern f_status_t controller_print_error_rule_item(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_status_t status, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_item(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t item, const f_status_t status, const f_string_t debug);
#endif // _di_controller_print_error_rule_item_
/**
* The status code representing the failure (without the error bit set).
* @param result
* The status code result.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_item_execute_
- extern f_status_t controller_print_error_rule_item_execute(fl_print_t * const print, const uint8_t script_is, const f_string_static_t name, const f_status_t status, const int result, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_item_execute(fl_print_t * const print, const uint8_t script_is, const f_string_static_t name, const f_status_t status, const int result, const f_string_t debug);
#endif // _di_controller_print_error_rule_item_execute_
/**
* @param no_action
* If TRUE, then nothing to execute because there is no item actions.
* If FALSE, then nothing to execute because there is no items.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_item_execute_none_
- extern f_status_t controller_print_error_rule_item_execute_none(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const uint8_t no_action, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_item_execute_none(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const uint8_t no_action, const f_string_t debug);
#endif // _di_controller_print_error_rule_item_execute_none_
/**
* The value that is the error or warning.
* @param why
* A short explanation on why this is an error or warning.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_item_need_want_wish_
- extern f_status_t controller_print_error_rule_item_need_want_wish(fl_print_t * const print, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_item_need_want_wish(fl_print_t * const print, const f_string_static_t need_want_wish, const f_string_static_t value, const f_string_t why, const f_string_t debug);
#endif // _di_controller_print_error_rule_item_need_want_wish_
/**
* Must not be NULL.
* @param alias
* The Rule alias of the Rule that is not loaded.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_item_rule_not_loaded_
- extern f_status_t controller_print_error_rule_item_rule_not_loaded(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_item_rule_not_loaded(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t alias, const f_string_t debug);
#endif // _di_controller_print_error_rule_item_rule_not_loaded_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_error_rule_setting_
- f_status_t controller_print_error_rule_setting(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t message, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t message, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format("%r%[%QRule setting %S.%]%r", print->to, f_string_eol_s, print->context, print->prefix, message, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_
#ifndef _di_controller_print_error_rule_setting_reason_name_
- f_status_t controller_print_error_rule_setting_reason_name(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t reason, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_reason_name(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t reason, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_reason_name_
#ifndef _di_controller_print_error_rule_setting_with_range_
- f_status_t controller_print_error_rule_setting_with_range(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t before, const f_string_static_t buffer, const f_range_t range_content, const f_string_t after, const f_number_unsigned_t start, const f_number_unsigned_t line, f_state_t * const state, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_with_range(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t before, const f_string_static_t buffer, const f_range_t range_content, const f_string_t after, const f_number_unsigned_t start, const f_number_unsigned_t line, f_state_t * const state, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range_content, print->notable);
fl_print_format("%['%S.%]%r", print->to, print->context, after, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_with_range_
#ifndef _di_controller_print_error_rule_setting_mapping_
- f_status_t controller_print_error_rule_setting_mapping(fl_print_t * const print, const f_string_static_t name, const f_string_map_t map, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_mapping(fl_print_t * const print, const f_string_static_t name, const f_string_map_t map, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
#endif // _di_controller_print_error_rule_setting_mapping_
#ifndef _di_controller_print_error_rule_setting_name_invalid_
- f_status_t controller_print_error_rule_setting_name_invalid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_name_invalid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format("%[', there must be at least 1 graph character.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_name_invalid_
#ifndef _di_controller_print_error_rule_setting_number_invalid_nice_
- f_status_t controller_print_error_rule_setting_number_invalid_nice(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_number_invalid_nice(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format("%[-20%] %[and%]", print->to, print->notable, print->notable, print->context, print->context);
fl_print_format("%[19%] %[are allowed.%]%r", print->to, print->notable, print->notable, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_number_invalid_nice_
#ifndef _di_controller_print_error_rule_setting_number_invalid_on_first_
- f_status_t controller_print_error_rule_setting_number_invalid_on_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_number_invalid_on_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format("%[' but only %r, %r, %r, %r, %r", print->to, print->context, controller_freeze_s, controller_kill_s, controller_pause_s, controller_reload_s, controller_restart_s);
fl_print_format("%r, %r, %r, and %r are supported.%]%r", print->to, controller_resume_s, controller_start_s, controller_stop_s, controller_thaw_s, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_number_invalid_on_first_
#ifndef _di_controller_print_error_rule_setting_number_invalid_on_second_
- f_status_t controller_print_error_rule_setting_number_invalid_on_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_number_invalid_on_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
fl_print_format("%[' but only supports %r, %r, and %r.%]%r", print->to, print->context, controller_need_s, controller_want_s, controller_wish_s, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_number_invalid_on_second_
#ifndef _di_controller_print_error_rule_setting_number_invalid_scheduler_
- f_status_t controller_print_error_rule_setting_number_invalid_scheduler(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const uint8_t zero_only, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_number_invalid_scheduler(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const uint8_t zero_only, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(" allowed for the designated scheduler.%]%r", print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_number_invalid_scheduler_
#ifndef _di_controller_print_error_rule_setting_number_invalid_timeout_
- f_status_t controller_print_error_rule_setting_number_invalid_timeout(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_number_invalid_timeout(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity == f_console_verbosity_quiet_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
fl_print_format("%[' but only %r, %r, and %r are supported.%]%r", print->to, print->context, controller_kill_s, controller_start_s, controller_stop_s, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_false, line_file);
+ controller_print_error_rule_cache(print, action, F_false, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_error_rule_setting_number_invalid_timeout_
#ifndef _di_controller_print_error_rule_setting_value_
- f_status_t controller_print_error_rule_setting_value(fl_print_t * const print, const f_string_static_t name, const f_string_static_t name_sub, const f_string_static_t value, const f_string_t suffix, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_value(fl_print_t * const print, const f_string_static_t name, const f_string_static_t name_sub, const f_string_static_t value, const f_string_t suffix, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
#endif // _di_controller_print_error_rule_setting_value_
#ifndef _di_controller_print_error_rule_setting_values_
- f_status_t controller_print_error_rule_setting_values(fl_print_t * const print, controller_cache_t * const cache, const f_string_static_t name, const f_number_unsigned_t index, const f_string_t line_file) {
+ f_status_t controller_print_error_rule_setting_values(fl_print_t * const print, controller_cache_t * const cache, const f_string_static_t name, const f_number_unsigned_t index, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
* Must not be NULL.
* @param message
* The string to append to the message being printed.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_
- extern f_status_t controller_print_error_rule_setting(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t message, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t message, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_
/**
* The reason for the error.
* @param name
* The name or value of the setting associated with the error.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_reason_name_
- extern f_status_t controller_print_error_rule_setting_reason_name(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t reason, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_reason_name(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t reason, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_reason_name_
/**
* The state.status is modified.
*
* Must not be NULL.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_with_range_
- extern f_status_t controller_print_error_rule_setting_with_range(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t before, const f_string_static_t buffer, const f_range_t range_content, const f_string_t after, const f_number_unsigned_t start, const f_number_unsigned_t line, f_state_t * const state, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_with_range(fl_print_t * const print, controller_cache_action_t * const action, const f_string_t before, const f_string_static_t buffer, const f_range_t range_content, const f_string_t after, const f_number_unsigned_t start, const f_number_unsigned_t line, f_state_t * const state, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_with_range_
/**
* The Object name of the setting being populated.
* @param map
* The map being applied.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_mapping_
- extern f_status_t controller_print_error_rule_setting_mapping(fl_print_t * const print, const f_string_static_t name, const f_string_map_t map, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_mapping(fl_print_t * const print, const f_string_static_t name, const f_string_map_t map, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_mapping_
/**
* F_output_not on success, but no printing is performed.
*
* F_output_not (with error bit) if setting is NULL.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*/
#ifndef _di_controller_print_error_rule_setting_name_invalid_
- extern f_status_t controller_print_error_rule_setting_name_invalid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_name_invalid(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_name_invalid_
/**
* The buffer containing the invalid number.
* @param range
* The ranger within the buffer representing the invalid number.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_number_invalid_nice_
- extern f_status_t controller_print_error_rule_setting_number_invalid_nice(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_number_invalid_nice(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_number_invalid_nice_
/**
* The buffer containing the invalid value.
* @param range
* The ranger within the buffer representing the invalid value.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_number_invalid_on_first_
- extern f_status_t controller_print_error_rule_setting_number_invalid_on_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_number_invalid_on_first(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_number_invalid_on_first_
/**
* The buffer containing the invalid value.
* @param range
* The ranger within the buffer representing the invalid value.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_number_invalid_on_second_
- extern f_status_t controller_print_error_rule_setting_number_invalid_on_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_number_invalid_on_second(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_number_invalid_on_second_
/**
* @param zero_only
* If TRUE, then only 0 is supported.
* If FALSE, then only the range 1 through 99 is supported.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_number_invalid_scheduler_
- extern f_status_t controller_print_error_rule_setting_number_invalid_scheduler(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const uint8_t zero_only, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_number_invalid_scheduler(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const uint8_t zero_only, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_number_invalid_scheduler_
/**
* The buffer containing the invalid value.
* @param range
* The ranger within the buffer representing the invalid value.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_number_invalid_timeout_
- extern f_status_t controller_print_error_rule_setting_number_invalid_timeout(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_number_invalid_timeout(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_number_invalid_timeout_
/**
* The value being set.
* @param suffix
* An additional message to append at the end (before the final period).
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_value_
- extern f_status_t controller_print_error_rule_setting_value(fl_print_t * const print, const f_string_static_t name, const f_string_static_t name_sub, const f_string_static_t value, const f_string_t suffix, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_value(fl_print_t * const print, const f_string_static_t name, const f_string_static_t name_sub, const f_string_static_t value, const f_string_t suffix, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_value_
/**
* The Object name of the setting being populated.
* @param index
* Position within the content_actions range cache array.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_error_rule_setting_values_
- extern f_status_t controller_print_error_rule_setting_values(fl_print_t * const print, controller_cache_t * const cache, const f_string_static_t name, const f_number_unsigned_t index, const f_string_t line_file);
+ extern f_status_t controller_print_error_rule_setting_values(fl_print_t * const print, controller_cache_t * const cache, const f_string_static_t name, const f_number_unsigned_t index, const f_string_t debug);
#endif // _di_controller_print_error_rule_setting_values_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_entry_action_failsafe_twice_
- f_status_t controller_print_warning_entry_action_failsafe_twice(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_action_failsafe_twice(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format("%r%[%QFailsafe may not be specified when running in failsafe, ignoring.%]%r", print->to, f_string_eol_s, print->context, print->prefix, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_warning_entry_action_failsafe_twice_
#ifndef _di_controller_print_warning_entry_action_multiple_
- f_status_t controller_print_warning_entry_action_multiple(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_action_multiple(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format("%[' %r Item Actions detected; only the first will be used.%]%r", print->to, print->context, is_entry ? controller_entry_s : controller_exit_s, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_warning_entry_action_multiple_
#ifndef _di_controller_print_warning_entry_action_unknown_
- f_status_t controller_print_warning_entry_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* @param is_entry
* If TRUE, then this loads as an Entry.
* If FALSE, then this loads as an Exit.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_action_failsafe_twice_
- extern f_status_t controller_print_warning_entry_action_failsafe_twice(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_action_failsafe_twice(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_t debug);
#endif // _di_controller_print_warning_entry_action_failsafe_twice_
/**
* If FALSE, then this loads as an Exit.
* @param name
* The item name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_action_multiple_
- extern f_status_t controller_print_warning_entry_action_multiple(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_action_multiple(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_entry_action_multiple_
/**
* The parameter name whose value is unknown.
* @param unknown
* The unknown value.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_action_unknown_
- extern f_status_t controller_print_warning_entry_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_entry_action_unknown_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_entry_item_duplicate_ignore_
- f_status_t controller_print_warning_entry_item_duplicate_ignore(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_item_duplicate_ignore(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
* If FALSE, then this loads as an Exit.
* @param name
* The item name.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_item_duplicate_ignore_
- extern f_status_t controller_print_warning_entry_item_duplicate_ignore(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_item_duplicate_ignore(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_entry_item_duplicate_ignore_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_entry_setting_unknown_action_
- f_status_t controller_print_warning_entry_setting_unknown_action(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_setting_unknown_action(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
#endif // _di_controller_print_warning_entry_setting_unknown_action_
#ifndef _di_controller_print_warning_entry_setting_unknown_action_value_
- f_status_t controller_print_warning_entry_setting_unknown_action_value(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file) {
+ f_status_t controller_print_warning_entry_setting_unknown_action_value(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t debug) {
if (!print || !print->custom || !cache) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_range_single_s.string, print->to, print->notable, buffer, range, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, debug);
controller_unlock_print_flush(print->to, &main->thread);
* If FALSE, then this loads as an Exit.
* @param name
* The parameter name whose value is unknown.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_setting_unknown_action_
- extern f_status_t controller_print_warning_entry_setting_unknown_action(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_setting_unknown_action(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_entry_setting_unknown_action_
/**
* The buffer containing the unknown value.
* @param range
* The range within the buffer representing the unknown value.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_entry_setting_unknown_action_value_
- extern f_status_t controller_print_warning_entry_setting_unknown_action_value(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t line_file);
+ extern f_status_t controller_print_warning_entry_setting_unknown_action_value(fl_print_t * const print, controller_cache_t * const cache, const uint8_t is_entry, const f_string_static_t name, const f_string_static_t buffer, const f_range_t range, const f_string_t debug);
#endif // _di_controller_print_warning_entry_setting_unknown_action_value_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_rule_action_unknown_
- f_status_t controller_print_warning_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* Must not be NULL.
* @param name
* The Action name that is unknown.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_rule_action_unknown_
- extern f_status_t controller_print_warning_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_rule_action_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_rule_action_unknown_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_rule_item_unknown_
- f_status_t controller_print_warning_rule_item_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file) {
+ f_status_t controller_print_warning_rule_item_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* Must not be NULL.
* @param name
* The Item name that is unknown.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_rule_item_unknown_
- extern f_status_t controller_print_warning_rule_item_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t line_file);
+ extern f_status_t controller_print_warning_rule_item_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t debug);
#endif // _di_controller_print_warning_rule_item_unknown_
#ifdef __cplusplus
#endif
#ifndef _di_controller_print_warning_rule_setting_unknown_
- f_status_t controller_print_warning_rule_setting_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t what, const f_string_t line_file) {
+ f_status_t controller_print_warning_rule_setting_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t what, const f_string_t debug) {
if (!print || !print->custom || !action) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_debug_e) return F_output_not;
fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, name, print->notable);
fl_print_format(f_string_format_sentence_end_single_quote_s.string, print->to, print->context, print->context, f_string_eol_s);
- controller_print_error_rule_cache(print, action, F_true, line_file);
+ controller_print_error_rule_cache(print, action, F_true, debug);
controller_unlock_print_flush(print->to, &main->thread);
* Must not be NULL.
* @param name
* The Item name that is unknown.
- * @param line_file
- * The line number and file name associated with the error.
- * Set this to macros like F_status_debug_source_d.
+ * @param debug
+ * (optional) The debug details, such as file, line number, and function.
*
* Set to NULL to disable.
*
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_controller_print_warning_rule_setting_unknown_
- extern f_status_t controller_print_warning_rule_setting_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t what, const f_string_t line_file);
+ extern f_status_t controller_print_warning_rule_setting_unknown(fl_print_t * const print, controller_cache_action_t * const action, const f_string_static_t name, const f_string_t what, const f_string_t debug);
#endif // _di_controller_print_warning_rule_setting_unknown_
#ifdef __cplusplus
}
else {
#ifdef _support_controller_controlfile_
- // @todo load the controlfile/initfile and start the thread. controller_main_flag_loaded_d
+ status = controller_file_load_controlfile(main); // @todo the main program needs to check if the controlfile exists and do not error when no entry is specified, a custom settings path can be used to override the location of the controlfile of PWD.
#endif // _support_controller_controlfile_
if (F_status_is_error_not(status)) {
status = controller_rule_expand(main, instance->rule.items.array[i].actions.array[j], instance);
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false);
break;
}
status = controller_rule_expand(main, instance->rule.items.array[i].actions.array[j], instance);
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false);
break;
}
status = controller_rule_expand(main, instance->rule.items.array[i].actions.array[j], instance);
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false);
break;
}
status = controller_rule_expand(main, instance->rule.items.array[i].actions.array[j], instance);
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false);
break;
}
}
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true);
return status;
}
status = f_string_dynamic_append(instance->rule.alias, &instance->cache.action.name_file);
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true);
return status;
}
}
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true);
return status;
}
if (!(main->setting.flag & controller_main_flag_loaded_d)) {
state.status = controller_file_load(main, F_true, controller_rules_s, rule->alias, controller_rule_s);
- /* @todo, how should this be handled?
- * Load the files at the start, so that this does not need to be loaded here?
- f_range_t offset = f_range_t_initialize;
+ if (F_status_is_error_not(state.status)) {
+ rule->timestamp = cache->timestamp;
- offset = main->thread.cache.object_actions.array[i];
+ if (cache->buffer_file.used) {
+ f_range_t range = macro_f_range_t_initialize_2(cache->buffer_file.used);
- if (main->setting.flag & controller_main_flag_loaded_d) {
- }*/
- }
-
- if (F_status_is_error_not(state.status)) {
- rule->timestamp = cache->timestamp;
-
- if (cache->buffer_file.used) {
- f_range_t range = macro_f_range_t_initialize_2(cache->buffer_file.used);
-
- fll_fss_basic_list_read(cache->buffer_file, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments, &state);
-
- if (F_status_is_error(state.status)) {
- controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
- }
- else {
- f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
+ fll_fss_basic_list_read(cache->buffer_file, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments, &state);
if (F_status_is_error(state.status)) {
controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
}
+ else {
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
+
+ if (F_status_is_error(state.status)) {
+ controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
+ }
+ }
}
}
}
fll_fss_extended_read(cache->buffer_item, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
return state.status;
}
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->object_actions.array[i], &cache->action.name_item);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(int32_t), (void **) &rule->affinity.array, &rule->affinity.used, &rule->affinity.size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
break;
}
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
state.status = F_status_set_error(state.status);
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_map_t), (void **) &setting_maps->array, &setting_maps->used, &setting_maps->size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], &setting_maps->array[setting_maps->used].key);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[1], &setting_maps->array[setting_maps->used].value);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = f_string_dynamic_append(main->process.path_cgroup, &rule->cgroup.path);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
}
else {
rule->cgroup.groups.used = 0;
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &rule->cgroup.groups.array, &rule->cgroup.groups.used, &rule->cgroup.groups.size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
break;
}
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[j], &rule->cgroup.groups.array[rule->cgroup.groups.used]);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
break;
}
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_limit_set_t), (void **) &rule->limits.array, &rule->limits.used, &rule->limits.size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
state.status = F_status_set_error(state.status);
else {
// This function should only return F_complete_not_utf on error.
- controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false);
if (F_status_is_error_not(status_return)) {
status_return = state.status;
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], setting_value);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
state.status = F_status_set_error(state.status);
if (F_status_is_error_not(status_return)) {
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
}
if (F_status_is_error_not(status_return)) {
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
state.status = F_status_set_error(state.status);
if (F_status_is_error_not(status_return)) {
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
}
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_int32s_t), (void **) &rule->groups.array, &rule->groups.used, &rule->groups.size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
}
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &setting_values->array, &setting_values->used, &setting_values->size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[j], &setting_values->array[setting_values->used]);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
setting_values->array[setting_values->used].used = 0;
else {
// This function should only return F_complete_not_utf on error.
- controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false);
if (F_status_is_error_not(status_return)) {
status_return = state.status;
}
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
}
else {
if (f_compare_dynamic_partial_string(controller_need_s.string, cache->buffer_item, controller_need_s.used, cache->content_actions.array[i].array[1]) == F_equal_to) {
state.status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &setting_values->array, &setting_values->used, &setting_values->size);
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
}
}
if (F_status_is_error(state.status)) {
setting_values->array[setting_values->used].used = 0;
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
case F_valid_not:
return F_status_set_error(F_valid_not);
+
+ case F_load_not:
+ return F_status_set_error(F_load_not);
};
return F_status_set_error(F_failure);
projects / controller / commitdiff