From: Kevin Day <Kevin@kevux.org>
Date: Wed, 12 Nov 2025 05:52:57 +0000 (-0600)
Subject: Update: Utilize the F_status_debug_source_d for handling the errors.
X-Git-Tag: 0.7.3~13
X-Git-Url: https://www.git.kevux.org/?a=commitdiff_plain;h=cb9998260a2153ae076b7ccbbad1f1147e9d3b6a;p=controller

Update: Utilize the F_status_debug_source_d for handling the errors.

This simplifies some of the logic and code.

However, there are some disadvantages of doing this.
One such disadvantage is losing the specific function that has failed.
The location in the source file should be sufficient, if not ideal.

Address issues where the `debug` mode is not being specified in some programs.
---

diff --git a/data/build/settings b/data/build/settings
index b49d93c..bf28ba9 100644
--- a/data/build/settings
+++ b/data/build/settings
@@ -53,7 +53,7 @@ build_libraries_static-individual_thread -l:libf_thread.a
 build_libraries_static-level -l:libfll_2.a -l:libfll_1.a -l:libfll_0.a -l:libcap.a
 build_libraries_static-monolithic -l:libfll.a -l:libcap.a
 
-build_sources_library common.c common/define.c common/enumeration.c common/print.c common/string.c common/type.c
+build_sources_library common.c common/define.c common/enumeration.c common/string.c common/type.c
 build_sources_library common/type/cache.c common/type/control.c common/type/entry.c common/type/execute.c common/type/instance.c common/type/interrupt.c common/type/lock.c common/type/process.c common/type/rule.c common/type/thread.c
 build_sources_library common/string/general.c common/string/rule.c
 build_sources_library convert.c instance.c instance/prepare.c instance/wait.c
@@ -74,7 +74,7 @@ build_sources_library signal.c status.c time.c
 build_sources_library thread.c thread/cleanup.c thread/control.c thread/enable.c thread/entry.c thread/instance.c thread/is.c thread/rule.c thread/signal.c
 build_sources_library validate.c
 
-build_sources_headers common.h controller.h common/define.h common/enumeration.h common/print.h common/string.h common/thread.h common/type.h
+build_sources_headers common.h controller.h common/define.h common/enumeration.h common/string.h common/thread.h common/type.h
 build_sources_headers common/define/control.h common/define/entry.h common/define/instance.h common/define/rule.h common/define/thread.h
 build_sources_headers common/enumeration/control.h common/enumeration/entry.h common/enumeration/instance.h common/enumeration/process.h common/enumeration/rule.h common/enumeration/thread.h
 build_sources_headers common/string/general.h common/string/rule.h
diff --git a/data/build/stand_alone/settings.controller b/data/build/stand_alone/settings.controller
index 6a8cfab..328959e 100644
--- a/data/build/stand_alone/settings.controller
+++ b/data/build/stand_alone/settings.controller
@@ -100,7 +100,7 @@ build_sources_program fll/level_2/fss.c fll/level_2/fss/basic.c fll/level_2/fss/
 build_sources_program fll/level_2/print.c
 build_sources_program fll/level_2/program.c fll/level_2/program/common.c fll/level_2/program/print.c fll/level_2/program/string.c fll/level_2/private-program.c
 
-build_sources_program program/controller/main/common.c program/controller/main/common/define.c program/controller/main/common/enumeration.c program/controller/main/common/print.c program/controller/main/common/string.c program/controller/main/common/type.c
+build_sources_program program/controller/main/common.c program/controller/main/common/define.c program/controller/main/common/enumeration.c program/controller/main/common/string.c program/controller/main/common/type.c
 build_sources_program program/controller/main/common/type/cache.c program/controller/main/common/type/control.c program/controller/main/common/type/entry.c program/controller/main/common/type/execute.c program/controller/main/common/type/instance.c program/controller/main/common/type/interrupt.c program/controller/main/common/type/lock.c program/controller/main/common/type/process.c program/controller/main/common/type/rule.c program/controller/main/common/type/thread.c
 build_sources_program program/controller/main/common/string/general.c program/controller/main/common/string/rule.c
 build_sources_program program/controller/main/convert.c program/controller/main/instance.c program/controller/main/instance/prepare.c program/controller/main/instance/wait.c
diff --git a/data/build/stand_alone/settings.init b/data/build/stand_alone/settings.init
index 2ed979a..4cf8883 100644
--- a/data/build/stand_alone/settings.init
+++ b/data/build/stand_alone/settings.init
@@ -100,7 +100,7 @@ build_sources_program fll/level_2/fss.c fll/level_2/fss/basic.c fll/level_2/fss/
 build_sources_program fll/level_2/print.c
 build_sources_program fll/level_2/program.c fll/level_2/program/common.c fll/level_2/program/print.c fll/level_2/program/string.c fll/level_2/private-program.c
 
-build_sources_program program/controller/main/common.c program/controller/main/common/define.c program/controller/main/common/enumeration.c program/controller/main/common/print.c program/controller/main/common/string.c program/controller/main/common/type.c
+build_sources_program program/controller/main/common.c program/controller/main/common/define.c program/controller/main/common/enumeration.c program/controller/main/common/string.c program/controller/main/common/type.c
 build_sources_program program/controller/main/common/type/cache.c program/controller/main/common/type/control.c program/controller/main/common/type/entry.c program/controller/main/common/type/execute.c program/controller/main/common/type/instance.c program/controller/main/common/type/interrupt.c program/controller/main/common/type/lock.c program/controller/main/common/type/process.c program/controller/main/common/type/rule.c program/controller/main/common/type/thread.c
 build_sources_program program/controller/main/common/string/general.c program/controller/main/common/string/rule.c
 build_sources_program program/controller/main/convert.c program/controller/main/instance.c program/controller/main/instance/prepare.c program/controller/main/instance/wait.c
