From: Kevin Day <Kevin@kevux.org>
Date: Sun, 9 Mar 2025 23:41:43 +0000 (-0500)
Subject: Update: The top-level directory recursion actions should have more fine-tuned control.
X-Git-Url: https://git.kevux.org/?a=commitdiff_plain;h=6d40ec7ec5e3238282ea5be39ef56d0e3c322122;p=fll

Update: The top-level directory recursion actions should have more fine-tuned control.

Provide `f_directory_recurse_do_flag_top_after_e` and `f_directory_recurse_do_flag_top_before_e` flags.
This requires increasing the size of the flags from `uint16_t` to `uint32_t`.

Be sure to pass the `path` rather than `recurse->path` at the top-level.

Make sure the `action` flag is set for the top-level action.

Add additional documentation comment regarding the `top` flag and the `recurse.path`.

Even though it is a listing of the path, still pass the `recurse.path` to the error handler at the top of `private_fl_directory_do_recurse()`.

Try to make the flag usage be ordered alphabetically.

Always perform the directory listing loading.
If this is not desired, then the `fl_directory_do()` function is likely not needed and simpler functions may be better choices.

Do not include the top-level flag for the directory listing for consistency with the recursion.
The recursion doesn't know the top-level, so do not set the top flag in this case.
The directory exists check is no longer needed and might have been redundant anyway.

Update the documentation comments.
I appear to have missed updating this in some of the previous commits that introduced operational changes.
Add additional documentation about checking the recurse parameter for NULL.

The private_fl_directory_do_recurse() already checks the error status.
Remove extra error checking after the `private_fl_directory_do_recurse()` call.
This extra error checking is redundant.
The return on error and return on done must still be performed.

After every private_inline_fl_directory_do_handle() call, the F_done is not being processed.
The check for `F_done` must be done for every single error handler call.
The only exception would be the last one in the top-level function because the function will always return after the last call anyway.

Update Featureless Make to work with the latest changes.
---

