Cleanup: Rename "output" to "stream".

Using the word "stream" is a better and more precise term.
The word "stream" is already in use elsewhere and using this makes the project more consistent.

diff --git a/level_0/f_print/c/print.c b/level_0/f_print/c/print.c
index 8bfdfb538d701a9a36fccde0abce5bbecf9c6ea7..09414a94bee9d74a71b4caf97138c9192d4e0895 100644 (file)
--- a/level_0/f_print/c/print.c
+++ b/level_0/f_print/c/print.c
@@ -6,26 +6,26 @@ extern "C" {
 #endif
 
 #ifndef _di_f_print_
-  f_status_t f_print(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t f_print(const f_string_t string, const f_array_length_t length, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print(string, length, output);
+    return private_f_print(string, length, stream);
   }
 #endif // _di_f_print_
 
 #ifndef _di_f_print_character_
-  f_status_t f_print_character(const f_char_t character, FILE * const output) {
+  f_status_t f_print_character(const f_char_t character, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
-    if (!fwrite_unlocked(&character, 1, 1, output)) {
+    if (!fwrite_unlocked(&character, 1, 1, stream)) {
       return F_status_set_error(F_output);
     }
 
@@ -34,33 +34,33 @@ extern "C" {
 #endif // _di_f_print_character_
 
 #ifndef _di_f_print_character_safely_
-  f_status_t f_print_character_safely(const f_char_t character, FILE * const output) {
+  f_status_t f_print_character_safely(const f_char_t character, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (character == 0x7f) {
-      if (fwrite_unlocked(f_print_sequence_delete_s.string, 1, f_print_sequence_delete_s.used, output) == f_print_sequence_delete_s.used) {
+      if (fwrite_unlocked(f_print_sequence_delete_s.string, 1, f_print_sequence_delete_s.used, stream) == f_print_sequence_delete_s.used) {
         return F_none;
       }
     }
     else if (macro_f_utf_byte_width_is(character) == 1) {
-      if (fwrite_unlocked(f_print_sequence_unknown_s.string, 1, f_print_sequence_unknown_s.used, output) == f_print_sequence_unknown_s.used) {
+      if (fwrite_unlocked(f_print_sequence_unknown_s.string, 1, f_print_sequence_unknown_s.used, stream) == f_print_sequence_unknown_s.used) {
         return F_none;
       }
     }
     else if (macro_f_utf_byte_width_is(character) > 1) {
-      if (fwrite_unlocked(&character, 1, 1, output)) {
+      if (fwrite_unlocked(&character, 1, 1, stream)) {
         return F_utf;
       }
     }
     else if (character > 0x1f) {
-      if (fwrite_unlocked(&character, 1, 1, output)) {
+      if (fwrite_unlocked(&character, 1, 1, stream)) {
         return F_none;
       }
     }
     else {
-      if (fwrite_unlocked(f_print_sequence_set_control_s[(unsigned int) character].string, 1, f_print_sequence_set_control_s[(unsigned int) character].used, output) == f_print_sequence_set_control_s[(unsigned int) character].used) {
+      if (fwrite_unlocked(f_print_sequence_set_control_s[(unsigned int) character].string, 1, f_print_sequence_set_control_s[(unsigned int) character].used, stream) == f_print_sequence_set_control_s[(unsigned int) character].used) {
         return F_none;
       }
     }
@@ -77,23 +77,23 @@ extern "C" {
 #endif // _di_f_print_character_safely_get_
 
 #ifndef _di_f_print_dynamic_
-  f_status_t f_print_dynamic(const f_string_static_t buffer, FILE * const output) {
+  f_status_t f_print_dynamic(const f_string_static_t buffer, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) {
       return F_data_not;
     }
 
-    return private_f_print(buffer.string, buffer.used, output);
+    return private_f_print(buffer.string, buffer.used, stream);
   }
 #endif // _di_f_print_dynamic_
 
 #ifndef _di_f_print_dynamic_partial_
-  f_status_t f_print_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, FILE * const output) {
+  f_status_t f_print_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -106,14 +106,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print(buffer.string + range.start, length, output);
+    return private_f_print(buffer.string + range.start, length, stream);
   }
 #endif // _di_f_print_dynamic_partial_
 
 #ifndef _di_f_print_dynamic_partial_raw_
-  f_status_t f_print_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, FILE * const output) {
+  f_status_t f_print_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -126,14 +126,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_raw(buffer.string + range.start, length, output);
+    return private_f_print_raw(buffer.string + range.start, length, stream);
   }
 #endif // _di_f_print_dynamic_partial_raw_
 
 #ifndef _di_f_print_dynamic_partial_raw_safely_
-  f_status_t f_print_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const output) {
+  f_status_t f_print_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -146,14 +146,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_raw_safely(buffer.string + range.start, length, output);
+    return private_f_print_raw_safely(buffer.string + range.start, length, stream);
   }
 #endif // _di_f_print_dynamic_partial_raw_safely_
 
 #ifndef _di_f_print_dynamic_partial_safely_
-  f_status_t f_print_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const output) {
+  f_status_t f_print_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -166,82 +166,82 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_safely(buffer.string + range.start, length, output);
+    return private_f_print_safely(buffer.string + range.start, length, stream);
   }
 #endif // _di_f_print_dynamic_partial_safely_
 
 #ifndef _di_f_print_dynamic_raw_
-  f_status_t f_print_dynamic_raw(const f_string_static_t buffer, FILE * const output) {
+  f_status_t f_print_dynamic_raw(const f_string_static_t buffer, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) {
       return F_data_not;
     }
 
-    return private_f_print_raw(buffer.string, buffer.used, output);
+    return private_f_print_raw(buffer.string, buffer.used, stream);
   }
 #endif // _di_f_print_dynamic_raw_
 
 #ifndef _di_f_print_dynamic_raw_safely_
-  f_status_t f_print_dynamic_raw_safely(const f_string_static_t buffer, FILE * const output) {
+  f_status_t f_print_dynamic_raw_safely(const f_string_static_t buffer, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) {
       return F_data_not;
     }
 
-    return private_f_print_raw_safely(buffer.string, buffer.used, output);
+    return private_f_print_raw_safely(buffer.string, buffer.used, stream);
   }
 #endif // _di_f_print_dynamic_raw_safely_
 
 #ifndef _di_f_print_dynamic_safely_
-  f_status_t f_print_dynamic_safely(const f_string_static_t buffer, FILE * const output) {
+  f_status_t f_print_dynamic_safely(const f_string_static_t buffer, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) {
       return F_data_not;
     }
 
-    return private_f_print_safely(buffer.string, buffer.used, output);
+    return private_f_print_safely(buffer.string, buffer.used, stream);
   }
 #endif // _di_f_print_dynamic_safely_
 
 #ifndef _di_f_print_except_
-  f_status_t f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except(string, offset, length, except, output);
+    return private_f_print_except(string, offset, length, except, stream);
   }
 #endif // _di_f_print_except_
 
 #ifndef _di_f_print_except_dynamic_
-  f_status_t f_print_except_dynamic(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except(buffer.string, 0, buffer.used, except, output);
+    return private_f_print_except(buffer.string, 0, buffer.used, except, stream);
   }
 #endif // _di_f_print_except_dynamic_
 
 #ifndef _di_f_print_except_dynamic_partial_
-  f_status_t f_print_except_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -254,14 +254,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except(buffer.string, range.start, range.start + length, except, output);
+    return private_f_print_except(buffer.string, range.start, range.start + length, except, stream);
   }
 #endif // _di_f_print_except_dynamic_partial_
 
 #ifndef _di_f_print_except_dynamic_partial_raw_
-  f_status_t f_print_except_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -274,14 +274,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_raw(buffer.string, range.start, range.start + length, except, output);
+    return private_f_print_except_raw(buffer.string, range.start, range.start + length, except, stream);
   }
 #endif // _di_f_print_except_dynamic_partial_raw_
 
 #ifndef _di_f_print_except_dynamic_partial_raw_safely_
-  f_status_t f_print_except_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -294,14 +294,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_raw_safely(buffer.string, range.start, range.start + length, except, output);
+    return private_f_print_except_raw_safely(buffer.string, range.start, range.start + length, except, stream);
   }
 #endif // _di_f_print_except_dynamic_partial_raw_safely_
 
 #ifndef _di_f_print_except_dynamic_partial_safely_
-  f_status_t f_print_except_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -314,76 +314,76 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_safely(buffer.string, range.start, range.start + length, except, output);
+    return private_f_print_except_safely(buffer.string, range.start, range.start + length, except, stream);
   }
 #endif // _di_f_print_except_dynamic_partial_safely_
 
 #ifndef _di_f_print_except_dynamic_raw_
-  f_status_t f_print_except_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_raw(buffer.string, 0, buffer.used, except, output);
+    return private_f_print_except_raw(buffer.string, 0, buffer.used, except, stream);
   }
 #endif // _di_f_print_except_dynamic_raw_
 
 #ifndef _di_f_print_except_dynamic_raw_safely_
-  f_status_t f_print_except_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_raw_safely(buffer.string, 0, buffer.used, except, output);
+    return private_f_print_except_raw_safely(buffer.string, 0, buffer.used, except, stream);
   }
 #endif // _di_f_print_except_dynamic_raw_safely_
 
 #ifndef _di_f_print_except_dynamic_safely_
-  f_status_t f_print_except_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_safely(buffer.string, 0, buffer.used, except, output);
+    return private_f_print_except_safely(buffer.string, 0, buffer.used, except, stream);
   }
 #endif // _di_f_print_except_dynamic_safely_
 
 #ifndef _di_f_print_except_in_
-  f_status_t f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_in(string, offset, length, except_at, except_in, output);
+    return private_f_print_except_in(string, offset, length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_
 
 #ifndef _di_f_print_except_in_dynamic_
-  f_status_t f_print_except_in_dynamic(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_in(buffer.string, 0, buffer.used, except_at, except_in, output);
+    return private_f_print_except_in(buffer.string, 0, buffer.used, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_
 
 #ifndef _di_f_print_except_in_dynamic_partial_
-  f_status_t f_print_except_in_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -396,14 +396,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_in(buffer.string, range.start, range.start + length, except_at, except_in, output);
+    return private_f_print_except_in(buffer.string, range.start, range.start + length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_partial_
 
 #ifndef _di_f_print_except_in_dynamic_partial_raw_
-  f_status_t f_print_except_in_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -416,14 +416,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_in_raw(buffer.string, range.start, range.start + length, except_at, except_in, output);
+    return private_f_print_except_in_raw(buffer.string, range.start, range.start + length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_partial_raw_
 
 #ifndef _di_f_print_except_in_dynamic_partial_raw_safely_
-  f_status_t f_print_except_in_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -436,14 +436,14 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_in_raw_safely(buffer.string, range.start, range.start + length, except_at, except_in, output);
+    return private_f_print_except_in_raw_safely(buffer.string, range.start, range.start + length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_partial_raw_safely_
 
 #ifndef _di_f_print_except_in_dynamic_partial_safely_
-  f_status_t f_print_except_in_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || range.start > range.stop || range.start >= buffer.used || !buffer.string) {
@@ -456,162 +456,162 @@ extern "C" {
       length = buffer.used - range.start;
     }
 
-    return private_f_print_except_in_safely(buffer.string, range.start, range.start + length, except_at, except_in, output);
+    return private_f_print_except_in_safely(buffer.string, range.start, range.start + length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_partial_safely_
 
 #ifndef _di_f_print_except_in_dynamic_raw_
-  f_status_t f_print_except_in_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_in_raw(buffer.string, 0, buffer.used, except_at, except_in, output);
+    return private_f_print_except_in_raw(buffer.string, 0, buffer.used, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_raw_
 
 #ifndef _di_f_print_except_in_dynamic_raw_safely_
-  f_status_t f_print_except_in_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_in_raw_safely(buffer.string, 0, buffer.used, except_at, except_in, output);
+    return private_f_print_except_in_raw_safely(buffer.string, 0, buffer.used, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_raw_safely_
 
 #ifndef _di_f_print_except_in_dynamic_safely_
-  f_status_t f_print_except_in_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer.used || !buffer.string) return F_data_not;
 
-    return private_f_print_except_in_safely(buffer.string, 0, buffer.used, except_at, except_in, output);
+    return private_f_print_except_in_safely(buffer.string, 0, buffer.used, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_dynamic_safely_
 
 #ifndef _di_f_print_except_in_raw_
-  f_status_t f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_in_raw(string, offset, length, except_at, except_in, output);
+    return private_f_print_except_in_raw(string, offset, length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_raw_
 
 #ifndef _di_f_print_except_in_raw_safely_
-  f_status_t f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_in_raw_safely(string, offset, length, except_at, except_in, output);
+    return private_f_print_except_in_raw_safely(string, offset, length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_raw_safely_
 
 #ifndef _di_f_print_except_in_safely_
-  f_status_t f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_in_safely(string, offset, length, except_at, except_in, output);
+    return private_f_print_except_in_safely(string, offset, length, except_at, except_in, stream);
   }
 #endif // _di_f_print_except_in_safely_
 
 #ifndef _di_f_print_except_raw_
-  f_status_t f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_raw(string, offset, length, except, output);
+    return private_f_print_except_raw(string, offset, length, except, stream);
   }
 #endif // _di_f_print_except_raw_
 
 #ifndef _di_f_print_except_raw_safely_
-  f_status_t f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_raw_safely(string, offset, length, except, output);
+    return private_f_print_except_raw_safely(string, offset, length, except, stream);
   }
 #endif // _di_f_print_except_raw_safely_
 
 #ifndef _di_f_print_except_safely_
-  f_status_t f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output) {
+  f_status_t f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_except_safely(string, offset, length, except, output);
+    return private_f_print_except_safely(string, offset, length, except, stream);
   }
 #endif // _di_f_print_except_safely_
 
 #ifndef _di_f_print_raw_
-  f_status_t f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_raw(string, length, output);
+    return private_f_print_raw(string, length, stream);
   }
 #endif // _di_f_print_raw_
 
 #ifndef _di_f_print_raw_safely_
-  f_status_t f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_raw_safely(string, length, output);
+    return private_f_print_raw_safely(string, length, stream);
   }
 #endif // _di_f_print_raw_safely_
 
 #ifndef _di_f_print_raw_terminated_
-  f_status_t f_print_raw_terminated(const f_string_t string, FILE * const output) {
+  f_status_t f_print_raw_terminated(const f_string_t string, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!string) {
@@ -619,21 +619,21 @@ extern "C" {
     }
 
     // The f_print_raw_terminated() and f_print_terminated() are functionality identical due to being NULL terminated.
-    return private_f_print_terminated(string, output);
+    return private_f_print_terminated(string, stream);
   }
 #endif // _di_f_print_raw_terminated_
 
 #ifndef _di_f_print_safely_
-  f_status_t f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!length || !string) {
       return F_data_not;
     }
 
-    return private_f_print_safely(string, length, output);
+    return private_f_print_safely(string, length, stream);
   }
 #endif // _di_f_print_safely_
 
@@ -645,9 +645,9 @@ extern "C" {
 #endif // _di_f_print_safely_get_
 
 #ifndef _di_f_print_safely_terminated_
-  f_status_t f_print_safely_terminated(const f_string_t string, FILE * const output) {
+  f_status_t f_print_safely_terminated(const f_string_t string, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!string) {
@@ -662,7 +662,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     for (register f_array_length_t i = 0; string[i]; ) {
 
@@ -698,9 +698,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -712,9 +712,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -730,9 +730,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -753,9 +753,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -767,16 +767,16 @@ extern "C" {
 #endif // _di_f_print_safely_terminated_
 
 #ifndef _di_f_print_terminated_
-  f_status_t f_print_terminated(const f_string_t string, FILE * const output) {
+  f_status_t f_print_terminated(const f_string_t string, FILE * const stream) {
     #ifndef _di_level_0_parameter_checking_
-      if (!output) return F_status_set_error(F_parameter);
+      if (!stream) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!string) {
       return F_data_not;
     }
 
-    return private_f_print_terminated(string, output);
+    return private_f_print_terminated(string, stream);
   }
 #endif // _di_f_print_terminated_
 

diff --git a/level_0/f_print/c/print.h b/level_0/f_print/c/print.h
index 5d59bb4e4f255e62a8874d91ace359d553bee472..5223549bf1d1768bba596b684735da2197e51427 100644 (file)
--- a/level_0/f_print/c/print.h
+++ b/level_0/f_print/c/print.h
@@ -49,7 +49,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -64,7 +64,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_
-  extern f_status_t f_print(const f_string_t string, const f_array_length_t length, FILE * const output);
+  extern f_status_t f_print(const f_string_t string, const f_array_length_t length, FILE * const stream);
 #endif // _di_f_print_
 
 /**
@@ -76,7 +76,7 @@ extern "C" {
  *
  * @param character
  *   The character to verify as safe or not and then print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -89,7 +89,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_character_
-  extern f_status_t f_print_character(const f_char_t character, FILE * const output);
+  extern f_status_t f_print_character(const f_char_t character, FILE * const stream);
 #endif // _di_f_print_character_
 
 /**
@@ -108,7 +108,7 @@ extern "C" {
  *
  * @param character
  *   The character to verify as safe or not and then print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -122,7 +122,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_character_safely_
-  extern f_status_t f_print_character_safely(const f_char_t character, FILE * const output);
+  extern f_status_t f_print_character_safely(const f_char_t character, FILE * const stream);
 #endif // _di_f_print_character_safely_
 
 /**
@@ -160,7 +160,7 @@ extern "C" {
  *
  * @param buffer
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -175,7 +175,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_
-  extern f_status_t f_print_dynamic(const f_string_static_t buffer, FILE * const output);
+  extern f_status_t f_print_dynamic(const f_string_static_t buffer, FILE * const stream);
 #endif // _di_f_print_dynamic_
 
 /**
@@ -191,7 +191,7 @@ extern "C" {
  *   The string to output.
  * @param range
  *   The range within the provided string to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -206,7 +206,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_partial_
-  extern f_status_t f_print_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, FILE * const output);
+  extern f_status_t f_print_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
 #endif // _di_f_print_dynamic_partial_
 
 /**
@@ -224,7 +224,7 @@ extern "C" {
  *   The string to output.
  * @param range
  *   The range within the provided string to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -239,7 +239,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_partial_raw_
-  extern f_status_t f_print_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, FILE * const output);
+  extern f_status_t f_print_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
 #endif // _di_f_print_dynamic_partial_raw_
 
 /**
@@ -260,7 +260,7 @@ extern "C" {
  *   The string to output.
  * @param range
  *   The range within the provided string to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -277,7 +277,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_partial_raw_safely_
-  extern f_status_t f_print_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const output);
+  extern f_status_t f_print_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
 #endif // _di_f_print_dynamic_partial_raw_safely_
 
 /**
@@ -296,7 +296,7 @@ extern "C" {
  *   The string to output.
  * @param range
  *   The range within the provided string to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -313,7 +313,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_partial_safely_
-  extern f_status_t f_print_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const output);
+  extern f_status_t f_print_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
 #endif // _di_f_print_dynamic_partial_safely_
 
 /**
@@ -329,7 +329,7 @@ extern "C" {
  *
  * @param buffer
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -344,7 +344,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_raw_
-  extern f_status_t f_print_dynamic_raw(const f_string_static_t buffer, FILE * const output);
+  extern f_status_t f_print_dynamic_raw(const f_string_static_t buffer, FILE * const stream);
 #endif // _di_f_print_dynamic_raw_
 
 /**
@@ -363,7 +363,7 @@ extern "C" {
  *
  * @param buffer
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -380,7 +380,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_raw_safely_
-  extern f_status_t f_print_dynamic_raw_safely(const f_string_static_t buffer, FILE * const output);
+  extern f_status_t f_print_dynamic_raw_safely(const f_string_static_t buffer, FILE * const stream);
 #endif // _di_f_print_dynamic_raw_safely_
 
 /**
@@ -397,7 +397,7 @@ extern "C" {
  *
  * @param buffer
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -414,7 +414,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_safely_
-  extern f_status_t f_print_dynamic_safely(const f_string_static_t buffer, FILE * const output);
+  extern f_status_t f_print_dynamic_safely(const f_string_static_t buffer, FILE * const stream);
 #endif // _di_f_print_dynamic_safely_
 
 /**
@@ -438,7 +438,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -453,7 +453,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_
-  extern f_status_t f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_
 
 /**
@@ -471,7 +471,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -486,7 +486,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_dynamic_
-  extern f_status_t f_print_except_dynamic(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_
 
 /**
@@ -506,7 +506,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -521,7 +521,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_except_partial_
-  extern f_status_t f_print_except_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_partial_
 
 /**
@@ -543,7 +543,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -558,7 +558,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_except_partial_raw_
-  extern f_status_t f_print_except_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_partial_raw_
 
 /**
@@ -583,7 +583,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -600,7 +600,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_except_partial_raw_safely_
-  extern f_status_t f_print_except_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_partial_raw_safely_
 
 /**
@@ -623,7 +623,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -640,7 +640,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_except_partial_safely_
-  extern f_status_t f_print_except_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_partial_safely_
 
 /**
@@ -660,7 +660,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -675,7 +675,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_dynamic_raw_
-  extern f_status_t f_print_except_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_raw_
 
 /**
@@ -698,7 +698,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -715,7 +715,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_dynamic_raw_safely_
-  extern f_status_t f_print_except_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_raw_safely_
 
 /**
@@ -736,7 +736,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -753,7 +753,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_dynamic_safely_
-  extern f_status_t f_print_except_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_dynamic_safely_
 
 /**
@@ -781,7 +781,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -796,7 +796,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_in_
-  extern f_status_t f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_
 
 /**
@@ -818,7 +818,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -833,7 +833,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_in_dynamic_
-  extern f_status_t f_print_except_in_dynamic(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_
 
 /**
@@ -857,7 +857,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -872,7 +872,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_except_partial_
-  extern f_status_t f_print_except_in_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_partial_
 
 /**
@@ -898,7 +898,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -913,7 +913,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_dynamic_except_partial_raw_
-  extern f_status_t f_print_except_in_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_partial_raw_
 
 /**
@@ -939,7 +939,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -956,7 +956,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_except_partial_raw_safely_
-  extern f_status_t f_print_except_in_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_partial_raw_safely_
 
 /**
@@ -980,7 +980,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -997,7 +997,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_dynamic_except_partial_safely_
-  extern f_status_t f_print_except_in_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_partial_safely_
 
 /**
@@ -1021,7 +1021,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1036,7 +1036,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_in_dynamic_raw_
-  extern f_status_t f_print_except_in_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_raw_
 
 /**
@@ -1063,7 +1063,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1080,7 +1080,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_in_dynamic_raw_safely_
-  extern f_status_t f_print_except_in_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_raw_safely_
 
 /**
@@ -1105,7 +1105,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1122,7 +1122,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_in_dynamic_safely_
-  extern f_status_t f_print_except_in_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_dynamic_safely_
 
 /**
@@ -1152,7 +1152,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1167,7 +1167,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_in_raw_
-  extern f_status_t f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_raw_
 
 /**
@@ -1200,7 +1200,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1217,7 +1217,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_in_raw_safely_
-  extern f_status_t f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_raw_safely_
 
 /**
@@ -1248,7 +1248,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1265,7 +1265,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_in_safely_
-  extern f_status_t f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output);
+  extern f_status_t f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream);
 #endif // _di_f_print_except_in_safely_
 
 /**
@@ -1291,7 +1291,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1306,7 +1306,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_except_raw_
-  extern f_status_t f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_raw_
 
 /**
@@ -1333,7 +1333,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1350,7 +1350,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_raw_safely_
-  extern f_status_t f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_raw_safely_
 
 /**
@@ -1375,7 +1375,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1392,7 +1392,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_except_safely_
-  extern f_status_t f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const output);
+  extern f_status_t f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except, FILE * const stream);
 #endif // _di_f_print_except_safely_
 
 /**
@@ -1410,7 +1410,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1425,7 +1425,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_raw_
-  extern f_status_t f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const output);
+  extern f_status_t f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const stream);
 #endif // _di_f_print_raw_
 
 /**
@@ -1446,7 +1446,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1463,7 +1463,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_raw_safely_
-  extern f_status_t f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const output);
+  extern f_status_t f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const stream);
 #endif // _di_f_print_raw_safely_
 
 /**
@@ -1477,7 +1477,7 @@ extern "C" {
  *
  * @param string
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1492,7 +1492,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_raw_terminated_
-  extern f_status_t f_print_raw_terminated(const f_string_t string, FILE * const output);
+  extern f_status_t f_print_raw_terminated(const f_string_t string, FILE * const stream);
 #endif // _di_f_print_raw_terminated_
 
 /**
@@ -1511,7 +1511,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1528,7 +1528,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_safely_
-  extern f_status_t f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const output);
+  extern f_status_t f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const stream);
 #endif // _di_f_print_safely_
 
 /**
@@ -1574,7 +1574,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1591,7 +1591,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #ifndef _di_f_print_safely_terminated_
-  extern f_status_t f_print_safely_terminated(const f_string_t string, FILE * const output);
+  extern f_status_t f_print_safely_terminated(const f_string_t string, FILE * const stream);
 #endif // _di_f_print_safely_terminated_
 
 /**
@@ -1605,7 +1605,7 @@ extern "C" {
  *
  * @param string
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -1620,7 +1620,7 @@ extern "C" {
  * @see fwrite_unlocked()
  */
 #ifndef _di_f_print_terminated_
-  extern f_status_t f_print_terminated(const f_string_t string, FILE * const output);
+  extern f_status_t f_print_terminated(const f_string_t string, FILE * const stream);
 #endif // _di_f_print_terminated_
 
 #ifdef __cplusplus

diff --git a/level_0/f_print/c/private-print.c b/level_0/f_print/c/private-print.c
index 75ee8624a2010fe367e0d5a303810d45de596a71..bfdeb205985f2462aeef82f0212093eb63b9c385 100644 (file)
--- a/level_0/f_print/c/private-print.c
+++ b/level_0/f_print/c/private-print.c
@@ -6,12 +6,12 @@ extern "C" {
 #endif
 
 #if !defined(_di_f_print_) || !defined(_di_f_print_dynamic_) || !defined(_di_f_print_dynamic_partial_)
-  f_status_t private_f_print(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t private_f_print(const f_string_t string, const f_array_length_t length, FILE * const stream) {
 
     f_array_length_t total = 0;
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     for (register f_array_length_t i = 0; i < length; ) {
 
@@ -25,9 +25,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + i + count, 1, total - count, output);
+          count += fwrite_unlocked(string + i + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -68,7 +68,7 @@ extern "C" {
 #endif // !defined(_di_f_print_character_safely_get_) || !defined(_di_f_print_dynamic_partial_safely_) || !defined(_di_f_print_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_) || !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_safely_) || !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_terminated_) || !defined(_di_f_print_to_dynamic_partial_safely_) || !defined(_di_f_print_to_dynamic_safely_) || !defined(_di_f_print_to_except_dynamic_partial_safely_) || !defined(_di_f_print_to_except_dynamic_safely_) || !defined(_di_f_print_to_except_in_dynamic_safely_) || !defined(_di_f_print_to_except_in_dynamic_partial_safely_) || !defined(_di_f_print_to_except_in_safely_) || !defined(_di_f_print_to_except_safely_) || !defined(_di_f_print_to_safely_)
 
 #if !defined(_di_f_print_except_) || !defined(_di_f_print_except_dynamic_) || !defined(_di_f_print_except_dynamic_partial_)
-  f_status_t private_f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) {
+  f_status_t private_f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) {
 
     register f_array_length_t i = offset;
     f_array_length_t j = 0;
@@ -76,7 +76,7 @@ extern "C" {
     f_array_length_t total = 0;
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -89,9 +89,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -114,9 +114,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -137,7 +137,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_) || !defined(_di_f_print_except_dynamic_) || !defined(_di_f_print_except_dynamic_partial_)
 
 #if !defined(_di_f_print_except_in_) || !defined(_di_f_print_except_in_dynamic_) || !defined(_di_f_print_except_in_dynamic_partial_)
-  f_status_t private_f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t private_f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t at = 0;
@@ -146,7 +146,7 @@ extern "C" {
     f_array_length_t total = 0;
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -159,9 +159,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -185,9 +185,9 @@ extern "C" {
             count = 0;
 
             do {
-              count += fwrite_unlocked(string + start + count, 1, total - count, output);
+              count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-              if (ferror_unlocked(output)) {
+              if (ferror_unlocked(stream)) {
                 return F_status_set_error(F_output);
               }
 
@@ -212,9 +212,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -235,7 +235,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_in_) || !defined(_di_f_print_except_in_dynamic_) || !defined(_di_f_print_except_in_dynamic_partial_)
 
 #if !defined(_di_f_print_except_in_raw_) || !defined(_di_f_print_except_in_dynamic_raw_) || !defined(_di_f_print_except_in_dynamic_partial_raw_)
-  f_status_t private_f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t private_f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t at = 0;
@@ -244,7 +244,7 @@ extern "C" {
     f_array_length_t total = 0;
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -257,9 +257,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -283,9 +283,9 @@ extern "C" {
             count = 0;
 
             do {
-              count += fwrite_unlocked(string + start + count, 1, total - count, output);
+              count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-              if (ferror_unlocked(output)) {
+              if (ferror_unlocked(stream)) {
                 return F_status_set_error(F_output);
               }
 
@@ -308,9 +308,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -331,7 +331,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_in_raw_) || !defined(_di_f_print_except_in_dynamic_raw_) || !defined(_di_f_print_except_in_dynamic_partial_raw_)
 
 #if !defined(_di_f_print_except_in_raw_safely_) || !defined(_di_f_print_except_in_dynamic_raw_safely_) || !defined(_di_f_print_except_in_dynamic_partial_raw_safely_)
-  f_status_t private_f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t private_f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t at = 0;
@@ -344,7 +344,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -357,9 +357,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -383,9 +383,9 @@ extern "C" {
             count = 0;
 
             do {
-              count += fwrite_unlocked(string + start + count, 1, total - count, output);
+              count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-              if (ferror_unlocked(output)) {
+              if (ferror_unlocked(stream)) {
                 return F_status_set_error(F_output);
               }
 
@@ -416,9 +416,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -430,9 +430,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -448,9 +448,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -468,9 +468,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -482,7 +482,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_in_raw_safely_) || !defined(_di_f_print_except_in_dynamic_raw_safely_) || !defined(_di_f_print_except_in_dynamic_partial_raw_safely_)
 
 #if !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
-  f_status_t private_f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const output) {
+  f_status_t private_f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, const f_string_ranges_t except_in, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t at = 0;
@@ -495,7 +495,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -508,9 +508,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -534,9 +534,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -562,9 +562,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -583,9 +583,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -597,9 +597,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -615,9 +615,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -635,9 +635,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -649,7 +649,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
 
 #if !defined(_di_f_print_except_raw_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
-  f_status_t private_f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) {
+  f_status_t private_f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) {
 
     register f_array_length_t i = offset;
     f_array_length_t j = 0;
@@ -657,7 +657,7 @@ extern "C" {
     f_array_length_t total = 0;
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -670,9 +670,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -693,9 +693,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -715,9 +715,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -729,7 +729,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_raw_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
 
 #if !defined(_di_f_print_except_raw_safely_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
-  f_status_t private_f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) {
+  f_status_t private_f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t j = 0;
@@ -741,7 +741,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -754,9 +754,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -785,9 +785,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -799,9 +799,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -817,9 +817,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -837,9 +837,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -851,7 +851,7 @@ extern "C" {
 #endif // !defined(_di_f_print_except_raw_safely_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
 
 #if !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_)
-  f_status_t private_f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) {
+  f_status_t private_f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) {
 
     f_array_length_t i = offset;
     f_array_length_t j = 0;
@@ -863,7 +863,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < stop) {
 
@@ -876,9 +876,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -902,9 +902,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -923,9 +923,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -937,9 +937,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -955,9 +955,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -975,9 +975,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -989,19 +989,19 @@ extern "C" {
 #endif // !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_)
 
 #if !defined(_di_f_print_raw_) || !defined(_di_f_print_raw_dynamic_) || !defined(_di_f_print_raw_dynamic_partial_)
-  f_status_t private_f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t private_f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const stream) {
 
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     if (length < F_print_write_max_d) {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + count, 1, length - count, output);
+        count += fwrite_unlocked(string + count, 1, length - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -1014,9 +1014,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + count, 1, F_print_write_max_d - count, output);
+            count += fwrite_unlocked(string + count, 1, F_print_write_max_d - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -1026,9 +1026,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + count, 1, length - total - count, output);
+            count += fwrite_unlocked(string + count, 1, length - total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -1044,7 +1044,7 @@ extern "C" {
 #endif // !defined(_di_f_print_raw_) || !defined(_di_f_print_raw_dynamic_) || !defined(_di_f_print_raw_dynamic_partial_)
 
 #if !defined(_di_f_print_raw_safely_) || !defined(_di_f_print_raw_safely_dynamic_) || !defined(_di_f_print_raw_safely_dynamic_partial_)
-  f_status_t private_f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t private_f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) {
 
     register f_array_length_t i = 0;
     f_array_length_t start = 0;
@@ -1055,7 +1055,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < length) {
 
@@ -1074,9 +1074,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -1088,9 +1088,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -1106,9 +1106,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -1126,9 +1126,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -1140,7 +1140,7 @@ extern "C" {
 #endif // !defined(_di_f_print_raw_safely_) || !defined(_di_f_print_raw_safely_dynamic_) || !defined(_di_f_print_raw_safely_dynamic_partial_)
 
 #if !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_dynamic_) || !defined(_di_f_print_safely_dynamic_partial_)
-  f_status_t private_f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const output) {
+  f_status_t private_f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) {
 
     register f_array_length_t i = 0;
     f_array_length_t start = 0;
@@ -1151,7 +1151,7 @@ extern "C" {
 
     uint8_t width = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     while (i < length) {
 
@@ -1165,9 +1165,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -1186,9 +1186,9 @@ extern "C" {
           count = 0;
 
           do {
-            count += fwrite_unlocked(string + start + count, 1, total - count, output);
+            count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-            if (ferror_unlocked(output)) {
+            if (ferror_unlocked(stream)) {
               return F_status_set_error(F_output);
             }
 
@@ -1200,9 +1200,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, output);
+          count += fwrite_unlocked(safe.string + count, 1, safe.used - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -1218,9 +1218,9 @@ extern "C" {
         count = 0;
 
         do {
-          count += fwrite_unlocked(string + start + count, 1, total - count, output);
+          count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-          if (ferror_unlocked(output)) {
+          if (ferror_unlocked(stream)) {
             return F_status_set_error(F_output);
           }
 
@@ -1238,9 +1238,9 @@ extern "C" {
       count = 0;
 
       do {
-        count += fwrite_unlocked(string + start + count, 1, total - count, output);
+        count += fwrite_unlocked(string + start + count, 1, total - count, stream);
 
-        if (ferror_unlocked(output)) {
+        if (ferror_unlocked(stream)) {
           return F_status_set_error(F_output);
         }
 
@@ -1275,17 +1275,17 @@ extern "C" {
 #endif // !defined(_di_f_print_character_safely_get_) || !defined(_di_f_print_dynamic_partial_safely_) || !defined(_di_f_print_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_) || !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_safely_) || !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_terminated_) || !defined(_di_f_print_to_dynamic_partial_safely_) || !defined(_di_f_print_to_dynamic_safely_) || !defined(_di_f_print_to_except_dynamic_partial_safely_) || !defined(_di_f_print_to_except_dynamic_safely_) || !defined(_di_f_print_to_except_in_dynamic_safely_) || !defined(_di_f_print_to_except_in_dynamic_partial_safely_) || !defined(_di_f_print_to_except_in_safely_) || !defined(_di_f_print_to_except_safely_) || !defined(_di_f_print_to_safely_)
 
 #if !defined(_di_f_print_terminated_) || !defined(_di_f_print_raw_terminated_)
-  f_status_t private_f_print_terminated(const f_string_t string, FILE * const output) {
+  f_status_t private_f_print_terminated(const f_string_t string, FILE * const stream) {
 
     const size_t length = strlen(string);
     f_array_length_t count = 0;
 
-    clearerr_unlocked(output);
+    clearerr_unlocked(stream);
 
     do {
-      count += fwrite_unlocked(string + count, 1, length - count, output);
+      count += fwrite_unlocked(string + count, 1, length - count, stream);
 
-      if (ferror_unlocked(output)) {
+      if (ferror_unlocked(stream)) {
         return F_status_set_error(F_output);
       }
 

diff --git a/level_0/f_print/c/private-print.h b/level_0/f_print/c/private-print.h
index 09ec94ce39aadd13f6c50dbcff222e64532fe24a..1d597be5d7af2d8a5e405fe30c6e15a8974e5ae9 100644 (file)
--- a/level_0/f_print/c/private-print.h
+++ b/level_0/f_print/c/private-print.h
@@ -24,7 +24,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -41,7 +41,7 @@ extern "C" {
  * @see f_print_dynamic_partial()
  */
 #if !defined(_di_f_print_) || !defined(_di_f_print_dynamic_) || !defined(_di_f_print_dynamic_partial_)
-  extern f_status_t private_f_print(const f_string_t string, const f_array_length_t length, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print(const f_string_t string, const f_array_length_t length, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_) || !defined(_di_f_print_dynamic_) || !defined(_di_f_print_dynamic_partial_)
 
 /**
@@ -51,7 +51,7 @@ extern "C" {
  *
  * @param character
  *   The character to verify as safe or not.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -76,7 +76,7 @@ extern "C" {
  * @see f_print_except_in_dynamic_partial_safely()
  */
 #if !defined(_di_f_print_character_safely_) || !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_dynamic_) || !defined(_di_f_print_safely_dynamic_partial_) || !defined(_di_f_print_safely_terminated_) || !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_) || !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
-  extern f_status_t private_f_print_character_safely(const f_char_t character, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_character_safely(const f_char_t character, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_character_safely_) || !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_dynamic_) || !defined(_di_f_print_safely_dynamic_partial_) || !defined(_di_f_print_safely_terminated_) || !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_) || !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_in_dynamic_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
 
 /**
@@ -132,7 +132,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -149,7 +149,7 @@ extern "C" {
  * @see f_print_except_dynamic_partial()
  */
 #if !defined(_di_f_print_except_) || !defined(_di_f_print_except_dynamic_) || !defined(_di_f_print_except_dynamic_partial_)
-  extern f_status_t private_f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_) || !defined(_di_f_print_except_dynamic_) || !defined(_di_f_print_except_dynamic_partial_)
 
 /**
@@ -169,7 +169,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -186,7 +186,7 @@ extern "C" {
  * @see f_print_except_in_dynamic_partial()
  */
 #if !defined(_di_f_print_except_in_) || !defined(_di_f_print_except_dynamic_in_) || !defined(_di_f_print_except_in_dynamic_partial_)
-  extern f_status_t private_f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_in(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_in_) || !defined(_di_f_print_except_dynamic_in_) || !defined(_di_f_print_except_in_dynamic_partial_)
 
 /**
@@ -206,7 +206,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -223,7 +223,7 @@ extern "C" {
  * @see f_print_except_in_dynamic_partial_raw()
  */
 #if !defined(_di_f_print_except_in_raw_) || !defined(_di_f_print_except_dynamic_in_raw_) || !defined(_di_f_print_except_in_dynamic_partial_raw_)
-  extern f_status_t private_f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_in_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_in_raw_) || !defined(_di_f_print_except_dynamic_in_raw_) || !defined(_di_f_print_except_in_dynamic_partial_raw_)
 
 /**
@@ -243,7 +243,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -261,7 +261,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #if !defined(_di_f_print_except_in_raw_safely_) || !defined(_di_f_print_except_dynamic_in_raw_safely_) || !defined(_di_f_print_except_in_dynamic_partial_raw_safely_)
-  extern f_status_t private_f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_in_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_in_raw_safely_) || !defined(_di_f_print_except_dynamic_in_raw_safely_) || !defined(_di_f_print_except_in_dynamic_partial_raw_safely_)
 
 /**
@@ -281,7 +281,7 @@ extern "C" {
  * @param except_in
  *   An array of ranges within the string to not print.
  *   The array of ranges is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -299,7 +299,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #if !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_dynamic_in_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
-  extern f_status_t private_f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_in_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except_at, f_string_ranges_t except_in, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_in_safely_) || !defined(_di_f_print_except_dynamic_in_safely_) || !defined(_di_f_print_except_in_dynamic_partial_safely_)
 
 /**
@@ -316,7 +316,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -333,7 +333,7 @@ extern "C" {
  * @see f_print_except_dynamic_partial_raw()
  */
 #if !defined(_di_f_print_except_raw_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
-  extern f_status_t private_f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_raw(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_raw_) || !defined(_di_f_print_except_dynamic_raw_) || !defined(_di_f_print_except_dynamic_partial_raw_)
 
 /**
@@ -350,7 +350,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -367,7 +367,7 @@ extern "C" {
  * @see f_print_except_dynamic_partial_raw_safely()
  */
 #if !defined(_di_f_print_except_raw_safely_) || !defined(_di_f_print_except_dynamic_raw_safely_) || !defined(_di_f_print_except_dynamic_partial_raw_safely_)
-  extern f_status_t private_f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_raw_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_raw_safely_) || !defined(_di_f_print_except_dynamic_raw_safely_) || !defined(_di_f_print_except_dynamic_partial_raw_safely_)
 
 /**
@@ -384,7 +384,7 @@ extern "C" {
  * @param except
  *   An array of locations within the given string to not print.
  *   The array of locations is required/assumed to be in linear order.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -402,7 +402,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #if !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_)
-  extern f_status_t private_f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_except_safely(const f_string_t string, const f_array_length_t offset, const f_array_length_t stop, const f_array_lengths_t except, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_except_safely_) || !defined(_di_f_print_except_dynamic_safely_) || !defined(_di_f_print_except_dynamic_partial_safely_)
 
 /**
@@ -414,7 +414,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -431,7 +431,7 @@ extern "C" {
  * @see f_print_raw_dynamic_partial()
  */
 #if !defined(_di_f_print_raw_) || !defined(_di_f_print_raw_dynamic_) || !defined(_di_f_print_raw_dynamic_partial_)
-  extern f_status_t private_f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_raw(const f_string_t string, const f_array_length_t length, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_raw_) || !defined(_di_f_print_raw_dynamic_) || !defined(_di_f_print_raw_dynamic_partial_)
 
 /**
@@ -443,7 +443,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -461,7 +461,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #if !defined(_di_f_print_raw_safely_) || !defined(_di_f_print_raw_safely_dynamic_) || !defined(_di_f_print_raw_safely_dynamic_partial_)
-  extern f_status_t private_f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_raw_safely_) || !defined(_di_f_print_raw_safely_dynamic_) || !defined(_di_f_print_raw_safely_dynamic_partial_)
 
 /**
@@ -473,7 +473,7 @@ extern "C" {
  *   The string to output.
  * @param length
  *   The total number of characters to print.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -491,7 +491,7 @@ extern "C" {
  * @see f_utf_is_valid()
  */
 #if !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_dynamic_) || !defined(_di_f_print_safely_dynamic_partial_)
-  extern f_status_t private_f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_safely(const f_string_t string, const f_array_length_t length, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_safely_) || !defined(_di_f_print_safely_dynamic_) || !defined(_di_f_print_safely_dynamic_partial_)
 
 /**
@@ -543,7 +543,7 @@ extern "C" {
  *
  * @param string
  *   The string to output.
- * @param output
+ * @param stream
  *   The file stream to output to, including standard streams such as stdout and stderr.
  *
  * @return
@@ -559,7 +559,7 @@ extern "C" {
  * @see f_print_raw_terminated()
  */
 #if !defined(_di_f_print_terminated_) || !defined(_di_f_print_raw_terminated_)
-  extern f_status_t private_f_print_terminated(const f_string_t string, FILE * const output) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_print_terminated(const f_string_t string, FILE * const stream) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_print_terminated_) || !defined(_di_f_print_raw_terminated_)
 
 #ifdef __cplusplus