The `controller_debug_file_line_d` has been implemented in FLL as `F_status_debug_source_d`.
Switch to using the FLL `F_status_debug_source_d` in place of `controller_debug_file_line_d`.
Update the build settings modes.
# fss-0000
-_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).
+_di_libcap_ Disable libcap support, allow for compiling and linking without libcap (-lcap).
+_di_thread_support_ Disables thread support.
_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.
+# - debug: Enable debugging, such as compile time debug options.
# - 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_target minor
modes android clang coverage debug gcc gcc_13 fanalyzer individual individual_thread level monolithic test thread threadless
-modes_default monolithic thread gcc debug
+modes_default debug gcc monolithic thread
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-debug -D_en_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines-threadless -D_di_thread_support_
# - 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 debugging, such as compile time debug options.
# - 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 debug gcc monolithic thread
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_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines-threadless -D_di_thread_support_
# - 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 debugging, such as compile time debug options.
# - 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 debug gcc monolithic thread
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_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines-threadless -D_di_thread_support_
#define _di_f_statess_destroy_callback_
#define _di_f_statess_t_
//#define _di_f_status_e_
+//#define _di_f_status_debug_d_
//#define _di_f_status_mask_d_
//#define _di_f_status_t_
#define _di_f_statuss_t_
#
# Modes:
# - 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.
+# - clang: Use CLang rather than the default, which is generally GCC.
# - coverage: Compile for building coverage.
+# - debug: Enable debugging, such as compile time debug options.
# - fanalyzer: Compile using GCC's -fanalyzer compile time option.
# - gcc: Use GCC specific settings.
+# - gcc_13: Use GCC version 13 or greater specific settings.
# - test: Compile for a test, such as unit testing.
# - thread: Compile with thread support.
# - threadless: Compile without thread support.
version_file micro
version_target minor
-modes android clang coverage fanalyzer gcc test thread threadless
-modes_default thread gcc
+modes android clang coverage debug fanalyzer gcc gcc_13 test thread threadless
+modes_default debug gcc thread
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_f_status_debug_
defines-thread -D_pthread_attr_unsupported_ -D_pthread_sigqueue_unsupported_
defines-threadless -D_di_thread_support_
#
# Modes:
# - 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.
+# - clang: Use CLang rather than the default, which is generally GCC.
# - coverage: Compile for building coverage.
+# - debug: Enable debugging, such as compile time debug options.
# - fanalyzer: Compile using GCC's -fanalyzer compile time option.
# - gcc: Use GCC specific settings.
+# - gcc_13: Use GCC version 13 or greater specific settings.
# - test: Compile for a test, such as unit testing.
# - thread: Compile with thread support.
# - threadless: Compile without thread support.
version_file micro
version_target minor
-modes android clang coverage fanalyzer gcc test thread threadless
-modes_default thread gcc
+modes android clang coverage debug fanalyzer gcc gcc_13 test thread threadless
+modes_default debug gcc thread
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_f_status_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
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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_apply_delimit), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_increase), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_count_lines), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_entry_item_duplicate_ignore(&main->program.warning, &main->thread.cache, is_entry, main->thread.cache.action.name_item, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_memory_array_resize), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry, F_status_debug_source_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
}
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_debug_file_line_d);
+ controller_print_error_entry_cache(&main->program.error, &main->thread.cache.action, is_entry, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "first parameter", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_action_parameter_empty(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, "second parameter", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_action_unsupported_reserve(&main->program.error, &main->thread.cache.action, entry->flag & controller_entry_flag_is_e, controller_main_s, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_resize), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_entry_action_multiple(&main->program.warning, cache, is_entry, controller_ready_s, F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_memory_array_increase), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_resize), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_increase_by), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_new), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_cache(&main->program.error, &cache->action, is_entry, F_status_debug_source_d);
controller_unlock_print_flush(main->program.error.to, &main->thread);
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_memory_array_increase), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_action_execution_missing(&main->program.error, &cache->action, is_entry, entry_action->parameters.array[0], F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(fll_execute_into), F_true, controller_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(fll_execute_into), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_action_execution_failure(&main->program.error, &cache->action, is_entry, result, F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_entry_action_failsafe_twice(&main->program.warning, cache, is_entry, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_item_invalid(&main->program.error, cache, is_entry, entry_action->number, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), macro_controller_f(f_string_dynamic_append_nulless), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(fll_fss_extended_read), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_apply_delimit), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(f_fss_count_lines), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_group_id), F_true, controller_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_group_id), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ 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", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_with_range(&main->program.error, cache, is_entry, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", F_status_debug_source_d);
}
else {
- controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true, controller_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_convert_user_id), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 2, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, F_status_debug_source_d);
continue;
}
if (main->setting.flag & controller_main_flag_pid_d) {
- controller_print_error_entry_setting_ignored(&main->program.error, cache, is_entry, controller_debug_file_line_d);
+ controller_print_error_entry_setting_ignored(&main->program.error, cache, is_entry, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), macro_controller_f(controller_path_canonical_relative), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_exactly(&main->program.error, cache, is_entry, 1, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_requires_between(&main->program.error, cache, is_entry, 1, 2, F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_entry_setting_support_not_number(&main->program.error, is_entry, cache->buffer_file, cache->content_actions.array[i].array[1], F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_perform_pid_file_create(&main->program.error, F_status_set_fine(status), macro_controller_f(controller_file_pid_create), is_entry, F_status_debug_source_d);
return status;
}
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*/
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
* 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 this to macros like F_status_debug_source_d.
*
* Set to NULL to disable.
*
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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[0], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_action.array[1], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_rerun_s, cache->buffer_item, cache->content_action.array[i], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_unknown(&main->program.error, &cache->action, controller_with_s, cache->buffer_item, cache->content_action.array[i], F_status_debug_source_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_debug_file_line_d);
+ controller_print_debug_rule_action_empty(&main->program.debug, cache, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_positive_number_not(&main->program.error, &cache->action, name, cache->buffer_item, cache->content_action, *index, status, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_missing_pid(&main->program.error, &instance->cache.action, instance->rule.alias, F_status_debug_source_d);
}
}
else {
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 && 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);
+ controller_print_error_rule_item_execute_none(&main->program.error, &instance->cache.action, instance->rule.alias, execute_nothing & 0x2, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_d);
return status_lock;
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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 (F_status_is_error(status_lock)) {
- controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, controller_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_main_print_debug_rule_execute_rerun(&main->program.output, instance, rerun_item, action, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "execute rule", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_type_unsupported(&main->program.error, &instance->cache.action, controller_convert_rule_action_type_string(instance->action), "validate Fule execution", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item_rule_not_loaded(&main->program.error, &instance->cache.action, dynamics[i]->array[j], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], dynamics[i]->array[j], "is not found", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], dynamics[i]->array[j], "is not found", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "failed during execution", F_status_debug_source_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_debug_file_line_d);
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "failed during execution", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "due to lock failure", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "is in a failed state", F_status_debug_source_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_debug_file_line_d);
+ controller_print_debug_rule_instance_need_want_wish(&main->program.warning, instance, strings[i], alias_other_buffer, "is in a failed state", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
}
}
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);
+ controller_print_error_rule_item(&main->program.error, &instance->cache.action, F_true, F_status_set_fine(status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item_rule_not_loaded(&main->program.error, &cache->action, alias_rule, F_status_debug_source_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_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);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status), F_false, F_status_debug_source_d);
return status;
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_d);
return status;
}
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_debug_file_line_d);
+ controller_print_error_rule_item_rule_not_loaded(&instance->main->program.error, &instance->cache.action, instance->rule.alias, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status_lock), F_false, F_status_debug_source_d);
return status_lock;
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false, F_status_debug_source_d);
return status;
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_false, F_status_debug_source_d);
return status;
}
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_debug_file_line_d);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_stack_already(&instance->main->program.error, &instance->cache.action, instance->rule.alias, F_true, F_status_debug_source_d);
break;
}
type = controller_rule_action_type_with_e;
}
else {
- controller_print_warning_rule_action_unknown(&main->program.warning, &cache->action, cache->action.name_action, controller_debug_file_line_d);
+ controller_print_warning_rule_action_unknown(&main->program.warning, &cache->action, cache->action.name_action, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_action_fss_0003_unsupported(&main->program.error, &cache->action, cache->action.name_action, F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_rule_item_unknown(&main->program.warning, &cache->action, cache->action.name_item, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, for_item, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Unknown", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_warning_rule_setting_unknown(&main->program.warning, &cache->action, cache->action.name_item, "Empty", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_affinity_s, i, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires two or more Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_d);
continue;
}
rule->has |= controller_rule_has_cgroup_d;
- controller_print_error_rule_setting_values(&main->program.error, cache, controller_cgroup_s, i, controller_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_cgroup_s, i, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires three Content", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "Unknown resource limit type", cache->action.name_action, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_reason_name(&main->program.error, &cache->action, "The resource limit type is already specified", cache->action.name_action, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_limit_s, i, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_d);
continue;
}
}
if (state.status == F_false) {
- controller_print_error_rule_setting_name_invalid(&main->program.error, &cache->action, *setting_value, controller_debug_file_line_d);
+ controller_print_error_rule_setting_name_invalid(&main->program.error, &cache->action, *setting_value, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, macro_controller_f(controller_validate_has_graph), F_true, F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_d);
continue;
}
- controller_print_error_rule_setting_value(&main->program.error, controller_path_s, f_string_empty_s, *setting_value, 0, controller_debug_file_line_d);
+ controller_print_error_rule_setting_value(&main->program.error, controller_path_s, f_string_empty_s, *setting_value, 0, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires either one or two Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_scheduler_s, i, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly two Content", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_number_invalid_timeout(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_value(&main->program.error, controller_timeout_s, name_sub, cache->action.generic, 0, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly one Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "failed to process the capabilities", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_value(&main->program.error, controller_capability_s, f_string_empty_s, cache->action.generic, 0, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_number_invalid_nice(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[0], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, controller_debug_file_line_d);
+ controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_value(&main->program.error, controller_nice_s, f_string_empty_s, cache->action.generic, 0, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_value(&main->program.error, controller_user_s, f_string_empty_s, cache->action.generic, 0, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires one or more Content", F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_d);
- controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), controller_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_group_s, i, F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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], F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, macro_controller_f(controller_validate_environment_name), F_true, F_false, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_values(&main->program.error, cache, controller_environment_s, i, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting(&main->program.error, &cache->action, "requires exactly four Content", F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_number_invalid_on_first(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_setting_number_invalid_on_second(&main->program.error, &cache->action, cache->buffer_item, cache->content_actions.array[i].array[1], F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(original), F_status_debug_source_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_debug_file_line_d);
+ 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, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), F_true, F_status_debug_source_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_debug_file_line_d);
+ controller_print_error_lock_critical(&main->program.error, F_status_set_fine(status_lock), !(locked & 0x4), F_status_debug_source_d);
return status_lock;
}
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);
+ controller_print_error_lock_critical(&instance->main->program.error, F_status_set_fine(status), F_true, F_status_debug_source_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);
projects / controller / commitdiff