Update: pipe and fifo, replace f_directory_mode with f_mode, f_file_copy()

Stick to only using fifo terminology in file types.

Replace f_directory_mode with f_mode, a global type to be shared between f_file, f_directory, and anything else.

Update f_file_copy() to use f_mode instead of mode_t.
This allows the caller to just send the mode.
The copy function already stats the file and processes it per file type, so it can make the decision on which mode to use.
This alleviates the need for the caller to also perform a file type stat check.

diff --git a/level_0/f_directory/c/directory_type.h b/level_0/f_directory/c/directory_type.h
index 86884e834e65398ee4265269d030fdea148389a9..458d8525569aab1e0ca6fafcd0aafbf3605ffe71 100644 (file)
--- a/level_0/f_directory/c/directory_type.h
+++ b/level_0/f_directory/c/directory_type.h
@@ -32,7 +32,7 @@ extern "C" {
     f_string_dynamics directory; // S_IFDIR
     f_string_dynamics regular;   // S_IFREG
     f_string_dynamics link;      // S_IFLNK
-    f_string_dynamics pipe;      // S_IFIFO
+    f_string_dynamics fifo;      // S_IFIFO
     f_string_dynamics socket;    // S_IFSOCK
     f_string_dynamics unknown;
   } f_directory_listing;
@@ -54,7 +54,7 @@ extern "C" {
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.directory) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.regular) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.link) \
-    if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.pipe) \
+    if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.fifo) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.socket) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.unknown)
 
@@ -64,7 +64,7 @@ extern "C" {
     if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.directory) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.regular) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.link) \
-    if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.pipe) \
+    if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.fifo) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_destroy(status, listing.socket) \
     if (!F_status_is_error(status)) f_macro_string_dynamics_delete(status, listing.unknown)
 
