Update: Change execute error code handling to better accommodate standard GNU Bash...

This introduces the status codes F_call and F_call_not as part of the required changes.
This also introduces F_yes, F_yes_not, F_no, and F_no_not.

Improve the wording of some of the error messages.

diff --git a/level_0/f_execute/c/execute.c b/level_0/f_execute/c/execute.c
index 15f5fc1833d0920cb90fa979572a31953d4c615a..e0b60b781b545f39dbd5371ce83b6321868d6e3c 100644 (file)
--- a/level_0/f_execute/c/execute.c
+++ b/level_0/f_execute/c/execute.c
@@ -147,6 +147,274 @@ extern "C" {
       return F_execute_valid_not;
     }
 
+    if (F_status_set_fine(status) == F_call_not) {
+      return F_execute_invoke_not;
+    }
+
+    if (F_status_set_fine(status) == F_found_not) {
+      return F_execute_found_not;
+    }
+
+    if (F_status_set_fine(status) == F_exit) {
+      return F_execute_exit_parameter;
+    }
+
+    if (F_status_set_fine(status) == F_signal_hangup) {
+      return F_execute_signal_hangup;
+    }
+
+    if (F_status_set_fine(status) == F_signal_interrupt) {
+      return F_execute_signal_interrupt;
+    }
+
+    if (F_status_set_fine(status) == F_signal_quit) {
+      return F_execute_signal_quit;
+    }
+
+    if (F_status_set_fine(status) == F_signal_illegal) {
+      return F_execute_signal_illegal;
+    }
+
+    if (F_status_set_fine(status) == F_signal_trap) {
+      return F_execute_signal_trap;
+    }
+
+    if (F_status_set_fine(status) == F_signal_abort) {
+      return F_execute_signal_abort;
+    }
+
+    if (F_status_set_fine(status) == F_signal_bus_error) {
+      return F_execute_signal_bus_error;
+    }
+
+    if (F_status_set_fine(status) == F_signal_floating_point_error) {
+      return F_execute_signal_floating_point_error;
+    }
+
+    if (F_status_set_fine(status) == F_signal_kill) {
+      return F_execute_signal_kill;
+    }
+
+    if (F_status_set_fine(status) == F_signal_user_1) {
+      return F_execute_signal_user_1;
+    }
+
+    if (F_status_set_fine(status) == F_signal_segmentation_fault) {
+      return F_execute_signal_segmentation_fault;
+    }
+
+    if (F_status_set_fine(status) == F_signal_user_2) {
+      return F_execute_signal_user_2;
+    }
+
+    if (F_status_set_fine(status) == F_signal_broken_pipe) {
+      return F_execute_signal_broken_pipe;
+    }
+
+    if (F_status_set_fine(status) == F_signal_alarm_clock) {
+      return F_execute_signal_alarm_clock;
+    }
+
+    if (F_status_set_fine(status) == F_signal_termination) {
+      return F_execute_signal_termination;
+    }
+
+    if (F_status_set_fine(status) == F_signal_stack_fault) {
+      return F_execute_signal_stack_fault;
+    }
+
+    if (F_status_set_fine(status) == F_signal_child) {
+      return F_execute_signal_child;
+    }
+
+    if (F_status_set_fine(status) == F_signal_continue) {
+      return F_execute_signal_continue;
+    }
+
+    if (F_status_set_fine(status) == F_signal_stop) {
+      return F_execute_signal_stop;
+    }
+
+    if (F_status_set_fine(status) == F_signal_keyboard_stop) {
+      return F_execute_signal_keyboard_stop;
+    }
+
+    if (F_status_set_fine(status) == F_signal_tty_in) {
+      return F_execute_signal_tty_in;
+    }
+
+    if (F_status_set_fine(status) == F_signal_tty_out) {
+      return F_execute_signal_tty_out;
+    }
+
+    if (F_status_set_fine(status) == F_signal_urgent) {
+      return F_execute_signal_urgent;
+    }
+
+    if (F_status_set_fine(status) == F_signal_cpu_limit) {
+      return F_execute_signal_cpu_limit;
+    }
+
+    if (F_status_set_fine(status) == F_signal_file_size_limit) {
+      return F_execute_signal_file_size_limit;
+    }
+
+    if (F_status_set_fine(status) == F_signal_virtual_alarm_clock) {
+      return F_execute_signal_virtual_alarm_clock;
+    }
+
+    if (F_status_set_fine(status) == F_signal_profile_alarm_clock) {
+      return F_execute_signal_profile_alarm_clock;
+    }
+
+    if (F_status_set_fine(status) == F_signal_window_size_change) {
+      return F_execute_signal_window_size_change;
+    }
+
+    if (F_status_set_fine(status) == F_signal_pollable_event) {
+      return F_execute_signal_pollable_event;
+    }
+
+    if (F_status_set_fine(status) == F_signal_power_failure) {
+      return F_execute_signal_power_failure;
+    }
+
+    if (F_status_set_fine(status) == F_signal_bad_system_call) {
+      return F_execute_signal_bad_system_call;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_32) {
+      return F_execute_signal_reserved_32;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_33) {
+      return F_execute_signal_reserved_33;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_34) {
+      return F_execute_signal_reserved_34;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_35) {
+      return F_execute_signal_reserved_35;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_36) {
+      return F_execute_signal_reserved_36;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_37) {
+      return F_execute_signal_reserved_37;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_38) {
+      return F_execute_signal_reserved_38;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_39) {
+      return F_execute_signal_reserved_39;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_40) {
+      return F_execute_signal_reserved_40;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_41) {
+      return F_execute_signal_reserved_41;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_42) {
+      return F_execute_signal_reserved_42;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_43) {
+      return F_execute_signal_reserved_43;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_44) {
+      return F_execute_signal_reserved_44;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_45) {
+      return F_execute_signal_reserved_45;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_46) {
+      return F_execute_signal_reserved_46;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_47) {
+      return F_execute_signal_reserved_47;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_48) {
+      return F_execute_signal_reserved_48;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_49) {
+      return F_execute_signal_reserved_49;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_50) {
+      return F_execute_signal_reserved_50;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_51) {
+      return F_execute_signal_reserved_51;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_52) {
+      return F_execute_signal_reserved_52;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_53) {
+      return F_execute_signal_reserved_53;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_54) {
+      return F_execute_signal_reserved_54;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_55) {
+      return F_execute_signal_reserved_55;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_56) {
+      return F_execute_signal_reserved_56;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_57) {
+      return F_execute_signal_reserved_57;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_58) {
+      return F_execute_signal_reserved_58;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_59) {
+      return F_execute_signal_reserved_59;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_60) {
+      return F_execute_signal_reserved_60;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_61) {
+      return F_execute_signal_reserved_61;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_62) {
+      return F_execute_signal_reserved_62;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_63) {
+      return F_execute_signal_reserved_63;
+    }
+
+    if (F_status_set_fine(status) == F_signal_reserved_64) {
+      return F_execute_signal_reserved_64;
+    }
+
     return F_execute_code_last;
   }
 #endif // _di_f_execute_status_from_status_
@@ -294,6 +562,274 @@ extern "C" {
       return F_valid_not;
     }
 