diff --git a/level_0/f_directory/c/directory/common.h b/level_0/f_directory/c/directory/common.h
index 74af237..d03b1a6 100644
--- a/level_0/f_directory/c/directory/common.h
+++ b/level_0/f_directory/c/directory/common.h
@@ -116,6 +116,8 @@ extern "C" {
  *   - dereference: Dereference symbolic links rather than operating on the link itself.
  *   - list:        Perform this action after directory listing is loaded.
  *   - top:         Operate on top-most directory, or for the callback parameter, designate that this is the top path.
+ *   - top_after:   Operate on top-most directory, after the top-level directory is processed or recursed.
+ *   - top_before:  Operate on top-most directory, before the top-level directory is processed or recursed.
  *
  *   For the actiona and handle callback parameter:
  *   - block:      File is a block.
@@ -139,17 +141,19 @@ extern "C" {
     f_directory_recurse_do_flag_dereference_e = 0x8,
     f_directory_recurse_do_flag_list_e        = 0x10,
     f_directory_recurse_do_flag_top_e         = 0x20,
+    f_directory_recurse_do_flag_top_after_e   = 0x40,
+    f_directory_recurse_do_flag_top_before_e  = 0x80,
 
     // For the action callback parameter.
-    f_directory_recurse_do_flag_block_e     = 0x40,
-    f_directory_recurse_do_flag_character_e = 0x80,
-    f_directory_recurse_do_flag_directory_e = 0x100,
-    f_directory_recurse_do_flag_fifo_e      = 0x200,
-    f_directory_recurse_do_flag_link_e      = 0x400,
-    f_directory_recurse_do_flag_path_e      = 0x800,
-    f_directory_recurse_do_flag_regular_e   = 0x1000,
-    f_directory_recurse_do_flag_socket_e    = 0x2000,
-    f_directory_recurse_do_flag_unknown_e   = 0x4000,
+    f_directory_recurse_do_flag_block_e     = 0x100,
+    f_directory_recurse_do_flag_character_e = 0x200,
+    f_directory_recurse_do_flag_directory_e = 0x400,
+    f_directory_recurse_do_flag_fifo_e      = 0x800,
+    f_directory_recurse_do_flag_link_e      = 0x1000,
+    f_directory_recurse_do_flag_path_e      = 0x2000,
+    f_directory_recurse_do_flag_regular_e   = 0x4000,
+    f_directory_recurse_do_flag_socket_e    = 0x8000,
+    f_directory_recurse_do_flag_unknown_e   = 0x10000,
   }; // enum
 #endif // _di_f_directory_recurse_do_flag_e_
 
diff --git a/level_0/f_directory/c/directory/recurse_do.h b/level_0/f_directory/c/directory/recurse_do.h
index 4132f4d..45d4d9d 100644
--- a/level_0/f_directory/c/directory/recurse_do.h
+++ b/level_0/f_directory/c/directory/recurse_do.h
@@ -61,12 +61,12 @@ extern "C" {
 #ifndef _di_f_directory_recurse_do_t_
   typedef struct f_directory_recurse_do_t_ f_directory_recurse_do_t;
 
-  typedef void (*f_directory_recurse_do_call_t) (f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint16_t flag);
+  typedef void (*f_directory_recurse_do_call_t) (f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint32_t flag);
 
   struct f_directory_recurse_do_t_ {
     f_number_unsigned_t depth;
     f_number_unsigned_t depth_max;
-    uint16_t flag;
+    uint32_t flag;
     f_mode_t mode;
 
     f_state_t state;
diff --git a/level_1/fl_directory/c/directory.c b/level_1/fl_directory/c/directory.c
index 10b182b..7b11271 100644
--- a/level_1/fl_directory/c/directory.c
+++ b/level_1/fl_directory/c/directory.c
@@ -67,14 +67,26 @@ extern "C" {
 
         private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e);
         if (F_status_is_error(recurse->state.status)) return;
+
+        if (recurse->state.status == F_done) {
+          recurse->state.status = F_okay;
+
+          return;
+        }
       }
     #endif // _di_level_1_parameter_checking_
 
     if (!path.used) {
       recurse->state.status = F_data_not;
 
-      private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e);
+      private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_top_e);
       if (F_status_is_error(recurse->state.status)) return;
+
+      if (recurse->state.status == F_done) {
+        recurse->state.status = F_okay;
+
+        return;
+      }
     }
 
     recurse->state.status = f_string_dynamic_append_nulless(path, &recurse->path);
@@ -96,17 +108,23 @@ extern "C" {
     }
 
     if (F_status_is_error(recurse->state.status)) {
-      private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e);
+      private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_top_e);
       if (F_status_is_error(recurse->state.status)) return;
+
+      if (recurse->state.status == F_done) {
+        recurse->state.status = F_okay;
+
+        return;
+      }
     }
 
-    if ((recurse->flag & f_directory_recurse_do_flag_top_e) && (recurse->flag & f_directory_recurse_do_flag_before_e)) {
+    if (recurse->flag & f_directory_recurse_do_flag_top_before_e) {
       recurse->state.status = F_okay;
 
-      recurse->action(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_before_e);
+      recurse->action(recurse, path, f_directory_recurse_do_flag_top_before_e);
 
       if (F_status_is_error(recurse->state.status)) {
-        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_before_e);
+        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_before_e);
         if (F_status_is_error(recurse->state.status)) return;
       }
 