@@ -74,7 +74,7 @@ extern "C" {
     f_macro_string_dynamics_delete_simple(listing.directory) \
     f_macro_string_dynamics_delete_simple(listing.regular) \
     f_macro_string_dynamics_delete_simple(listing.link) \
-    f_macro_string_dynamics_delete_simple(listing.pipe) \
+    f_macro_string_dynamics_delete_simple(listing.fifo) \
     f_macro_string_dynamics_delete_simple(listing.socket) \
     f_macro_string_dynamics_delete_simple(listing.unknown)
 
@@ -84,79 +84,12 @@ extern "C" {
     f_macro_string_dynamics_destroy_simple(listing.directory) \
     f_macro_string_dynamics_destroy_simple(listing.regular) \
     f_macro_string_dynamics_destroy_simple(listing.link) \
-    f_macro_string_dynamics_destroy_simple(listing.pipe) \
+    f_macro_string_dynamics_destroy_simple(listing.fifo) \
     f_macro_string_dynamics_destroy_simple(listing.socket) \
     f_macro_string_dynamics_destroy_simple(listing.unknown)
 #endif // _di_f_directory_listing_
 
 /**
- * A structure representing a set of modes intended to be used by directory operations.
- *
- * A small set of macros are provider to help simplify assigning modes.
- *
- * The pipe (S_IFIFO) is intentionally not supported.
- */
-#ifndef _di_f_directory_mode_
-  typedef struct {
-    mode_t block;     // S_IFBLK
-    mode_t character; // S_IFCHR
-    mode_t directory; // S_IFDIR
-    mode_t regular;   // S_IFREG
-    mode_t link;      // S_IFLNK
-    mode_t socket;    // S_IFSOCK
-    mode_t unknown;
-  } f_directory_mode;
-
-  #define f_directory_mode_initialize { \
-    0, \
-    0, \
-    0, \
-    0, \
-    0, \
-    0, \
-    0, \
-  }
-
-  #define f_macro_directory_mode_set_default(modes) \
-    modes.block = f_file_mode_all_rw; \
-    modes.character = f_file_mode_all_rw; \
-    modes.directory = f_file_mode_all_rwx; \
-    modes.regular = f_file_mode_all_rw; \
-    modes.link = f_file_mode_all_rw; \
-    modes.socket = f_file_mode_all_rw; \
-    modes.unknown = f_file_mode_all_rw;
-
-  #define f_macro_directory_mode_set_default_umask(modes, mask) \
-    modes.block = f_file_mode_all_rw & ~mask; \
-    modes.character = f_file_mode_all_rw & ~mask; \
-    modes.directory = f_file_mode_all_rwx & ~mask; \
-    modes.regular = f_file_mode_all_rw & ~mask; \
-    modes.link = f_file_mode_all_rw & ~mask; \
-    modes.socket = f_file_mode_all_rw & ~mask; \
-    modes.unknown = f_file_mode_all_rw & ~mask;
-
-  #define f_macro_directory_mode_set_all(modes, mode) \
-    modes.block = mode; \
-    modes.character = mode; \
-    modes.directory = mode; \
-    modes.regular = mode; \
-    modes.link = mode; \
-    modes.socket = mode; \
-    modes.unknown = mode;
-
-  #define f_macro_directory_mode_set_common(modes, mode_directory, mode_file, mode_link) \
-    modes.directory = mode_directory; \
-    modes.regular = mode_file; \
-    modes.link = mode_link;
-
-  #define f_macro_directory_mode_set_uncommon(modes, mode_block, mode_character, mode_socket, mode_unknown) \
-    modes.block = mode_block; \
-    modes.character = mode_character; \
-    modes.socket = mode_socket; \
-    modes.unknown = mode_unknown;
-#endif // _di_f_directory_mode_
-
-/**
  * An association of a path and a status code.
  *
  * The allocation macros apply to the path.

diff --git a/level_0/f_file/c/file.c b/level_0/f_file/c/file.c
index dfb1678a2dd38d563264cd887e7976f297340e91..b4a97aef3a44d88adda657db61abd5fb1db2bc17 100644 (file)
--- a/level_0/f_file/c/file.c
+++ b/level_0/f_file/c/file.c
@@ -119,31 +119,29 @@ extern "C" {
 #endif // _di_f_file_close_
 
 #ifndef _di_f_file_copy_
-  f_return_status f_file_copy(const f_string source, const f_string destination, const mode_t mode, const f_number_unsigned size_block, const bool exclusive) {
+  f_return_status f_file_copy(const f_string source, const f_string destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive) {
     f_status status = F_none;
     struct stat source_stat;
 
-    // remove the file type from the mode.
-    const mode_t mode_access = (~f_file_type_mask) & mode;
-
     memset(&source_stat, 0, sizeof(struct stat));
 
     status = private_f_file_stat(source, F_false, &source_stat);
     if (F_status_is_error(status)) return status;
 
     if (f_macro_file_type_is_regular(source_stat.st_mode)) {
-      status = private_f_file_create(destination, mode_access, exclusive);
+
+      status = private_f_file_create(destination, (~f_file_type_mask) & mode.regular, exclusive);
       if (F_status_is_error(status)) return status;
 
       if (!exclusive) {
-        status = private_f_file_change_mode(destination, mode_access);
+        status = private_f_file_change_mode(destination, (~f_file_type_mask) & mode.regular);
         if (F_status_is_error(status)) return status;
       }
 
       return private_f_file_copy_content(source, destination, size_block == 0 ? f_file_default_read_size : size_block);
     }
     else if (f_macro_file_type_is_directory(source_stat.st_mode)) {
-      status = private_f_file_create_directory(destination, mode_access);
+      status = private_f_file_create_directory(destination, (~f_file_type_mask) & mode.directory);
 
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) != F_file_found || exclusive) {
@@ -151,7 +149,7 @@ extern "C" {
         }
       }
 
-      status = private_f_file_change_mode(destination, mode_access);
+      status = private_f_file_change_mode(destination, (~f_file_type_mask) & mode.directory);
       if (F_status_is_error(status)) return status;
 
       return F_none;
@@ -178,7 +176,7 @@ extern "C" {
       return F_none;
     }
     else if (f_macro_file_type_is_fifo(source_stat.st_mode)) {
-      status = private_f_file_create_fifo(destination, mode_access);
+      status = private_f_file_create_fifo(destination, (~f_file_type_mask) & mode.fifo);
 
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) != F_file_found || exclusive) {
@@ -186,13 +184,13 @@ extern "C" {
         }
       }
 
-      status = private_f_file_change_mode(destination, mode_access);
+      status = private_f_file_change_mode(destination, (~f_file_type_mask) & mode.fifo);
       if (F_status_is_error(status)) return status;
 
       return F_none;
     }
     else if (f_macro_file_type_is_socket(source_stat.st_mode)) {
-      status = private_f_file_create_node(destination, f_macro_file_type_get(source_stat.st_mode) | mode_access, source_stat.st_rdev);
+      status = private_f_file_create_node(destination, f_macro_file_type_get(source_stat.st_mode) | (~f_file_type_mask) & mode.socket, source_stat.st_rdev);
 
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) != F_file_found || exclusive) {
@@ -200,13 +198,13 @@ extern "C" {
         }
       }
 
-      status = private_f_file_change_mode(destination, mode_access);
+      status = private_f_file_change_mode(destination, (~f_file_type_mask) & mode.socket);
       if (F_status_is_error(status)) return status;
 
       return F_none;
     }
     else if (f_macro_file_type_is_block(source_stat.st_mode) || f_macro_file_type_is_character(source_stat.st_mode)) {
-      status = private_f_file_create_node(destination, f_macro_file_type_get(source_stat.st_mode) | mode_access, source_stat.st_rdev);
+      status = private_f_file_create_node(destination, f_macro_file_type_get(source_stat.st_mode) | (~f_file_type_mask) & mode.block, source_stat.st_rdev);
 
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) != F_file_found || exclusive) {
@@ -214,7 +212,7 @@ extern "C" {
         }
       }
 
-      status = private_f_file_change_mode(destination, mode_access);
+      status = private_f_file_change_mode(destination, (~f_file_type_mask) & mode.block);
       if (F_status_is_error(status)) return status;
 
       return F_none;

diff --git a/level_0/f_file/c/file.h b/level_0/f_file/c/file.h
index b18c04a09119687ce5e77cbf6c18d90d3e5e0f4a..bf15f36c2db304d20654b1551309ca11a8678895 100644 (file)
--- a/level_0/f_file/c/file.h
+++ b/level_0/f_file/c/file.h
@@ -66,8 +66,6 @@ extern "C" {
 
 /**
  * Provide file type macros.
- *
- * Note: f_file_type_pipe and f_file_type_fifo are the same.
  */
 #ifndef _di_f_file_type_
   #define f_file_type_mask S_IFMT
@@ -77,7 +75,6 @@ extern "C" {
   #define f_file_type_directory S_IFDIR
   #define f_file_type_fifo      S_IFIFO
   #define f_file_type_link      S_IFLNK
-  #define f_file_type_pipe      S_IFIFO
   #define f_file_type_regular   S_IFREG
   #define f_file_type_socket    S_IFSOCK
 
@@ -88,7 +85,6 @@ extern "C" {
   #define f_macro_file_type_is_directory(mode) f_macro_file_type_get(mode) == f_file_type_directory
   #define f_macro_file_type_is_fifo(mode)      f_macro_file_type_get(mode) == f_file_type_fifo
   #define f_macro_file_type_is_link(mode)      f_macro_file_type_get(mode) == f_file_type_link
-  #define f_macro_file_type_is_pipe(mode)      f_macro_file_type_get(mode) == f_file_type_pipe
   #define f_macro_file_type_is_regular(mode)   f_macro_file_type_get(mode) == f_file_type_regular
   #define f_macro_file_type_is_socket(mode)    f_macro_file_type_get(mode) == f_file_type_socket
 #endif // _di_f_file_type_
@@ -540,7 +536,7 @@ extern "C" {
  * @param destination
  *   The path to copy to.
  * @param mode
- *   The file mode assigned to the destination file.
+ *   The file mode assigned to the destination file, based on the file type.
  * @param size_block
  *   The default number of chunks to read at a time with each chunk being 1-byte.
  *   Set to 0 to use default block read size.
@@ -572,7 +568,7 @@ extern "C" {
  *   F_file_write (with error bit) on file write error.
  */
 #ifndef _di_f_file_copy_
-  extern f_return_status f_file_copy(const f_string source, const f_string destination, const mode_t mode, const f_number_unsigned size_block, const bool exclusive);
+  extern f_return_status f_file_copy(const f_string source, const f_string destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive);
 #endif // _di_f_file_copy_
 
 /**

diff --git a/level_0/f_type/c/type.h b/level_0/f_type/c/type.h
index e056c9a4940a3663d7cf719115af77777cae12b9..782b99163cbc0b65c340c1ba0c4881058cd0f308 100644 (file)
--- a/level_0/f_type/c/type.h
+++ b/level_0/f_type/c/type.h
@@ -13,6 +13,7 @@
 // libc includes
 #include <stdbool.h>
 #include <stdint.h>
+#include <sys/stat.h>
 #include <unistd.h>
 
 #ifdef __cplusplus
@@ -214,6 +215,76 @@ extern "C" {
   #define f_gcc_attribute_visibility_protected __attribute__((visibility("protected")))
 #endif // _di_f_gcc_specific_
 
+
+/**
+ * A structure representing a set of modes intended to be used by file or directory operations.
+ */
+#ifndef _di_f_mode_
+  typedef struct {
+    mode_t block;     // S_IFBLK
+    mode_t character; // S_IFCHR
+    mode_t directory; // S_IFDIR
+    mode_t fifo;      // S_IFIFO
+    mode_t regular;   // S_IFREG
+    mode_t link;      // S_IFLNK
+    mode_t socket;    // S_IFSOCK
+    mode_t unknown;
+  } f_mode;
+
+  #define f_mode_initialize { \
+    0, \
+    0, \
+    0, \
+    0, \
+    0, \
+    0, \
+    0, \
+    0, \
+  }
+
+  #define f_macro_mode_set_default(mode) \
+    mode.block = f_file_mode_all_rw; \
+    mode.character = f_file_mode_all_rw; \
+    mode.directory = f_file_mode_all_rwx; \
+    mode.fifo = f_file_mode_all_rw; \
+    mode.regular = f_file_mode_all_rw; \
+    mode.link = f_file_mode_all_rw; \
+    mode.socket = f_file_mode_all_rw; \
+    mode.unknown = f_file_mode_all_rw;
+
+  #define f_macro_mode_set_default_umask(mode, mask) \
+    mode.block = f_file_mode_all_rw & ~mask; \
+    mode.character = f_file_mode_all_rw & ~mask; \
+    mode.directory = f_file_mode_all_rwx & ~mask; \
+    mode.fifo = f_file_mode_all_rw & ~mask; \
+    mode.regular = f_file_mode_all_rw & ~mask; \
+    mode.link = f_file_mode_all_rw & ~mask; \
+    mode.socket = f_file_mode_all_rw & ~mask; \
+    mode.unknown = f_file_mode_all_rw & ~mask;
+
+  #define f_macro_mode_set_all(mode, value) \
+    mode.block = value; \
+    mode.character = value; \
+    mode.directory = value; \
+    mode.fifo = value; \
+    mode.regular = value; \
+    mode.link = value; \
+    mode.socket = value; \
+    mode.unknown = value;
+
+  #define f_macro_mode_set_common(mode, value_directory, value_file, value_link) \
+    mode.directory = value_directory; \
+    mode.regular = value_file; \
+    mode.link = value_link;
+
+  #define f_macro_mode_set_uncommon(mode, value_block, value_character, value_fifo, value_socket, value_unknown) \
+    mode.block = value_block; \
+    mode.character = value_character; \
+    mode.fifo = value_fifo; \
+    mode.socket = value_socket; \
+    mode.unknown = value_unknown;
+#endif // _di_f_directory_mode_
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

diff --git a/level_1/fl_directory/c/directory.c b/level_1/fl_directory/c/directory.c
index b7379240c661a97b3a6c3f6c9641f8694a975977..f651127664258258ccba7ad25d18caeab0add270 100644 (file)
--- a/level_1/fl_directory/c/directory.c
+++ b/level_1/fl_directory/c/directory.c
@@ -6,7 +6,7 @@ extern "C" {
 #endif
 
 #ifndef _di_fl_directory_clone_
-  f_return_status fl_directory_clone(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status fl_directory_clone(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = f_directory_exists(source);
 
     if (F_status_is_error(status)) return status;
@@ -40,6 +40,10 @@ extern "C" {
       if (F_status_is_error(status)) return status;
     }
 
+    if (verbose) {
+      fprintf(verbose, "Cloned '%s' to '%s'.%c", source, destination, f_string_eol);
+    }
+
     f_string_static static_source = { source, source_length, source_length };
     f_string_static static_destination = { destination, destination_length, destination_length };
 
@@ -62,12 +66,12 @@ extern "C" {
       } // for
     }
 
-    return private_fl_directory_clone(static_source, static_destination, role, size_block, exclusive, failures);
+    return private_fl_directory_clone(static_source, static_destination, role, size_block, exclusive, verbose, failures);
   }
 #endif // _di_fl_directory_clone_
 
 #ifndef _di_fl_directory_clone_content_
-  f_return_status fl_directory_clone_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status fl_directory_clone_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = f_directory_exists(source);
 
     if (F_status_is_error(status)) return status;
@@ -99,12 +103,12 @@ extern "C" {
       } // for
     }
 
-    return private_fl_directory_clone(static_source, static_destination, role, size_block, exclusive, failures);
+    return private_fl_directory_clone(static_source, static_destination, role, size_block, exclusive, verbose, failures);
   }
 #endif // _di_fl_directory_clone_content_
 
 #ifndef _di_fl_directory_copy_
-  f_return_status fl_directory_copy(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status fl_directory_copy(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = f_directory_exists(source);
 
     if (F_status_is_error(status)) return status;
@@ -126,6 +130,10 @@ extern "C" {
       if (F_status_is_error(status)) return status;
     }
 
+    if (verbose) {
+      fprintf(verbose, "Copied '%s' to '%s'.%c", source, destination, f_string_eol);
+    }
+
     f_string_static static_source = { source, source_length, source_length };
     f_string_static static_destination = { destination, destination_length, destination_length };
 
@@ -148,12 +156,12 @@ extern "C" {
       } // for
     }
 
-    return private_fl_directory_copy(static_source, static_destination, mode, size_block, exclusive, failures);
+    return private_fl_directory_copy(static_source, static_destination, mode, size_block, exclusive, verbose, failures);
   }
 #endif // _di_fl_directory_copy_
 
 #ifndef _di_fl_directory_copy_content_
-  f_return_status fl_directory_copy_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status fl_directory_copy_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = f_directory_exists(source);
 
     if (F_status_is_error(status)) return status;
@@ -185,7 +193,7 @@ extern "C" {
       } // for
     }
 
-    return private_fl_directory_copy(static_source, static_destination, mode, size_block, exclusive, failures);
+    return private_fl_directory_copy(static_source, static_destination, mode, size_block, exclusive, verbose, failures);
   }
 #endif // _di_fl_directory_copy_content_
 

diff --git a/level_1/fl_directory/c/directory.h b/level_1/fl_directory/c/directory.h
index d848c6cf73672bfe72b5bb8f9c0d81a5109c36b9..fdb489d0681ccaece863bbbcb3cd0cd78787bed8 100644 (file)
--- a/level_1/fl_directory/c/directory.h
+++ b/level_1/fl_directory/c/directory.h
@@ -74,6 +74,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for clone failures.
  *   If 0, then this and statuses is ignored.
@@ -105,7 +108,7 @@ extern "C" {
  * @see f_file_clone()
  */
 #ifndef _di_fl_directory_clone_
-  extern f_return_status fl_directory_clone(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures);
+  extern f_return_status fl_directory_clone(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures);
 #endif // _di_fl_directory_clone_
 
 /**
@@ -140,6 +143,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for clone failures.
  *   If 0, then this and statuses is ignored.
@@ -171,7 +177,7 @@ extern "C" {
  * @see f_file_clone()
  */
 #ifndef _di_fl_directory_clone_content_
-  extern f_return_status fl_directory_clone_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures);
+  extern f_return_status fl_directory_clone_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures);
 #endif // _di_fl_directory_clone_content_
 
 /**
@@ -202,9 +208,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
- * @param exclusive
- *   If TRUE, will fail when file already exists.
- *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for copy failures.
  *   If 0, then this and statuses is ignored.
@@ -236,7 +242,7 @@ extern "C" {
  * @see f_file_copy()
  */
 #ifndef _di_fl_directory_copy_