+    if (status == F_execute_invoke_not) {
+      return F_call_not;
+    }
+
+    if (status == F_execute_found_not) {
+      return F_found_not;
+    }
+
+    if (status == F_execute_exit_parameter) {
+      return F_exit;
+    }
+
+    if (status == F_execute_signal_hangup) {
+      return F_signal_hangup;
+    }
+
+    if (status == F_execute_signal_interrupt) {
+      return F_signal_interrupt;
+    }
+
+    if (status == F_execute_signal_quit) {
+      return F_signal_quit;
+    }
+
+    if (status == F_execute_signal_illegal) {
+      return F_signal_illegal;
+    }
+
+    if (status == F_execute_signal_trap) {
+      return F_signal_trap;
+    }
+
+    if (status == F_execute_signal_abort) {
+      return F_signal_abort;
+    }
+
+    if (status == F_execute_signal_bus_error) {
+      return F_signal_bus_error;
+    }
+
+    if (status == F_execute_signal_floating_point_error) {
+      return F_signal_floating_point_error;
+    }
+
+    if (status == F_execute_signal_kill) {
+      return F_signal_kill;
+    }
+
+    if (status == F_execute_signal_user_1) {
+      return F_signal_user_1;
+    }
+
+    if (status == F_execute_signal_segmentation_fault) {
+      return F_signal_segmentation_fault;
+    }
+
+    if (status == F_execute_signal_user_2) {
+      return F_signal_user_2;
+    }
+
+    if (status == F_execute_signal_broken_pipe) {
+      return F_signal_broken_pipe;
+    }
+
+    if (status == F_execute_signal_alarm_clock) {
+      return F_signal_alarm_clock;
+    }
+
+    if (status == F_execute_signal_termination) {
+      return F_signal_termination;
+    }
+
+    if (status == F_execute_signal_stack_fault) {
+      return F_signal_stack_fault;
+    }
+
+    if (status == F_execute_signal_child) {
+      return F_signal_child;
+    }
+
+    if (status == F_execute_signal_continue) {
+      return F_signal_continue;
+    }
+
+    if (status == F_execute_signal_stop) {
+      return F_signal_stop;
+    }
+
+    if (status == F_execute_signal_keyboard_stop) {
+      return F_signal_keyboard_stop;
+    }
+
+    if (status == F_execute_signal_tty_in) {
+      return F_signal_tty_in;
+    }
+
+    if (status == F_execute_signal_tty_out) {
+      return F_signal_tty_out;
+    }
+
+    if (status == F_execute_signal_urgent) {
+      return F_signal_urgent;
+    }
+
+    if (status == F_execute_signal_cpu_limit) {
+      return F_signal_cpu_limit;
+    }
+
+    if (status == F_execute_signal_file_size_limit) {
+      return F_signal_file_size_limit;
+    }
+
+    if (status == F_execute_signal_virtual_alarm_clock) {
+      return F_signal_virtual_alarm_clock;
+    }
+
+    if (status == F_execute_signal_profile_alarm_clock) {
+      return F_signal_profile_alarm_clock;
+    }
+
+    if (status == F_execute_signal_window_size_change) {
+      return F_signal_window_size_change;
+    }
+
+    if (status == F_execute_signal_pollable_event) {
+      return F_signal_pollable_event;
+    }
+
+    if (status == F_execute_signal_power_failure) {
+      return F_signal_power_failure;
+    }
+
+    if (status == F_execute_signal_bad_system_call) {
+      return F_signal_bad_system_call;
+    }
+
+    if (status == F_execute_signal_reserved_32) {
+      return F_signal_reserved_32;
+    }
+
+    if (status == F_execute_signal_reserved_33) {
+      return F_signal_reserved_33;
+    }
+
+    if (status == F_execute_signal_reserved_34) {
+      return F_signal_reserved_34;
+    }
+
+    if (status == F_execute_signal_reserved_35) {
+      return F_signal_reserved_35;
+    }
+
+    if (status == F_execute_signal_reserved_36) {
+      return F_signal_reserved_36;
+    }
+
+    if (status == F_execute_signal_reserved_37) {
+      return F_signal_reserved_37;
+    }
+
+    if (status == F_execute_signal_reserved_38) {
+      return F_signal_reserved_38;
+    }
+
+    if (status == F_execute_signal_reserved_39) {
+      return F_signal_reserved_39;
+    }
+
+    if (status == F_execute_signal_reserved_40) {
+      return F_signal_reserved_40;
+    }
+
+    if (status == F_execute_signal_reserved_41) {
+      return F_signal_reserved_41;
+    }
+
+    if (status == F_execute_signal_reserved_42) {
+      return F_signal_reserved_42;
+    }
+
+    if (status == F_execute_signal_reserved_43) {
+      return F_signal_reserved_43;
+    }
+
+    if (status == F_execute_signal_reserved_44) {
+      return F_signal_reserved_44;
+    }
+
+    if (status == F_execute_signal_reserved_45) {
+      return F_signal_reserved_45;
+    }
+
+    if (status == F_execute_signal_reserved_46) {
+      return F_signal_reserved_46;
+    }
+
+    if (status == F_execute_signal_reserved_47) {
+      return F_signal_reserved_47;
+    }
+
+    if (status == F_execute_signal_reserved_48) {
+      return F_signal_reserved_48;
+    }
+
+    if (status == F_execute_signal_reserved_49) {
+      return F_signal_reserved_49;
+    }
+
+    if (status == F_execute_signal_reserved_50) {
+      return F_signal_reserved_50;
+    }
+
+    if (status == F_execute_signal_reserved_51) {
+      return F_signal_reserved_51;
+    }
+
+    if (status == F_execute_signal_reserved_52) {
+      return F_signal_reserved_52;
+    }
+
+    if (status == F_execute_signal_reserved_53) {
+      return F_signal_reserved_53;
+    }
+
+    if (status == F_execute_signal_reserved_54) {
+      return F_signal_reserved_54;
+    }
+
+    if (status == F_execute_signal_reserved_55) {
+      return F_signal_reserved_55;
+    }
+
+    if (status == F_execute_signal_reserved_56) {
+      return F_signal_reserved_56;
+    }
+
+    if (status == F_execute_signal_reserved_57) {
+      return F_signal_reserved_57;
+    }
+
+    if (status == F_execute_signal_reserved_58) {
+      return F_signal_reserved_58;
+    }
+
+    if (status == F_execute_signal_reserved_59) {
+      return F_signal_reserved_59;
+    }
+
+    if (status == F_execute_signal_reserved_60) {
+      return F_signal_reserved_60;
+    }
+
+    if (status == F_execute_signal_reserved_61) {
+      return F_signal_reserved_61;
+    }
+
+    if (status == F_execute_signal_reserved_62) {
+      return F_signal_reserved_62;
+    }
+
+    if (status == F_execute_signal_reserved_63) {
+      return F_signal_reserved_63;
+    }
+
+    if (status == F_execute_signal_reserved_64) {
+      return F_signal_reserved_64;
+    }
+
     return F_status_set_error(F_known_not);
   }
 #endif // _di_f_execute_status_to_status_