@@ -121,57 +139,44 @@ extern "C" {
       recurse->depth = 1;
 
       private_fl_directory_do_recurse(recurse);
+      if (F_status_is_error(recurse->state.status)) return;
 
-      recurse->path.used = path.used;
-      recurse->depth = 0;
+      if (recurse->state.status == F_done) {
+        recurse->state.status = F_okay;
 
-      if (F_status_is_error(recurse->state.status)) {
-        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_before_e);
-        if (F_status_is_error(recurse->state.status)) return;
+        return;
       }
     }
     else {
-      recurse->state.status = f_directory_exists(path);
+      recurse->state.status = F_okay;
 
-      if (F_status_is_error_not(recurse->state.status) && recurse->state.status != F_true) {
-        if (recurse->state.status == F_false) {
-          recurse->state.status = F_status_set_error(F_directory_not);
-        }
-        else {
-          recurse->state.status = F_status_set_error(recurse->state.status);
-        }
-      }
+      recurse->listing.block.used = 0;
+      recurse->listing.character.used = 0;
+      recurse->listing.directory.used = 0;
+      recurse->listing.regular.used = 0;
+      recurse->listing.link.used = 0;
+      recurse->listing.fifo.used = 0;
+      recurse->listing.socket.used = 0;
+      recurse->listing.unknown.used = 0;
+
+      recurse->state.status = private_fl_directory_list(path, 0, 0, recurse->flag & f_directory_recurse_do_flag_dereference_e, &recurse->listing);
 
       if (F_status_is_error(recurse->state.status)) {
-        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e);
+        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e);
         if (F_status_is_error(recurse->state.status)) return;
       }
 
-      if (recurse->flag & f_directory_recurse_do_flag_list_e) {
+      if (recurse->state.status == F_done) {
         recurse->state.status = F_okay;
 
-        recurse->listing.block.used = 0;
-        recurse->listing.character.used = 0;
-        recurse->listing.directory.used = 0;
-        recurse->listing.regular.used = 0;
-        recurse->listing.link.used = 0;
-        recurse->listing.fifo.used = 0;
-        recurse->listing.socket.used = 0;
-        recurse->listing.unknown.used = 0;
-
-        recurse->state.status = private_fl_directory_list(recurse->path, 0, 0, recurse->flag & f_directory_recurse_do_flag_dereference_e, &recurse->listing);
-
-        if (F_status_is_error(recurse->state.status)) {
-          private_inline_fl_directory_do_handle(recurse, f_string_empty_s, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e);
-
-          if (F_status_is_error(recurse->state.status)) return;
-        }
+        return;
+      }
 
-        recurse->action(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_list_e);
+      if (recurse->flag & f_directory_recurse_do_flag_list_e) {
+        recurse->action(recurse, path, f_directory_recurse_do_flag_list_e);
 
         if (F_status_is_error(recurse->state.status)) {
-          private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_list_e);
-
+          private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_list_e);
           if (F_status_is_error(recurse->state.status)) return;
         }
 
@@ -184,10 +189,10 @@ extern "C" {
 
       recurse->state.status = F_okay;
 
-      recurse->action(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e);
+      recurse->action(recurse, path, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_e);
 
       if (F_status_is_error(recurse->state.status)) {
-        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e);
+        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_e);
         if (F_status_is_error(recurse->state.status)) return;
       }
 
@@ -198,15 +203,15 @@ extern "C" {
       }
     }
 
-    if ((recurse->flag & f_directory_recurse_do_flag_top_e) && (recurse->flag & f_directory_recurse_do_flag_after_e)) {
+    if (recurse->flag & f_directory_recurse_do_flag_top_after_e) {
       recurse->state.status = F_okay;
 
-      recurse->action(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_after_e);
-    }
+      recurse->action(recurse, path, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_top_after_e);
 
-    if (F_status_is_error(recurse->state.status)) {
-      private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_after_e);
-      if (F_status_is_error(recurse->state.status)) return;
+      if (F_status_is_error(recurse->state.status)) {
+        private_inline_fl_directory_do_handle(recurse, path, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_top_after_e);
+        if (F_status_is_error(recurse->state.status)) return;
+      }
     }
 
     recurse->state.status = F_okay;