-  extern f_return_status fl_directory_copy(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures);
+  extern f_return_status fl_directory_copy(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures);
 #endif // _di_fl_directory_copy_
 
 /**
@@ -269,6 +275,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for copy failures.
  *   If 0, then this and statuses is ignored.
@@ -300,7 +309,7 @@ extern "C" {
  * @see f_file_copy()
  */
 #ifndef _di_fl_directory_copy_content_
-  extern f_return_status fl_directory_copy_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures);
+  extern f_return_status fl_directory_copy_content(const f_string source, const f_string destination, const f_string_length source_length, const f_string_length destination_length, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures);
 #endif // _di_fl_directory_copy_content_
 
 /**

diff --git a/level_1/fl_directory/c/private-directory.c b/level_1/fl_directory/c/private-directory.c
index b043b131f7f2b6f1f54662351e923674208f7480..71580215aaeb40fee0d0a938863dc9e742a0d309 100644 (file)
--- a/level_1/fl_directory/c/private-directory.c
+++ b/level_1/fl_directory/c/private-directory.c
@@ -6,7 +6,7 @@ extern "C" {
 #endif
 
 #if !defined(_di_fl_directory_clone_)
-  f_return_status private_fl_directory_clone(const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status private_fl_directory_clone(const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = F_none;
     f_directory_listing listing = f_directory_listing_initialize;
 
@@ -24,37 +24,37 @@ extern "C" {
     f_string_length failures_used = failures ? failures->used : 0;
 
     for (; F_status_is_fine(status) && i < listing.block.used; i++) {
-      status = private_fl_directory_clone_file(listing.block.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.block.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.block);
 
     for (i = 0; F_status_is_fine(status) && i < listing.character.used; i++) {
-      status = private_fl_directory_clone_file(listing.character.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.character.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.character);
 
     for (i = 0; F_status_is_fine(status) && i < listing.regular.used; i++) {
-      status = private_fl_directory_clone_file(listing.regular.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.regular.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.regular);
 
     for (i = 0; F_status_is_fine(status) && i < listing.link.used; i++) {
-      status = private_fl_directory_clone_file(listing.link.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.link.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.link);
 
     for (i = 0; F_status_is_fine(status) && i < listing.socket.used; i++) {
-      status = private_fl_directory_clone_file(listing.socket.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.socket.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.socket);
 
     for (i = 0; F_status_is_fine(status) && i < listing.unknown.used; i++) {
-      status = private_fl_directory_clone_file(listing.unknown.array[i], source, destination, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone_file(listing.unknown.array[i], source, destination, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.unknown);
@@ -126,7 +126,7 @@ extern "C" {
         }
       }
 
-      status = private_fl_directory_clone(source_sub, destination_sub, role, size_block, exclusive, failures);
+      status = private_fl_directory_clone(source_sub, destination_sub, role, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.directory);
@@ -140,7 +140,7 @@ extern "C" {
 #endif // !defined(_di_fl_directory_clone_)
 
 #if !defined(_di_fl_directory_clone_file_)
-  f_return_status private_fl_directory_clone_file(const f_string_static file, const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status private_fl_directory_clone_file(const f_string_static file, const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     char path_source[source.used + file.used + 2];
     char path_destination[destination.used + file.used + 2];
 
@@ -227,12 +227,16 @@ extern "C" {
       return F_failure;
     }
 
+    if (verbose) {
+      fprintf(verbose, "Cloned '%s' to '%s'.%c", source.string, destination.string, f_string_eol);
+    }
+
     return F_none;
   }
 #endif // !defined(_di_fl_directory_clone_file_)
 
 #if !defined(_di_fl_directory_copy_)
-  f_return_status private_fl_directory_copy(const f_string_static source, const f_string_static destination, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status private_fl_directory_copy(const f_string_static source, const f_string_static destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     f_status status = F_none;
     f_directory_listing listing = f_directory_listing_initialize;
 
@@ -250,37 +254,43 @@ extern "C" {
     f_string_length failures_used = failures ? failures->used : 0;
 
     for (; F_status_is_fine(status) && i < listing.block.used; i++) {
-      status = private_fl_directory_copy_file(listing.block.array[i], source, destination, mode.block, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.block.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.block);
 
     for (i = 0; F_status_is_fine(status) && i < listing.character.used; i++) {
-      status = private_fl_directory_copy_file(listing.character.array[i], source, destination, mode.character, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.character.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.character);
 
+    for (i = 0; F_status_is_fine(status) && i < listing.fifo.used; i++) {
+      status = private_fl_directory_copy_file(listing.fifo.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
+    } // for
+
+    f_macro_string_dynamics_delete_simple(listing.fifo);
+
     for (i = 0; F_status_is_fine(status) && i < listing.regular.used; i++) {
-      status = private_fl_directory_copy_file(listing.regular.array[i], source, destination, mode.regular, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.regular.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.regular);
 
     for (i = 0; F_status_is_fine(status) && i < listing.link.used; i++) {
-      status = private_fl_directory_copy_file(listing.link.array[i], source, destination, mode.link, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.link.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.link);
 
     for (i = 0; F_status_is_fine(status) && i < listing.socket.used; i++) {
-      status = private_fl_directory_copy_file(listing.socket.array[i], source, destination, mode.socket, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.socket.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.socket);
 
     for (i = 0; F_status_is_fine(status) && i < listing.unknown.used; i++) {
-      status = private_fl_directory_copy_file(listing.unknown.array[i], source, destination, mode.unknown, size_block, exclusive, failures);
+      status = private_fl_directory_copy_file(listing.unknown.array[i], source, destination, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.unknown);
@@ -338,7 +348,7 @@ extern "C" {
         if (F_status_is_error(status)) break;
       }
 
-      status = private_fl_directory_copy(source_sub, destination_sub, mode, size_block, exclusive, failures);
+      status = private_fl_directory_copy(source_sub, destination_sub, mode, size_block, exclusive, verbose, failures);
     } // for
 
     f_macro_string_dynamics_delete_simple(listing.directory);
@@ -352,7 +362,7 @@ extern "C" {
 #endif // !defined(_di_fl_directory_copy_)
 
 #if !defined(_di_fl_directory_copy_file_)
-  f_return_status private_fl_directory_copy_file(const f_string_static file, const f_string_static source, const f_string_static destination, const mode_t mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) {
+  f_return_status private_fl_directory_copy_file(const f_string_static file, const f_string_static source, const f_string_static destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) {
     char path_source[source.used + file.used + 2];
     char path_destination[destination.used + file.used + 2];
 
@@ -439,6 +449,10 @@ extern "C" {
       return F_failure;
     }
 
+    if (verbose) {
+      fprintf(verbose, "Copied '%s' to '%s'.%c", source.string, destination.string, f_string_eol);
+    }
+
     return F_none;
   }
 #endif // !defined(_di_fl_directory_copy_file_)
@@ -539,8 +553,8 @@ extern "C" {
       else if (mode == f_file_type_link) {
         names = &listing->link;
       }
-      else if (mode == f_file_type_pipe) {
-        names = &listing->pipe;
+      else if (mode == f_file_type_fifo) {
+        names = &listing->fifo;
       }
       else if (mode == f_file_type_socket) {
         names = &listing->socket;

diff --git a/level_1/fl_directory/c/private-directory.h b/level_1/fl_directory/c/private-directory.h
index 698faa8f016a382cec7d8c74843cb8fdb36463ea..7df04b1f3bbe7cc91b8e3034e8ae164faa6c72e6 100644 (file)
--- a/level_1/fl_directory/c/private-directory.h
+++ b/level_1/fl_directory/c/private-directory.h
@@ -35,6 +35,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for clone failures.
  *   If 0, then this and statuses is ignored.
@@ -66,7 +69,7 @@ extern "C" {
  * @see fl_directory_clone()
  */
 #if !defined(_di_fl_directory_clone_)