diff --git a/level_0/f_execute/c/execute/common.h b/level_0/f_execute/c/execute/common.h
index b262edaf6bbdbda877995d0ba2297b9c32c855d1..9aebf538ac5e64ff58c0342f14d1607cc8d29673 100644 (file)
--- a/level_0/f_execute/c/execute/common.h
+++ b/level_0/f_execute/c/execute/common.h
@@ -24,6 +24,15 @@ extern "C" {
  *
  * All codes, except 0, represent an error.
  *
+ * Code 1 is used as a general error code across many programs.
+ * Code 2 is used as invalid parameters.
+ * Special code F_execute_code_middle is used as the middle point and must be less than 126.
+ * Special codes 126 to 255 are intended to match GNU Bash like exit codes.
+ * All other codes are in alphabetic order (inclusively between codes 3 to 125).
+ *
+ * Anything between F_execute_code_middle and 126 is a hole (not used for any status code).
+ * The codes in this hole are available for custom use.
+ *
  * F_execute_code_last, this is intended to designate the last code provided by level_0 execute project.
  * All code sets started by another project must start at this number + 1 with a code start map.
  *
@@ -33,6 +42,8 @@ extern "C" {
 #ifndef _di_f_execute_codes_
   enum {
     F_execute_none = 0,
+    F_execute_failure,
+    F_execute_parameter,
     F_execute_access,
     F_execute_bad,
     F_execute_buffer,
@@ -41,7 +52,6 @@ extern "C" {
     F_execute_control_group,
     F_execute_child,
     F_execute_directory_not,
-    F_execute_failure,
     F_execute_file_found_not,
     F_execute_file_type_directory,
     F_execute_fork_not,
@@ -53,7 +63,6 @@ extern "C" {
     F_execute_memory_not,
     F_execute_name_not,
     F_execute_nice,
-    F_execute_parameter,
     F_execute_pipe,
     F_execute_processor,
     F_execute_prohibited,
@@ -67,9 +76,79 @@ extern "C" {
     F_execute_too_large,
     F_execute_user,
     F_execute_valid_not,
+    F_execute_code_middle,
+
+    // Special codes for compatibility with GNU Bash like return codes.
+    F_execute_invoke_not = 126,
+    F_execute_found_not,
+    F_execute_exit_parameter,
+    F_execute_signal_hangup,
+    F_execute_signal_interrupt,
+    F_execute_signal_quit,
+    F_execute_signal_illegal,
+    F_execute_signal_trap,
+    F_execute_signal_abort,
+    F_execute_signal_bus_error,
+    F_execute_signal_floating_point_error,
+    F_execute_signal_kill,
+    F_execute_signal_user_1,
+    F_execute_signal_segmentation_fault,
+    F_execute_signal_user_2,
+    F_execute_signal_broken_pipe,
+    F_execute_signal_alarm_clock,
+    F_execute_signal_termination,
+    F_execute_signal_stack_fault,
+    F_execute_signal_child,
+    F_execute_signal_continue,
+    F_execute_signal_stop,
+    F_execute_signal_keyboard_stop,
+    F_execute_signal_tty_in,
+    F_execute_signal_tty_out,
+    F_execute_signal_urgent,
+    F_execute_signal_cpu_limit,
+    F_execute_signal_file_size_limit,
+    F_execute_signal_virtual_alarm_clock,
+    F_execute_signal_profile_alarm_clock,
+    F_execute_signal_window_size_change,
+    F_execute_signal_pollable_event,
+    F_execute_signal_power_failure,
+    F_execute_signal_bad_system_call,
+    F_execute_signal_reserved_32,
+    F_execute_signal_reserved_33,
+    F_execute_signal_reserved_34,
+    F_execute_signal_reserved_35,
+    F_execute_signal_reserved_36,
+    F_execute_signal_reserved_37,
+    F_execute_signal_reserved_38,
+    F_execute_signal_reserved_39,
+    F_execute_signal_reserved_40,
+    F_execute_signal_reserved_41,
+    F_execute_signal_reserved_42,
+    F_execute_signal_reserved_43,
+    F_execute_signal_reserved_44,
+    F_execute_signal_reserved_45,
+    F_execute_signal_reserved_46,
+    F_execute_signal_reserved_47,
+    F_execute_signal_reserved_48,
+    F_execute_signal_reserved_49,
+    F_execute_signal_reserved_50,
+    F_execute_signal_reserved_51,
+    F_execute_signal_reserved_52,
+    F_execute_signal_reserved_53,
+    F_execute_signal_reserved_54,
+    F_execute_signal_reserved_55,
+    F_execute_signal_reserved_56,
+    F_execute_signal_reserved_57,
+    F_execute_signal_reserved_58,
+    F_execute_signal_reserved_59,
+    F_execute_signal_reserved_60,
+    F_execute_signal_reserved_61,
+    F_execute_signal_reserved_62,
+    F_execute_signal_reserved_63,
+    F_execute_signal_reserved_64,
 
     // Required.
-    F_execute_code_last,
+    F_execute_code_last = 255,
   }; // enum
 #endif // _di_f_execute_codes_
 

diff --git a/level_0/f_execute/tests/unit/c/test-execute-status_from_status.c b/level_0/f_execute/tests/unit/c/test-execute-status_from_status.c
index c9ca6f2b71ed20b9d56e8da702b3e5b73f395396..3fd438ab748674db21c22834526a451fe3bc4597 100644 (file)
--- a/level_0/f_execute/tests/unit/c/test-execute-status_from_status.c
+++ b/level_0/f_execute/tests/unit/c/test-execute-status_from_status.c
@@ -45,6 +45,73 @@ void test__f_execute_status_from_status__fails(void **state) {
     if (i == F_too_large) continue;
     if (i == F_user) continue;
     if (i == F_valid_not) continue;
+    if (i == F_call_not) continue;
+    if (i == F_found_not) continue;
+    if (i == F_exit) continue;
+    if (i == F_signal_hangup) continue;
+    if (i == F_signal_interrupt) continue;
+    if (i == F_signal_quit) continue;
+    if (i == F_signal_illegal) continue;
+    if (i == F_signal_trap) continue;
+    if (i == F_signal_abort) continue;
+    if (i == F_signal_bus_error) continue;
+    if (i == F_signal_floating_point_error) continue;
+    if (i == F_signal_kill) continue;
+    if (i == F_signal_user_1) continue;
+    if (i == F_signal_segmentation_fault) continue;
+    if (i == F_signal_user_2) continue;
+    if (i == F_signal_broken_pipe) continue;
+    if (i == F_signal_alarm_clock) continue;
+    if (i == F_signal_termination) continue;
+    if (i == F_signal_stack_fault) continue;
+    if (i == F_signal_child) continue;
+    if (i == F_signal_continue) continue;
+    if (i == F_signal_stop) continue;
+    if (i == F_signal_keyboard_stop) continue;
+    if (i == F_signal_tty_in) continue;
+    if (i == F_signal_tty_out) continue;
+    if (i == F_signal_urgent) continue;
+    if (i == F_signal_cpu_limit) continue;
+    if (i == F_signal_file_size_limit) continue;
+    if (i == F_signal_virtual_alarm_clock) continue;
+    if (i == F_signal_profile_alarm_clock) continue;
+    if (i == F_signal_window_size_change) continue;
+    if (i == F_signal_pollable_event) continue;
+    if (i == F_signal_power_failure) continue;
+    if (i == F_signal_bad_system_call) continue;
+    if (i == F_signal_reserved_32) continue;
+    if (i == F_signal_reserved_33) continue;
+    if (i == F_signal_reserved_34) continue;
+    if (i == F_signal_reserved_35) continue;
+    if (i == F_signal_reserved_36) continue;
+    if (i == F_signal_reserved_37) continue;
+    if (i == F_signal_reserved_38) continue;
+    if (i == F_signal_reserved_39) continue;
+    if (i == F_signal_reserved_40) continue;
+    if (i == F_signal_reserved_41) continue;
+    if (i == F_signal_reserved_42) continue;
+    if (i == F_signal_reserved_43) continue;
+    if (i == F_signal_reserved_44) continue;
+    if (i == F_signal_reserved_45) continue;
+    if (i == F_signal_reserved_46) continue;
+    if (i == F_signal_reserved_47) continue;
+    if (i == F_signal_reserved_48) continue;
+    if (i == F_signal_reserved_49) continue;
+    if (i == F_signal_reserved_50) continue;
+    if (i == F_signal_reserved_51) continue;
+    if (i == F_signal_reserved_52) continue;
+    if (i == F_signal_reserved_53) continue;
+    if (i == F_signal_reserved_54) continue;
+    if (i == F_signal_reserved_55) continue;
+    if (i == F_signal_reserved_56) continue;
+    if (i == F_signal_reserved_57) continue;
+    if (i == F_signal_reserved_58) continue;
+    if (i == F_signal_reserved_59) continue;
+    if (i == F_signal_reserved_60) continue;
+    if (i == F_signal_reserved_61) continue;
+    if (i == F_signal_reserved_62) continue;
+    if (i == F_signal_reserved_63) continue;
+    if (i == F_signal_reserved_64) continue;
 
     const uint8_t execute_status = f_execute_status_from_status(i);
 
@@ -90,6 +157,73 @@ void test__f_execute_status_from_status__works(void **state) {
     F_execute_too_large,
     F_execute_user,
     F_execute_valid_not,
+    F_execute_invoke_not,
+    F_execute_found_not,
+    F_execute_exit_parameter,
+    F_execute_signal_hangup,
+    F_execute_signal_interrupt,
+    F_execute_signal_quit,
+    F_execute_signal_illegal,
+    F_execute_signal_trap,
+    F_execute_signal_abort,
+    F_execute_signal_bus_error,
+    F_execute_signal_floating_point_error,
+    F_execute_signal_kill,
+    F_execute_signal_user_1,
+    F_execute_signal_segmentation_fault,
+    F_execute_signal_user_2,
+    F_execute_signal_broken_pipe,
+    F_execute_signal_alarm_clock,
+    F_execute_signal_termination,
+    F_execute_signal_stack_fault,
+    F_execute_signal_child,
+    F_execute_signal_continue,
+    F_execute_signal_stop,
+    F_execute_signal_keyboard_stop,
+    F_execute_signal_tty_in,
+    F_execute_signal_tty_out,
+    F_execute_signal_urgent,
+    F_execute_signal_cpu_limit,
+    F_execute_signal_file_size_limit,
+    F_execute_signal_virtual_alarm_clock,
+    F_execute_signal_profile_alarm_clock,
+    F_execute_signal_window_size_change,
+    F_execute_signal_pollable_event,
+    F_execute_signal_power_failure,
+    F_execute_signal_bad_system_call,
+    F_execute_signal_reserved_32,
+    F_execute_signal_reserved_33,
+    F_execute_signal_reserved_34,
+    F_execute_signal_reserved_35,
+    F_execute_signal_reserved_36,
+    F_execute_signal_reserved_37,
+    F_execute_signal_reserved_38,
+    F_execute_signal_reserved_39,
+    F_execute_signal_reserved_40,
+    F_execute_signal_reserved_41,
+    F_execute_signal_reserved_42,
+    F_execute_signal_reserved_43,
+    F_execute_signal_reserved_44,
+    F_execute_signal_reserved_45,
+    F_execute_signal_reserved_46,
+    F_execute_signal_reserved_47,
+    F_execute_signal_reserved_48,
+    F_execute_signal_reserved_49,
+    F_execute_signal_reserved_50,
+    F_execute_signal_reserved_51,
+    F_execute_signal_reserved_52,
+    F_execute_signal_reserved_53,
+    F_execute_signal_reserved_54,
+    F_execute_signal_reserved_55,
+    F_execute_signal_reserved_56,
+    F_execute_signal_reserved_57,
+    F_execute_signal_reserved_58,
+    F_execute_signal_reserved_59,
+    F_execute_signal_reserved_60,
+    F_execute_signal_reserved_61,
+    F_execute_signal_reserved_62,
+    F_execute_signal_reserved_63,
+    F_execute_signal_reserved_64,
   };
 
   const f_status_t statuss[] = {
@@ -128,9 +262,76 @@ void test__f_execute_status_from_status__works(void **state) {
     F_too_large,
     F_user,
     F_valid_not,
+    F_call_not,
+    F_found_not,
+    F_exit,
+    F_signal_hangup,
+    F_signal_interrupt,
+    F_signal_quit,
+    F_signal_illegal,
+    F_signal_trap,
+    F_signal_abort,
+    F_signal_bus_error,
+    F_signal_floating_point_error,
+    F_signal_kill,
+    F_signal_user_1,
+    F_signal_segmentation_fault,
+    F_signal_user_2,
+    F_signal_broken_pipe,
+    F_signal_alarm_clock,
+    F_signal_termination,
+    F_signal_stack_fault,
+    F_signal_child,
+    F_signal_continue,
+    F_signal_stop,
+    F_signal_keyboard_stop,
+    F_signal_tty_in,
+    F_signal_tty_out,
+    F_signal_urgent,
+    F_signal_cpu_limit,
+    F_signal_file_size_limit,
+    F_signal_virtual_alarm_clock,
+    F_signal_profile_alarm_clock,
+    F_signal_window_size_change,
+    F_signal_pollable_event,
+    F_signal_power_failure,
+    F_signal_bad_system_call,
+    F_signal_reserved_32,
+    F_signal_reserved_33,
+    F_signal_reserved_34,
+    F_signal_reserved_35,
+    F_signal_reserved_36,
+    F_signal_reserved_37,
+    F_signal_reserved_38,
+    F_signal_reserved_39,
+    F_signal_reserved_40,
+    F_signal_reserved_41,
+    F_signal_reserved_42,
+    F_signal_reserved_43,
+    F_signal_reserved_44,
+    F_signal_reserved_45,
+    F_signal_reserved_46,
+    F_signal_reserved_47,
+    F_signal_reserved_48,
+    F_signal_reserved_49,
+    F_signal_reserved_50,
+    F_signal_reserved_51,
+    F_signal_reserved_52,
+    F_signal_reserved_53,
+    F_signal_reserved_54,
+    F_signal_reserved_55,
+    F_signal_reserved_56,
+    F_signal_reserved_57,
+    F_signal_reserved_58,
+    F_signal_reserved_59,
+    F_signal_reserved_60,
+    F_signal_reserved_61,
+    F_signal_reserved_62,
+    F_signal_reserved_63,
+    F_signal_reserved_64,
   };
 
-  for (uint8_t i = 0; i < 35; ++i) {
+  for (uint8_t i = 0; i < 102; ++i) {
 
     const uint8_t execute_status = f_execute_status_from_status(statuss[i]);
 

diff --git a/level_0/f_execute/tests/unit/c/test-execute-status_to_status.c b/level_0/f_execute/tests/unit/c/test-execute-status_to_status.c
index ad14792d48efac0ab6032cdbaa98ed69ec721876..3223197b374b0fcf15ae6619834d81336bc28b17 100644 (file)
--- a/level_0/f_execute/tests/unit/c/test-execute-status_to_status.c
+++ b/level_0/f_execute/tests/unit/c/test-execute-status_to_status.c
@@ -45,6 +45,73 @@ void test__f_execute_status_to_status__fails(void **state) {
     if (i == F_execute_too_large) continue;
     if (i == F_execute_user) continue;
     if (i == F_execute_valid_not) continue;
+    if (i == F_execute_invoke_not) continue;
+    if (i == F_execute_found_not) continue;
+    if (i == F_execute_exit_parameter) continue;
+    if (i == F_execute_signal_hangup) continue;
+    if (i == F_execute_signal_interrupt) continue;
+    if (i == F_execute_signal_quit) continue;
+    if (i == F_execute_signal_illegal) continue;
+    if (i == F_execute_signal_trap) continue;
+    if (i == F_execute_signal_abort) continue;
+    if (i == F_execute_signal_bus_error) continue;
+    if (i == F_execute_signal_floating_point_error) continue;
+    if (i == F_execute_signal_kill) continue;
+    if (i == F_execute_signal_user_1) continue;
+    if (i == F_execute_signal_segmentation_fault) continue;
+    if (i == F_execute_signal_user_2) continue;
+    if (i == F_execute_signal_broken_pipe) continue;
+    if (i == F_execute_signal_alarm_clock) continue;
+    if (i == F_execute_signal_termination) continue;
+    if (i == F_execute_signal_stack_fault) continue;
+    if (i == F_execute_signal_child) continue;
+    if (i == F_execute_signal_continue) continue;
+    if (i == F_execute_signal_stop) continue;
+    if (i == F_execute_signal_keyboard_stop) continue;
+    if (i == F_execute_signal_tty_in) continue;
+    if (i == F_execute_signal_tty_out) continue;
+    if (i == F_execute_signal_urgent) continue;
+    if (i == F_execute_signal_cpu_limit) continue;
+    if (i == F_execute_signal_file_size_limit) continue;
+    if (i == F_execute_signal_virtual_alarm_clock) continue;
+    if (i == F_execute_signal_profile_alarm_clock) continue;
+    if (i == F_execute_signal_window_size_change) continue;
+    if (i == F_execute_signal_pollable_event) continue;
+    if (i == F_execute_signal_power_failure) continue;
+    if (i == F_execute_signal_bad_system_call) continue;
+    if (i == F_execute_signal_reserved_32) continue;
+    if (i == F_execute_signal_reserved_33) continue;
+    if (i == F_execute_signal_reserved_34) continue;
+    if (i == F_execute_signal_reserved_35) continue;
+    if (i == F_execute_signal_reserved_36) continue;
+    if (i == F_execute_signal_reserved_37) continue;
+    if (i == F_execute_signal_reserved_38) continue;
+    if (i == F_execute_signal_reserved_39) continue;
+    if (i == F_execute_signal_reserved_40) continue;
+    if (i == F_execute_signal_reserved_41) continue;
+    if (i == F_execute_signal_reserved_42) continue;
+    if (i == F_execute_signal_reserved_43) continue;
+    if (i == F_execute_signal_reserved_44) continue;
+    if (i == F_execute_signal_reserved_45) continue;
+    if (i == F_execute_signal_reserved_46) continue;
+    if (i == F_execute_signal_reserved_47) continue;
+    if (i == F_execute_signal_reserved_48) continue;
+    if (i == F_execute_signal_reserved_49) continue;
+    if (i == F_execute_signal_reserved_50) continue;
+    if (i == F_execute_signal_reserved_51) continue;
+    if (i == F_execute_signal_reserved_52) continue;
+    if (i == F_execute_signal_reserved_53) continue;
+    if (i == F_execute_signal_reserved_54) continue;
+    if (i == F_execute_signal_reserved_55) continue;
+    if (i == F_execute_signal_reserved_56) continue;
+    if (i == F_execute_signal_reserved_57) continue;
+    if (i == F_execute_signal_reserved_58) continue;
+    if (i == F_execute_signal_reserved_59) continue;
+    if (i == F_execute_signal_reserved_60) continue;
+    if (i == F_execute_signal_reserved_61) continue;
+    if (i == F_execute_signal_reserved_62) continue;
+    if (i == F_execute_signal_reserved_63) continue;
+    if (i == F_execute_signal_reserved_64) continue;
 
     const f_status_t status = f_execute_status_to_status(i);
 
@@ -90,6 +157,73 @@ void test__f_execute_status_to_status__works(void **state) {
     F_execute_too_large,
     F_execute_user,
     F_execute_valid_not,
+    F_execute_invoke_not,
+    F_execute_found_not,
+    F_execute_exit_parameter,
+    F_execute_signal_hangup,
+    F_execute_signal_interrupt,
+    F_execute_signal_quit,
+    F_execute_signal_illegal,
+    F_execute_signal_trap,
+    F_execute_signal_abort,
+    F_execute_signal_bus_error,
+    F_execute_signal_floating_point_error,
+    F_execute_signal_kill,
+    F_execute_signal_user_1,
+    F_execute_signal_segmentation_fault,
+    F_execute_signal_user_2,
+    F_execute_signal_broken_pipe,
+    F_execute_signal_alarm_clock,
+    F_execute_signal_termination,
+    F_execute_signal_stack_fault,
+    F_execute_signal_child,
+    F_execute_signal_continue,
+    F_execute_signal_stop,
+    F_execute_signal_keyboard_stop,
+    F_execute_signal_tty_in,
+    F_execute_signal_tty_out,
+    F_execute_signal_urgent,
+    F_execute_signal_cpu_limit,
+    F_execute_signal_file_size_limit,
+    F_execute_signal_virtual_alarm_clock,
+    F_execute_signal_profile_alarm_clock,
+    F_execute_signal_window_size_change,
+    F_execute_signal_pollable_event,
+    F_execute_signal_power_failure,
+    F_execute_signal_bad_system_call,
+    F_execute_signal_reserved_32,
+    F_execute_signal_reserved_33,
+    F_execute_signal_reserved_34,
+    F_execute_signal_reserved_35,
+    F_execute_signal_reserved_36,
+    F_execute_signal_reserved_37,
+    F_execute_signal_reserved_38,
+    F_execute_signal_reserved_39,
+    F_execute_signal_reserved_40,
+    F_execute_signal_reserved_41,
+    F_execute_signal_reserved_42,
+    F_execute_signal_reserved_43,
+    F_execute_signal_reserved_44,
+    F_execute_signal_reserved_45,
+    F_execute_signal_reserved_46,
+    F_execute_signal_reserved_47,
+    F_execute_signal_reserved_48,
+    F_execute_signal_reserved_49,
+    F_execute_signal_reserved_50,
+    F_execute_signal_reserved_51,
+    F_execute_signal_reserved_52,
+    F_execute_signal_reserved_53,
+    F_execute_signal_reserved_54,
+    F_execute_signal_reserved_55,
+    F_execute_signal_reserved_56,
+    F_execute_signal_reserved_57,
+    F_execute_signal_reserved_58,
+    F_execute_signal_reserved_59,
+    F_execute_signal_reserved_60,
+    F_execute_signal_reserved_61,
+    F_execute_signal_reserved_62,
+    F_execute_signal_reserved_63,
+    F_execute_signal_reserved_64,
   };
 
   const f_status_t statuss[] = {
@@ -128,9 +262,76 @@ void test__f_execute_status_to_status__works(void **state) {
     F_too_large,
     F_user,
     F_valid_not,
+    F_call_not,
+    F_found_not,
+    F_exit,
+    F_signal_hangup,
+    F_signal_interrupt,
+    F_signal_quit,
+    F_signal_illegal,
+    F_signal_trap,
+    F_signal_abort,
+    F_signal_bus_error,
+    F_signal_floating_point_error,
+    F_signal_kill,
+    F_signal_user_1,
+    F_signal_segmentation_fault,
+    F_signal_user_2,
+    F_signal_broken_pipe,
+    F_signal_alarm_clock,
+    F_signal_termination,
+    F_signal_stack_fault,
+    F_signal_child,
+    F_signal_continue,
+    F_signal_stop,
+    F_signal_keyboard_stop,
+    F_signal_tty_in,
+    F_signal_tty_out,
+    F_signal_urgent,
+    F_signal_cpu_limit,
+    F_signal_file_size_limit,
+    F_signal_virtual_alarm_clock,
+    F_signal_profile_alarm_clock,
+    F_signal_window_size_change,
+    F_signal_pollable_event,
+    F_signal_power_failure,
+    F_signal_bad_system_call,
+    F_signal_reserved_32,
+    F_signal_reserved_33,
+    F_signal_reserved_34,
+    F_signal_reserved_35,
+    F_signal_reserved_36,
+    F_signal_reserved_37,
+    F_signal_reserved_38,
+    F_signal_reserved_39,
+    F_signal_reserved_40,
+    F_signal_reserved_41,
+    F_signal_reserved_42,
+    F_signal_reserved_43,
+    F_signal_reserved_44,
+    F_signal_reserved_45,
+    F_signal_reserved_46,
+    F_signal_reserved_47,
+    F_signal_reserved_48,
+    F_signal_reserved_49,
+    F_signal_reserved_50,
+    F_signal_reserved_51,
+    F_signal_reserved_52,
+    F_signal_reserved_53,
+    F_signal_reserved_54,
+    F_signal_reserved_55,
+    F_signal_reserved_56,
+    F_signal_reserved_57,
+    F_signal_reserved_58,
+    F_signal_reserved_59,
+    F_signal_reserved_60,
+    F_signal_reserved_61,
+    F_signal_reserved_62,
+    F_signal_reserved_63,
+    F_signal_reserved_64,
   };
 
-  for (uint8_t i = 0; i < 35; ++i) {
+  for (uint8_t i = 0; i < 102; ++i) {
 
     {
       const f_status_t status = f_execute_status_to_status(status_executes[i]);

diff --git a/level_0/f_status/c/status.h b/level_0/f_status/c/status.h
index 9f4d7d84586d9444cedf4649e3d6c28eb77e959d..4813ebf5ddcafc61a9b124b4c4f8c8929831e1bc 100644 (file)
--- a/level_0/f_status/c/status.h
+++ b/level_0/f_status/c/status.h
@@ -227,6 +227,8 @@ extern "C" {
       F_bound_not,
       F_break,
       F_break_not,
+      F_call,
+      F_call_not,
       F_capability,
       F_capability_not,
       F_child,
@@ -364,6 +366,8 @@ extern "C" {
       F_next_not,
       F_nice,
       F_nice_not,
+      F_no,
+      F_no_not,
       F_object,
       F_object_not,
       F_once,
@@ -491,6 +495,8 @@ extern "C" {
       F_write,
       F_write_not,
       F_write_only,
+      F_yes,
+      F_yes_not,
     #endif // _di_f_status_basic_
 
     #ifndef _di_f_status_return_

diff --git a/level_0/f_status_string/c/status_string.c b/level_0/f_status_string/c/status_string.c
index 66fe668415ad6037cb00cdb4bd46990e9116f589..3d7098d9602c7e8183af19b2f75ab36239616b2f 100644 (file)
--- a/level_0/f_status_string/c/status_string.c
+++ b/level_0/f_status_string/c/status_string.c
@@ -101,6 +101,8 @@ extern "C" {
     const f_string_static_t f_status_bound_not_s = macro_f_string_static_t_initialize(F_status_bound_not_s, 0, F_status_bound_not_s_length);
     const f_string_static_t f_status_break_s = macro_f_string_static_t_initialize(F_status_break_s, 0, F_status_break_s_length);
     const f_string_static_t f_status_break_not_s = macro_f_string_static_t_initialize(F_status_break_not_s, 0, F_status_break_not_s_length);
+    const f_string_static_t f_status_call_s = macro_f_string_static_t_initialize(F_status_call_s, 0, F_status_call_s_length);
+    const f_string_static_t f_status_call_not_s = macro_f_string_static_t_initialize(F_status_call_not_s, 0, F_status_call_not_s_length);
     const f_string_static_t f_status_capability_s = macro_f_string_static_t_initialize(F_status_capability_s, 0, F_status_capability_s_length);
     const f_string_static_t f_status_capability_not_s = macro_f_string_static_t_initialize(F_status_capability_not_s, 0, F_status_capability_not_s_length);
     const f_string_static_t f_status_child_s = macro_f_string_static_t_initialize(F_status_child_s, 0, F_status_child_s_length);
@@ -238,6 +240,8 @@ extern "C" {
     const f_string_static_t f_status_next_not_s = macro_f_string_static_t_initialize(F_status_next_not_s, 0, F_status_next_not_s_length);
     const f_string_static_t f_status_nice_s = macro_f_string_static_t_initialize(F_status_nice_s, 0, F_status_nice_s_length);
     const f_string_static_t f_status_nice_not_s = macro_f_string_static_t_initialize(F_status_nice_not_s, 0, F_status_nice_not_s_length);
+    const f_string_static_t f_status_no_s = macro_f_string_static_t_initialize(F_status_no_s, 0, F_status_no_s_length);
+    const f_string_static_t f_status_no_not_s = macro_f_string_static_t_initialize(F_status_no_not_s, 0, F_status_no_not_s_length);
     const f_string_static_t f_status_object_s = macro_f_string_static_t_initialize(F_status_object_s, 0, F_status_object_s_length);
     const f_string_static_t f_status_object_not_s = macro_f_string_static_t_initialize(F_status_object_not_s, 0, F_status_object_not_s_length);
     const f_string_static_t f_status_once_s = macro_f_string_static_t_initialize(F_status_once_s, 0, F_status_once_s_length);
@@ -365,6 +369,8 @@ extern "C" {
     const f_string_static_t f_status_write_s = macro_f_string_static_t_initialize(F_status_write_s, 0, F_status_write_s_length);
     const f_string_static_t f_status_write_not_s = macro_f_string_static_t_initialize(F_status_write_not_s, 0, F_status_write_not_s_length);
     const f_string_static_t f_status_write_only_s = macro_f_string_static_t_initialize(F_status_write_only_s, 0, F_status_write_only_s_length);
+    const f_string_static_t f_status_yes_s = macro_f_string_static_t_initialize(F_status_yes_s, 0, F_status_yes_s_length);
+    const f_string_static_t f_status_yes_not_s = macro_f_string_static_t_initialize(F_status_yes_not_s, 0, F_status_yes_not_s_length);
   #endif // _di_f_status_basic_
 
   #ifndef _di_f_status_return_
@@ -1108,6 +1114,16 @@ extern "C" {
 
           break;
 
+        case F_call:
+          *name = f_status_call_s;
+
+          break;
+
+        case F_call_not:
+          *name = f_status_call_not_s;
+
+          break;
+
         case F_capability:
           *name = f_status_capability_s;
 
@@ -1783,6 +1799,16 @@ extern "C" {
 
           break;
 
+        case F_no:
+          *name = f_status_no_s;
+
+          break;
+
+        case F_no_not:
+          *name = f_status_no_not_s;
+
+          break;
+
         case F_object:
           *name = f_status_object_s;
 
@@ -2427,6 +2453,16 @@ extern "C" {
           *name = f_status_write_only_s;
 
           break;
+
+        case F_yes:
+          *name = f_status_yes_s;
+
+          break;
+
+        case F_yes_not:
+          *name = f_status_yes_not_s;
+
+          break;
       #endif // _di_f_status_basic_
 
       #ifndef _di_f_status_return_

diff --git a/level_0/f_status_string/c/status_string.h b/level_0/f_status_string/c/status_string.h
index d3a0ddf0c34d64e11c470fc79c058f0f0b05e624..bf649e7330a6e966202a499a24cb397b8d2921ce 100644 (file)
--- a/level_0/f_status_string/c/status_string.h
+++ b/level_0/f_status_string/c/status_string.h
@@ -99,7 +99,7 @@ extern "C" {
     #define F_status_signal_reserved_63_s          "F_signal_reserved_63"
     #define F_status_signal_reserved_64_s          "F_signal_reserved_64"
 
-    #define F_status_signal_hangup_s_length             15
+    #define F_status_signal_hangup_s_length               15
     #define F_status_signal_interrupt_s_length            18
     #define F_status_signal_quit_s_length                 13
     #define F_status_signal_illegal_s_length              16
@@ -254,6 +254,8 @@ extern "C" {
     #define F_status_bound_not_s         "F_bound_not"
     #define F_status_break_s             "F_break"
     #define F_status_break_not_s         "F_break_not"
+    #define F_status_call_s              "F_call"
+    #define F_status_call_not_s          "F_call_not"
     #define F_status_capability_s        "F_capability"
     #define F_status_capability_not_s    "F_capability_not"
     #define F_status_child_s             "F_child"
@@ -391,6 +393,8 @@ extern "C" {
     #define F_status_next_not_s          "F_next_not"
     #define F_status_nice_s              "F_nice"
     #define F_status_nice_not_s          "F_nice_not"
+    #define F_status_no_s                "F_no"
+    #define F_status_no_not_s            "F_no_not"
     #define F_status_object_s            "F_object"
     #define F_status_object_not_s        "F_object_not"
     #define F_status_once_s              "F_once"
@@ -518,6 +522,8 @@ extern "C" {
     #define F_status_write_s             "F_write"
     #define F_status_write_not_s         "F_write_not"
     #define F_status_write_only_s        "F_write_only"
+    #define F_status_yes_s               "F_yes"
+    #define F_status_yes_not_s           "F_yes_not"
 
     #define F_status_none_s_length              6
     #define F_status_abort_s_length             7
@@ -542,6 +548,8 @@ extern "C" {
     #define F_status_body_not_s_length          10
     #define F_status_bound_s_length             7
     #define F_status_bound_not_s_length         11
+    #define F_status_call_s_length              6
+    #define F_status_call_not_s_length          10
     #define F_status_capability_s_length        12
     #define F_status_capability_not_s_length    16
     #define F_status_child_s_length             7
@@ -679,6 +687,8 @@ extern "C" {
     #define F_status_next_not_s_length          10
     #define F_status_nice_s_length              6
     #define F_status_nice_not_s_length          10
+    #define F_status_no_s_length                4
+    #define F_status_no_not_s_length            8
     #define F_status_object_s_length            8
     #define F_status_object_not_s_length        12
     #define F_status_once_s_length              6
@@ -806,6 +816,8 @@ extern "C" {
     #define F_status_write_s_length             7
     #define F_status_write_not_s_length         11
     #define F_status_write_only_s_length        12
+    #define F_status_yes_s_length               5
+    #define F_status_yes_not_s_length           9
 
     extern const f_string_static_t f_status_none_s;
     extern const f_string_static_t f_status_abort_s;
@@ -830,6 +842,8 @@ extern "C" {
     extern const f_string_static_t f_status_bound_not_s;
     extern const f_string_static_t f_status_break_s;
     extern const f_string_static_t f_status_break_not_s;
+    extern const f_string_static_t f_status_call_s;
+    extern const f_string_static_t f_status_call_not_s;
     extern const f_string_static_t f_status_capability_s;
     extern const f_string_static_t f_status_capability_not_s;
     extern const f_string_static_t f_status_child_s;
@@ -969,6 +983,8 @@ extern "C" {
     extern const f_string_static_t f_status_next_not_s;
     extern const f_string_static_t f_status_nice_s;
     extern const f_string_static_t f_status_nice_not_s;
+    extern const f_string_static_t f_status_no_s;
+    extern const f_string_static_t f_status_no_not_s;
     extern const f_string_static_t f_status_object_s;
     extern const f_string_static_t f_status_object_not_s;
     extern const f_string_static_t f_status_once_s;
@@ -1096,6 +1112,8 @@ extern "C" {
     extern const f_string_static_t f_status_write_s;
     extern const f_string_static_t f_status_write_not_s;
     extern const f_string_static_t f_status_write_only_s;
+    extern const f_string_static_t f_status_yes_s;
+    extern const f_string_static_t f_status_yes_not_s;
   #endif // _di_f_status_basic_
 
   #ifndef _di_f_status_return_

diff --git a/level_0/f_status_string/tests/unit/c/test-status_string-to.c b/level_0/f_status_string/tests/unit/c/test-status_string-to.c
index 9026a10ac5924ebacfbc2b595da414ccba0c250b..b62b3aa5d963946fe47579594af91ce48de70747 100644 (file)
--- a/level_0/f_status_string/tests/unit/c/test-status_string-to.c
+++ b/level_0/f_status_string/tests/unit/c/test-status_string-to.c
@@ -117,6 +117,8 @@ void test__f_status_string_to__works(void **state) {
     F_bound_not,
     F_break,
     F_break_not,
+    F_call,
+    F_call_not,
     F_capability,
     F_capability_not,
     F_child,
@@ -254,6 +256,8 @@ void test__f_status_string_to__works(void **state) {
     F_next_not,
     F_nice,
     F_nice_not,
+    F_no,
+    F_no_not,
     F_object,
     F_object_not,
     F_once,
@@ -381,6 +385,8 @@ void test__f_status_string_to__works(void **state) {
     F_write,
     F_write_not,
     F_write_only,
+    F_yes,
+    F_yes_not,
     F_debug,
     F_debug_not,
     F_error,
@@ -701,6 +707,8 @@ void test__f_status_string_to__works(void **state) {
     f_status_bound_not_s,
     f_status_break_s,
     f_status_break_not_s,
+    f_status_call_s,
+    f_status_call_not_s,
     f_status_capability_s,
     f_status_capability_not_s,
     f_status_child_s,
@@ -838,6 +846,8 @@ void test__f_status_string_to__works(void **state) {
     f_status_next_not_s,
     f_status_nice_s,
     f_status_nice_not_s,
+    f_status_no_s,
+    f_status_no_not_s,
     f_status_object_s,
     f_status_object_not_s,
     f_status_once_s,
@@ -965,6 +975,8 @@ void test__f_status_string_to__works(void **state) {
     f_status_write_s,
     f_status_write_not_s,
     f_status_write_only_s,
+    f_status_yes_s,
+    f_status_yes_not_s,
     f_status_debug_s,
     f_status_debug_not_s,
     f_status_error_s,
@@ -1197,7 +1209,7 @@ void test__f_status_string_to__works(void **state) {
     f_status_status_code_last_s,
   };
 
-  for (uint16_t i = 0; i < 581; ++i) {
+  for (uint16_t i = 0; i < 587; ++i) {
 
     f_string_static_t result = f_string_static_t_initialize;
 

diff --git a/level_2/fll_status_string/c/status_string.c b/level_2/fll_status_string/c/status_string.c
index 8b7a1bcf4fa42343e81041fa0fd789e12c539468..981f5166e7b723c6d210691d07d1b32112a43869 100644 (file)
--- a/level_2/fll_status_string/c/status_string.c
+++ b/level_2/fll_status_string/c/status_string.c
@@ -564,6 +564,18 @@ extern "C" {
         return F_none;
       }
 
+      if (fl_string_dynamic_compare(name, f_status_call_s) == F_equal_to) {
+        *code = F_call;
+
+        return F_none;
+      }
+
+      if (fl_string_dynamic_compare(name, f_status_call_not_s) == F_equal_to) {
+        *code = F_call_not;
+
+        return F_none;
+      }
+
       if (fl_string_dynamic_compare(name, f_status_capability_s) == F_equal_to) {
         *code = F_capability;
 
@@ -1386,6 +1398,18 @@ extern "C" {
         return F_none;
       }
 
+      if (fl_string_dynamic_compare(name, f_status_no_s) == F_equal_to) {
+        *code = F_no;
+
+        return F_none;
+      }
+
+      if (fl_string_dynamic_compare(name, f_status_no_not_s) == F_equal_to) {
+        *code = F_no_not;
+
+        return F_none;
+      }
+
       if (fl_string_dynamic_compare(name, f_status_object_s) == F_equal_to) {
         *code = F_object;
 
@@ -2147,6 +2171,18 @@ extern "C" {
 
         return F_none;
       }
+
+      if (fl_string_dynamic_compare(name, f_status_yes_s) == F_equal_to) {
+        *code = F_yes;
+
+        return F_none;
+      }
+
+      if (fl_string_dynamic_compare(name, f_status_yes_not_s) == F_equal_to) {
+        *code = F_yes_not;
+
+        return F_none;
+      }
     #endif // _di_f_status_basic_
 
     #ifndef _di_f_status_return_

diff --git a/level_2/fll_status_string/tests/unit/c/test-status_string-from.c b/level_2/fll_status_string/tests/unit/c/test-status_string-from.c
index dae4d5fba23374d3728a8ba385b262ac8b3fee0a..585e37f90b1ccb147ce41f4ed0728778b175152a 100644 (file)
--- a/level_2/fll_status_string/tests/unit/c/test-status_string-from.c
+++ b/level_2/fll_status_string/tests/unit/c/test-status_string-from.c
@@ -133,6 +133,8 @@ void test__fll_status_string_from__works(void **state) {
     F_bound_not,
     F_break,
     F_break_not,
+    F_call,
+    F_call_not,
     F_capability,
     F_capability_not,
     F_child,
@@ -270,6 +272,8 @@ void test__fll_status_string_from__works(void **state) {
     F_next_not,
     F_nice,
     F_nice_not,
+    F_no,
+    F_no_not,
     F_object,
     F_object_not,
     F_once,
@@ -397,6 +401,8 @@ void test__fll_status_string_from__works(void **state) {
     F_write,
     F_write_not,
     F_write_only,
+    F_yes,
+    F_yes_not,
     F_debug,
     F_debug_not,
     F_error,
@@ -717,6 +723,8 @@ void test__fll_status_string_from__works(void **state) {
     f_status_bound_not_s,
     f_status_break_s,
     f_status_break_not_s,
+    f_status_call_s,
+    f_status_call_not_s,
     f_status_capability_s,
     f_status_capability_not_s,
     f_status_child_s,
@@ -854,6 +862,8 @@ void test__fll_status_string_from__works(void **state) {
     f_status_next_not_s,
     f_status_nice_s,
     f_status_nice_not_s,
+    f_status_no_s,
+    f_status_no_not_s,
     f_status_object_s,
     f_status_object_not_s,
     f_status_once_s,
@@ -981,6 +991,8 @@ void test__fll_status_string_from__works(void **state) {
     f_status_write_s,
     f_status_write_not_s,
     f_status_write_only_s,
+    f_status_yes_s,
+    f_status_yes_not_s,
     f_status_debug_s,
     f_status_debug_not_s,
     f_status_error_s,
@@ -1213,7 +1225,7 @@ void test__fll_status_string_from__works(void **state) {
     f_status_status_code_last_s,
   };
 
-  for (uint16_t i = 0; i < 581; ++i) {
+  for (uint16_t i = 0; i < 587; ++i) {
 
     f_status_t result = F_none;
 

diff --git a/level_3/controller/c/rule/private-rule_print.c b/level_3/controller/c/rule/private-rule_print.c
index c275c6dac5c66486706d972edb381d4751d2d914..a9287d0eef2368b3d412432b27dab7cdc74094bb 100644 (file)
--- a/level_3/controller/c/rule/private-rule_print.c
+++ b/level_3/controller/c/rule/private-rule_print.c
@@ -89,7 +89,7 @@ extern "C" {
       fl_print_format("%[%Q%]", print->to.stream, print->notable, name, print->notable);
 
       if (status == F_control_group || status == F_limit || status == F_processor || status == F_schedule) {
-        fl_print_format("%[' failed due to a failure to setup the '%]%[", print->to.stream, print->context, print->context, print->notable);
+        fl_print_format("%[' failed to setup the '%]%[", print->to.stream, print->context, print->context, print->notable);
 
         if (status == F_control_group) {
           f_print_dynamic_raw(controller_cgroup_s, print->to.stream);
@@ -161,7 +161,7 @@ extern "C" {
           fl_print_format("%[' max recursion reached.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
         }
         else if (code == F_execute_memory_not) {
-          fl_print_format("%[' out of memory.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+          fl_print_format("%[' is out of memory.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
         }
         else if (code == F_execute_name_not) {
           fl_print_format("%[' file name or path is too long.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
@@ -170,7 +170,7 @@ extern "C" {
           fl_print_format("%[' failed to setup niceness.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
         }
         else if (code == F_execute_parameter) {
-          fl_print_format("%[' invalid parameter.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+          fl_print_format("%[' failed due to an invalid parameter.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
         }
         else if (code == F_execute_pipe) {
           fl_print_format("%[' pipe failed.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
@@ -211,6 +211,108 @@ extern "C" {
         else if (code == F_execute_valid_not) {
           fl_print_format("%[' unknown ELF interpreter format.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
         }
+        else if (code == F_execute_invoke_not) {
+          fl_print_format("%[' cannot execute command.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_found_not) {
+          fl_print_format("%[' command not found.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_found_not) {
+          fl_print_format("%[' invalid argument to exit().%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_hangup) {
+          fl_print_format("%[' hang up signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_interrupt) {
+          fl_print_format("%[' interrupt signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_quit) {
+          fl_print_format("%[' quit signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_illegal) {
+          fl_print_format("%[' illegal signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_trap) {
+          fl_print_format("%[' trap signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_abort) {
+          fl_print_format("%[' abort signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_bus_error) {
+          fl_print_format("%[' bus error signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_floating_point_error) {
+          fl_print_format("%[' floating point error signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_kill) {
+          fl_print_format("%[' kill signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_user_1) {
+          fl_print_format("%[' user 1 signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_segmentation_fault) {
+          fl_print_format("%[' segmentation fault signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_user_2) {
+          fl_print_format("%[' user 2 signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_broken_pipe) {
+          fl_print_format("%[' broken pipe signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_alarm_clock) {
+          fl_print_format("%[' alarm clock signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_termination) {
+          fl_print_format("%[' terminate signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_stack_fault) {
+          fl_print_format("%[' stack fault signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_child) {
+          fl_print_format("%[' child signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_continue) {
+          fl_print_format("%[' continue signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_stop) {
+          fl_print_format("%[' stop signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_keyboard_stop) {
+          fl_print_format("%[' keyboard stop signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_tty_in) {
+          fl_print_format("%[' TTY in signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_tty_out) {
+          fl_print_format("%[' TTY out signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_urgent) {
+          fl_print_format("%[' urgent signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_cpu_limit) {
+          fl_print_format("%[' CPU limit signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_file_size_limit) {
+          fl_print_format("%[' file size signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_virtual_alarm_clock) {
+          fl_print_format("%[' virtual alarm clock signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_profile_alarm_clock) {
+          fl_print_format("%[' profile alarm clock signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_window_size_change) {
+          fl_print_format("%[' window size change signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_pollable_event) {
+          fl_print_format("%[' pollable signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_power_failure) {
+          fl_print_format("%[' power failure signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
+        else if (code == F_execute_signal_bad_system_call) {
+          fl_print_format("%[' bad system call signal received.%]%r", print->to.stream, print->context, print->context, f_string_eol_s);
+        }
         else {
           fl_print_format("%[' failed with the execute error code %]", print->to.stream, print->context, print->context);
           fl_print_format("%[%i%]", print->to.stream, print->notable, code, print->notable);