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.
* - 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.
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_
#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;
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);
}
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;
}
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;
}
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;
}
}
}
- 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;
*
* 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.
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)) {
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,
}
// 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
} // 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) {
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;
}
}
// 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]) {
}
}
- 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
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);
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.
#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;
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);
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)) {
#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;
* @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_
/**
* 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
projects / fll / commitdiff