diff --git a/level_1/fl_directory/c/directory.h b/level_1/fl_directory/c/directory.h
index da3e08e..ae9497c 100644
--- a/level_1/fl_directory/c/directory.h
+++ b/level_1/fl_directory/c/directory.h
@@ -90,49 +90,71 @@ extern "C" {
  *
  * This is intended to be used as an alternative to functions like fl_directory_list(), giving more control over the recursion process.
  *
- * When recursing the directory, except for the top directory, handle() with the before and after flags set is called after the recurse.path is updated.
- * For the top directory, handle() is called with the before and after flags set when the path is not updated.
+ * When recursing the directory, except for the top directory, handle() is called after the recurse.path is updated (with both the before and after flags set).
+ * For the top directory, handle() is called when the path is not updated (with the before and after flags set).
  *
  * This function is designed and intended to be used on directories.
- * If depth is 0, the operations callacks are still called but done at the top level.
+ * If depth is 0, the operations callacks are still called but are done at the top level.
+ * Be sure to use the recurse.path_top when depth is 0 or when f_directory_recurse_do_flag_top_e is set (the recurse.path may have been altered during the recursion).
  *
  * The action callback must set the error bit on recurse.state.status to ensure that the handle callbacks are called or not set the error bit to prevent this behavior.
  *
- * This exits on error if, after the handle callback is called, that the recurse.state.status still has the error bit set.
+ * This exits on error if, after the handle callback is called, when the recurse.state.status still has the error bit set.
  * This allows for the caller to inform this function to effectively ignore any errors.
  *
+ * This does not perform the operations on the top level directory when the max depth is set to 0.
+ * Use the before and after flags to perform top level directory actions in this situation.
+ * This is done so that the caller can better determine if top level directory actions must be performed before or after the recursed operations.
+ * Be sure to add the appropriate before and after flags when calling this function in order to make this possible.
+ *
+ * The recurse parameter may be NULL if parameter checking fails or may be NULL if no parameter checking is performed.
+ * The caller should consider checking if recurse is NULL.
+ *
  * General behavior flow:
  *   1. Check recurse.action existence (if not _di_level_1_parameter_checking_), calling recurse.handle with (f_directory_recurse_do_flag_top_e) on error.
- *   2. Check path.used, call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e) on error.
- *   3. Prepare recurse.path, call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e) on error.
- *   4. If recurse.flag has (f_directory_recurse_do_flag_top_e) or (f_directory_recurse_do_flag_before_e), call recurse.action with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_before_e).
- *     - Call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_before_e) on error.
+ *   2. Check path.used, call recurse.handle with (f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_top_e) on error.
+ *   3. Prepare recurse.path, call recurse.handle with (f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_top_e) on error.
+ *   4. If recurse.flag has (f_directory_recurse_do_flag_top_before_e), call recurse.action with (f_directory_recurse_do_flag_top_before_e).
+ *     - Call recurse.handle with (f_directory_recurse_do_flag_top_before_e) on error.
+ *
  *   5. If recurse.depth_max > 0, perform recursion.
  *     1. Load directory listing, call recurse.handle with (f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e) on error.
  *     2. If recurse.flag has (f_directory_recurse_do_flag_list_e), call recurse.action with (f_directory_recurse_do_flag_list_e).
  *       - Call recurse.handle with (f_directory_recurse_do_flag_list_e) on error.
+ *
  *     3. For each file type, except directory (optionally calling recurse->state.interrupt() at the top of each loop):
  *       1. Prepare list array, call recurse.handle with (f_directory_recurse_do_flag_directory_e) on error.
- *       2. Call recurse.action with (f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_*_e, where * represents type).
+ *       2. If recurse.flag has (f_directory_recurse_do_flag_before_e), call recurse.action with (f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_*_e, where * represents type).
  *         - Call recurse.handle with (f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_*_e, where * represents type) on error.
+ *
  *       3. Call recurse.action with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_*_e, where * represents type).
  *         - Call recurse.handle with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_*_e, where * represents type) on error.
