* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
- * Errors (with error bit) from: f_utf_is_valid()
+ * Errors (with error bit) from: f_utf_is_combining().
+ * Errors (with error bit) from: f_utf_is_valid().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_
extern f_status_t fl_print_trim(const f_string_t string, const f_array_length_t length, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_raw_
extern f_status_t fl_print_trim_raw(const f_string_t string, const f_array_length_t length, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_raw_safely_
extern f_status_t fl_print_trim_raw_safely(const f_string_t string, const f_array_length_t length, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_safely_
extern f_status_t fl_print_trim_safely(const f_string_t string, const f_array_length_t length, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_
extern f_status_t fl_print_trim_dynamic(const f_string_static_t buffer, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_raw_
extern f_status_t fl_print_trim_dynamic_raw(const f_string_static_t buffer, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_raw_safely_
extern f_status_t fl_print_trim_dynamic_raw_safely(const f_string_static_t buffer, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_safely_
extern f_status_t fl_print_trim_dynamic_safely(const f_string_static_t buffer, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_partial_
extern f_status_t fl_print_trim_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_partial_raw_
extern f_status_t fl_print_trim_dynamic_partial_raw(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_partial_raw_safely_
extern f_status_t fl_print_trim_dynamic_partial_raw_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_dynamic_partial_safely_
extern f_status_t fl_print_trim_dynamic_partial_safely(const f_string_static_t buffer, const f_string_range_t range, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_
extern f_status_t fl_print_trim_except(const f_string_t string, const f_array_length_t offset, const f_array_length_t length, const f_array_lengths_t except_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_raw_
extern f_status_t fl_print_trim_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_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_raw_safely_
extern f_status_t fl_print_trim_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_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_safely_
extern f_status_t fl_print_trim_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_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_
extern f_status_t fl_print_trim_except_dynamic(const f_string_static_t buffer, const f_array_lengths_t except_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_raw_
extern f_status_t fl_print_trim_except_dynamic_raw(const f_string_static_t buffer, const f_array_lengths_t except_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_raw_safely_
extern f_status_t fl_print_trim_except_dynamic_raw_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_safely_
extern f_status_t fl_print_trim_except_dynamic_safely(const f_string_static_t buffer, const f_array_lengths_t except_at, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_raw_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_raw_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_raw_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_raw_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_partial_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_partial_raw_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_partial_raw_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_in_dynamic_partial_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_partial_
extern f_status_t fl_print_trim_except_dynamic_partial(const f_string_static_t buffer, const f_string_range_t range, const f_array_lengths_t except, FILE * const stream);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_partial_raw_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_partial_raw_safely_
extern f_status_t fl_print_trim_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);
* F_parameter (with error bit) if a parameter is invalid.
* F_utf_not (with error bit) if character is an invalid UTF-8 character.
*
+ * Errors (with error bit) from: f_utf_is_combining().
* Errors (with error bit) from: f_utf_is_valid()
* Errors (with error bit) from: f_utf_is_whitespace().
*
* @see fputc_unlocked()
+ *
+ * @see f_utf_is_combining()
+ * @see f_utf_is_valid()
+ * @see f_utf_is_whitespace()
*/
#ifndef _di_fl_print_trim_except_dynamic_partial_safely_
extern f_status_t fl_print_trim_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);
f_array_length_t i = offset;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_array_length_t at = 0;
f_array_length_t at2 = 0;
f_array_length_t in = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < stop) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
return status;
}
- if (status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, stop - i);
+
+ if (F_status_is_error(status)) {
+ if (F_status_set_fine(status) == F_maybe) {
+ return F_status_set_error(F_utf_not);
+ }
+
+ return status;
+ }
+
+ if (status == F_true) {
+ i = previous;
+ }
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
return status;
}
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < stop) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (at2 < except_at.used && except_at.array[at2] == j) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (in2 < except_in.used && except_in.array[in2].start <= j && except_in.array[in2].stop >= j) {
+ previous = j;
j = except_in.array[in2].stop + 1;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, stop - j);
if (F_status_is_error(status)) {
if (status == F_false && string[j]) break;
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < stop; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, stop - k);
+
+ break;
+ }
+ } // while
+
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ if (k >= stop) {
+ j = k;
+
+ break;
+ }
+ }
+
+ previous = j;
j += macro_f_utf_byte_width(string[j]);
} // while
if (j >= stop) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
if (!string[i]) {
if (i >= stop) break;
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = offset;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_array_length_t at = 0;
f_array_length_t at2 = 0;
f_array_length_t in = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < stop) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
}
status = f_utf_is_whitespace(string + i, stop - i);
+ if (F_status_is_error(status)) break;
- // Consider invalid data not-whitespace.
- if (F_status_is_error(status) || status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, stop - i);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_true) {
+ i = previous;
+ }
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
status = f_utf_is_whitespace(string + i, stop - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < stop) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (at2 < except_at.used && except_at.array[at2] == j) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (in2 < except_in.used && except_in.array[in2].start <= j && except_in.array[in2].stop >= j) {
+ previous = j;
j = except_in.array[in2].stop + 1;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, stop - j);
+ if (F_status_is_error(status)) break;
- if (F_status_is_error(status) || (status == F_false && string[j])) break;
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < stop; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, stop - k);
+
+ break;
+ }
+ } // while
+
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ if (k >= stop) {
+ j = k;
+ break;
+ }
+ }
+
+ previous = j;
j += macro_f_utf_byte_width(string[j]);
} // while
if (j >= stop) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
while (at < except_at.used && except_at.array[at] < i) {
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = offset;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_array_length_t at = 0;
f_array_length_t at2 = 0;
f_array_length_t in = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < stop) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
}
status = f_utf_is_whitespace(string + i, stop - i);
+ if (F_status_is_error(status)) break;
- // Invalid UTF will not be treated as whitespace.
- if (F_status_is_error(status) || status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, stop - i);
+ if (F_status_is_error(status)) break;
+ if (status == F_true) {
+ i = previous;
+ }
+
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
status = f_utf_is_whitespace(string + i, stop - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = j;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < stop) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (at2 < except_at.used && except_at.array[at2] == j) {
- ++j;
+ previous = j++;
continue;
}
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, stop - j);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < stop; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, stop - k);
+
+ break;
+ }
+ } // while
+
+ if (status == F_true) {
+ j = k;
- if (F_status_is_error(status) || (status == F_false && string[i])) break;
+ break;
+ }
+ if (k >= stop) {
+ j = k;
+
+ break;
+ }
+ }
+
+ previous = j;
j += macro_f_utf_byte_width(string[j]);
} // while
if (j >= stop || status == F_true) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
while (at < except_at.used && except_at.array[at] < i) {
return F_status_set_error(F_output);
}
+ previous = i;
+
if (status == F_false) {
i += macro_f_utf_byte_width(string[i]);
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = offset;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_array_length_t at = 0;
f_array_length_t at2 = 0;
f_array_length_t in = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < stop) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
}
status = f_utf_is_whitespace(string + i, stop - i);
+ if (F_status_is_error(status)) break;
- // Invalid UTF will not be treated as whitespace.
- if (F_status_is_error(status) || status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, stop - i);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_true) {
+ i = previous;
+ }
+
+ break;
+ }
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
} // while
if (at < except_at.used && except_at.array[at] == i) {
- ++i;
+ previous = i++;
continue;
}
} // while
if (in < except_in.used && except_in.array[in].start <= i && except_in.array[in].stop >= i) {
+ previous = i;
i = except_in.array[in].stop + 1;
continue;
status = f_utf_is_whitespace(string + i, stop - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < stop) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (at2 < except_at.used && except_at.array[at2] == j) {
- ++j;
+ previous = j++;
continue;
}
} // while
if (in2 < except_in.used && except_in.array[in2].start <= j && except_in.array[in2].stop >= j) {
+ previous = i;
j = except_in.array[in2].stop + 1;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, stop - j);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < stop; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, stop - k);
+
+ break;
+ }
+ } // while
- if (F_status_is_error(status) || (status == F_false && string[i])) break;
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ if (k >= stop) {
+ j = k;
+
+ break;
+ }
+ }
+
+ previous = j;
+ j += macro_f_utf_byte_width(string[j]);
} // while
if (j == stop || status == F_true || !string[i]) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
while (at < except_at.used && except_at.array[at] < i) {
return F_status_set_error(F_output);
}
+ previous = i;
+
if (status == F_false) {
i += macro_f_utf_byte_width(string[i]);
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = 0;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < length) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
return status;
}
- if (status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, length - i);
+ if (F_status_is_error(status)) {
+ if (F_status_set_fine(status) == F_maybe) {
+ return F_status_set_error(F_utf_not);
+ }
+
+ return status;
+ }
+
+ if (status == F_true) {
+ i = previous;
+ }
+
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
return status;
}
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < length) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, length - j);
if (F_status_is_error(status)) {
return status;
}
- if (status == F_false && string[i]) break;
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < length; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, length - k);
+
+ break;
+ }
+ } // while
+
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ if (k >= length) {
+ j = k;
+
+ break;
+ }
+ }
+
+ previous = j;
+ j += macro_f_utf_byte_width(string[j]);
} // while
- if (j == length) break;
+ if (j >= length) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
if (!string[i]) {
if (i >= length) break;
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = 0;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < length) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
status = f_utf_is_whitespace(string + i, length - i);
- // Consider invalid data not-whitespace.
- if (F_status_is_error(status) || status == F_false) break;
+ // Consider invalid data not-white space.
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, length - i);
+ if (F_status_is_error(status)) break;
+ if (status == F_true) {
+ i = previous;
+ }
+
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
status = f_utf_is_whitespace(string + i, length - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < length) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, length - j);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ status = F_none;
+
+ for (k = j + macro_f_utf_byte_width(string[j]); k < length; k += macro_f_utf_byte_width(string[k])) {
+
+ if (string[k]) {
+ status = f_utf_is_combining(string + k, length - k);
+
+ break;
+ }
+ } // while
+
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ if (k >= length) {
+ j = k;
+
+ break;
+ }
+ }
- if (F_status_is_error(status) || (status == F_false && string[i])) break;
+ previous = j;
+ j += macro_f_utf_byte_width(string[j]);
} // while
- if (j == length) break;
+ if (j >= length) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
if (fwrite_unlocked(string + i, 1, macro_f_utf_byte_width(string[i]), stream) < macro_f_utf_byte_width(string[i])) {
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = 0;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < length) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
status = f_utf_is_whitespace(string + i, length - i);
- // Invalid UTF will not be treated as whitespace.
- if (F_status_is_error(status) || status == F_false) break;
+ // Consider invalid data not-white space.
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, length - i);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_true) {
+ i = previous;
+ }
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
status = f_utf_is_whitespace(string + i, length - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = i;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < length) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
status = f_utf_is_whitespace(string + j, length - j);
- if (F_status_is_error(status) || (status == F_false && string[i])) break;
+ if (F_status_is_error(status) || (status == F_false && string[j])) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ k = j + macro_f_utf_byte_width(string[j]);
+
+ if (k < length && string[k]) {
+ status = f_utf_is_combining(string + k, length - k);
+
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ // Reset status.
+ status = F_true;
+
+ if (k >= length) {
+ j = k;
+
+ break;
+ }
+ }
+ }
+
+ previous = j;
+ j += macro_f_utf_byte_width(string[j]);
} // while
- if (j == length || status == F_true) break;
+ if (j >= length || status == F_true) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
if (i + macro_f_utf_byte_width(string[i]) >= length) {
return F_status_set_error(F_output);
}
+ previous = i;
+
if (status == F_false) {
i += macro_f_utf_byte_width(string[i]);
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
f_array_length_t i = 0;
f_array_length_t j = 0;
+ f_array_length_t k = 0;
+ f_array_length_t previous = 0;
f_status_t status = F_none;
- // Skip past leading whitespace.
+ // Skip past leading white space.
while (i < length) {
if (!string[i]) {
- ++i;
+ previous = i++;
continue;
}
status = f_utf_is_whitespace(string + i, length - i);
-
- // Invalid UTF will not be treated as whitespace.
if (F_status_is_error(status) || status == F_false) break;
+ if (status == F_false) {
+ status = f_utf_is_combining(string + i, length - i);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_true) {
+ i = previous;
+ }
+
+ break;
+ }
+
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
status = f_utf_is_whitespace(string + i, length - i);
- // Determine if this is an end of string whitespace that needs to be trimmed.
+ // Determine if this is an end of string white space that needs to be trimmed.
if (status == F_true || !string[i]) {
+ previous = j;
j = i + macro_f_utf_byte_width(string[i]);
status = F_none;
while (j < length) {
if (!string[j]) {
- ++j;
+ previous = j++;
continue;
}
- // @todo need to also check for combining character after this.
status = f_utf_is_whitespace(string + j, length - j);
+ if (F_status_is_error(status)) break;
+
+ if (status == F_false && string[j]) break;
+
+ // Search for the next non-NULL character and check if it is a combining character.
+ if (status == F_true) {
+ k = j + macro_f_utf_byte_width(string[j]);
+
+ if (k < length && string[k]) {
+ status = f_utf_is_combining(string + k, length - k);
- if (F_status_is_error(status) || (status == F_false && string[i])) break;
+ if (status == F_true) {
+ j = k;
+
+ break;
+ }
+
+ // Reset status.
+ status = F_true;
+
+ if (k >= length) {
+ j = k;
+
+ break;
+ }
+ }
+ }
+
+ previous = j;
+ j += macro_f_utf_byte_width(string[j]);
} // while
- if (j == length || status == F_true || !string[i]) break;
+ if (j >= length || status == F_true || !string[j]) break;
- // Print all processed whitespace (note: control characters are not whitespace so no checks for this are needed).
+ // Print all processed white space (note: control characters are not white space so no checks for this are needed).
while (i < j) {
if (i + macro_f_utf_byte_width(string[i]) >= length) {
return F_status_set_error(F_output);
}
+ previous = i;
+
if (status == F_false) {
i += macro_f_utf_byte_width(string[i]);
}
return F_status_set_error(F_output);
}
+ previous = i;
i += macro_f_utf_byte_width(string[i]);
} // while
projects / fll / commitdiff