diff --git a/sources/c/program/controller/main/common.c b/sources/c/program/controller/main/common.c
index ee3ccef..a4a4f1d 100644
--- a/sources/c/program/controller/main/common.c
+++ b/sources/c/program/controller/main/common.c
@@ -83,7 +83,7 @@ extern "C" {
     main->setting.state.step_small = controller_allocation_small_d;
 
     if (F_status_is_error(main->setting.state.status)) {
-      controller_print_error(&main->program.error, macro_controller_f(f_console_parameter_process));
+      controller_print_error(&main->program.error, F_status_debug_source_d);
 
       return;
     }
@@ -91,7 +91,7 @@ extern "C" {
     main->setting.state.status = fll_program_parameter_process_context_standard(F_true, &main->program);
 
     if (F_status_is_error(main->setting.state.status)) {
-      controller_print_error(&main->program.error, macro_controller_f(fll_program_parameter_process_context_standard));
+      controller_print_error(&main->program.error, F_status_debug_source_d);
 
       return;
     }
@@ -99,7 +99,7 @@ extern "C" {
     main->setting.state.status = fll_program_parameter_process_verbosity_standard(F_true, &main->program);
 
     if (F_status_is_error(main->setting.state.status)) {
-      controller_print_error(&main->program.error, macro_controller_f(fll_program_parameter_process_verbosity_standard));
+      controller_print_error(&main->program.error, F_status_debug_source_d);
 
       return;
     }
@@ -185,7 +185,7 @@ extern "C" {
     main->setting.state.status = f_string_dynamic_append(main->program.parameters.remaining.used ? args[main->program.parameters.remaining.array[0]] : controller_default_s, &main->process.name_entry);
 
     if (F_status_is_error(main->setting.state.status)) {
-      controller_print_error(&main->program.error, macro_controller_f(fll_program_parameter_process_verbosity_standard));
+      controller_print_error(&main->program.error, F_status_debug_source_d);
 
       return;
     }
@@ -193,7 +193,7 @@ extern "C" {
     main->setting.state.status = f_path_current(F_false, &main->process.path_current);
 
     if (F_status_is_error(main->setting.state.status)) {
-      controller_print_error(&main->program.error, macro_controller_f(f_path_current));
+      controller_print_error(&main->program.error, F_status_debug_source_d);
 
       return;
     }
@@ -224,7 +224,7 @@ extern "C" {
       main->setting.state.status = controller_path_canonical_relative(main, main->process.path_current, args[index], &main->process.path_setting);
 
       if (F_status_is_error(main->setting.state.status)) {
-        controller_print_error_file(&main->program.error, macro_controller_f(controller_path_canonical_relative), args[index], f_file_operation_verify_s, fll_error_file_type_path_e);
+        controller_print_error_file(&main->program.error, F_status_debug_source_d, args[index], f_file_operation_verify_s, fll_error_file_type_path_e);
 
         return;
       }
@@ -233,7 +233,7 @@ extern "C" {
       main->setting.state.status = f_string_dynamic_append(controller_default_path_settings_s, &main->process.path_setting);
 
       if (F_status_is_error(main->setting.state.status)) {
-        controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_append));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
 
         return;
       }
@@ -259,7 +259,7 @@ extern "C" {
       }
 
       if (F_status_is_error(main->setting.state.status)) {
-        controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_append));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
 
         return;
       }
@@ -272,7 +272,7 @@ extern "C" {
         main->setting.state.status = controller_path_canonical_relative(main, main->process.path_current, args[index], &main->process.path_cgroup);
 
         if (F_status_is_error(main->setting.state.status)) {
-          controller_print_error_file(&main->program.error, macro_controller_f(controller_path_canonical_relative), args[index], f_file_operation_verify_s, fll_error_file_type_path_e);
+          controller_print_error_file(&main->program.error, F_status_debug_source_d, args[index], f_file_operation_verify_s, fll_error_file_type_path_e);
 
           return;
         }
@@ -280,7 +280,7 @@ extern "C" {
         main->setting.state.status = f_string_append_assure(F_path_separator_s, 1, &main->process.path_cgroup);
 
         if (F_status_is_error(main->setting.state.status)) {
-          controller_print_error(&main->program.error, macro_controller_f(f_string_append_assure));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
 
           return;
         }
@@ -297,7 +297,7 @@ extern "C" {
       }
 
       if (F_status_is_error(main->setting.state.status)) {
-        controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
 
         return;
       }
@@ -305,7 +305,7 @@ extern "C" {
       main->setting.state.status = f_string_dynamic_append_assure(f_path_separator_s, &main->process.path_cgroup);
 
       if (F_status_is_error(main->setting.state.status)) {
-        controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_append_assure));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
 
         return;
       }
diff --git a/sources/c/program/controller/main/controller.h b/sources/c/program/controller/main/controller.h
index 2e35567..d8ec8e1 100644
--- a/sources/c/program/controller/main/controller.h
+++ b/sources/c/program/controller/main/controller.h
@@ -74,7 +74,6 @@
 // Controller includes.
 #include <program/controller/main/common/define.h>
 #include <program/controller/main/common/enumeration.h>
-#include <program/controller/main/common/print.h>
 #include <program/controller/main/common/string.h>
 #include <program/controller/main/common/string/general.h>
 #include <program/controller/main/common/string/rule.h>
diff --git a/sources/c/program/controller/main/entry.c b/sources/c/program/controller/main/entry.c
index afc2ba3..4573abc 100644
--- a/sources/c/program/controller/main/entry.c
+++ b/sources/c/program/controller/main/entry.c
@@ -95,18 +95,18 @@ extern "C" {
         fll_fss_basic_list_read(main->thread.cache.buffer_file, &range, &main->thread.cache.object_items, &main->thread.cache.content_items, &main->thread.cache.delimits, 0, &main->thread.cache.comments, &state);
 
         if (F_status_is_error(state.status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(fll_fss_basic_list_read), F_status_set_fine(state.status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
         }
         else {
           f_fss_apply_delimit(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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
           }
         }
       }
       else {
-        controller_print_error_file_status(&main->program.error, macro_controller_f(controller_file_load), is_entry ? controller_entry_s : controller_exit_s, f_file_operation_read_s, fll_error_file_type_file_e, F_status_set_fine(state.status));
+        controller_print_error_file_status(&main->program.error, F_status_debug_source_d, is_entry ? controller_entry_s : controller_exit_s, f_file_operation_read_s, fll_error_file_type_file_e, F_status_set_fine(state.status));
       }
     }
 
@@ -114,7 +114,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
       }
       else {
 
@@ -150,7 +150,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             break;
           }
@@ -158,7 +158,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             break;
           }
@@ -166,7 +166,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             break;
           }
@@ -205,7 +205,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
               break;
             }
@@ -217,7 +217,7 @@ extern "C" {
               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, F_status_debug_source_d);
+                controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                 break;
               }