-  extern f_return_status private_fl_directory_clone(const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
+  extern f_return_status private_fl_directory_clone(const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
 #endif // !defined(_di_fl_directory_clone_)
 
 /**
@@ -93,6 +96,9 @@ extern "C" {
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for clone failures.
  *   If 0, then this and statuses is ignored.
@@ -124,7 +130,7 @@ extern "C" {
  * @see fl_directory_clone()
  */
 #if !defined(_di_fl_directory_clone_file_)
-  extern f_return_status private_fl_directory_clone_file(const f_string_static file, const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
+  extern f_return_status private_fl_directory_clone_file(const f_string_static file, const f_string_static source, const f_string_static destination, const bool role, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
 #endif // !defined(_di_fl_directory_clone_file_)
 
 /**
@@ -139,13 +145,16 @@ extern "C" {
  *   The destination file path.
  *   Must be NULL terminated.
  * @param mode
- *   The directory modes.
+ *   The mode for each file type.
  * @param size_block
  *   The default number of chunks to read at a time with each chunk being 1-byte.
  *   Must be greater than 0.
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for copy failures.
  *   If 0, then this and statuses is ignored.
@@ -177,7 +186,7 @@ extern "C" {
  * @see fl_directory_copy()
  */
 #if !defined(_di_fl_directory_copy_)
-  extern f_return_status private_fl_directory_copy(const f_string_static source, const f_string_static destination, const f_directory_mode mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
+  extern f_return_status private_fl_directory_copy(const f_string_static source, const f_string_static destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
 #endif // !defined(_di_fl_directory_copy_)
 
 /**
@@ -195,13 +204,16 @@ extern "C" {
  *   The destination file path.
  *   Must be NULL terminated.
  * @param mode
- *   The directory mode.
+ *   The mode for each file type.
  * @param size_block
  *   The default number of chunks to read at a time with each chunk being 1-byte.
  *   Must be greater than 0.
  * @param exclusive
  *   If TRUE, will fail when file already exists.
  *   If FALSE, will not fail if file already exists (existing file will be replaced).
+ * @param verbose
+ *   Set to 0 to not print copy operation values on successful copy.
+ *   Set to a valid file pointer, such as f_type_output (stdout), to print on successful copy.
  * @param failures
  *   A list of paths and their respective status codes for copy failures.
  *   If 0, then this and statuses is ignored.
@@ -233,7 +245,7 @@ extern "C" {
  * @see fl_directory_copy()
  */
 #if !defined(_di_fl_directory_copy_file_)
-  extern f_return_status private_fl_directory_copy_file(const f_string_static file, const f_string_static source, const f_string_static destination, const mode_t mode, const f_number_unsigned size_block, const bool exclusive, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
+  extern f_return_status private_fl_directory_copy_file(const f_string_static file, const f_string_static source, const f_string_static destination, const f_mode mode, const f_number_unsigned size_block, const bool exclusive, FILE *verbose, f_directory_statuss *failures) f_gcc_attribute_visibility_internal;
 #endif // !defined(_di_fl_directory_copy_file_)
 
 /**