A recent work in progress commit resulted in the actions being incorrectly initialized.
This presents a good opportunity to improve the error reporting with the specific file and line number of the error.
This behavior can be disabled by turning off debug during build time.
The debug is enabled using the `debug` build setting mode.
This `debug` build settings mode is enabled by default.
Move the `controller_rule_instance_perform()` logic out and then collapse the `controller_rule_instance_perform_details()` functions into `er_rule_instance_perform()` functions to shorten their names.
This addresses some more locking issues resulting from many of the recent threading changes.
There is still a lot more work to do.
Particularly, there is addressing the problem causes the actions to be empty.
# fss-0000
-_di_libcap_ Disable libcap support, allow for compiling and linking without libcap (-lcap).
-_di_thread_support_ Disables thread support.
+_di_libcap_ Disable libcap support, allow for compiling and linking without libcap (-lcap).
+_di_thread_support_ Disables thread support.
+_en_controller_debug_ Enable debug support (such as printing file and line number in error messages).
_libcap_legacy_only_ Disable functionality provided by later versions of libcap (2.43 and later).
# - android: Compile on an android system (using Termux; may need modification depending on the android system).
# - clang: Use CLang rather than the default, which is generally GCC.
# - coverage: Compile for building coverage.
+# - debug: Enable debug support.
# - fanalyzer: Compile using GCC's -fanalyzer compile time option.
# - gcc: Use GCC specific settings.
# - gcc_13: Use GCC version 13 or greater specific settings.
version_file micro
version_target minor
-modes android clang coverage gcc gcc_13 fanalyzer individual individual_thread level monolithic test thread threadless
-modes_default monolithic thread gcc
+modes android clang coverage debug gcc gcc_13 fanalyzer individual individual_thread level monolithic test thread threadless
+modes_default monolithic thread gcc debug
build_compiler gcc
build_compiler-clang clang
#defines -D_di_libcap_
defines -D_libcap_legacy_only_
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_controller_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines-threadless -D_di_thread_support_
#define controller_with_session_same_d 0x4
#endif // _di_controller_with_d_
+/**
+ * Debug related macros and defines
+ *
+ * The line_number and line_string macro parts are both required due to how macro expansion works, even with the stringify macro (the '#').
+ *
+ * controller_debug_*_d:
+ * - file_line: Print the current file and line number (and possibly the function, if __FUNCTION__ is supported).
+ *
+ * macro_controller_debug_*:
+ * - line_number: Convert the pre-defined __LINE__ macro into a string for use by the file_line, final part.
+ * - line_string: Convert the pre-defined __LINE__ macro into a string for use by the file_line, first part.
+ */
+#ifndef _di_controller_debug_d_
+ #ifdef _en_controller_debug_
+ #define macro_controller_debug_line_number(line) #line
+ #define macro_controller_debug_line_string(line) macro_controller_debug_line_number(line)
+
+ #ifdef __FUNCTION__
+ #define controller_debug_file_line_d "" __FILE__ ":" macro_controller_debug_line_string(__LINE__) ":" __FUNCTION__
+ #else
+ #define controller_debug_file_line_d "" __FILE__ ":" macro_controller_debug_line_string(__LINE__)
+ #endif // __FUNCTION__
+ #else
+ #define controller_debug_file_line_d ""
+ #endif // _en_controller_debug_
+#endif // _di_controller_with_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
"controller_file_pid_create",
"controller_lock_create",
"controller_rule_copy",
+ "controller_rule_execute",
"controller_rule_expand",
"controller_path_canonical_relative",
"controller_validate_environment_name",
controller_f_controller_file_pid_create_e,
controller_f_controller_lock_create_e,
controller_f_controller_rule_copy_e,
+ controller_f_controller_rule_execute_e,
controller_f_controller_rule_expand_e,
controller_f_controller_path_canonical_relative_e,
controller_f_controller_validate_environment_name_e,
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), macro_controller_f(f_fss_apply_delimit), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_apply_delimit), F_true, controller_debug_file_line_d);
}
}
}
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
}
else {
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), macro_controller_f(f_memory_array_increase), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, controller_debug_file_line_d);
break;
}
state.status = f_string_dynamic_partial_append(main->thread.cache.buffer_file, main->thread.cache.object_items.array[i], &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), macro_controller_f(f_string_dynamic_partial_append), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_fss_count_lines), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_count_lines), F_true, controller_debug_file_line_d);
break;
}
for (j = (code & 0x1) ? 1 : 0; j < entry->items.used; ++j) {
if (f_compare_dynamic(entry->items.array[j].name, main->thread.cache.action.name_item) == F_equal_to) {
- controller_print_warning_entry_item_duplicate_ignore(&main->program.warning, &main->thread.cache, is_entry, main->thread.cache.action.name_item);
+ controller_print_warning_entry_item_duplicate_ignore(&main->program.warning, &main->thread.cache, is_entry, main->thread.cache.action.name_item, controller_debug_file_line_d);
code |= 0x2;
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_memory_array_resize), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_resize), F_true, controller_debug_file_line_d);
break;
}
if (F_status_set_fine(state.status) != F_interrupt) {
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry);
+ controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry, controller_debug_file_line_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
}
entry->status = controller_status_simplify_error(F_status_set_fine(state.status));
if (F_status_set_fine(state.status) != F_interrupt) {
- controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry);
+ controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry, controller_debug_file_line_d);
}
}
else {
}
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), macro_controller_f(fll_fss_extended_read), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(fll_fss_extended_read), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_fss_apply_delimit), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_fss_apply_delimit), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_fss_count_lines), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_fss_count_lines), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_rip_dynamic_partial_nulless), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_rip_dynamic_partial_nulless), F_true, controller_debug_file_line_d);
break;
}
actions->array[actions->used].type = controller_entry_action_type_timeout_e;
}
else {
- controller_print_warning_entry_action_unknown(&main->program.warning, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, main->thread.cache.action.name_action);
+ controller_print_warning_entry_action_unknown(&main->program.warning, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, main->thread.cache.action.name_action, controller_debug_file_line_d);
continue;
}
if (main->thread.cache.content_actions.array[i].used < at_least || main->thread.cache.content_actions.array[i].used > at_most) {
action->status = controller_status_simplify_error(F_parameter);
- controller_print_error_entry_action_requires_range(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, main->thread.cache.action.name_action, at_least, at_most, action->type);
+ controller_print_error_entry_action_requires_range(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, main->thread.cache.action.name_action, at_least, at_most, action->type, controller_debug_file_line_d);
}
else {
action->status = F_okay;
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(controller_path_canonical_relative), F_true, main->thread.cache.action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e);
+ controller_print_error_entry_file(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(controller_path_canonical_relative), F_true, main->thread.cache.action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, controller_debug_file_line_d);
action->status = state.status;
status_action = action->status;
}
- controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "first parameter");
+ controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "first parameter", controller_debug_file_line_d);
}
if (action->parameters.array[1].used) {
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), macro_controller_f(f_file_name_base), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(f_file_name_base), F_true, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_action = controller_status_simplify_error(state.status);
}
else {
if (f_compare_dynamic(action->parameters.array[1], main->thread.cache.buffer_path) == F_equal_to_not) {
- controller_print_error_entry_action_parameter_second_base(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, action->parameters.array[1], main->thread.cache.buffer_path);
+ controller_print_error_entry_action_parameter_second_base(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, action->parameters.array[1], main->thread.cache.buffer_path, controller_debug_file_line_d);
action->status = controller_status_simplify_error(F_parameter);
status_action = action->status;
}
- controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "second parameter");
+ controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "second parameter", controller_debug_file_line_d);
}
for (j = 2; j < action->parameters.used; ++j) {
}
}
- controller_print_error_entry_action_invalid_allow_3(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "third parameter (and beyond)", action->parameters.array[j], controller_asynchronous_s, controller_require_s, controller_wait_s);
+ controller_print_error_entry_action_invalid_allow_3(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "third parameter (and beyond)", action->parameters.array[j], controller_asynchronous_s, controller_require_s, controller_wait_s, controller_debug_file_line_d);
}
} // for
}
status_action = action->status;
}
- controller_print_error_entry_action_unsupported_reserve(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, controller_main_s);
+ controller_print_error_entry_action_unsupported_reserve(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, controller_main_s, controller_debug_file_line_d);
}
}
else if (action->type == controller_entry_action_type_timeout_e) {
status_action = action->status;
}
- controller_print_error_entry_action_invalid_allow_3(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, 0, action->parameters.array[0], controller_kill_s, controller_start_s, controller_stop_s);
+ controller_print_error_entry_action_invalid_allow_3(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, 0, action->parameters.array[0], controller_kill_s, controller_start_s, controller_stop_s, controller_debug_file_line_d);
}
if (action->status == F_okay) {
}
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), macro_controller_f(fl_conversion_dynamic_to_unsigned_detect), F_true);
+ controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_to_unsigned_detect), F_true, controller_debug_file_line_d);
status_action = state.status;
break;
}
- controller_print_error_entry_action_unsupported_number(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, action->parameters.array[1]);
+ controller_print_error_entry_action_unsupported_number(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, action->parameters.array[1], controller_debug_file_line_d);
}
}
else {
else {
action->status = controller_status_simplify_error(F_support_not);
- controller_print_error_entry_action_invalid_allow_1(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, 0, action->parameters.array[0], controller_wait_s);
+ controller_print_error_entry_action_invalid_allow_1(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, 0, action->parameters.array[0], controller_wait_s, controller_debug_file_line_d);
}
}
}
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), macro_controller_f(f_memory_array_resize), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_resize), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
return status2;
}
if (actions->array[cache->ats.array[at_j]].type == controller_entry_action_type_ready_e) {
if (main->process.ready == controller_process_ready_wait_e) {
- controller_print_warning_entry_action_multiple(&main->program.warning, cache, is_entry, controller_ready_s);
+ controller_print_warning_entry_action_multiple(&main->program.warning, cache, is_entry, controller_ready_s, controller_debug_file_line_d);
}
else {
main->process.ready = controller_process_ready_wait_e;
for (j = 2; j < cache->ats.used; j += 2) {
if (cache->ats.array[j] == i) {
- controller_print_error_entry_item_failure(&main->program.error, cache, is_entry, entry->items.array[i].name, "cannot be executed because recursion is not allowed");
+ controller_print_error_entry_item_failure(&main->program.error, cache, is_entry, entry->items.array[i].name, "cannot be executed because recursion is not allowed", controller_debug_file_line_d);
if (F_status_is_error_not(status)) {
status = F_status_set_error(F_recurse);
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), macro_controller_f(f_memory_array_increase), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_memory_array_increase), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
return status2;
}
if (error_has || i >= entry->items.used) {
if (i >= entry->items.used) {
- controller_print_error_entry_item_failure(&main->program.error, cache, is_entry, actions->array[cache->ats.array[at_j]].parameters.array[0], "does not exist");
+ controller_print_error_entry_item_failure(&main->program.error, cache, is_entry, actions->array[cache->ats.array[at_j]].parameters.array[0], "does not exist", controller_debug_file_line_d);
if (F_status_is_error_not(status)) {
status = F_status_set_error(F_valid_not);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_memory_array_resize), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_resize), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
return status;
}
if (entry_action->number == 0 || entry_action->number >= entry->items.used || failsafe && entry_action->number == main->process.failsafe_item_id) {
// This should not happen if the pre-process is working as intended, but in case it doesn't, return a critical error to prevent infinite recursion and similar errors.
- controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number);
+ controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number, controller_debug_file_line_d);
return F_status_is_error(F_critical);
}
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), macro_controller_f(f_memory_array_increase_by), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_increase_by), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
return status;
}
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), macro_controller_f(f_memory_new), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_new), F_true, controller_debug_file_line_d);
return 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);
+ controller_print_error_entry_cache(&main->program.error, &cache->action, is_entry, controller_debug_file_line_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
}
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);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
break;
}
f_thread_unlock(&main->thread.lock.rule);
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_increase), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_increase), F_true, controller_debug_file_line_d);
return status;
}
if (F_status_is_error(status)) {
if (F_status_set_fine(status) == F_file_found_not) {
- controller_print_error_entry_action_execution_missing(&main->program.error, &cache->action, is_entry, entry_action->parameters.array[0]);
+ controller_print_error_entry_action_execution_missing(&main->program.error, &cache->action, is_entry, entry_action->parameters.array[0], controller_debug_file_line_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(fll_execute_into), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(fll_execute_into), F_true, controller_debug_file_line_d);
}
return F_status_set_error(F_execute);
}
else if (result != 0) {
- controller_print_error_entry_action_execution_failure(&main->program.error, &cache->action, is_entry, result);
+ controller_print_error_entry_action_execution_failure(&main->program.error, &cache->action, is_entry, result, controller_debug_file_line_d);
return F_status_set_error(F_execute);
}
}
else if (entry_action->type == controller_entry_action_type_failsafe_e) {
if (failsafe) {
- controller_print_warning_entry_action_failsafe_twice(&main->program.warning, cache, is_entry);
+ controller_print_warning_entry_action_failsafe_twice(&main->program.warning, cache, is_entry, controller_debug_file_line_d);
}
else {
if (entry_action->number == 0 || entry_action->number >= entry->items.used) {
// This should not happen if the pre-process is working as designed, but in case it doesn't, return a critical error to prevent infinite recursion and similar errors.
- controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number);
+ controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number, controller_debug_file_line_d);
return F_status_is_error(F_critical);
}
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), macro_controller_f(f_string_dynamic_append_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, controller_debug_file_line_d);
break;
}
}
if (F_status_is_error(state.status)) {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(fll_fss_extended_read), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(fll_fss_extended_read), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_fss_apply_delimit), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_apply_delimit), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_fss_count_lines), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_count_lines), F_true, controller_debug_file_line_d);
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), macro_controller_f(f_rip_dynamic_partial_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_rip_dynamic_partial_nulless), F_true, controller_debug_file_line_d);
break;
}
if (is_entry && f_compare_dynamic(controller_control_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used < 1 || cache->content_actions.array[i].used > 2) {
- controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2);
+ controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2, controller_debug_file_line_d);
continue;
}
main->process.control.flag |= controller_control_flag_readonly_e;
}
else {
- controller_print_error_entry_item_setting_support_not_option(&main->program.error, cache, is_entry, cache->buffer_file, cache->content_actions.array[i].array[1]);
+ controller_print_error_entry_item_setting_support_not_option(&main->program.error, cache, is_entry, cache->buffer_file, cache->content_actions.array[i].array[1], controller_debug_file_line_d);
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), macro_controller_f(f_rip_dynamic_partial_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_rip_dynamic_partial_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(controller_path_canonical_relative), F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e);
+ controller_print_error_entry_file(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_path_canonical_relative), F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, controller_debug_file_line_d);
continue;
}
if (F_status_is_error(state.status)) {
if (F_status_set_fine(state.status) == F_exist_not) {
- 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 no group was found by that name");
+ 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 no group was found by that name", controller_debug_file_line_d);
}
else if (F_status_set_fine(state.status) == F_number_too_large) {
- 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 too large");
+ 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 too large", controller_debug_file_line_d);
}
else if (F_status_set_fine(state.status) == F_number) {
- 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");
+ 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", controller_debug_file_line_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_group_id), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_group_id), F_true, controller_debug_file_line_d);
}
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), macro_controller_f(f_rip_dynamic_partial_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_rip_dynamic_partial_nulless), F_true, controller_debug_file_line_d);
break;
}
state.status = f_file_mode_from_string(cache->action.generic, main->program.umask, &mode_file, &replace);
if (F_status_is_error(state.status)) {
- controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an unsupported mode", cache->content_actions.array[i].array[0], ", because the format is unknown or contains invalid data");
+ controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an unsupported mode", cache->content_actions.array[i].array[0], ", because the format is unknown or contains invalid data", controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_file_mode_to_mode), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_file_mode_to_mode), F_true, controller_debug_file_line_d);
continue;
}
if (F_status_is_error(state.status)) {
if (F_status_set_fine(state.status) == F_exist_not) {
- 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 no user was found by that name");
+ 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 no user was found by that name", controller_debug_file_line_d);
}
else if (F_status_set_fine(state.status) == F_number_too_large) {
- 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 too large");
+ 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 too large", controller_debug_file_line_d);
}
else if (F_status_set_fine(state.status) == F_number) {
- 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");
+ 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", controller_debug_file_line_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true, controller_debug_file_line_d);
}
continue;
}
else if (f_compare_dynamic(controller_define_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 2) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2, controller_debug_file_line_d);
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), macro_controller_f(controller_entry_setting_read_map), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_entry_setting_read_map), F_true, controller_debug_file_line_d);
continue;
}
}
else if (is_entry && f_compare_dynamic(controller_mode_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 1) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, controller_debug_file_line_d);
continue;
}
main->process.mode = controller_process_mode_program_e;
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
continue;
}
}
else if (f_compare_dynamic(controller_parameter_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 2) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2, controller_debug_file_line_d);
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), macro_controller_f(controller_entry_setting_read_map), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_entry_setting_read_map), F_true, controller_debug_file_line_d);
continue;
}
}
else if (f_compare_dynamic(controller_pid_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 1) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, controller_debug_file_line_d);
continue;
}
entry->pid = controller_entry_pid_require_e;
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
continue;
}
}
else if (is_entry && f_compare_dynamic(controller_pid_file_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 1) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, controller_debug_file_line_d);
continue;
}
if (main->setting.flag & controller_main_flag_pid_d) {
- controller_print_error_entry_setting_ignored(&main->program.error, cache, is_entry);
+ controller_print_error_entry_setting_ignored(&main->program.error, cache, is_entry, controller_debug_file_line_d);
}
else {
cache->action.generic.used = 0;
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), macro_controller_f(f_rip_dynamic_partial_nulless), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_rip_dynamic_partial_nulless), F_true, controller_debug_file_line_d);
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), macro_controller_f(controller_path_canonical_relative), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_path_canonical_relative), F_true, controller_debug_file_line_d);
continue;
}
}
else if (f_compare_dynamic(controller_session_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 1) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, controller_debug_file_line_d);
continue;
}
entry->session = controller_entry_session_same_e;
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
continue;
}
}
else if (f_compare_dynamic(controller_show_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used != 1) {
- controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, controller_debug_file_line_d);
continue;
}
entry->show = controller_entry_show_init_e;
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
continue;
}
}
else if (f_compare_dynamic(controller_timeout_s, cache->action.name_action) == F_equal_to) {
if (cache->content_actions.array[i].used < 1 || cache->content_actions.array[i].used > 2) {
- controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2);
+ controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2, controller_debug_file_line_d);
continue;
}
time = &entry->timeout_stop;
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
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), macro_controller_f(fl_conversion_dynamic_partial_to_unsigned_detect), F_true);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_unsigned_detect), F_true, controller_debug_file_line_d);
continue;
}
- controller_print_error_entry_setting_support_not_number(&main->program.error, is_entry, cache->buffer_file, cache->content_actions.array[i].array[1]);
+ controller_print_error_entry_setting_support_not_number(&main->program.error, is_entry, cache->buffer_file, cache->content_actions.array[i].array[1], controller_debug_file_line_d);
}
}
else {
- controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0]);
+ controller_print_warning_entry_setting_unknown_action_value(&main->program.warning, cache, is_entry, cache->action.name_action, cache->buffer_file, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
continue;
}
f_status_t status = controller_lock_read_standard(is_normal, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.instance);
if (status != F_okay) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
return status;
}
status = controller_lock_write_standard(is_normal, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.instance);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, controller_debug_file_line_d);
}
else {
if (F_status_is_error_not(status)) {
status_lock = controller_lock_read_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
break;
}
// 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), macro_controller_f(controller_file_pid_create), is_entry);
+ controller_print_error_perform_pid_file_create(&main->program.error, F_status_set_fine(status), macro_controller_f(controller_file_pid_create), is_entry, controller_debug_file_line_d);
return status;
}
f_file_stream_lock(print->to);
- controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, 0);
controller_unlock_print_flush(print->to, &main->thread);
}
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, &cache->action, F_true, line_file);
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 controller_debug_file_line_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_debug_rule_action_empty_
- extern f_status_t controller_print_debug_rule_action_empty(fl_print_t * const print, controller_cache_t * const cache);
+ 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);
#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) {
+ 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) {
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 {
* 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 controller_debug_file_line_d.
+ *
+ * Set to NULL to disable.
*
* @return
* F_okay on success.
* 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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, line_file);
- controller_print_error_rule_cache(print, &instance->cache.action, F_true);
+ controller_print_error_rule_cache(print, &instance->cache.action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 function, const uint8_t fallback) {
+ 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 function, const uint8_t fallback, const f_string_t line_file) {
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);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
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) {
+ 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) {
if (!print || !action) 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_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 function, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type) {
+ 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 function, 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) {
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);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
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 controller_debug_file_line_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 function, const uint8_t fallback);
+ 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 function, const uint8_t fallback, const f_string_t line_file);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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 function, const uint8_t fallback, const f_string_static_t name, const f_string_static_t operation, const uint8_t type);
+ 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 function, 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);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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_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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, action, is_entry, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#endif // _di_controller_print_error_entry_action_invalid_allow_3_
/**
* 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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
* 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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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;
* @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 controller_debug_file_line_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_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);
+ 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);
#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 function, const uint8_t is_entry) {
+ f_status_t controller_print_error_perform_pid_file_create(fl_print_t * const print, const f_status_t status, const f_string_t function, const uint8_t is_entry, const f_string_t line_file) {
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);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, line_file);
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 controller_debug_file_line_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 function, const uint8_t is_entry);
+ 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 function, const uint8_t is_entry, const f_string_t line_file);
#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 function, const uint8_t fallback, const uint8_t item) {
+ 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 function, const uint8_t fallback, const uint8_t item, const f_string_t line_file) {
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);
+ controller_print_error_rule_cache(print, action, item, line_file);
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) {
+ 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) {
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);
+ }
+
fl_print_format(".%]%r", print->to, print->context, f_string_eol_s);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, item, line_file);
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 controller_debug_file_line_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 function, const uint8_t fallback, const uint8_t item);
+ 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 function, const uint8_t fallback, const uint8_t item, const f_string_t line_file);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_item_need_want_wish(print, need_want_wish, value, why, line_file);
- controller_print_error_rule_cache(print, &instance->cache.action, F_true);
+ controller_print_error_rule_cache(print, &instance->cache.action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, item, line_file);
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) {
+ 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) {
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) {
+ 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) {
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 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, alias, print->notable);
- fl_print_format("%[' has no Items to execute.%]%r", print->to, print->context, print->context, f_string_eol_s);
+ fl_print_format("%[' has no ", print->to, print->context);
+
+ if (no_action) {
+ fl_print_format("Actions on any ", print->to);
+ }
+
+ fl_print_format("Items to execute.%]%r", print->to, print->context, f_string_eol_s);
controller_unlock_print_flush(print->to, &main->thread);
}
#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) {
+ 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) {
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#endif // _di_controller_print_error_rule_item_execute_
/**
* Must not be NULL.
* @param alias
* The Rule alias of the Rule that has no Items.
+ * @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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_false, line_file);
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) {
+ 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) {
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) {
+ 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) {
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_d.
+ *
+ * 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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#endif // _di_controller_print_error_rule_setting_values_
#ifdef __cplusplus
fl_print_format(" %[state, skipping.%]%r", print->to, print->context, print->context, f_string_eol_s);
}
- controller_print_error_entry_cache(print, &cache->action, is_entry);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, 0);
controller_unlock_print_flush(print->to, &main->thread);
fl_print_format(f_string_format_Q_single_s.string, print->to, print->set->title, name, print->set->title);
fl_print_format("' %Q.", print->to, reason, f_string_eol_s);
- controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry);
+ controller_print_error_entry_cache(print, &main->thread.cache.action, is_entry, 0);
controller_unlock_print_flush(print->to, &main->thread);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
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) {
+ 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) {
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);
+ controller_print_error_entry_cache(print, &cache->action, is_entry, line_file);
controller_unlock_print_flush(print->to, &main->thread);
/**
* Print a message for when an Entry Setting Action is unknown.
*
+ * @fixme Not used anymore? Is it intended to be used? Remove this if not used and not planned to be used. Remove this comment once determined that this should remain.
+ *
* @param print
* The output structure to print to.
*
* 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 controller_debug_file_line_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_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);
+ 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);
#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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#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) {
+ 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) {
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);
+ controller_print_error_rule_cache(print, action, F_true, line_file);
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 controller_debug_file_line_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_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);
+ 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);
#endif // _di_controller_print_warning_rule_setting_unknown_
#ifdef __cplusplus
f_status_t status = controller_lock_read_standard(is_entry, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.rule);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
return status;
}
if (!type_rerun) {
state->status = F_status_set_error(F_valid_not);
- controller_print_error_rule_action_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[0]);
+ controller_print_error_rule_action_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[0], controller_debug_file_line_d);
return;
}
else {
state->status = F_status_set_error(F_valid_not);
- controller_print_error_rule_action_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[1]);
+ controller_print_error_rule_action_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[1], controller_debug_file_line_d);
return;
}
else {
state->status = F_status_set_error(F_valid_not);
- controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_rerun_s, cache->buffer_item, cache->content_action.array[i]);
+ controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_rerun_s, cache->buffer_item, cache->content_action.array[i], controller_debug_file_line_d);
return;
}
item->with &= ~controller_with_session_new_d;
}
else {
- controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_with_s, cache->buffer_item, cache->content_action.array[i]);
+ controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_with_s, cache->buffer_item, cache->content_action.array[i], controller_debug_file_line_d);
state->status = F_status_set_error(F_valid_not);
}
if (F_status_is_error_not(state->status) && state->status == F_data_not) {
- controller_print_debug_rule_action_empty(&main->program.debug, cache);
+ controller_print_debug_rule_action_empty(&main->program.debug, cache, controller_debug_file_line_d);
}
}
#endif // _di_controller_rule_action_read_
controller_print_error(&main->program.error, macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect));
}
else {
- controller_print_error_rule_action_positive_number_not(&main->program.error, &cache->action, name, cache->buffer_item, cache->content_action, *index, status);
+ controller_print_error_rule_action_positive_number_not(&main->program.error, &cache->action, name, cache->buffer_item, cache->content_action, *index, status, controller_debug_file_line_d);
}
}
}
}
}
+ // 0x1 = No Item, 0x2 = No action.
+ uint8_t execute_nothing = 0x3;
+
for (i = 0; i < instance->rule.items.used && controller_thread_is_enabled_instance(instance); ++i) {
if (instance->rule.items.array[i].type == controller_rule_item_type_settings_e) continue;
+ execute_nothing &= ~0x1;
+
for (j = 0; j < instance->rule.items.array[i].actions.used; ++j) {
if (!controller_thread_is_enabled_instance(instance)) {
if (instance->rule.items.array[i].actions.array[j].type != action) continue;
+ execute_nothing &= ~0x2;
+
execute_set.parameter.data = 0;
execute_set.parameter.option = FL_execute_parameter_option_threadsafe_d | FL_execute_parameter_option_return_d;
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), macro_controller_f(controller_rule_expand), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(controller_rule_expand), F_true, F_false, controller_debug_file_line_d);
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), macro_controller_f(controller_rule_expand), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(controller_rule_expand), F_true, F_false, controller_debug_file_line_d);
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), macro_controller_f(controller_rule_expand), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(controller_rule_expand), F_true, F_false, controller_debug_file_line_d);
break;
}
else {
success = F_status_set_error(F_failure);
- controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias);
+ controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias, controller_debug_file_line_d);
}
}
else if (instance->rule.items.array[i].type == controller_rule_item_type_utility_e) {
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), macro_controller_f(controller_rule_expand), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(controller_rule_expand), F_true, F_false, controller_debug_file_line_d);
break;
}
else {
success = F_status_set_error(F_failure);
- controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias);
+ controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias, controller_debug_file_line_d);
}
}
else {
}
} // for
- // Lock failed, attempt to re-establish lock before returning.
- if (F_status_set_fine(status) == F_lock || F_status_set_fine(status) == F_lock_read || F_status_set_fine(status) == F_lock_write) {
- success = F_false;
-
- return status;
- }
+ // Lock failed, attempt to re-establish lock before returning. @fixme out of date?
+ if (F_status_set_fine(status) == F_lock || F_status_set_fine(status) == F_lock_read || F_status_set_fine(status) == F_lock_write) return status;
- if (success == false && !instance->rule.items.used) {
- controller_print_error_rule_item_execute_none(&main->program.error, &instance->cache.action, instance->rule.alias);
+ if (success == false && execute_nothing) {
+ controller_print_error_rule_item_execute_none(&main->program.error, &instance->cache.action, instance->rule.alias, execute_nothing & 0x2, controller_debug_file_line_d);
}
if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
f_status_t status_lock = controller_lock_write_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
return status_lock;
}
const f_status_t status_lock = controller_lock_read_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
return status_lock;
}
}
if ((WIFEXITED(instance->result) && WEXITSTATUS(instance->result)) || status == F_control_group || status == F_failure || status == F_limit || status == F_processor || status == F_schedule) {
- controller_print_error_rule_item_execute(&instance->main->program.error, type == controller_rule_item_type_script_e, program.used ? program : arguments.array[0], status, instance->result);
+ controller_print_error_rule_item_execute(&instance->main->program.error, type == controller_rule_item_type_script_e, program.used ? program : arguments.array[0], status, instance->result, controller_debug_file_line_d);
}
else {
controller_print_error_status(&instance->main->program.error, macro_controller_f(fll_execute_program), F_status_set_fine(status));
f_status_t status_lock = controller_lock_write_instance(instance, &instance->use);
if (status_lock != F_okay) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
return status_lock;
}
status_lock = controller_lock_write_instance(instance, &instance->use);
if (status_lock != F_okay) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
return F_status_set_error(F_lock_write);
}
const f_status_t status_lock = controller_lock_read_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
return status_lock;
}
}
if ((WIFEXITED(instance->result) && WEXITSTATUS(instance->result)) || status == F_control_group || status == F_failure || status == F_limit || status == F_processor || status == F_schedule) {
- controller_print_error_rule_item_execute(&instance->main->program.error, type == controller_rule_item_type_utility_e, program.used ? program : arguments.array[0], status, instance->result);
+ controller_print_error_rule_item_execute(&instance->main->program.error, type == controller_rule_item_type_utility_e, program.used ? program : arguments.array[0], status, instance->result, controller_debug_file_line_d);
}
else {
controller_print_error_status(&instance->main->program.error, macro_controller_f(fll_execute_program), F_status_set_fine(status));
if (!controller_thread_is_enabled_instance(instance)) return -2;
if (!rerun_item->max || rerun_item->count < rerun_item->max) {
- controller_main_print_debug_rule_execute_rerun(&main->program.output, instance, rerun_item, action);
+ controller_main_print_debug_rule_execute_rerun(&main->program.output, instance, rerun_item, action, controller_debug_file_line_d);
if (rerun_item->delay) {
f_time_spec_t delay = f_time_spec_t_initialize;
break;
default:
- controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "execute rule");
+ controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "execute rule", controller_debug_file_line_d);
return F_status_set_error(F_parameter);
}
}
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append), F_true, F_true);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append), F_true, F_true, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_append), F_true, F_true);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append), F_true, F_true, controller_debug_file_line_d);
return status;
}
}
if (F_status_is_error(status)) {
- controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append), F_true, F_true);
+ controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append), F_true, F_true, controller_debug_file_line_d);
return status;
}
break;
default:
- controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "validate Fule execution");
+ controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "validate Fule execution", controller_debug_file_line_d);
break;
}
if (!controller_thread_is_enabled_instance_type(&main->thread, instance->type)) return F_status_set_error(F_interrupt);
}
- controller_print_error_rule_item_rule_not_loaded(&main->program.error, &instance->cache.action, dynamics[i]->array[j]);
+ controller_print_error_rule_item_rule_not_loaded(&main->program.error, &instance->cache.action, dynamics[i]->array[j], controller_debug_file_line_d);
return status;
}
status_lock = controller_lock_read_instance(instance, &dependency->active);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
status = F_false;
dependency = 0;
rule = 0;
if (i) {
- controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], dynamics[i]->array[j], "is not found");
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], dynamics[i]->array[j], "is not found", controller_debug_file_line_d);
}
else {
status = F_status_set_error(F_found_not);
- controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], dynamics[i]->array[j], "is not found");
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], dynamics[i]->array[j], "is not found", controller_debug_file_line_d);
if (!(instance->options & controller_instance_option_simulate_d)) {
if (dependency) {
status_lock = controller_lock_read_instance(instance, &dependency->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
status = status_lock;
}
status_lock = controller_lock_read_instance(instance, &dependency->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
status = status_lock;
}
if (F_status_is_error(status)) {
if (i == 0 || i == 1 || F_status_set_fine(status) == F_memory_not) {
- controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "failed during execution");
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "failed during execution", controller_debug_file_line_d);
if (!(dependency->options & controller_instance_option_simulate_d) || F_status_set_fine(status) == F_memory_not) {
f_thread_unlock(&dependency->active);
}
}
else {
- controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "failed during execution");
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "failed during execution", controller_debug_file_line_d);
}
}
}
status = status_lock;
if (F_status_set_fine(status_lock) != F_interrupt) {
- controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "due to lock failure");
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "due to lock failure", controller_debug_file_line_d);
}
}
else if (controller_rule_status_is_error(instance->action, *rule)) {
if (i == 0 || i == 1) {
status = F_status_set_error(F_found_not);
- controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "is in a failed state");
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "is in a failed state", controller_debug_file_line_d);
if (!(dependency->options & controller_instance_option_simulate_d)) {
f_thread_unlock(&dependency->active);
}
}
else {
- controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "is in a failed state");
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "is in a failed state", controller_debug_file_line_d);
}
}
}
if (missing) {
status = F_status_set_error(F_parameter);
- controller_print_error_rule_action_unknown_execute(&main->program.error, &instance->cache.action, instance->rule.name, controller_convert_rule_action_type_string(instance->action), instance->rule.items.used);
+ controller_print_error_rule_action_unknown_execute(&main->program.error, &instance->cache.action, instance->rule.name, controller_convert_rule_action_type_string(instance->action), instance->rule.items.used, controller_debug_file_line_d);
}
}
if (status == F_child || F_status_set_fine(status) == F_interrupt || F_status_set_fine(status) == F_lock || F_status_set_fine(status) == F_lock_read) return status;
if (F_status_is_error(status)) {
- controller_print_error_rule_item(&main->program.error, &instance->cache.action, F_true, F_status_set_fine(status));
+ if (F_status_set_fine(status) == F_parameter) {
+ controller_print_error_status(&main->program.error, macro_controller_f(controller_rule_execute), F_status_set_fine(status));
+ }
+
+ controller_print_error_rule_item(&main->program.error, &instance->cache.action, F_true, F_status_set_fine(status), controller_debug_file_line_d);
}
}
}
status_lock = controller_lock_write_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
return status_lock;
}
if (F_status_is_error(status_lock)) {
f_thread_unlock(&instance->use);
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
return F_status_set_error(status_lock);
}
if (F_status_is_error(status_lock)) {
f_thread_unlock(&instance->use);
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
return F_status_set_error(status_lock);
}
f_status_t status = controller_instance_prepare(main, type != controller_instance_type_exit_e, action, alias_rule, &instance);
if (F_status_is_error(status)) {
- controller_print_error_rule_item_rule_not_loaded(&main->program.error, &cache->action, alias_rule);
+ controller_print_error_rule_item_rule_not_loaded(&main->program.error, &cache->action, alias_rule, controller_debug_file_line_d);
return status;
}
status = controller_lock_read_standard(type != controller_instance_type_exit_e, controller_lock_check_flag_yes_d, &main->thread, &instance->active);
if (status != F_okay) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(status));
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(status), controller_debug_file_line_d);
return status;
}
if (F_status_is_error(status)) {
f_thread_unlock(&instance->active);
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, controller_debug_file_line_d);
return status;
}
if (F_status_is_error(status)) {
f_thread_unlock(&instance->active);
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
return status;
}
if (F_status_is_error(status)) {
f_thread_unlock(&instance->active);
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, controller_debug_file_line_d);
return status;
}
if (!instance || !instance->main) return F_status_set_error(F_parameter);
- f_status_t status = F_okay;
-
- if (options_force & controller_instance_option_asynchronous_d) {
- status = controller_lock_read_instance(instance, &instance->active);
-
- if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true);
-
- return status;
- }
- }
-
- status = controller_rule_instance_perform_details(instance, options_force);
-
- if (options_force & controller_instance_option_asynchronous_d) {
- f_thread_unlock(&instance->active);
- }
-
- return status;
- }
-#endif // _di_controller_rule_instance_perform_
-
-#ifndef _di_controller_rule_instance_perform_details_
- f_status_t controller_rule_instance_perform_details(controller_instance_t * const instance, const uint8_t options_force) {
-
- if (!instance || !instance->main) return F_status_set_error(F_parameter);
-
f_status_t status = controller_lock_read_instance(instance, &instance->use);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
return status;
}
if (F_status_is_error(status)) return status;
if (status == F_true) {
- status = controller_rule_instance_perform_details_copy(instance, *rule, &instance->rule);
+ status = controller_rule_instance_perform_copy(instance, *rule, &instance->rule);
if (F_status_is_error_not(status)) {
return F_process_not;
}
- status = controller_rule_instance_perform_details_stack_verify(instance, rule);
+ status = controller_rule_instance_perform_stack_verify(instance, rule);
if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
if (F_status_is_error_not(status)) {
- status = controller_rule_instance_perform_details_stack_rule_append(instance, rule);
+ status = controller_rule_instance_perform_stack_rule_append(instance, rule);
if (F_status_is_error_not(status)) {
status = controller_rule_instance(instance);
else {
status = F_status_set_error(F_found_not);
- controller_print_error_rule_item_rule_not_loaded(&instance->main->program.error, &instance->cache.action, instance->rule.alias);
+ controller_print_error_rule_item_rule_not_loaded(&instance->main->program.error, &instance->cache.action, instance->rule.alias, controller_debug_file_line_d);
}
if (status == F_child) return status;
const f_status_t status_lock = controller_lock_write_instance(instance, &instance->use);
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_false);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
return status_lock;
}
return controller_thread_is_enabled_instance(instance) ? status : F_status_set_error(F_interrupt);
}
-#endif // _di_controller_rule_instance_perform_details_
+#endif // _di_controller_rule_instance_perform_
-#ifndef _di_controller_rule_instance_perform_details_copy_
- f_status_t controller_rule_instance_perform_details_copy(controller_instance_t * const instance, const controller_rule_t source, controller_rule_t * const destination) {
+#ifndef _di_controller_rule_instance_perform_copy_
+ f_status_t controller_rule_instance_perform_copy(controller_instance_t * const instance, const controller_rule_t source, controller_rule_t * const destination) {
if (!instance || !instance->main) return F_status_set_error(F_parameter);
f_status_t status = controller_lock_write_instance(instance, &instance->use);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false, controller_debug_file_line_d);
return status;
}
return status;
}
-#endif // _di_controller_rule_instance_perform_details_copy_
+#endif // _di_controller_rule_instance_perform_copy_
-#ifndef _di_controller_rule_instance_perform_details_stack_rule_append_
- f_status_t controller_rule_instance_perform_details_stack_rule_append(controller_instance_t * const instance, controller_rule_t * const rule) {
+#ifndef _di_controller_rule_instance_perform_stack_rule_append_
+ f_status_t controller_rule_instance_perform_stack_rule_append(controller_instance_t * const instance, controller_rule_t * const rule) {
if (!instance || !instance->main || !rule) return F_status_set_error(F_parameter);
f_status_t status = controller_lock_write_instance(instance, &instance->use);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false, controller_debug_file_line_d);
return status;
}
return status;
}
-#endif // _di_controller_rule_instance_perform_details_stack_rule_append_
+#endif // _di_controller_rule_instance_perform_stack_rule_append_
-#ifndef _di_controller_rule_instance_perform_details_stack_verify_
- f_status_t controller_rule_instance_perform_details_stack_verify(controller_instance_t * const instance, controller_rule_t * const rule) {
+#ifndef _di_controller_rule_instance_perform_stack_verify_
+ f_status_t controller_rule_instance_perform_stack_verify(controller_instance_t * const instance, controller_rule_t * const rule) {
if (!instance || !instance->main || !rule) return F_status_set_error(F_parameter);
f_status_t status = controller_lock_read_instance(instance, &instance->use);
if (F_status_is_error(status)) {
- controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
return status;
}
// Never continue on circular recursion errors even in simulate mode.
status = F_status_set_error(F_recurse);
- controller_print_error_rule_stack_already(&instance->main->program.error, &instance->cache.action, instance->rule.alias, F_true);
+ controller_print_error_rule_stack_already(&instance->main->program.error, &instance->cache.action, instance->rule.alias, F_true, controller_debug_file_line_d);
break;
}
return status;
}
-#endif // _di_controller_rule_instance_perform_details_stack_verify_
+#endif // _di_controller_rule_instance_perform_stack_verify_
#ifdef __cplusplus
} // extern "C"
#endif // _di_controller_rule_instance_begin_
/**
- * A wrapper to controller_rule_instance_perform_details() that handles the active and instance locks.
- *
- * Enable active lock before calling controller_rule_instance_perform_details().
- * Disable active lock after calling controller_rule_instance_perform_details().
- *
- * The instance and active locks shall be held for the duration of this instance processing (aside from switching between read to/from write).
- *
- * @param instance
- * The instance data.
- *
- * Must not be NULL.
- * @param options_force
- * Force the given instance options, only supporting a subset of instance options.
- *
- * If controller_instance_option_asynchronous_d, then asynchronously execute.
- * If not controller_instance_option_asynchronous_d, then synchronously execute.
- *
- * @return
- * Status from: controller_rule_instance_perform_details().
- *
- * F_parameter (with error bit) on invalid parameter.
- *
- * @see controller_rule_instance_perform_details()
- */
-#ifndef _di_controller_rule_instance_perform_
- extern f_status_t controller_rule_instance_perform(controller_instance_t * const instance, const uint8_t options_force);
-#endif // _di_controller_rule_instance_perform_
-
-/**
* Perform the work.
*
* This does all the preparation work that needs to be synchronously performed within the same thread.
* @see controller_rule_instance_begin()
* @see controller_lock_read_instance()
*/
-#ifndef _di_controller_rule_instance_perform_details_
- extern f_status_t controller_rule_instance_perform_details(controller_instance_t * const instance, const uint8_t options_force);
-#endif // _di_controller_rule_instance_perform_details_
+#ifndef _di_controller_rule_instance_perform_
+ extern f_status_t controller_rule_instance_perform(controller_instance_t * const instance, const uint8_t options_force);
+#endif // _di_controller_rule_instance_perform_
/**
* Wrap controller_rule_copy(), handling locking and prepping of rule before actual copy.
*
* @see controller_rule_copy()
*/
-#ifndef _di_controller_rule_instance_perform_details_copy_
- extern f_status_t controller_rule_instance_perform_details_copy(controller_instance_t * const instance, const controller_rule_t source, controller_rule_t * const destination);
-#endif // _di_controller_rule_instance_perform_details_copy_
+#ifndef _di_controller_rule_instance_perform_copy_
+ extern f_status_t controller_rule_instance_perform_copy(controller_instance_t * const instance, const controller_rule_t source, controller_rule_t * const destination);
+#endif // _di_controller_rule_instance_perform_copy_
/**
* Append the rule to the stack.
*
* @see controller_lock_read_instance()
*/
-#ifndef _di_controller_rule_instance_perform_details_stack_rule_append_
- extern f_status_t controller_rule_instance_perform_details_stack_rule_append(controller_instance_t * const instance, controller_rule_t * const rule);
-#endif // _di_controller_rule_instance_perform_details_stack_rule_append_
+#ifndef _di_controller_rule_instance_perform_stack_rule_append_
+ extern f_status_t controller_rule_instance_perform_stack_rule_append(controller_instance_t * const instance, controller_rule_t * const rule);
+#endif // _di_controller_rule_instance_perform_stack_rule_append_
/**
* Check if the rule is on the stack already.
*
* @see controller_lock_read_instance()
*/
-#ifndef _di_controller_rule_instance_perform_details_stack_verify_
- extern f_status_t controller_rule_instance_perform_details_stack_verify(controller_instance_t * const instance, controller_rule_t * const rule);
-#endif // _di_controller_rule_instance_perform_details_stack_verify_
+#ifndef _di_controller_rule_instance_perform_stack_verify_
+ extern f_status_t controller_rule_instance_perform_stack_verify(controller_instance_t * const instance, controller_rule_t * const rule);
+#endif // _di_controller_rule_instance_perform_stack_verify_
#ifdef __cplusplus
} // extern "C"
type = controller_rule_action_type_with_e;
}
else {
- controller_print_warning_rule_action_unknown(&main->program.warning, &cache->action, cache->action.name_action);
+ controller_print_warning_rule_action_unknown(&main->program.warning, &cache->action, cache->action.name_action, controller_debug_file_line_d);
continue;
}
if (type == controller_rule_action_type_group_e || type == controller_rule_action_type_pid_file_e || type == controller_rule_action_type_user_e) {
state->status = F_status_set_error(F_support_not);
- controller_print_error_rule_action_fss_0003_unsupported(&main->program.error, &cache->action, cache->action.name_action);
+ controller_print_error_rule_action_fss_0003_unsupported(&main->program.error, &cache->action, cache->action.name_action, controller_debug_file_line_d);
break;
}
rule->items.array[rule->items.used].type = controller_rule_item_type_utility_e;
}
else {
- controller_print_warning_rule_item_unknown(&main->program.warning, &cache->action, cache->action.name_item);
+ controller_print_warning_rule_item_unknown(&main->program.warning, &cache->action, cache->action.name_item, controller_debug_file_line_d);
continue;
}
}
if (F_status_is_error(state.status)) {
- controller_print_error_rule_item(&main->program.error, &cache->action, for_item, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, for_item, F_status_set_fine(state.status), controller_debug_file_line_d);
rule->status[0] = controller_error_simplify(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), macro_controller_f(fll_fss_extended_read), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fll_fss_extended_read), F_true, F_false, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
else {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Unknown");
+ controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Unknown", controller_debug_file_line_d);
continue;
}
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
if (empty_disallow) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Empty");
+ controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Empty", controller_debug_file_line_d);
continue;
}
if (!cache->content_actions.array[i].used) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
break;
}
if (state.status == F_data_not || state.status == F_number || state.status == F_number_overflow || state.status == F_number_underflow || state.status == F_number_negative || state.status == F_number_decimal) {
if (state.status == F_number_underflow) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too small for this system", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too small for this system", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number_overflow || state.status == F_number_positive) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid number", cache->buffer_item, cache->content_actions.array[i].array[j], ", only whole numbers are allowed for an affinity value", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid number", cache->buffer_item, cache->content_actions.array[i].array[j], ", only whole numbers are allowed for an affinity value", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
state.status = F_status_set_error(F_valid_not);
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false, controller_debug_file_line_d);
state.status = F_status_set_error(state.status);
rule->affinity.array[rule->affinity.used++] = number;
} // for
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_affinity_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_affinity_s, i, controller_debug_file_line_d);
continue;
}
if (cache->content_actions.array[i].used != 2) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
- controller_print_error_rule_setting_mapping(&main->program.error, type == controller_rule_setting_type_define_e ? controller_define_s : controller_parameter_s, setting_maps->array[setting_maps->used]);
+ controller_print_error_rule_setting_mapping(&main->program.error, type == controller_rule_setting_type_define_e ? controller_define_s : controller_parameter_s, setting_maps->array[setting_maps->used], controller_debug_file_line_d);
++setting_maps->used;
if (cache->content_actions.array[i].used < 2 || rule->has & controller_rule_has_cgroup_d) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires two or more Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires two or more Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
rule->cgroup.as_new = F_true;
}
else {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unknown option", cache->buffer_item, cache->content_actions.array[i].array[0], "", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unknown option", cache->buffer_item, cache->content_actions.array[i].array[0], "", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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), macro_controller_f(f_string_dynamic_append), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_append), F_true, F_false, controller_debug_file_line_d);
}
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
break;
}
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
rule->has |= controller_rule_has_cgroup_d;
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_cgroup_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_cgroup_s, i, controller_debug_file_line_d);
continue;
}
if (cache->content_actions.array[i].used != 3) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires three Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires three Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
else {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "Unknown resource limit type", cache->action.name_action);
+ controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "Unknown resource limit type", cache->action.name_action, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
state.status = F_status_set_error(F_valid_not);
- controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "The resource limit type is already specified", cache->action.name_action);
+ controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "The resource limit type is already specified", cache->action.name_action, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = state.status;
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
if (state.status == F_data_not || state.status == F_number || state.status == F_number_overflow || state.status == F_number_underflow || state.status == F_number_negative || state.status == F_number_positive || state.status == F_number_decimal) {
if (state.status == F_number_underflow) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too small for this system", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too small for this system", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number_overflow) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", only whole numbers are allowed for a resource limit value", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[j], ", only whole numbers are allowed for a resource limit value", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
state.status = F_status_set_error(F_valid_not);
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false, controller_debug_file_line_d);
state.status = F_status_set_error(state.status);
rule->limits.array[rule->limits.used++].type = type;
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_limit_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_limit_s, i, controller_debug_file_line_d);
continue;
}
if (setting_value->used || !cache->content_actions.array[i].used) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
}
if (state.status == F_false) {
- controller_print_error_rule_setting_name_invalid(&main->program.error, &cache->action, *setting_value);
+ controller_print_error_rule_setting_name_invalid(&main->program.error, &cache->action, *setting_value, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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, macro_controller_f(controller_validate_has_graph), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, macro_controller_f(controller_validate_has_graph), F_true, F_false, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = state.status;
}
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
}
setting_value->used = 0;
continue;
}
- controller_print_error_rule_setting_value(&main->program.error, type == controller_rule_setting_type_name_e ? controller_name_s : controller_engine_s, f_string_empty_s, *setting_value, 0);
+ controller_print_error_rule_setting_value(&main->program.error, type == controller_rule_setting_type_name_e ? controller_name_s : controller_engine_s, f_string_empty_s, *setting_value, 0, controller_debug_file_line_d);
}
else if (type == controller_rule_setting_type_path_e) {
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
- controller_print_error_rule_setting_value(&main->program.error, controller_path_s, f_string_empty_s, *setting_value, 0);
+ controller_print_error_rule_setting_value(&main->program.error, controller_path_s, f_string_empty_s, *setting_value, 0, controller_debug_file_line_d);
}
continue;
if (cache->content_actions.array[i].used < 1 || cache->content_actions.array[i].used > 2 || rule->has & controller_rule_has_scheduler_d) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires either one or two Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires either one or two Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
rule->scheduler.priority = 49;
}
else {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unknown scheduler", cache->buffer_item, cache->content_actions.array[i].array[0], "", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unknown scheduler", cache->buffer_item, cache->content_actions.array[i].array[0], "", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
state.status = original;
}
- controller_print_error_rule_setting_number_invalid_scheduler(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], zero_only);
+ controller_print_error_rule_setting_number_invalid_scheduler(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], zero_only, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false, controller_debug_file_line_d);
state.status = F_status_set_error(state.status);
if (F_status_is_error_not(status_return)) {
rule->has |= controller_rule_has_scheduler_d;
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_scheduler_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_scheduler_s, i, controller_debug_file_line_d);
continue;
}
if (cache->content_actions.array[i].used != 2) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
state.status = original;
}
- controller_print_error_rule_setting_number_invalid_timeout(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0]);
+ controller_print_error_rule_setting_number_invalid_timeout(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
state.status = F_status_set_fine(state.status);
if (state.status == F_number_overflow) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[1], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an unsupported number", cache->buffer_item, cache->content_actions.array[i].array[1], ", the number is too large for this system", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_data_not || state.status == F_number || state.status == F_number_underflow || state.status == F_number_negative || state.status == F_number_positive || state.status == F_number_decimal) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid number", cache->buffer_item, cache->content_actions.array[i].array[1], ", only positive whole numbers are allowed", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid number", cache->buffer_item, cache->content_actions.array[i].array[1], ", only positive whole numbers are allowed", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else {
{
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false, controller_debug_file_line_d);
}
if (F_status_is_error_not(status_return)) {
break;
}
- controller_print_error_rule_setting_value(&main->program.error, controller_timeout_s, name_sub, cache->action.generic, 0);
+ controller_print_error_rule_setting_value(&main->program.error, controller_timeout_s, name_sub, cache->action.generic, 0, controller_debug_file_line_d);
}
}
if (cache->content_actions.array[i].used != 1 || type == controller_rule_setting_type_capability_e && rule->capability || type == controller_rule_setting_type_group_e && (rule->has & controller_rule_has_group_d) || type == controller_rule_setting_type_nice_e && (rule->has & controller_rule_has_nice_d) || type == controller_rule_setting_type_user_e && (rule->has & controller_rule_has_user_d)) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly one Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly one Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
controller_lock_print(main->program.error.to, &main->thread);
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_capability_from_text), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_capability_from_text), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "failed to process the capabilities");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "failed to process the capabilities", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
continue;
}
- controller_print_error_rule_setting_value(&main->program.error, controller_capability_s, f_string_empty_s, cache->action.generic, 0);
+ controller_print_error_rule_setting_value(&main->program.error, controller_capability_s, f_string_empty_s, cache->action.generic, 0, controller_debug_file_line_d);
}
else if (type == controller_rule_setting_type_nice_e) {
f_number_signed_t number = 0;
state.status = original;
}
- controller_print_error_rule_setting_number_invalid_nice(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0]);
+ controller_print_error_rule_setting_number_invalid_nice(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0], controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
}
}
else {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect), F_true, F_false, controller_debug_file_line_d);
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
}
if (F_status_is_error_not(state.status)) {
- controller_print_error_rule_setting_value(&main->program.error, controller_nice_s, f_string_empty_s, cache->action.generic, 0);
+ controller_print_error_rule_setting_value(&main->program.error, controller_nice_s, f_string_empty_s, cache->action.generic, 0, controller_debug_file_line_d);
}
}
}
state.status = F_status_set_fine(state.status);
if (state.status == F_exist_not) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because no user was found by that name", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because no user was found by that name", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number_too_large) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because the given ID is too large", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because the given ID is too large", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid user", cache->buffer_item, cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else {
{
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
}
if (F_status_is_error_not(status_return)) {
state.status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], &cache->action.generic);
- controller_print_error_rule_setting_value(&main->program.error, controller_user_s, f_string_empty_s, cache->action.generic, 0);
+ controller_print_error_rule_setting_value(&main->program.error, controller_user_s, f_string_empty_s, cache->action.generic, 0, controller_debug_file_line_d);
}
}
}
if (!cache->content_actions.array[i].used) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
state.status = F_status_set_fine(state.status);
if (state.status == F_exist_not) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because no group was found by that name", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because no group was found by that name", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number_too_large) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because the given ID is too large", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because the given ID is too large", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else if (state.status == F_number) {
- controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because the given ID is not a valid supported number", cache->object_actions.array[i].start, line_item, &state);
+ controller_print_error_rule_setting_with_range(&main->program.error, &cache->action, " has an invalid group", cache->buffer_item, cache->content_actions.array[i].array[j], ", because the given ID is not a valid supported number", cache->object_actions.array[i].start, line_item, &state, controller_debug_file_line_d);
}
else {
{
state.status = original;
}
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_account_group_id_by_name), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_account_group_id_by_name), F_true, F_false, controller_debug_file_line_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
}
if (F_status_is_error_not(status_return)) {
}
} // for
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_group_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_group_s, i, controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_string_dynamic_partial_append_nulless), F_true, F_false, controller_debug_file_line_d);
setting_values->array[setting_values->used].used = 0;
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
}
if (state.status == F_false) {
- controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "Rule setting has an invalid environment variable name", setting_values->array[setting_values->used]);
+ controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "Rule setting has an invalid environment variable name", setting_values->array[setting_values->used], controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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, macro_controller_f(controller_validate_environment_name), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, macro_controller_f(controller_validate_environment_name), F_true, F_false, controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = state.status;
setting_values->array[setting_values->used].used = 0;
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
continue;
}
rule->has |= controller_rule_has_environment_d;
if (cache->content_actions.array[i].used) {
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_environment_s, i);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_environment_s, i, controller_debug_file_line_d);
}
else {
controller_print_output_rule_execute_setting_empty_set(&main->program.output, controller_environment_s);
if (cache->content_actions.array[i].used != 4) {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, line_item, &state);
- controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly four Content");
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly four Content", controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
else {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_setting_number_invalid_on_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1]);
+ controller_print_error_rule_setting_number_invalid_on_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
}
if (F_status_is_error(state.status)) {
- controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
}
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) {
else {
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_setting_number_invalid_on_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1]);
+ controller_print_error_rule_setting_number_invalid_on_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], controller_debug_file_line_d);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
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), macro_controller_f(f_memory_array_increase), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_false, controller_debug_file_line_d);
}
}
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
controller_rule_setting_line_action(main, &cache->action, cache->buffer_item, cache->object_actions.array[i].start, cache->action.line_item, &state);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original));
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), controller_debug_file_line_d);
continue;
}
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), macro_controller_f(f_file_name_base), F_true, F_false);
+ controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), macro_controller_f(f_file_name_base), F_true, F_false, controller_debug_file_line_d);
if (F_status_set_fine(state.status) == F_memory_not) {
status_return = state.status;
f_status_t status_lock = controller_lock_read_standard(is_normal, controller_lock_check_flag_no_d, &main->thread, &main->thread.lock.instance);
if (status_lock != F_okay) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, controller_debug_file_line_d);
return status_lock;
}
}
if (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), !(locked & 0x4));
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), !(locked & 0x4), controller_debug_file_line_d);
return status_lock;
}
if (!instance || !instance->main) return;
if (!controller_thread_enable_is_normal(&instance->main->thread, is_normal)) return;
- const f_status_t status = controller_rule_instance_perform(instance, controller_instance_option_asynchronous_d);
+ f_status_t status = F_okay;
+
+ status = controller_lock_read_instance(instance, &instance->active);
+
+ if (F_status_is_error(status)) {
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, controller_debug_file_line_d);
+
+ // According to some man pages, pthread_exit() calls exit(0), so expliticly exit to ensure a non-zero code is returned when needed.
+ exit(EXIT_FAILURE);
+ }
+
+ status = controller_rule_instance_perform(instance, controller_instance_option_asynchronous_d);
+
+ f_thread_unlock(&instance->active);
// A forked child Instance should de-allocate memory on exit.
// It seems that this function doesn't return to the calling thread for a forked child Instance, even with the "return 0;" below.
projects / controller / commitdiff