- *       4. Call recurse.action with (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_*_e, where * represents type).
+ *
+ *       4. If recurse.flag has (f_directory_recurse_do_flag_after_e), call recurse.action with (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_*_e, where * represents type).
  *         - Call recurse.handle with (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_*_e, where * represents type) on error.
+ *
  *     4. For each directory (optionally calling recurse->state.interrupt() at the top of each loop):
  *       1. Prepare list array, call recurse.handle with (f_directory_recurse_do_flag_directory_e) on error.
- *       2. Call recurse.action with (f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_directory_e).
- *         - Call recurse.handle with (f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_directory_e) on error.
+ *       2. Call recurse.action with (f_directory_recurse_do_flag_action_e| f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_directory_e).
+ *         - Call recurse.handle with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_directory_e) on error.
+ *
  *       3. If depth max is not reached, perform recursion.
  *       4. If depth max is reached, call recurse.action with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e).
  *         - Call recurse.handle with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e) on error.
+ *
  *       5. Call recurse.action with (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_directory_e).
  *         - Call recurse.handle with (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_directory_e) on error.
+ *
  *   6. Else if recurse.depth_max == 0, process directory, call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e) on error.
- *     1. Call recurse.action with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e).
- *       - Call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_directory_e) on error.
- *     2. If recurse.flag has (f_directory_recurse_do_flag_top_e) or (f_directory_recurse_do_flag_after_e), call recurse.action with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_after_e).
- *       - Call recurse.handle with (f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_path_e | f_directory_recurse_do_flag_after_e) on error.
+ *     1. Load directory listing, call recurse.handle with (f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e) on error.
+ *     2. If recurse.flag has (f_directory_recurse_do_flag_list_e), call recurse.action with (f_directory_recurse_do_flag_list_e).
+ *       - Call recurse.handle with (f_directory_recurse_do_flag_list_e) on error.
+ *
+ *     3. Call recurse.action with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_e).
+ *       - Call recurse.handle with (f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_e) on error.
+ *
+ *   7. If recurse.flag has (f_directory_recurse_do_flag_top_after_e), call recurse.action with (f_directory_recurse_do_flag_top_after_e).
+ *     - Call recurse.handle with (f_directory_recurse_do_flag_top_after_e) on error.
  *
  * @param path
  *   The directory file path.