@@ -235,7 +235,7 @@ extern "C" {
           state.status = f_string_dynamic_append_nulless(main->thread.cache.action.name_item, &entry->items.array[at].name);
 
           if (F_status_is_error(state.status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless), F_status_set_fine(state.status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
             break;
           }
@@ -315,7 +315,7 @@ extern "C" {
                     state.status = f_string_dynamic_append_nulless(entry->items.array[i].name, &main->thread.cache.action.name_item);
 
                     if (F_status_is_error(state.status)) {
-                      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless), F_status_set_fine(state.status));
+                      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
                       break;
                     }
diff --git a/sources/c/program/controller/main/entry/action.c b/sources/c/program/controller/main/entry/action.c
index 264c54f..8cfe761 100644
--- a/sources/c/program/controller/main/entry/action.c
+++ b/sources/c/program/controller/main/entry/action.c
@@ -34,7 +34,7 @@ extern "C" {
     }
 
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return state.status;
     }
@@ -42,7 +42,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return state.status;
     }
@@ -52,7 +52,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return state.status;
     }
@@ -83,7 +83,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         break;
       }
@@ -93,7 +93,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         break;
       }
@@ -196,7 +196,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           action->status = state.status;
 
@@ -216,7 +216,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             break;
           }
@@ -224,7 +224,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             break;
           }
@@ -240,7 +240,7 @@ extern "C" {
               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, F_status_debug_source_d);
+                controller_print_error_entry_file(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, main->thread.cache.action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, F_status_debug_source_d);
 
                 action->status = state.status;
 
@@ -271,7 +271,7 @@ extern "C" {
               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, F_status_debug_source_d);
+                controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                 if (F_status_set_fine(state.status) == F_memory_not) {
                   status_action = controller_status_simplify_error(state.status);
@@ -380,7 +380,7 @@ extern "C" {
                   }
 
                   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, F_status_debug_source_d);
+                    controller_print_error_entry(&main->program.error, entry->flag & controller_entry_flag_is_e, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                     status_action = state.status;
 
diff --git a/sources/c/program/controller/main/entry/preprocess.c b/sources/c/program/controller/main/entry/preprocess.c
index 8d63268..874461c 100644
--- a/sources/c/program/controller/main/entry/preprocess.c
+++ b/sources/c/program/controller/main/entry/preprocess.c
@@ -36,7 +36,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         return status;
       }
@@ -53,7 +53,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return status;
     }
@@ -70,7 +70,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           return status2;
         }
@@ -116,7 +116,7 @@ extern "C" {
               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, F_status_debug_source_d);
+                controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                 return status2;
               }
@@ -141,7 +141,7 @@ extern "C" {
               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, F_status_debug_source_d);
+                controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                 return status2;
               }
@@ -186,7 +186,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status2), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           return status2;
         }
diff --git a/sources/c/program/controller/main/entry/process.c b/sources/c/program/controller/main/entry/process.c
index 9231ee7..3d0c090 100644
--- a/sources/c/program/controller/main/entry/process.c
+++ b/sources/c/program/controller/main/entry/process.c
@@ -37,7 +37,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         return status;
       }
@@ -54,7 +54,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return status;
     }
@@ -83,7 +83,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           return status;
         }
@@ -151,7 +151,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             return status;
           }
@@ -174,7 +174,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             return status;
           }
@@ -221,7 +221,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
               return status;
             }
@@ -310,7 +310,7 @@ extern "C" {
 
                 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, F_status_debug_source_d);
+                controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
                 return status;
               }
@@ -380,7 +380,7 @@ extern "C" {
               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, F_status_debug_source_d);
+              controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
             }
 
             return F_status_set_error(F_execute);
@@ -464,7 +464,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           break;
         }
diff --git a/sources/c/program/controller/main/entry/setting.c b/sources/c/program/controller/main/entry/setting.c
index 07da2a2..2473fa7 100644
--- a/sources/c/program/controller/main/entry/setting.c
+++ b/sources/c/program/controller/main/entry/setting.c
@@ -20,7 +20,7 @@ extern "C" {
     }
 
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return state.status;
     }
@@ -28,7 +28,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
       return state.status;
     }
@@ -46,7 +46,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         break;
       }
@@ -57,7 +57,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
         break;
       }
@@ -89,7 +89,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           break;
         }
@@ -99,7 +99,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry_file(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, F_status_debug_source_d);
 
           continue;
         }
@@ -120,7 +120,7 @@ extern "C" {
             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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
           }
 
           continue;
@@ -139,7 +139,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           break;
         }
@@ -155,7 +155,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           continue;
         }
@@ -179,7 +179,7 @@ extern "C" {
             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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
           }
 
           continue;
@@ -198,7 +198,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           continue;
         }
@@ -235,7 +235,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
           continue;
         }
@@ -278,7 +278,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             continue;
           }
@@ -288,7 +288,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             continue;
           }
@@ -395,7 +395,7 @@ extern "C" {
           *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, F_status_debug_source_d);
+            controller_print_error_entry(&main->program.error, is_entry, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_status_debug_source_d);
 
             continue;
           }
diff --git a/sources/c/program/controller/main/file.c b/sources/c/program/controller/main/file.c
index 52f13aa..365cf2b 100644
--- a/sources/c/program/controller/main/file.c
+++ b/sources/c/program/controller/main/file.c
@@ -35,7 +35,7 @@ extern "C" {
     }
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
       return status;
     }
@@ -85,14 +85,14 @@ extern "C" {
       }
 
       if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
-        controller_print_error_file_status(&main->program.error, macro_controller_f(f_file_stream_open), path, f_file_operation_open_s, fll_error_file_type_file_e, F_status_set_fine(status));
+        controller_print_error_file_status(&main->program.error, F_status_debug_source_d, path, f_file_operation_open_s, fll_error_file_type_file_e, F_status_set_fine(status));
       }
     }
     else {
       status = f_file_stream_read(file, &main->thread.cache.buffer_file);
 
       if (F_status_is_error(status)) {
-        controller_print_error_file_status(&main->program.error, macro_controller_f(f_file_stream_read), path, f_file_operation_read_s, fll_error_file_type_file_e, F_status_set_fine(status));
+        controller_print_error_file_status(&main->program.error, F_status_debug_source_d, path, f_file_operation_read_s, fll_error_file_type_file_e, F_status_set_fine(status));
       }
     }
 