diff --git a/level_1/fl_directory/c/private-directory.c b/level_1/fl_directory/c/private-directory.c
index dee1885..f7fd412 100644
--- a/level_1/fl_directory/c/private-directory.c
+++ b/level_1/fl_directory/c/private-directory.c
@@ -30,7 +30,7 @@ extern "C" {
     recurse->state.status = private_fl_directory_list(recurse->path, 0, 0, recurse->flag & f_directory_recurse_do_flag_dereference_e, &recurse->listing);
 
     if (F_status_is_error(recurse->state.status)) {
-      private_inline_fl_directory_do_handle(recurse, f_string_empty_s, f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e);
+      private_inline_fl_directory_do_handle(recurse, recurse->path, f_directory_recurse_do_flag_list_e | f_directory_recurse_do_flag_path_e);
 
       // Only the directory is to be freed because all others are preserved between recursions.
       if (F_status_is_error(recurse->state.status)) {
@@ -63,13 +63,13 @@ extern "C" {
     uint8_t j = 0;
     const f_number_unsigned_t used_original = recurse->path.used;
 
-    static const uint16_t flag_actions[] = {
+    static const uint32_t flag_actions[] = {
       f_directory_recurse_do_flag_before_e,
       f_directory_recurse_do_flag_action_e,
       f_directory_recurse_do_flag_after_e,
     };
 
-    static const uint16_t flags[] = {
+    static const uint32_t flags[] = {
       f_directory_recurse_do_flag_block_e,
       f_directory_recurse_do_flag_character_e,
       f_directory_recurse_do_flag_regular_e,
@@ -136,12 +136,11 @@ extern "C" {
               }
 
               // This loop is not considered a loop for breaking and continuing.
-              if (recurse->state.status == F_break || recurse->state.status == F_done || recurse->state.status == F_continue) break;
+              if (recurse->state.status == F_break || recurse->state.status == F_done || recurse->state.status == F_continue || F_status_set_fine(recurse->state.status) == F_interrupt) break;
             }
           } // for
 
-          if (F_status_is_error(recurse->state.status)) break;
-          if (recurse->state.status == F_break || recurse->state.status == F_done) break;
+          if (F_status_is_error(recurse->state.status) || recurse->state.status == F_break || recurse->state.status == F_done) break;
           if (recurse->state.status == F_continue) continue;
         } // for
 
@@ -149,7 +148,7 @@ extern "C" {
       } // for
     }
 
-    if (recurse->state.status != F_done && F_status_is_error_not(recurse->state.status)) {
+    if (recurse->state.status != F_done && F_status_is_error_not(recurse->state.status) && F_status_set_fine(recurse->state.status) != F_interrupt) {
       for (i = 0; i < recurse->listing.directory.used; ++i) {
 
         if (recurse->state.interrupt) {
@@ -183,8 +182,7 @@ extern "C" {
         if (F_status_is_error(recurse->state.status)) {
           private_inline_fl_directory_do_handle(recurse, recurse->listing.directory.array[i], f_directory_recurse_do_flag_directory_e);
 
-          if (F_status_is_error(recurse->state.status)) break;
-          if (recurse->state.status == F_break || recurse->state.status == F_done) break;
+          if (F_status_is_error(recurse->state.status) || recurse->state.status == F_break || recurse->state.status == F_done) break;
           if (recurse->state.status == F_continue) continue;
         }
 
@@ -213,7 +211,7 @@ extern "C" {
             }
 
             // This loop is not considered a loop for breaking and continuing.
-            if (recurse->state.status == F_break || recurse->state.status == F_done || recurse->state.status == F_continue) break;
+            if (recurse->state.status == F_break || recurse->state.status == F_done || recurse->state.status == F_continue || F_status_set_fine(recurse->state.status) != F_interrupt) break;
           }
           else {
             if (recurse->flag & flag_actions[j]) {
@@ -226,8 +224,7 @@ extern "C" {
             }
           }
 
-          if (F_status_is_error(recurse->state.status)) break;
-          if (recurse->state.status == F_break || recurse->state.status == F_done) break;
+          if (F_status_is_error(recurse->state.status) || recurse->state.status == F_break || recurse->state.status == F_done || F_status_set_fine(recurse->state.status) != F_interrupt) break;
           if (recurse->state.status == F_continue) continue;
         } // for
 
diff --git a/level_3/fake/c/main/build.c b/level_3/fake/c/main/build.c
index c221d75..4ef3cce 100644
--- a/level_3/fake/c/main/build.c
+++ b/level_3/fake/c/main/build.c
@@ -181,7 +181,7 @@ extern "C" {
     main->cache_recurse_do.handle = &fake_do_copy_handle;
     main->cache_recurse_do.state.custom = (void *) &local;
     main->cache_recurse_do.state.code = fake_state_code_local_d;
-    main->cache_recurse_do.flag = f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_after_e;
+    main->cache_recurse_do.flag = f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_before_e | f_directory_recurse_do_flag_top_e | f_directory_recurse_do_flag_top_after_e | f_directory_recurse_do_flag_top_before_e;
     main->cache_recurse_do.mode = mode;
 
     fake_string_dynamic_reset(&main->cache_recurse_do.path);
@@ -241,7 +241,7 @@ extern "C" {
         fl_directory_do(main->cache_2, &main->cache_recurse_do);
         if (F_status_set_fine(main->setting.state.status) == F_interrupt) break;
 
-        // Always provide a finall error message to the copy message.
+        // Always provide a final error message to the copy message.
         if (F_status_is_error(main->setting.state.status)) {
 
           // The final message will be generic failure if a message is already printed, otherwise a more detailed message is printed.
diff --git a/level_3/fake/c/main/fake/do.c b/level_3/fake/c/main/fake/do.c
index c367a57..feb0312 100644
--- a/level_3/fake/c/main/fake/do.c
+++ b/level_3/fake/c/main/fake/do.c
@@ -5,7 +5,7 @@ extern "C" {
 #endif
 
 #ifndef _di_fake_do_copy_action_
-  void fake_do_copy_action(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint16_t flag) {
+  void fake_do_copy_action(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint32_t flag) {
 
     if (!recurse || !recurse->state.custom) return;
 
@@ -27,49 +27,49 @@ extern "C" {
 
     f_string_map_t * const map = (f_string_map_t *) local->custom_1;
 
-    if (flag & f_directory_recurse_do_flag_before_e) {
-      if (flag & f_directory_recurse_do_flag_top_e) {
-        if (recurse->state.code & fake_state_code_clone_d) {
-          fake_print_verbose_cloning(&local->main->program.message, *recurse->path_top, map->key);
+    if (flag & f_directory_recurse_do_flag_top_before_e) {
+      if (recurse->state.code & fake_state_code_clone_d) {
+        fake_print_verbose_cloning(&local->main->program.message, *recurse->path_top, map->key);
 
-          recurse->state.status = f_file_clone(*recurse->path_top, map->key, F_file_default_size_write_d, f_file_stat_flag_group_e | f_file_stat_flag_owner_e | (f_directory_recurse_do_flag_dereference_e ? 0 : f_file_stat_flag_reference_e));
-        }
-        else {
-          fake_print_verbose_copying(&local->main->program.message, *recurse->path_top, map->key);
+        recurse->state.status = f_file_clone(*recurse->path_top, map->key, F_file_default_size_write_d, f_file_stat_flag_group_e | f_file_stat_flag_owner_e | (f_directory_recurse_do_flag_dereference_e ? 0 : f_file_stat_flag_reference_e));
+      }
+      else {
+        fake_print_verbose_copying(&local->main->program.message, *recurse->path_top, map->key);
 
-          recurse->state.status = f_file_copy(*recurse->path_top, map->key, recurse->mode, F_file_default_size_write_d, f_directory_recurse_do_flag_dereference_e ? 0 : f_file_stat_flag_reference_e);
-        }
+        recurse->state.status = f_file_copy(*recurse->path_top, map->key, recurse->mode, F_file_default_size_write_d, f_directory_recurse_do_flag_dereference_e ? 0 : f_file_stat_flag_reference_e);
+      }
 
-        if (F_status_is_error(recurse->state.status)) {
-          local->main->setting.state.status = recurse->state.status;
+      if (F_status_is_error(recurse->state.status)) {
+        local->main->setting.state.status = recurse->state.status;
 
-          fake_print_error_file(&local->main->program.error, (recurse->state.code & fake_state_code_clone_d) ? macro_fake_f(f_file_clone) : macro_fake_f(f_file_copy), *recurse->path_top, (recurse->state.code & fake_state_code_clone_d) ? f_file_operation_clone_s : f_file_operation_copy_s, fll_error_file_type_directory_e);
+        fake_print_error_file(&local->main->program.error, (recurse->state.code & fake_state_code_clone_d) ? macro_fake_f(f_file_clone) : macro_fake_f(f_file_copy), *recurse->path_top, (recurse->state.code & fake_state_code_clone_d) ? f_file_operation_clone_s : f_file_operation_copy_s, fll_error_file_type_directory_e);
 
-          // Save the error status for when the error message is printed.
-          *((f_status_t *) local->custom_2) = recurse->state.status;
-        }
-        else {
-          fake_string_dynamic_reset(&recurse->path_cache);
+        // Save the error status for when the error message is printed.
+        *((f_status_t *) local->custom_2) = recurse->state.status;
+      }
+      else {
+        fake_string_dynamic_reset(&recurse->path_cache);
 
-          // Pre-populate the destination into the path cache.
-          recurse->state.status = f_string_dynamic_append_nulless(map->key, &recurse->path_cache);
+        // Pre-populate the destination into the path cache.
+        recurse->state.status = f_string_dynamic_append_nulless(map->key, &recurse->path_cache);
 
-          if (F_status_is_error_not(recurse->state.status)) {
-            recurse->state.status = F_okay;
+        if (F_status_is_error_not(recurse->state.status)) {
+          recurse->state.status = F_okay;
 
-            // Do not allow trailing path separators in the string's length calculation, except root directory '/'.
-            for (; recurse->path_cache.used; --recurse->path_cache.used) {
-              if (recurse->path_cache.string[recurse->path_cache.used - 1] != f_path_separator_s.string[0]) break;
-            } // for
+          // Do not allow trailing path separators in the string's length calculation, except root directory '/'.
+          for (; recurse->path_cache.used; --recurse->path_cache.used) {
+            if (recurse->path_cache.string[recurse->path_cache.used - 1] != f_path_separator_s.string[0]) break;
+          } // for
 
-            recurse->path_cache.string[recurse->path_cache.used] = 0;
-          }
+          recurse->path_cache.string[recurse->path_cache.used] = 0;
         }
-
-        return;
       }
 
-      if (flag & f_directory_recurse_do_flag_directory_e) {
+      return;
+    }
+
+    if (flag & f_directory_recurse_do_flag_before_e) {
+      if ((flag & f_directory_recurse_do_flag_directory_e) && (flag & f_directory_recurse_do_flag_action_e)) {
 
         // Push the directory name on the path stack (the destination path is expected to be pre-populated).
         recurse->state.status = f_memory_array_increase_by(f_path_separator_s.used + name.used + 1, sizeof(f_char_t), (void **) &recurse->path_cache.string, &recurse->path_cache.used, &recurse->path_cache.size);
@@ -111,8 +111,8 @@ extern "C" {
       return;
     }
 
-    if (flag & f_directory_recurse_do_flag_after_e) {
-      if (flag & f_directory_recurse_do_flag_directory_e) {
+    if (flag & (f_directory_recurse_do_flag_after_e | f_directory_recurse_do_flag_top_after_e)) {
+      if ((flag & f_directory_recurse_do_flag_directory_e) && (flag & f_directory_recurse_do_flag_action_e)) {
 
         // Pop the current path off of the path stack.
         if (F_status_is_error_not(recurse->state.status)) {
@@ -170,7 +170,7 @@ extern "C" {
 #endif // _di_fake_do_copy_action_
 
 #ifndef _di_fake_do_copy_handle_
-  void fake_do_copy_handle(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint16_t flag) {
+  void fake_do_copy_handle(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint32_t flag) {
 
     if (!recurse || !recurse->state.custom || F_status_set_fine(recurse->state.status) == F_interrupt) return;
 
diff --git a/level_3/fake/c/main/fake/do.h b/level_3/fake/c/main/fake/do.h
index 11ea040..2ee1806 100644
--- a/level_3/fake/c/main/fake/do.h
+++ b/level_3/fake/c/main/fake/do.h
@@ -54,7 +54,7 @@ extern "C" {
  * @see fake_build_copy()
  */
 #ifndef _di_fake_do_copy_action_
-  extern void fake_do_copy_action(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint16_t flag);
+  extern void fake_do_copy_action(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint32_t flag);
 #endif // _di_fake_do_copy_action_
 
 /**
@@ -81,7 +81,7 @@ extern "C" {
  *   The flags representing the action.
  */
 #ifndef _di_fake_do_copy_handle_
-  extern void fake_do_copy_handle(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint16_t flag);
+  extern void fake_do_copy_handle(f_directory_recurse_do_t * const recurse, const f_string_static_t name, const uint32_t flag);
 #endif // _di_fake_do_copy_handle_
 
 #ifdef __cplusplus