@@ -107,7 +107,7 @@ extern "C" {
       status = f_file_stat(path, F_true, &stat_file);
 
       if (F_status_is_error(status)) {
-        controller_print_error_file_status(&main->program.error, macro_controller_f(f_file_stat), path, f_file_operation_stat_s, fll_error_file_type_file_e, F_status_set_fine(status));
+        controller_print_error_file_status(&main->program.error, F_status_debug_source_d, path, f_file_operation_stat_s, fll_error_file_type_file_e, F_status_set_fine(status));
       }
       else {
         main->thread.cache.timestamp.seconds = stat_file.st_ctim.tv_sec;
diff --git a/sources/c/program/controller/main/perform.c b/sources/c/program/controller/main/perform.c
index 5c6a717..25cbc46 100644
--- a/sources/c/program/controller/main/perform.c
+++ b/sources/c/program/controller/main/perform.c
@@ -28,12 +28,12 @@ extern "C" {
 
         // 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, F_status_debug_source_d);
+          controller_print_error_perform_pid_file_create(&main->program.error, F_status_set_fine(status), F_status_debug_source_d, is_entry, F_status_debug_source_d);
 
           return status;
         }
 
-        controller_print_debug_perform_pid_file_create_problem(&main->program.debug, F_status_set_fine(status), macro_controller_f(controller_file_pid_create), is_entry);
+        controller_print_debug_perform_pid_file_create_problem(&main->program.debug, F_status_set_fine(status), F_status_debug_source_d, is_entry);
 
         status = F_okay;
       }
@@ -75,7 +75,7 @@ extern "C" {
 
     if (F_status_is_error(status)) {
       if (F_status_set_fine(status) == F_memory_not) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_socket_create), F_status_set_fine(status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
       else {
         // @todo make all message strings passed to controller_print_debug_perform_control_socket_failure() into global static strings and update the function accordingly.
@@ -89,7 +89,7 @@ extern "C" {
       status = f_file_remove(main->process.path_control);
 
       if (F_status_set_fine(status) == F_memory_not) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_file_remove), F_status_set_fine(status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
         return status;
       }
@@ -107,7 +107,7 @@ extern "C" {
       }
 
       if (F_status_set_fine(status) == F_memory_not) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_socket_bind), F_status_set_fine(status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
       else {
         controller_print_debug_perform_control_socket_failure(&main->program.debug, F_status_set_fine(status), "could not be bound");
@@ -127,7 +127,7 @@ extern "C" {
         }
 
         if (F_status_set_fine(status) == F_memory_not) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_file_role_change), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
         }
         else {
           controller_print_debug_perform_control_socket_failure(&main->program.debug, F_status_set_fine(status), "failed to set file roles");
@@ -148,7 +148,7 @@ extern "C" {
         }
 
         if (F_status_set_fine(status) == F_memory_not) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_file_role_change), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
         }
         else {
           controller_print_debug_perform_control_socket_failure(&main->program.debug, F_status_set_fine(status), "failed to set file mode");
@@ -179,7 +179,7 @@ extern "C" {
         main->thread.id_control = 0;
       }
 
-      controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
     }
 
     return F_okay;
diff --git a/sources/c/program/controller/main/print/debug/perform/pid.h b/sources/c/program/controller/main/print/debug/perform/pid.h
index df0d016..c88dfa0 100644
--- a/sources/c/program/controller/main/print/debug/perform/pid.h
+++ b/sources/c/program/controller/main/print/debug/perform/pid.h
@@ -63,7 +63,7 @@ extern "C" {
  *   F_output_not (with error bit) if setting is NULL.
  */
 #ifndef _di_controller_print_debug_perform_pid_file_create_problem_
-  extern f_status_t controller_print_debug_perform_pid_file_create_problem(fl_print_t * const print, const f_status_t status, const f_string_t function, const uint8_t is_entry);
+  extern f_status_t controller_print_debug_perform_pid_file_create_problem(fl_print_t * const print, const f_status_t status, const f_string_t debug, const uint8_t is_entry);
 #endif // _di_controller_print_debug_perform_pid_file_create_problem_
 
 /**
diff --git a/sources/c/program/controller/main/process.c b/sources/c/program/controller/main/process.c
index 1e70768..97d5664 100644
--- a/sources/c/program/controller/main/process.c
+++ b/sources/c/program/controller/main/process.c
@@ -51,7 +51,7 @@ extern "C" {
     status = controller_lock_create(&main->thread.lock);
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&main->program.error, macro_controller_f(controller_lock_create), status);
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, status);
     }
     else {
       status = f_thread_create(0, &main->thread.id_signal, &controller_thread_signal_normal, (void *) main);
@@ -70,7 +70,7 @@ extern "C" {
         main->thread.id_signal = 0;
         main->thread.id_cleanup = 0;
 
-        controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), status);
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, status);
       }
       else {
         if (main->setting.flag & controller_main_flag_daemon_d) {
@@ -87,7 +87,7 @@ extern "C" {
           status = f_thread_create(0, &main->thread.id_entry, &controller_thread_entry, (void *) main);
 
           if (F_status_is_error(status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), status);
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, status);
           }
           else {
             if (main->thread.id_entry) {
@@ -115,7 +115,7 @@ extern "C" {
           if (F_status_is_error(status)) {
             main->thread.id_rule = 0;
 
-            controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), status);
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, status);
           }
         }
       }
diff --git a/sources/c/program/controller/main/rule.c b/sources/c/program/controller/main/rule.c
index 800ec01..e4ebdd0 100644
--- a/sources/c/program/controller/main/rule.c
+++ b/sources/c/program/controller/main/rule.c
@@ -278,7 +278,7 @@ extern "C" {
     }
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_partial_append_nulless), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
     }
 
     return status;
diff --git a/sources/c/program/controller/main/rule/action.c b/sources/c/program/controller/main/rule/action.c
index fd3b824..f4a6b56 100644
--- a/sources/c/program/controller/main/rule/action.c
+++ b/sources/c/program/controller/main/rule/action.c
@@ -95,7 +95,7 @@ extern "C" {
       fl_fss_extended_list_content_read(cache->buffer_item, range, &cache->content_action, &cache->close, &cache->delimits, &cache->comments, state);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error(&main->program.error, macro_controller_f(fl_fss_extended_list_content_read));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
 
         return;
       }
@@ -104,7 +104,7 @@ extern "C" {
         f_fss_apply_delimit(cache->delimits, &cache->buffer_item, state);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error(&main->program.error, macro_controller_f(f_fss_apply_delimit));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
 
           return;
         }
@@ -116,7 +116,7 @@ extern "C" {
           state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &actions->array[actions->used].parameters.array, &actions->array[actions->used].parameters.used, &actions->array[actions->used].parameters.size);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_memory_array_increase));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -124,7 +124,7 @@ extern "C" {
           state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_iki_data_t), (void **) &actions->array[actions->used].ikis.array, &actions->array[actions->used].ikis.used, &actions->array[actions->used].ikis.size);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_memory_array_increase));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -136,7 +136,7 @@ extern "C" {
           state->status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_action.array[0], &actions->array[actions->used].parameters.array[0]);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             actions->array[actions->used++].status = controller_error_simplify(F_status_set_fine(state->status));
 
@@ -161,7 +161,7 @@ extern "C" {
             state->interrupt = old_interrupt;
 
             if (F_status_is_error(state->status)) {
-              controller_print_error(&main->program.error, macro_controller_f(fl_iki_read));
+              controller_print_error(&main->program.error, F_status_debug_source_d);
 
               actions->array[actions->used++].status = controller_error_simplify(F_status_set_fine(state->status));
 
@@ -181,7 +181,7 @@ extern "C" {
         fll_fss_extended_read(cache->buffer_item, &cache->content_action.array[0], &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, state);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error(&main->program.error, macro_controller_f(fll_fss_extended_read));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
 
           return;
         }
@@ -189,7 +189,7 @@ extern "C" {
         f_fss_apply_delimit(cache->delimits, &cache->buffer_item, state);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error(&main->program.error, macro_controller_f(f_fss_apply_delimit));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
 
           return;
         }
@@ -199,7 +199,7 @@ extern "C" {
           state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_rule_action_t), (void **) &actions->array, &actions->used, &actions->size);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_memory_array_increase));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -207,7 +207,7 @@ extern "C" {
           f_fss_count_lines(cache->buffer_item, cache->object_actions.array[i].start, &actions->array[actions->used].line, state);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_fss_count_lines));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -237,13 +237,13 @@ extern "C" {
       fl_fss_extended_content_read(cache->buffer_item, range, &cache->content_action, 0, &cache->delimits, state);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error(&main->program.error, macro_controller_f(fll_fss_extended_content_read));
+        controller_print_error(&main->program.error, F_status_debug_source_d);
       }
       else if (state->status == F_fss_found_content) {
         f_fss_apply_delimit(cache->delimits, &cache->buffer_item, state);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error(&main->program.error, macro_controller_f(f_fss_apply_delimit));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
         }
         else if (type == controller_rule_action_type_pid_file_e) {
           item->pid_file.used = 0;
@@ -251,7 +251,7 @@ extern "C" {
           state->status = f_rip_dynamic_partial(cache->buffer_item, cache->content_action.array[0], &item->pid_file);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_rip_dynamic_partial));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
           }
         }
         else if (type == controller_rule_action_type_rerun_e) {
@@ -366,7 +366,7 @@ extern "C" {
           state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &actions->array[actions->used].parameters.array, &actions->array[actions->used].parameters.used, &actions->array[actions->used].parameters.size);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_memory_array_increase));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -374,7 +374,7 @@ extern "C" {
           state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(f_iki_data_t), (void **) &actions->array[actions->used].ikis.array, &actions->array[actions->used].ikis.used, &actions->array[actions->used].ikis.size);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_memory_array_increase));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -391,7 +391,7 @@ extern "C" {
           } // for
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_string_dynamic_partial_mash_nulless));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             actions->array[actions->used++].status = controller_error_simplify(F_status_set_fine(state->status));
 
@@ -416,7 +416,7 @@ extern "C" {
             state->interrupt = old_interrupt;
 
             if (F_status_is_error(state->status)) {
-              controller_print_error(&main->program.error, macro_controller_f(fl_iki_read));
+              controller_print_error(&main->program.error, F_status_debug_source_d);
 
               actions->array[actions->used++].status = controller_error_simplify(F_status_set_fine(state->status));
 
@@ -431,7 +431,7 @@ extern "C" {
           f_fss_count_lines(cache->buffer_item, range->start, &actions->array[actions->used].line, state);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error(&main->program.error, macro_controller_f(f_fss_count_lines));
+            controller_print_error(&main->program.error, F_status_debug_source_d);
 
             return;
           }
@@ -488,7 +488,7 @@ extern "C" {
         status = F_status_set_fine(status);
 
         if (status != F_valid_not && status != F_number && status != F_number_decimal && status != F_number_overflow && status != F_number_underflow && status != F_number_negative) {
-          controller_print_error(&main->program.error, macro_controller_f(fl_conversion_dynamic_partial_to_signed_detect));
+          controller_print_error(&main->program.error, F_status_debug_source_d);
         }
         else {
           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);
diff --git a/sources/c/program/controller/main/rule/execute.c b/sources/c/program/controller/main/rule/execute.c
index 4ed6e3e..a147736 100644
--- a/sources/c/program/controller/main/rule/execute.c
+++ b/sources/c/program/controller/main/rule/execute.c
@@ -41,7 +41,7 @@ extern "C" {
         status = fll_control_group_prepare(instance->rule.cgroup);
 
         if (F_status_is_error(status)) {
-          controller_print_error_file_status(&main->program.error, macro_controller_f(fll_control_group_prepare), instance->rule.cgroup.path, controller_print_rule_control_groups_prepare_s, fll_error_file_type_directory_e, F_status_set_fine(status));
+          controller_print_error_file_status(&main->program.error, F_status_debug_source_d, instance->rule.cgroup.path, controller_print_rule_control_groups_prepare_s, fll_error_file_type_directory_e, F_status_set_fine(status));
 
           return status;
         }
@@ -83,7 +83,7 @@ extern "C" {
         status = fl_environment_load_names(instance->rule.environment, &instance->environment);
 
         if (F_status_is_error(status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(fl_environment_load_names), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
           return status;
         }
@@ -103,7 +103,7 @@ extern "C" {
                     status = f_string_dynamic_append(entry->define.array[i].value, &instance->environment.array[k].value);
 
                     if (F_status_is_error(status)) {
-                      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append), F_status_set_fine(status));
+                      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
                       return status;
                     }
@@ -116,7 +116,7 @@ extern "C" {
                   status = f_string_maps_append(entry->define.array[i], &instance->environment);
 
                   if (F_status_is_error(status)) {
-                    controller_print_error_status(&main->program.error, macro_controller_f(f_string_maps_append), F_status_set_fine(status));
+                    controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
                     return status;
                   }
@@ -144,7 +144,7 @@ extern "C" {
                   status = f_string_dynamic_append(instance->rule.define.array[i].value, &instance->environment.array[k].value);
 
                   if (F_status_is_error(status)) {
-                    controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append), F_status_set_fine(status));
+                    controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
                     return status;
                   }
@@ -157,7 +157,7 @@ extern "C" {
                 status = f_string_maps_append(instance->rule.define.array[i], &instance->environment);
 
                 if (F_status_is_error(status)) {
-                  controller_print_error_status(&main->program.error, macro_controller_f(f_string_maps_append), F_status_set_fine(status));
+                  controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
                   return status;
                 }
@@ -177,7 +177,7 @@ extern "C" {
           status = f_environment_get_all(&instance->environment);
 
           if (F_status_is_error(status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_environment_get_all), F_status_set_fine(status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
             return status;
           }
@@ -187,7 +187,7 @@ extern "C" {
             status = f_string_maps_append(entry->define.array[i], &instance->environment);
 
             if (F_status_is_error(status)) {
-              controller_print_error_status(&main->program.error, macro_controller_f(f_string_maps_append), F_status_set_fine(status));
+              controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
               return status;
             }
@@ -198,7 +198,7 @@ extern "C" {
             status = f_string_maps_append(instance->rule.define.array[i], &instance->environment);
 
             if (F_status_is_error(status)) {
-              controller_print_error_status(&main->program.error, macro_controller_f(f_string_maps_append), F_status_set_fine(status));
+              controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
               return status;
             }
@@ -248,7 +248,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             break;
           }
@@ -278,7 +278,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             break;
           }
@@ -320,7 +320,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             break;
           }
@@ -358,7 +358,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               break;
             }
@@ -445,7 +445,7 @@ extern "C" {
     if (F_status_is_error(status)) {
       if (F_status_set_fine(status) == F_interrupt) return status;
 
-      controller_print_error_status(&main->program.error, macro_controller_f(f_memory_array_increase), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
       return status;
     }
@@ -464,7 +464,7 @@ extern "C" {
         status = f_time_spec_millisecond(0, controller_thread_timeout_simulation_d, &delay);
 
         if (F_status_is_error(status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_time_spec_millisecond), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
         }
         else {
           status = controller_time_sleep_nanoseconds(instance->main, delay);
@@ -548,7 +548,7 @@ extern "C" {
         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));
+        controller_print_error_status(&instance->main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
 
       f_thread_unlock(&instance->use);
@@ -619,7 +619,7 @@ extern "C" {
     if (F_status_is_error(status)) {
       f_thread_unlock(&instance->use);
 
-      controller_print_error_status(&main->program.error, macro_controller_f(f_memory_array_increase), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
       return status;
     }
@@ -632,7 +632,7 @@ extern "C" {
     status = f_file_exists(pid_file, F_true);
 
     if (F_status_is_error(status) || status == F_true) {
-      controller_print_error_file_status(&main->program.error, macro_controller_f(f_file_exists), pid_file, status == F_true ? f_file_operation_create_s : f_file_operation_find_s, fll_error_file_type_file_e, status == F_true ? F_file_found : F_status_set_fine(status));
+      controller_print_error_file_status(&main->program.error, F_status_debug_source_d, pid_file, status == F_true ? f_file_operation_create_s : f_file_operation_find_s, fll_error_file_type_file_e, status == F_true ? F_file_found : F_status_set_fine(status));
 
       return status;
     }
@@ -640,7 +640,7 @@ extern "C" {
     status = f_string_dynamic_append_nulless(pid_file, process_child_pid_file);
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless), F_status_set_fine(status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
       return status;
     }
@@ -655,7 +655,7 @@ extern "C" {
         status = f_time_spec_millisecond(0, controller_thread_timeout_simulation_d, &delay);
 
         if (F_status_is_error(status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_time_spec_millisecond), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
         }
         else {
           status = controller_time_sleep_nanoseconds(instance->main, delay);
@@ -746,7 +746,7 @@ extern "C" {
         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));
+        controller_print_error_status(&instance->main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
 
       f_thread_unlock(&instance->use);
@@ -781,7 +781,7 @@ extern "C" {
             f_status_t status = f_time_spec_millisecond(0, rerun_item->delay, &delay);
 
             if (F_status_is_error(status)) {
-              controller_print_error_status(&main->program.error, macro_controller_f(f_time_spec_millisecond), F_status_set_fine(status));
+              controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
 
               return -1;
             }
diff --git a/sources/c/program/controller/main/rule/instance.c b/sources/c/program/controller/main/rule/instance.c
index d6b1407..e5b54a0 100644
--- a/sources/c/program/controller/main/rule/instance.c
+++ b/sources/c/program/controller/main/rule/instance.c
@@ -42,7 +42,7 @@ extern "C" {
     }
 
     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, F_status_debug_source_d);
+      controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
 
       return status;
     }
@@ -50,7 +50,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
 
       return status;
     }
@@ -62,7 +62,7 @@ extern "C" {
     }
 
     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, F_status_debug_source_d);
+      controller_print_error_rule(&main->program.error, &instance->cache.action, F_status_set_fine(status), F_status_debug_source_d, F_true, F_true, F_status_debug_source_d);
 
       return status;
     }
@@ -352,7 +352,7 @@ extern "C" {
 
         if (F_status_is_error(status)) {
           if (F_status_set_fine(status) == F_parameter) {
-            controller_print_error_status(&main->program.error, macro_controller_f(controller_rule_execute), F_status_set_fine(status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
           }
 
           controller_print_error_rule_item(&main->program.error, &instance->cache.action, F_true, F_status_set_fine(status), F_status_debug_source_d);
@@ -522,7 +522,7 @@ extern "C" {
       }
 
       if (F_status_is_error(status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_memory_array_resize), F_status_set_fine(status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
       else {
         for (f_number_unsigned_t i = 0; i < stack.used; ++i) {
@@ -544,7 +544,7 @@ extern "C" {
         status = f_string_dynamic_append(cache->action.name_item, &instance->cache.action.name_item);
       }
       else {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append), F_status_set_fine(status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
       }
     }
 
@@ -563,7 +563,7 @@ extern "C" {
           }
 
           if (F_status_is_error(status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), F_status_set_fine(status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
           }
         }
         else {
@@ -724,7 +724,7 @@ extern "C" {
     status = controller_rule_copy(source, destination);
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&instance->main->program.error, macro_controller_f(controller_rule_copy), F_status_set_fine(status));
+      controller_print_error_status(&instance->main->program.error, F_status_debug_source_d, F_status_set_fine(status));
     }
 
     f_thread_unlock(&instance->use);
@@ -749,7 +749,7 @@ extern "C" {
     status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_rule_t *), (void **) &instance->stack.array, &instance->stack.used, &instance->stack.size);
 
     if (F_status_is_error(status)) {
-      controller_print_error_status(&instance->main->program.error, macro_controller_f(f_memory_array_increase), F_status_set_fine(status));
+      controller_print_error_status(&instance->main->program.error, F_status_debug_source_d, F_status_set_fine(status));
     }
     else {
       instance->stack.array[instance->stack.used++] = rule;
diff --git a/sources/c/program/controller/main/rule/item.c b/sources/c/program/controller/main/rule/item.c
index f95d8d2..2c843a2 100644
--- a/sources/c/program/controller/main/rule/item.c
+++ b/sources/c/program/controller/main/rule/item.c
@@ -29,7 +29,7 @@ extern "C" {
       fl_fss_extended_list_object_read(cache->buffer_item, &range, &cache->range_action, &cache->delimits, state);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(fl_fss_extended_list_object_read), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         break;
       }
@@ -46,7 +46,7 @@ extern "C" {
         fl_fss_extended_object_read(cache->buffer_item, &range, &cache->range_action, 0, &cache->delimits, state);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(fl_fss_extended_object_read), F_status_set_fine(state->status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
           break;
         }
@@ -58,7 +58,7 @@ extern "C" {
       f_fss_apply_delimit(cache->delimits, &cache->buffer_item, state);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_fss_apply_delimit), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         break;
       }
@@ -66,7 +66,7 @@ extern "C" {
       f_fss_count_lines(cache->buffer_item, cache->range_action.start, &cache->action.line_action, state);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_fss_count_lines), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         break;
       }
@@ -77,7 +77,7 @@ extern "C" {
       state->status = f_rip_dynamic_partial_nulless(cache->buffer_item, cache->range_action, &cache->action.name_action);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_rip_dynamic_partial_nulless), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         break;
       }
@@ -148,7 +148,7 @@ extern "C" {
       state->status = f_memory_array_increase(controller_allocation_small_d, sizeof(controller_rule_action_t), (void **) &item->actions.array, &item->actions.used, &item->actions.size);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_memory_array_increase_by), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         break;
       }
diff --git a/sources/c/program/controller/main/rule/parameter.c b/sources/c/program/controller/main/rule/parameter.c
index 5df6afc..cf4c00f 100644
--- a/sources/c/program/controller/main/rule/parameter.c
+++ b/sources/c/program/controller/main/rule/parameter.c
@@ -33,7 +33,7 @@ extern "C" {
       }
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, content ? macro_controller_f(f_memory_array_increase_by) : macro_controller_f(f_memory_array_increase), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         return;
       }
@@ -47,7 +47,7 @@ extern "C" {
       state->status = f_string_dynamic_partial_append_nulless(buffer, *object, &action->parameters.array[0]);
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_partial_append_nulless), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         return;
       }
@@ -64,7 +64,7 @@ extern "C" {
       }
 
       if (F_status_is_error(state->status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_memory_array_increase_by), F_status_set_fine(state->status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
         return;
       }
@@ -92,7 +92,7 @@ extern "C" {
         state->status = f_string_dynamic_partial_append_nulless(buffer, content->array[i], &action->parameters.array[action->parameters.used]);
 
         if (F_status_is_error(state->status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_partial_append_nulless), F_status_set_fine(state->status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
           break;
         }
@@ -104,7 +104,7 @@ extern "C" {
           fl_iki_read(&action->parameters.array[action->parameters.used], &range, &action->ikis.array[action->ikis.used], state);
 
           if (F_status_is_error(state->status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(fl_iki_read), F_status_set_fine(state->status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state->status));
 
             action->parameters.array[action->parameters.used].used = 0;
 
diff --git a/sources/c/program/controller/main/rule/read.c b/sources/c/program/controller/main/rule/read.c
index 320cba2..b927936 100644
--- a/sources/c/program/controller/main/rule/read.c
+++ b/sources/c/program/controller/main/rule/read.c
@@ -170,7 +170,7 @@ extern "C" {
     state.status = f_string_dynamic_append_nulless(alias, &rule->alias);
 
     if (F_status_is_error(state.status)) {
-      controller_print_error_status(&main->program.error, macro_controller_f(f_string_dynamic_append_nulless), F_status_set_fine(state.status));
+      controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
     }
     else {
       state.status = controller_file_load(main, F_true, controller_rules_s, rule->alias, controller_rule_s);
@@ -185,13 +185,13 @@ extern "C" {
         fll_fss_basic_list_read(cache->buffer_file, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments, &state);
 
         if (F_status_is_error(state.status)) {
-          controller_print_error_status(&main->program.error, macro_controller_f(fll_fss_basic_list_read), F_status_set_fine(state.status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
         }
         else {
           f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
 
           if (F_status_is_error(state.status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_fss_apply_delimit), F_status_set_fine(state.status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
           }
         }
       }
@@ -203,7 +203,7 @@ extern "C" {
       }
 
       if (F_status_is_error(state.status)) {
-        controller_print_error_status(&main->program.error, macro_controller_f(f_memory_arrays_resize), F_status_set_fine(state.status));
+        controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
       }
       else {
         f_number_unsigned_t i = 0;
@@ -241,7 +241,7 @@ extern "C" {
           f_fss_count_lines(cache->buffer_file, cache->object_items.array[i].start, &cache->action.line_item, &state);
 
           if (F_status_is_error(state.status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_fss_count_lines), F_status_set_fine(state.status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
             break;
           }
@@ -251,7 +251,7 @@ extern "C" {
           state.status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->object_items.array[i], &cache->action.name_item);
 
           if (F_status_is_error(state.status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_rip_dynamic_partial_nulless), F_status_set_fine(state.status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
             break;
           }
@@ -280,7 +280,7 @@ extern "C" {
           state.status = f_string_dynamic_partial_append(cache->buffer_file, cache->content_items.array[i].array[0], &cache->buffer_item);
 
           if (F_status_is_error(state.status)) {
-            controller_print_error_status(&main->program.error, macro_controller_f(f_rip_dynamic_partial_nulless), F_status_set_fine(state.status));
+            controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
             break;
           }
diff --git a/sources/c/program/controller/main/rule/setting.c b/sources/c/program/controller/main/rule/setting.c
index fb8823e..29d7f6a 100644
--- a/sources/c/program/controller/main/rule/setting.c
+++ b/sources/c/program/controller/main/rule/setting.c
@@ -127,7 +127,7 @@ extern "C" {
     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, F_status_debug_source_d);
+      controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
       return state.status;
     }
@@ -163,7 +163,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
         if (F_status_set_fine(state.status) == F_memory_not) {
           status_return = state.status;
@@ -258,7 +258,7 @@ extern "C" {
             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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
           controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
 
@@ -307,7 +307,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             break;
           }
@@ -344,7 +344,7 @@ extern "C" {
               }
             }
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               state.status = F_status_set_error(state.status);
 
@@ -387,7 +387,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
           if (F_status_set_fine(state.status) == F_memory_not) {
             status_return = state.status;
@@ -414,7 +414,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
           if (F_status_set_fine(state.status) == F_memory_not) {
             status_return = state.status;
@@ -438,7 +438,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
           if (F_status_set_fine(state.status) == F_memory_not) {
             status_return = state.status;
@@ -500,7 +500,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
         }
         else {
           rule->cgroup.groups.used = 0;
@@ -510,7 +510,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               break;
             }
@@ -520,7 +520,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               break;
             }
@@ -651,7 +651,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
           if (F_status_set_fine(state.status) == F_memory_not) {
             status_return = state.status;
@@ -708,7 +708,7 @@ extern "C" {
               }
             }
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               state.status = F_status_set_error(state.status);
 
@@ -826,7 +826,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               if (F_status_is_error_not(status_return)) {
                 status_return = state.status;
@@ -846,7 +846,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             if (F_status_set_fine(state.status) == F_memory_not) {
               status_return = state.status;
@@ -957,7 +957,7 @@ extern "C" {
               }
             }
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
               state.status = F_status_set_error(state.status);
 
               if (F_status_is_error_not(status_return)) {
@@ -1051,7 +1051,7 @@ extern "C" {
               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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
           }
 
           if (F_status_is_error_not(status_return)) {
@@ -1084,7 +1084,7 @@ extern "C" {
             state.status = f_rip_dynamic_partial_nulless(cache->buffer_item, cache->content_actions.array[i].array[1], &cache->action.generic);
 
             if (F_status_is_error(state.status)) {
-              controller_print_error_status(&main->program.error, macro_controller_f(f_rip_dynamic_partial_nulless), F_status_set_fine(state.status));
+              controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(state.status));
 
               break;
             }
@@ -1125,7 +1125,7 @@ extern "C" {
 
             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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
 
@@ -1156,7 +1156,7 @@ extern "C" {
 
               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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
 
@@ -1213,7 +1213,7 @@ extern "C" {
               }
             }
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
               state.status = F_status_set_error(state.status);
 
               if (F_status_is_error_not(status_return)) {
@@ -1241,7 +1241,7 @@ extern "C" {
 
                 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, F_status_debug_source_d);
+                controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
                 controller_print_error_rule_cache(&main->program.error, &cache->action, F_false, F_status_debug_source_d);
 
@@ -1290,7 +1290,7 @@ extern "C" {
                 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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
             }
@@ -1338,7 +1338,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             if (F_status_set_fine(state.status) == F_memory_not) {
               status_return = state.status;
@@ -1382,7 +1382,7 @@ extern "C" {
                 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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               controller_print_error_rule_item(&main->program.error, &cache->action, F_false, F_status_set_fine(state.status), F_status_debug_source_d);
             }
@@ -1415,7 +1415,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             if (F_status_set_fine(state.status) == F_memory_not) {
               status_return = state.status;
@@ -1441,7 +1441,7 @@ extern "C" {
           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, F_status_debug_source_d);
+            controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
             setting_values->array[setting_values->used].used = 0;
 
@@ -1485,7 +1485,7 @@ extern "C" {
             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, F_status_debug_source_d);
+              controller_print_error_rule(&main->program.error, &cache->action, F_complete_not_utf, F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
               if (F_status_is_error_not(status_return)) {
                 status_return = state.status;
@@ -1575,7 +1575,7 @@ extern "C" {
       }
 
       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, F_status_debug_source_d);
+        controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, 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) {
@@ -1602,7 +1602,7 @@ extern "C" {
         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, F_status_debug_source_d);
+          controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
         }
       }
 
@@ -1657,7 +1657,7 @@ extern "C" {
       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, F_status_debug_source_d);
+        controller_print_error_rule(&main->program.error, &cache->action, F_status_set_fine(state.status), F_status_debug_source_d, F_true, F_false, F_status_debug_source_d);
 
         if (F_status_set_fine(state.status) == F_memory_not) {
           status_return = state.status;
diff --git a/sources/c/program/controller/main/thread/instance.c b/sources/c/program/controller/main/thread/instance.c
index e918d1f..e377ac7 100644
--- a/sources/c/program/controller/main/thread/instance.c
+++ b/sources/c/program/controller/main/thread/instance.c
@@ -448,7 +448,7 @@ extern "C" {
 
       if (F_status_is_error(status)) {
         if (main->program.error.verbosity > f_console_verbosity_quiet_e) {
-          controller_print_error_status(&main->program.error, macro_controller_f(f_thread_create), F_status_set_fine(status));
+          controller_print_error_status(&main->program.error, F_status_debug_source_d, F_status_set_fine(status));
         }
 
         controller_thread_enable_set(&main->thread, controller_thread_enable_not_e, 0);