I am not a fan of having so many "_not".
I believe I even made efforts to reduce its usage in the past.
Having said that, there ended up being too many different cases where "_not" makes sense.
I want things to be consistent, so this commit introduces "_not" more thoroughly unless it makes sense not to.
There are also cases where I have prefixes, such as "un" in unknown.
Change this to be consistent with the "_not" logic.
This results in changes like F_unknown -> F_known_not.
Other minor cleanups exist, such as F_interrupted -> F_interrupt.
I expect down the road there will be changes where these "_not" are used in functions where the "_not" is not used.
(Example: it may be that a function returns F_number (with error bit set) on invalid number, but it may be better to now use F_number_not.)
int result = getgrnam_r(name, &grp, buffer, length, &pointer);
if (result) {
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
const int result = getgrnam_r(name, &grp, buffer, length, &pointer);
if (result) {
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
const int result = getpwnam_r(name, &password, buffer, length, &pointer);
if (result) {
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
const int result = getpwnam_r(name, &password, buffer, length, &pointer);
if (result) {
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
* F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_open_max (with error bit) too many open files.
* F_input_output (with error bit) if an I/O error occurred.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other failure.
* F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_open_max (with error bit) too many open files.
* F_input_output (with error bit) if an I/O error occurred.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other failure.
if (errno == EACCES) return F_status_set_error(F_access_denied);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EBADF) return F_status_set_error(F_directory_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
* F_failure (with error bit) if failed to read directory information.
* F_file_open_max (with error bit) too many open files.
* F_file_type_directory_not (with error bit) file is not a directory.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_failure (with error bit) if failed to read directory information.
* F_file_open_max (with error bit) too many open files.
* F_file_type_directory_not (with error bit) file is not a directory.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
*
* @return
* F_none on success.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
* F_data_not if name.used is 0.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
if (setenv(name, value, replace) < 0) {
if (errno == EINVAL) {
- return F_status_set_error(F_invalid);
+ return F_status_set_error(F_valid_not);
}
else if (errno == ENOMEM) {
return F_status_set_error(F_memory_not);
if (unsetenv(name) < 0) {
if (errno == EINVAL) {
- return F_status_set_error(F_invalid);
+ return F_status_set_error(F_valid_not);
}
else if (errno == ENOMEM) {
return F_status_set_error(F_memory_not);
*
* @return
* F_none on success.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
- * F_invalid (with error bit) if name is an invalid string.
+ * F_valid_not (with error bit) if name is an invalid string.
* F_memory_not (with error bit) on out of memory.
* F_failure (with error bit) on any other error.
*
return F_none;
}
- return F_unsupported;
+ return F_supported_not;
}
#endif // _di_f_file_clone_
return F_none;
}
- return F_unsupported;
+ return F_supported_not;
}
#endif // _di_f_file_copy_
if (!f_macro_file_type_is_fifo(mode) && !f_macro_file_type_is_character(mode) && !f_macro_file_type_is_block(mode)) {
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
const dev_t device = makedev(major, minor);
#endif // _di_level_0_parameter_checking_
if (!f_macro_file_type_is_fifo(mode) && !f_macro_file_type_is_character(mode) && !f_macro_file_type_is_block(mode)) {
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
const dev_t device = makedev(major, minor);
#endif // _di_level_0_parameter_checking_
if (!f_macro_file_type_is_fifo(mode) && !f_macro_file_type_is_character(mode) && !f_macro_file_type_is_block(mode)) {
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
return private_f_file_create_node(path, mode, device);
#endif // _di_level_0_parameter_checking_
if (!f_macro_file_type_is_fifo(mode) && !f_macro_file_type_is_character(mode) && !f_macro_file_type_is_block(mode)) {
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
return private_f_file_create_node_at(at_id, path, mode, device);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENOENT) return F_status_set_error(F_file_found_not);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENOENT) return F_status_set_error(F_file_found_not);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (*seeked < 0) {
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EINVAL) return F_status_set_error(F_parameter);
- if (errno == ENXIO) return F_status_set_error(F_bound_out);
+ if (errno == ENXIO) return F_status_set_error(F_bound_not);
if (errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
if (errno == ESPIPE) return F_status_set_error(F_file_type_pipe);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EDEADLK) return F_status_set_error(F_deadlock);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENOLCK) return F_status_set_error(F_lock);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EDEADLK) return F_status_set_error(F_deadlock);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENOLCK) return F_status_set_error(F_lock);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
if (errno == EROFS) return F_status_set_error(F_read_only);
if (errno == ETXTBSY) return F_status_set_error(F_busy);
if (errno == EISDIR) return F_status_set_error(F_directory);
- if (errno == EOPNOTSUPP) return F_status_set_error(F_unsupported);
+ if (errno == EOPNOTSUPP) return F_status_set_error(F_supported_not);
return F_status_set_error(F_failure);
}
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EDEADLK) return F_status_set_error(F_deadlock);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENOLCK) return F_status_set_error(F_lock);
* F_file_read (with error bit) on file read error.
* F_file_write (with error bit) on file write error.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported if copying a given type of file is unsupported.
+ * F_supported_not if copying a given type of file is unsupported.
* F_failure (with error bit) for any other error.
*/
#ifndef _di_f_file_clone_
* F_file_synchronize (with error bit) on flush failure.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
*
* @see fclose()
* F_file_read (with error bit) on file read error.
* F_file_write (with error bit) on file write error.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported if copying a given type of file is unsupported.
+ * F_supported_not if copying a given type of file is unsupported.
* F_failure (with error bit) for any other error.
*/
#ifndef _di_f_file_copy_
* F_file_found (with error bit) if a file was found while exclusive is TRUE.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file was found while exclusive is TRUE.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see makedev()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see makedev()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see mkfifo()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see mkfifoat()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see mknod()
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_failure (with error bit) for any other error.
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
*
* @see mknodat()
*/
* F_input_output (with error bit) on I/O error.
* F_parameter (with error bit) if a parameter is invalid.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) if the file system or file type does not support flushing.
+ * F_supported_not (with error bit) if the file system or file type does not support flushing.
* F_failure (with error bit) on any other failure.
*
* @see fsync()
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_directory (with error bit) if a supposed directory in path is not actually a directory.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file aleady exists at the path.
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file aleady exists at the path.
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file aleady exists at the path.
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_file_type_not_directory (with error bit) if F_NOTIFY was specified and file.id is not a directory.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name is too long.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
- * F_unsupported (with error bit) fo unsupported file types.
+ * F_supported_not (with error bit) fo unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see open()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
*
* @return
* F_none on success.
- * F_bound_out (with error bit) if SEEK_DATA or SEEK_HOLE is specified as whence and offset is beyond the end of file.
+ * F_bound_not (with error bit) if SEEK_DATA or SEEK_HOLE is specified as whence and offset is beyond the end of file.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_pipe (with error bit) if file descriptor represents a pipe, socket, or FIFO.
* F_number_overflow (with error bit) on overflow for offset.
* F_file_type_not_directory (with error bit) if F_NOTIFY was specified and file.id is not a directory.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_lock (with error bit) if failed to lock, such as lock table is full or too many open segments.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_file_descriptor (with error bit) if file descriptor is invalid.
* F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_type_not_directory (with error bit) if F_NOTIFY was specified and file.id is not a directory.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_lock (with error bit) if failed to lock, such as lock table is full or too many open segments.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_file_type_not_directory (with error bit) if F_NOTIFY was specified and file.id is not a directory.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name is too long.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
- * F_unsupported (with error bit) fo unsupported file types.
+ * F_supported_not (with error bit) fo unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see fileno()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fread()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fread()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fread()
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_file_type_not_directory (with error bit) if F_NOTIFY was specified and file.id is not a directory.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name is too long.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
- * F_unsupported (with error bit) fo unsupported file types.
+ * F_supported_not (with error bit) fo unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see fileno()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fwrite()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fwrite()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fwrite()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fwrite()
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
if (close(*id) < 0) {
if (errno == EBADF) return F_status_set_error(F_directory_descriptor);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOSPC) return F_status_set_error(F_space_not);
if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOSPC) return F_status_set_error(F_space_not);
- if (errno == EROFS) return F_status_set_error(F_unsupported);
+ if (errno == EROFS) return F_status_set_error(F_supported_not);
if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
return F_status_set_error(F_failure);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENOENT) return F_status_set_error(F_file_found_not);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENOENT) return F_status_set_error(F_file_found_not);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
if (errno == EROFS) return F_status_set_error(F_read_only);
if (errno == ETXTBSY) return F_status_set_error(F_busy);
if (errno == EISDIR) return F_status_set_error(F_directory);
- if (errno == EOPNOTSUPP) return F_status_set_error(F_unsupported);
+ if (errno == EOPNOTSUPP) return F_status_set_error(F_supported_not);
return F_status_set_error(F_failure);
}
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EFBIG || errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
if (errno == EROFS) return F_status_set_error(F_read_only);
if (errno == ETXTBSY) return F_status_set_error(F_busy);
if (errno == EISDIR) return F_status_set_error(F_directory);
- if (errno == EOPNOTSUPP) return F_status_set_error(F_unsupported);
+ if (errno == EOPNOTSUPP) return F_status_set_error(F_supported_not);
return F_status_set_error(F_failure);
}
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
* F_file_synchronize (with error bit) on flush failure.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_parameter (with error bit) if a parameter is invalid.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
*
* F_file_read (with error bit) on file read error.
* F_file_write (with error bit) on file write error.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_read_only (with error bit) if file is read-only.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported if copying a given type of file is unsupported.
+ * F_supported_not if copying a given type of file is unsupported.
* F_failure (with error bit) for any other error.
*
* @see f_file_copy()
* F_file_found (with error bit) if a file was found while exclusive is TRUE.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file was found while exclusive is TRUE.
* F_file_open_max (with error bit) when system-wide max open files is reached.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see f_file_create_fifo()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see f_file_create_fifo_at()
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
* F_failure (with error bit) for any other error.
*
* @see f_file_copy()
* F_prohibited (with error bit) if filesystem does not allow for making changes.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_failure (with error bit) for any other error.
- * F_unsupported (with error bit) for unsupported file types.
+ * F_supported_not (with error bit) for unsupported file types.
*
* @see f_file_copy_at()
* @see f_file_create_device_at()
* F_input_output (with error bit) on I/O error.
* F_parameter (with error bit) if a parameter is invalid.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) if the file system or file type does not support flushing.
+ * F_supported_not (with error bit) if the file system or file type does not support flushing.
* F_failure (with error bit) on any other failure.
*
* @see f_file_close()
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_directory (with error bit) if a supposed directory in path is not actually a directory.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_found (with error bit) if a file aleady exists at the path.
* F_file_found_not (with error bit) if a parent path in point does not exist or is a broken symlink.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_loop (with error bit) on loop error.
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see f_file_stream_write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see f_file_write()
else if (width == 1) {
// Do not operate on UTF-8 fragments that are not the first byte of the character.
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
if (range->start + width >= buffer.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
if (range->start + width > range->stop) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
}
else if (width == 1) {
// Do not operate on UTF-8 fragments that are not the first byte of the character.
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
if (range->start + width >= buffer.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
if (range->start + width > range->stop) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
}
* F_none_eol on success and EOL was reached.
* F_none_eos on success and EOS was reached.
* F_none_stop on success and stop point was reached.
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment was found.
- * F_incomplete_utf_eos (with error bit) if unable to get entire UTF-8 sequence due to EOS.
- * F_incomplete_utf_stop (with error bit) if unable to get entire UTF-8 sequence due to stop point reached.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment was found.
+ * F_complete_not_utf_eos (with error bit) if unable to get entire UTF-8 sequence due to EOS.
+ * F_complete_not_utf_stop (with error bit) if unable to get entire UTF-8 sequence due to stop point reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_is_control().
* F_none_eol on success and EOL was reached.
* F_none_eos on success and EOS was reached.
* F_none_stop on success and stop point was reached.
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment was found.
- * F_incomplete_utf_eos (with error bit) if unable to get entire UTF-8 sequence due to EOS.
- * F_incomplete_utf_stop (with error bit) if unable to get entire UTF-8 sequence due to stop point reached.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment was found.
+ * F_complete_not_utf_eos (with error bit) if unable to get entire UTF-8 sequence due to EOS.
+ * F_complete_not_utf_stop (with error bit) if unable to get entire UTF-8 sequence due to stop point reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_is_graph().
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see f_print_to()
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see f_print_to_except()
return F_none_eos;
}
- if (i + width > serialize.used) return F_status_set_error(F_incomplete_utf_eos);
+ if (i + width > serialize.used) return F_status_set_error(F_complete_not_utf_eos);
} // for
return F_data_not_eos;
* F_none on success.
* F_none_eos on success at end of string.
* F_data_not_eos if end of string reached before index was reached.
- * F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#if !defined(_di_f_serialize_un_simple_find_) || !defined(_di_f_serialize_un_simple_get_)
}
if (i + width > serialize.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
start = i + width;
}
else if (i + width > serialize.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
i += width;
locations->used++;
if (i + width > serialize.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
start = i + width;
}
else if (i + width > serialize.used) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
} // for
*
* @return
* F_none on success.
- * F_incomplete_utf_eos if end of sting is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos if end of sting is reached before a complete UTF-8 character can be processed.
* F_array_too_large (with error bit) if a buffer would exceed maximum length.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_none on success.
- * F_incomplete_utf_eos if end of sting is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos if end of sting is reached before a complete UTF-8 character can be processed.
* F_array_too_large (with error bit) if a buffer would exceed memory max length.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none on success.
* F_none_eos on success at end of string.
* F_data_not_eos if end of string reached before index was reached.
- * F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_serialize_un_simple_find_
* F_none on success.
* F_none_eos on success at end of string.
* F_data_not_eos if end of string reached before index was reached (dynamic->used is set to 0).
- * F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
*/
if (close(signal->id) < 0) {
if (errno == EBADF) return F_status_set_error(F_descriptor);
if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOSPC) return F_status_set_error(F_parameter);
if (result < 0) {
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == ENOMEM) return F_status_set_error(F_memory_not);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
* F_descriptor (with error bit) if id is an invalid descriptor.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_input_output (with error bit) if an I/O error occurred.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) for any other error.
*
* F_block (with error bit) if file descriptor is set to non-block and the read would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_descriptor (with error bit) if the signal descriptor is invalid.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_input_output (with error bit) on I/O error.
if (bind(id, (struct sockaddr *) address, sizeof(struct sockaddr_un)) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
if (errno == EADDRINUSE) return F_status_set_error(F_busy_address);
- if (errno == EADDRNOTAVAIL) return F_status_set_error(F_unavailable_address);
+ if (errno == EADDRNOTAVAIL) return F_status_set_error(F_available_not_address);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EINVAL) return F_status_set_error(F_busy_socket);
if (errno == ELOOP) return F_status_set_error(F_loop);
if (errno == EADDRINUSE) return F_status_set_error(F_busy_address);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == ENOTSOCK) return F_status_set_error(F_descriptor);
- if (errno == EOPNOTSUPP) return F_status_set_error(F_unsupported);
+ if (errno == EOPNOTSUPP) return F_status_set_error(F_supported_not);
return F_status_set_error(F_failure);
}
result = shutdown(id, action);
}
else {
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
}
if (result < 0) {
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_value);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOTCONN) return F_connected_not;
* F_memory_not (with error bit) if out of memory.
* F_name (with error bit) on path name error.
* F_string_too_large (with error bit) if string is too large to store in the buffer.
- * F_unavailable_address (with error bit) if address is unavailable (is non-existent or not local).
+ * F_available_not_address (with error bit) if address is unavailable (is non-existent or not local).
* F_failure (with error bit) for any other error.
*
* @see bind()
* F_busy_address (with error bit) if address is already in use (therefore unavailable).
* F_descriptor (with error bit) if the id is not a socket descriptor.
* F_file_descriptor (with error bit) if id is an invalid descriptor.
- * F_unsupported (with error bit) if this socket does not support the listen() operation.
+ * F_supported_not (with error bit) if this socket does not support the listen() operation.
* F_failure (with error bit) for any other error.
*
* @see listen()
* F_file_descriptor (with error bit) if id is an invalid descriptor.
* F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_input_output (with error bit) if an I/O error occurred.
- * F_interrupted (with error bit) when program received an interrupt signal, halting operation.
+ * F_interrupt (with error bit) when program received an interrupt signal, halting operation.
* F_parameter (with error bit) if a parameter is invalid.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
- * F_unsupported (with error bit) if this socket does not support the listen() operation.
+ * F_supported_not (with error bit) if this socket does not support the listen() operation.
* F_failure (with error bit) for any other error.
*
* @see close()
#ifndef _di_F_status_basic_
F_none = 197,
F_absolute,
+ F_absolute_not,
F_address,
+ F_address_not,
F_block,
- F_bound_out,
+ F_block_not,
+ F_bound,
+ F_bound_not,
+ F_complete,
+ F_complete_not,
F_connected,
F_connected_not,
F_critical,
+ F_critical_not,
F_deadlock,
+ F_deadlock_not,
F_descriptor,
+ F_descriptor_not,
F_device,
+ F_device_not,
F_dummy,
+ F_dummy_not,
F_encoding,
F_encoding_not,
F_eof,
+ F_eof_not,
F_eol,
+ F_eol_not,
F_eos,
+ F_eos_not,
F_exist,
F_exist_not,
F_failure,
+ F_failure_not,
F_fork,
+ F_fork_not,
F_found,
F_found_not,
- F_incomplete,
F_input,
+ F_input_not,
F_input_output,
- F_interrupted,
- F_invalid,
- F_output,
+ F_interrupt,
+ F_interrupt_not,
+ F_known,
+ F_known_not,
F_link,
F_link_not,
F_lock,
F_lock_not,
F_loop,
+ F_loop_not,
F_maybe,
- F_memory,
- F_memory_not,
+ F_maybe_not,
F_mount,
+ F_mount_not,
F_name,
+ F_name_not,
+ F_output,
+ F_output_not,
F_parameter,
+ F_parameter_not,
F_pipe,
+ F_pipe_not,
F_port,
- F_process,
- F_process_too_many,
+ F_port_not,
F_prohibited,
+ F_prohibited_not,
F_range,
F_range_not,
+ F_read,
+ F_read_not,
F_read_only,
F_recurse,
+ F_recurse_not,
F_relative,
+ F_relative_not,
F_resource,
F_resource_not,
F_search,
+ F_search_not,
F_signal,
+ F_signal_not,
F_space,
F_space_not,
F_stop,
+ F_stop_not,
+ F_string,
+ F_string_not,
+ F_string_too_large,
+ F_string_too_small,
+ F_supported,
+ F_supported_not,
F_syntax,
- F_unknown,
- F_unsupported,
+ F_syntax_not,
F_utf,
F_utf_not,
+ F_valid,
+ F_valid_not,
F_value,
F_value_not,
F_warn,
+ F_warn_not,
+ F_write,
+ F_write_not,
F_write_only,
#endif // _di_F_status_basic_
#ifndef _di_F_status_array_
F_array,
+ F_array_not,
F_array_too_large,
F_array_too_small,
#endif // _di_F_status_array_
+ #ifndef _di_F_status_available_
+ F_available,
+ F_available_not,
+ F_available_not_address,
+ F_available_not_buffer,
+ F_available_not_device,
+ F_available_not_pipe,
+ F_available_not_port,
+ F_available_not_process,
+ F_available_not_socket,
+ #endif // _di_F_status_available_
+
#ifndef _di_F_status_busy_
F_busy,
F_busy_address,
F_busy_buffer,
F_busy_device,
+ F_busy_not,
F_busy_pipe,
F_busy_port,
F_busy_process,
F_busy_socket,
#endif // _di_F_status_busy_
- #ifndef _di_F_status_unavailable_
- F_unavailable,
- F_unavailable_address,
- F_unavailable_buffer,
- F_unavailable_device,
- F_unavailable_pipe,
- F_unavailable_port,
- F_unavailable_process,
- F_unavailable_socket,
- #endif // _di_F_status_unavailable_
-
#ifndef _di_F_status_number_
F_number,
F_number_decimal,
+ F_number_decimal_not,
F_number_divide_by_zero,
F_number_negative,
+ F_number_negative_not,
+ F_number_not,
F_number_overflow,
F_number_positive,
+ F_number_positive_not,
F_number_underflow,
F_number_whole,
+ F_number_whole_not,
F_number_zero,
+ F_number_zero_not,
#endif // _di_F_status_number_
#ifndef _di_F_status_buffer_
F_buffer,
- F_buffer_too_small,
+ F_buffer_not,
F_buffer_too_large,
- F_incomplete_utf,
- F_incomplete_utf_block,
- F_incomplete_utf_eof,
- F_incomplete_utf_eol,
- F_incomplete_utf_eos,
- F_incomplete_utf_stop,
+ F_buffer_too_small,
+ F_complete_not_utf,
+ F_complete_not_utf_block,
+ F_complete_not_utf_eof,
+ F_complete_not_utf_eol,
+ F_complete_not_utf_eos,
+ F_complete_not_utf_stop,
F_none_block,
F_none_eof,
F_none_eol,
F_data_not_eol,
F_data_not_eos,
F_data_not_stop,
- F_string_too_small,
- F_string_too_large,
- F_unterminated,
- F_unterminated_block,
- F_unterminated_eof,
- F_unterminated_eol,
- F_unterminated_eos,
- F_unterminated_stop,
- F_unterminated_group,
- F_unterminated_group_block,
- F_unterminated_group_eof,
- F_unterminated_group_eol,
- F_unterminated_group_eos,
- F_unterminated_group_stop,
- F_unterminated_nest,
- F_unterminated_nest_block,
- F_unterminated_nest_eof,
- F_unterminated_nest_eol,
- F_unterminated_nest_eos,
- F_unterminated_nest_stop,
+ F_terminated,
+ F_terminated_not,
+ F_terminated_not_block,
+ F_terminated_not_eof,
+ F_terminated_not_eol,
+ F_terminated_not_eos,
+ F_terminated_not_group,
+ F_terminated_not_group_block,
+ F_terminated_not_group_eof,
+ F_terminated_not_group_eol,
+ F_terminated_not_group_eos,
+ F_terminated_not_group_stop,
+ F_terminated_not_nest,
+ F_terminated_not_nest_block,
+ F_terminated_not_nest_eof,
+ F_terminated_not_nest_eol,
+ F_terminated_not_nest_eos,
+ F_terminated_not_nest_stop,
+ F_terminated_not_stop,
#endif // _di_F_status_buffer_
#ifndef _di_F_status_memory_
+ F_memory,
F_memory_allocation,
F_memory_deallocation,
+ F_memory_not,
F_memory_reallocation,
#endif // _di_F_status_memory_
+ #ifndef _di_F_status_process_
+ F_process,
+ F_process_not,
+ F_process_too_many,
+ #endif // _di_F_status_process_
+
#ifndef _di_F_status_file_
F_file,
F_file_allocation,
F_file_flush,
F_file_found,
F_file_found_not,
+ F_file_not,
F_file_open,
F_file_opened,
F_file_open_max,
#ifndef _di_F_status_filesystem_
F_filesystem,
+ F_filesystem_not,
F_filesystem_quota_block,
F_filesystem_quota_reached,
#endif // _di_F_status_filesystem_
F_directory_found_not,
F_directory_flush,
F_directory_link_max,
+ F_directory_not,
F_directory_open,
F_directory_purge,
F_directory_read,
#ifndef _di_F_status_socket_
F_socket,
F_socket_client,
+ F_socket_not,
F_socket_receive,
F_socket_send,
F_socket_target,
F_access_granted_write,
F_access_group,
F_access_mode,
+ F_access_not,
F_access_owner,
#endif // _di_F_status_access_
if (width > range->start) {
if (width > 1) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
return F_none_eos;
if (range->start + width > range->stop) {
if (width > 1) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
range->start += width;
}
else if (range->start + width >= buffer.used) {
if (width > 1) {
- return F_status_set_error(F_incomplete_utf_eos);
+ return F_status_set_error(F_complete_not_utf_eos);
}
range->start += width;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
return F_true;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
const uint8_t width = f_macro_utf_byte_width_is(*character);
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
}
if (width == 1) {
- return F_status_is_error(F_incomplete_utf);
+ return F_status_is_error(F_complete_not_utf);
}
f_utf_character_t character_utf = 0;
* F_none_stop if the stop range is reached before all steps are completed.
* F_none_eos if the end of buffer is reached before all steps are completed.
* F_data_not if buffer is empty or out of range.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_utf_buffer_decrement_
* F_none_stop if the stop range is reached before all steps are completed.
* F_none_eos if the end of buffer is reached before all steps are completed.
* F_data_not if buffer is empty or out of range.
- * F_incomplete_utf_stop (with error bit) if the stop range is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop range is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_utf_buffer_increment_
* @return
* F_true if a UTF-8 character.
* F_false if not a UTF-8 character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_utf_is_
* @return
* F_true if a UTF-8 alphabet character.
* F_false if not a UTF-8 alphabet character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalpha()
*/
* @return
* F_true if a UTF-8 alphabet character.
* F_false if not a UTF-8 alpha-numeric character.x
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalnum()
*/
* @return
* F_true if a UTF-8 alphabet character.
* F_false if not a UTF-8 alpha-numeric character.x
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalnum()
*/
* @return
* F_true if an ASCII character.
* F_false if not an ASCII character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_ascii_
extern f_return_status f_utf_is_ascii(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 control picture character.
* F_false if not a UTF-8 control picture character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_combining_
extern f_return_status f_utf_is_combining(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 control character.
* F_false if not a UTF-8 control character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see iscntrl()
*/
* @return
* F_true if a UTF-8 control picture character.
* F_false if not a UTF-8 control picture character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_control_picture_
extern f_return_status f_utf_is_control_picture(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 digit character.
* F_false if not a UTF-8 digit character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isdigit()
*/
* @return
* F_true if a UTF-8 emoji character.
* F_false if not a UTF-8 emoji character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_emoji_
extern f_return_status f_utf_is_emoji(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 graph.
* F_false if not a UTF-8 graph.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_maybe (with error bit) if this could be a graph but width is not long enough.
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_true if a UTF-8 numeric character.
* F_false if not a UTF-8 numeric character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isdigit()
*/
* @return
* F_true if a UTF-8 phonetic character.
* F_false if not a UTF-8 phonetic character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_phonetic_
extern f_return_status f_utf_is_phonetic(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 punctuation character.
* F_false if not a UTF-8 punctuation character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_private_
extern f_return_status f_utf_is_private(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 punctuation character.
* F_false if not a UTF-8 punctuation character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_punctuation_
extern f_return_status f_utf_is_punctuation(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if a UTF-8 symbol character.
* F_false if not a UTF-8 symbol character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*/
#ifndef _di_f_utf_is_symbol_
extern f_return_status f_utf_is_symbol(const f_string_t character, const f_string_length_t width_max);
* @return
* F_true if an unassigned UTF-8 character.
* F_false if not an unassigned UTF-8 character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_parameter (with error bit) if a parameter is inunassigned.
*/
#ifndef _di_f_utf_is_unassigned_
* @return
* F_true if a valid UTF-8 character.
* F_false if not a valid UTF-8 character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_utf_is_valid_
* @return
* F_true if a UTF-8 whitespace.
* F_false if not a UTF-8 whitespace.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_maybe (with error bit) if this could be a whitespace but width is not long enough.
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_true if a UTF-8 whitespace.
* F_false if not a UTF-8 whitespace.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_maybe (with error bit) if this could be a whitespace but width is not long enough.
* F_parameter (with error bit) if a parameter is invalid.
*/
* @return
* F_true if a UTF-8 whitespace.
* F_false if not a UTF-8 whitespace.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_maybe (with error bit) if this could be a whitespace but width is not long enough.
* F_parameter (with error bit) if a parameter is invalid.
*/
* @return
* F_true if a UTF-8 word character.
* F_false if not a UTF-8 word character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalnum()
*/
* @return
* F_true if a UTF-8 word or dash character.
* F_false if not a UTF-8 word or dash character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalnum()
*/
* @return
* F_true if a UTF-8 word or dash character.
* F_false if not a UTF-8 word or dash character.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
* @see isalnum()
*/
* @return
* F_true if a UTF-8 whitespace.
* F_false if not a UTF-8 whitespace.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_maybe (with error bit) if this could be a whitespace but width is not long enough.
* F_parameter (with error bit) if a parameter is invalid.
*/
if (F_status_is_error(status)) {
if (status == F_status_set_error(F_maybe)) {
- status = F_status_set_error(F_incomplete_utf);
+ status = F_status_set_error(F_complete_not_utf);
}
return status;
if (F_status_is_error(status)) {
if (status == F_status_set_error(F_maybe)) {
- status = F_status_set_error(F_incomplete_utf);
+ status = F_status_set_error(F_complete_not_utf);
}
return status;
* @return
* F_none on success.
* F_data_not if string starts with a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
* @return
* F_none on success.
* F_data_not if string starts with a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_positive (with error bit) on positive value (has a +, such as '+1', when only '1' is valid here).
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
f_status_t status = f_file_clone(path_source, path_destination, role, recurse.size_block, recurse.exclusive);
- if (F_status_is_error(status) || status == F_unsupported) {
+ if (F_status_is_error(status) || status == F_supported_not) {
if (status == F_status_set_error(F_memory_allocation) || status == F_status_set_error(F_memory_reallocation)) {
return F_status_set_error(status);
}
f_status_t status = f_file_copy(path_source, path_destination, mode, recurse.size_block, recurse.exclusive);
- if (F_status_is_error(status) || status == F_unsupported) {
+ if (F_status_is_error(status) || status == F_supported_not) {
if (status == F_status_set_error(F_memory_allocation) || status == F_status_set_error(F_memory_reallocation)) {
return F_status_set_error(status);
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
if (status == F_true) continue;
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
return status;
}
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_buffer_increment().
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_buffer_increment().
* F_none_stop on success after reaching the range stop.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
graph_first = 0x1;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow_delimited((buffer), (*range), (*found), positions_start, objects, F_none_eos, F_none_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop);
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop);
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop);
if (F_status_is_error(status)) break;
if (depth > 0) {
- fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
+ fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_terminated_not_nest_eos, F_terminated_not_nest_stop)
}
else {
fl_macro_fss_nest_return_on_overflow((buffer), (*range), (*found), (*delimits), delimits_used, (*comments), comments_used, positions_start, objects, F_data_not_eos, F_data_not_stop)
if (range->start > range->stop) {
if (!depth) {
- return F_status_set_error(F_unterminated_stop);
+ return F_status_set_error(F_terminated_not_stop);
}
- return F_status_set_error(F_unterminated_nest_stop);
+ return F_status_set_error(F_terminated_not_nest_stop);
}
if (!depth) {
- return F_status_set_error(F_unterminated_eos);
+ return F_status_set_error(F_terminated_not_eos);
}
- return F_status_set_error(F_unterminated_nest_eos);
+ return F_status_set_error(F_terminated_not_nest_eos);
}
#endif // _di_fl_fss_embedded_list_content_read_
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
content_found = 2;
break;
}
- else if (status == F_unterminated_group_eos || status == F_unterminated_group_eos) {
+ else if (status == F_terminated_not_group_eos || status == F_terminated_not_group_eos) {
if (content_found) {
content_found = 2;
}
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_buffer_increment().
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_utf_buffer_increment().
* F_none_stop on success after reaching the range stop.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching the range stop.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_none_stop on success after reaching stopping point .
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
status = f_fss_is_space(*destination, destination_range);
// when going backwards, getting incomplete UTF-8 sequences is not an error.
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
if (F_status_is_error(status)) {
destination->used = used_start;
status = f_fss_is_space(*destination, destination_range);
// when going backwards, getting incomplete UTF-8 sequences is not an error.
- if (F_status_set_fine(status) == F_incomplete_utf) continue;
+ if (F_status_set_fine(status) == F_complete_not_utf) continue;
if (F_status_is_error(status)) {
destination->used = used_start;
if (range->start >= buffer.used) {
found->stop = buffer.used - 1;
- return F_unterminated_group_eos;
+ return F_terminated_not_group_eos;
}
if (range->start > range->stop) {
found->stop = range->stop;
- return F_unterminated_group_stop;
+ return F_terminated_not_group_stop;
}
if (buffer.string[range->start] == quote_found) {
if (range->start >= buffer.used) {
found->stop = buffer.used - 1;
- return F_unterminated_group_eos;
+ return F_terminated_not_group_eos;
}
if (range->start > range->stop) {
found->stop = range->stop;
- return F_unterminated_group_stop;
+ return F_terminated_not_group_stop;
}
}
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
- * F_unterminated_group_eos if EOS was reached before the a group termination was reached.
- * F_unterminated_group_stop if stop point was reached before the a group termination was reached.
+ * F_terminated_not_group_eos if EOS was reached before the a group termination was reached.
+ * F_terminated_not_group_stop if stop point was reached before the a group termination was reached.
* F_array_too_large (with error bit) if a buffer is too large.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_none_stop on success after reaching the range stop.
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none_eol (with error bit) after reaching an EOL, which is not supported by the standard.
* F_parameter (with error bit) if a parameter is invalid.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
* @return
* F_none on success.
* F_data_not on success but there is nothing to print.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
* F_output (with error bit) on error when printing to output.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
case F_absolute:
*string = FL_status_string_absolute;
break;
+ case F_absolute_not:
+ *string = FL_status_string_absolute_not;
+ break;
case F_address:
*string = FL_status_string_address;
break;
+ case F_address_not:
+ *string = FL_status_string_address_not;
+ break;
case F_block:
*string = FL_status_string_block;
break;
- case F_bound_out:
- *string = FL_status_string_bound_out;
+ case F_block_not:
+ *string = FL_status_string_block_not;
+ break;
+ case F_bound:
+ *string = FL_status_string_bound;
+ break;
+ case F_bound_not:
+ *string = FL_status_string_bound_not;
+ break;
+ case F_complete:
+ *string = FL_status_string_complete;
+ break;
+ case F_complete_not:
+ *string = FL_status_string_complete_not;
break;
case F_connected:
*string = FL_status_string_connected;
case F_critical:
*string = FL_status_string_critical;
break;
+ case F_critical_not:
+ *string = FL_status_string_critical_not;
+ break;
case F_deadlock:
*string = FL_status_string_deadlock;
break;
+ case F_deadlock_not:
+ *string = FL_status_string_deadlock_not;
+ break;
case F_descriptor:
*string = FL_status_string_descriptor;
break;
+ case F_descriptor_not:
+ *string = FL_status_string_descriptor_not;
+ break;
case F_device:
*string = FL_status_string_device;
break;
+ case F_device_not:
+ *string = FL_status_string_device_not;
+ break;
case F_dummy:
*string = FL_status_string_dummy;
break;
+ case F_dummy_not:
+ *string = FL_status_string_dummy_not;
+ break;
case F_encoding:
*string = FL_status_string_encoding;
break;
case F_eof:
*string = FL_status_string_eof;
break;
+ case F_eof_not:
+ *string = FL_status_string_eof_not;
+ break;
case F_eol:
*string = FL_status_string_eol;
break;
+ case F_eol_not:
+ *string = FL_status_string_eol_not;
+ break;
case F_eos:
*string = FL_status_string_eos;
break;
+ case F_eos_not:
+ *string = FL_status_string_eos_not;
+ break;
case F_exist:
*string = FL_status_string_exist;
break;
case F_failure:
*string = FL_status_string_failure;
break;
+ case F_failure_not:
+ *string = FL_status_string_failure_not;
+ break;
case F_fork:
*string = FL_status_string_fork;
break;
+ case F_fork_not:
+ *string = FL_status_string_fork_not;
+ break;
case F_found:
*string = FL_status_string_found;
break;
case F_found_not:
*string = FL_status_string_found_not;
break;
- case F_incomplete:
- *string = FL_status_string_incomplete;
- break;
case F_input:
*string = FL_status_string_input;
break;
+ case F_input_not:
+ *string = FL_status_string_input_not;
+ break;
case F_input_output:
*string = FL_status_string_input_output;
break;
- case F_interrupted:
- *string = FL_status_string_interrupted;
+ case F_interrupt:
+ *string = FL_status_string_interrupt;
break;
- case F_invalid:
- *string = FL_status_string_invalid;
+ case F_interrupt_not:
+ *string = FL_status_string_interrupt_not;
break;
- case F_output:
- *string = FL_status_string_output;
+ case F_valid:
+ *string = FL_status_string_valid;
+ break;
+ case F_valid_not:
+ *string = FL_status_string_valid_not;
break;
case F_link:
*string = FL_status_string_link;
case F_loop:
*string = FL_status_string_loop;
break;
+ case F_loop_not:
+ *string = FL_status_string_loop_not;
+ break;
case F_maybe:
*string = FL_status_string_maybe;
break;
- case F_memory:
- *string = FL_status_string_memory;
- break;
- case F_memory_not:
- *string = FL_status_string_memory_out;
+ case F_maybe_not:
+ *string = FL_status_string_maybe_not;
break;
case F_mount:
*string = FL_status_string_mount;
break;
+ case F_mount_not:
+ *string = FL_status_string_mount_not;
+ break;
case F_name:
*string = FL_status_string_name;
break;
+ case F_name_not:
+ *string = FL_status_string_name_not;
+ break;
+ case F_output:
+ *string = FL_status_string_output;
+ break;
+ case F_output_not:
+ *string = FL_status_string_output_not;
+ break;
case F_parameter:
*string = FL_status_string_parameter;
break;
+ case F_parameter_not:
+ *string = FL_status_string_parameter_not;
+ break;
case F_pipe:
*string = FL_status_string_pipe;
break;
+ case F_pipe_not:
+ *string = FL_status_string_pipe_not;
+ break;
case F_port:
*string = FL_status_string_port;
break;
- case F_process:
- *string = FL_status_string_process;
- break;
- case F_process_too_many:
- *string = FL_status_string_process_too_many;
+ case F_port_not:
+ *string = FL_status_string_port_not;
break;
case F_prohibited:
*string = FL_status_string_prohibited;
break;
+ case F_prohibited_not:
+ *string = FL_status_string_prohibited_not;
+ break;
case F_range:
*string = FL_status_string_range;
break;
case F_range_not:
*string = FL_status_string_range_not;
break;
+ case F_read:
+ *string = FL_status_string_read;
+ break;
+ case F_read_not:
+ *string = FL_status_string_read_not;
+ break;
case F_read_only:
*string = FL_status_string_read_only;
break;
case F_recurse:
*string = FL_status_string_recurse;
break;
+ case F_recurse_not:
+ *string = FL_status_string_recurse_not;
+ break;
case F_relative:
*string = FL_status_string_relative;
break;
+ case F_relative_not:
+ *string = FL_status_string_relative_not;
+ break;
case F_resource:
*string = FL_status_string_resource;
break;
case F_search:
*string = FL_status_string_search;
break;
+ case F_search_not:
+ *string = FL_status_string_search_not;
+ break;
case F_signal:
*string = FL_status_string_signal;
break;
+ case F_signal_not:
+ *string = FL_status_string_signal_not;
+ break;
case F_space:
*string = FL_status_string_space;
break;
case F_stop:
*string = FL_status_string_stop;
break;
+ case F_stop_not:
+ *string = FL_status_string_stop_not;
+ break;
+ case F_string:
+ *string = FL_status_string_string;
+ break;
+ case F_string_not:
+ *string = FL_status_string_string_not;
+ break;
+ case F_string_too_large:
+ *string = FL_status_string_string_too_large;
+ break;
+ case F_string_too_small:
+ *string = FL_status_string_string_too_small;
+ break;
case F_syntax:
*string = FL_status_string_syntax;
break;
- case F_unknown:
- *string = FL_status_string_unknown;
+ case F_syntax_not:
+ *string = FL_status_string_syntax_not;
+ break;
+ case F_known:
+ *string = FL_status_string_known;
+ break;
+ case F_known_not:
+ *string = FL_status_string_known_not;
break;
- case F_unsupported:
- *string = FL_status_string_unsupported;
+ case F_supported:
+ *string = FL_status_string_supported;
+ break;
+ case F_supported_not:
+ *string = FL_status_string_supported_not;
break;
case F_utf:
*string = FL_status_string_utf;
case F_warn:
*string = FL_status_string_warn;
break;
+ case F_warn_not:
+ *string = FL_status_string_warn_not;
+ break;
+ case F_write:
+ *string = FL_status_string_write;
+ break;
+ case F_write_not:
+ *string = FL_status_string_write_not;
+ break;
case F_write_only:
*string = FL_status_string_write_only;
break;
case F_array:
*string = FL_status_string_array;
break;
- case F_array_too_small:
- *string = FL_status_string_array_too_small;
+ case F_array_not:
+ *string = FL_status_string_array_not;
break;
case F_array_too_large:
*string = FL_status_string_array_too_large;
break;
+ case F_array_too_small:
+ *string = FL_status_string_array_too_small;
+ break;
#endif // _di_F_status_array_
+ #ifndef _di_F_status_available_
+ case F_available:
+ *string = FL_status_string_available;
+ break;
+ case F_available_not:
+ *string = FL_status_string_available_not;
+ break;
+ case F_available_not_address:
+ *string = FL_status_string_available_not_address;
+ break;
+ case F_available_not_buffer:
+ *string = FL_status_string_available_not_buffer;
+ break;
+ case F_available_not_device:
+ *string = FL_status_string_available_not_device;
+ break;
+ case F_available_not_pipe:
+ *string = FL_status_string_available_not_pipe;
+ break;
+ case F_available_not_port:
+ *string = FL_status_string_available_not_port;
+ break;
+ case F_available_not_process:
+ *string = FL_status_string_available_not_process;
+ break;
+ case F_available_not_socket:
+ *string = FL_status_string_available_not_socket;
+ break;
+ #endif // _di_F_status_available_
+
#ifndef _di_F_status_busy_
case F_busy:
*string = FL_status_string_busy;
case F_busy_device:
*string = FL_status_string_busy_device;
break;
+ case F_busy_not:
+ *string = FL_status_string_busy_not;
+ break;
case F_busy_pipe:
*string = FL_status_string_busy_pipe;
break;
break;
#endif // _di_F_status_busy_
- #ifndef _di_F_status_unavailable_
- case F_unavailable:
- *string = FL_status_string_unavailable;
- break;
- case F_unavailable_address:
- *string = FL_status_string_unavailable_address;
- break;
- case F_unavailable_buffer:
- *string = FL_status_string_unavailable_buffer;
- break;
- case F_unavailable_device:
- *string = FL_status_string_unavailable_device;
- break;
- case F_unavailable_pipe:
- *string = FL_status_string_unavailable_pipe;
- break;
- case F_unavailable_port:
- *string = FL_status_string_unavailable_port;
- break;
- case F_unavailable_process:
- *string = FL_status_string_unavailable_process;
- break;
- case F_unavailable_socket:
- *string = FL_status_string_unavailable_socket;
- break;
- #endif // _di_F_status_unavailable_
-
#ifndef _di_F_status_number_
case F_number:
*string = FL_status_string_number;
case F_number_decimal:
*string = FL_status_string_number_decimal;
break;
+ case F_number_decimal_not:
+ *string = FL_status_string_number_decimal_not;
+ break;
case F_number_divide_by_zero:
*string = FL_status_string_number_divide_by_zero;
break;
case F_number_negative:
*string = FL_status_string_number_negative;
break;
+ case F_number_negative_not:
+ *string = FL_status_string_number_negative_not;
+ break;
+ case F_number_not:
+ *string = FL_status_string_number_not;
+ break;
case F_number_overflow:
*string = FL_status_string_number_overflow;
break;
case F_number_positive:
*string = FL_status_string_number_positive;
break;
+ case F_number_positive_not:
+ *string = FL_status_string_number_positive_not;
+ break;
case F_number_underflow:
*string = FL_status_string_number_underflow;
break;
case F_number_whole:
*string = FL_status_string_number_whole;
break;
+ case F_number_whole_not:
+ *string = FL_status_string_number_whole_not;
+ break;
case F_number_zero:
*string = FL_status_string_number_zero;
break;
+ case F_number_zero_not:
+ *string = FL_status_string_number_zero_not;
+ break;
#endif // _di_F_status_number_
#ifndef _di_F_status_buffers_
case F_buffer:
*string = FL_status_string_buffer;
break;
- case F_buffer_too_small:
- *string = FL_status_string_buffer_too_small;
+ case F_buffer_not:
+ *string = FL_status_string_buffer_not;
break;
case F_buffer_too_large:
*string = FL_status_string_buffer_too_large;
break;
- case F_incomplete_utf:
- *string = FL_status_string_incomplete_utf;
+ case F_buffer_too_small:
+ *string = FL_status_string_buffer_too_small;
break;
- case F_incomplete_utf_block:
- *string = FL_status_string_incomplete_utf_block;
+ case F_complete_not_utf_block:
+ *string = FL_status_string_complete_not_utf_block;
break;
- case F_incomplete_utf_eof:
- *string = FL_status_string_incomplete_utf_eof;
+ case F_complete_not_utf_eof:
+ *string = FL_status_string_complete_not_utf_eof;
break;
- case F_incomplete_utf_eol:
- *string = FL_status_string_incomplete_utf_eol;
+ case F_complete_not_utf_eol:
+ *string = FL_status_string_complete_not_utf_eol;
break;
- case F_incomplete_utf_eos:
- *string = FL_status_string_incomplete_utf_eos;
+ case F_complete_not_utf_eos:
+ *string = FL_status_string_complete_not_utf_eos;
break;
- case F_incomplete_utf_stop:
- *string = FL_status_string_incomplete_utf_stop;
+ case F_complete_not_utf_stop:
+ *string = FL_status_string_complete_not_utf_stop;
break;
case F_none_block:
*string = FL_status_string_none_block;
case F_data_not_stop:
*string = FL_status_string_data_not_stop;
break;
- case F_string_too_small:
- *string = FL_status_string_string_too_small;
+ case F_terminated:
+ *string = FL_status_string_terminated;
break;
- case F_string_too_large:
- *string = FL_status_string_string_too_large;
+ case F_terminated_not:
+ *string = FL_status_string_terminated_not;
break;
- case F_unterminated:
- *string = FL_status_string_unterminated;
+ case F_terminated_not_block:
+ *string = FL_status_string_terminated_not_block;
break;
- case F_unterminated_block:
- *string = FL_status_string_unterminated_block;
+ case F_terminated_not_eof:
+ *string = FL_status_string_terminated_not_eof;
break;
- case F_unterminated_eof:
- *string = FL_status_string_unterminated_eof;
+ case F_terminated_not_eol:
+ *string = FL_status_string_terminated_not_eol;
break;
- case F_unterminated_eol:
- *string = FL_status_string_unterminated_eol;
+ case F_terminated_not_eos:
+ *string = FL_status_string_terminated_not_eos;
break;
- case F_unterminated_eos:
- *string = FL_status_string_unterminated_eos;
+ case F_terminated_not_group:
+ *string = FL_status_string_terminated_not_group;
break;
- case F_unterminated_stop:
- *string = FL_status_string_unterminated_stop;
+ case F_terminated_not_group_block:
+ *string = FL_status_string_terminated_not_group_block;
break;
- case F_unterminated_group:
- *string = FL_status_string_unterminated_group;
+ case F_terminated_not_group_eof:
+ *string = FL_status_string_terminated_not_group_eof;
break;
- case F_unterminated_group_block:
- *string = FL_status_string_unterminated_group_block;
+ case F_terminated_not_group_eol:
+ *string = FL_status_string_terminated_not_group_eol;
break;
- case F_unterminated_group_eof:
- *string = FL_status_string_unterminated_group_eof;
+ case F_terminated_not_group_eos:
+ *string = FL_status_string_terminated_not_group_eos;
break;
- case F_unterminated_group_eol:
- *string = FL_status_string_unterminated_group_eol;
+ case F_terminated_not_group_stop:
+ *string = FL_status_string_terminated_not_group_stop;
break;
- case F_unterminated_group_eos:
- *string = FL_status_string_unterminated_group_eos;
+ case F_terminated_not_nest:
+ *string = FL_status_string_terminated_not_nest;
break;
- case F_unterminated_group_stop:
- *string = FL_status_string_unterminated_group_stop;
+ case F_terminated_not_nest_block:
+ *string = FL_status_string_terminated_not_nest_block;
break;
- case F_unterminated_nest:
- *string = FL_status_string_unterminated_nest;
+ case F_terminated_not_nest_eof:
+ *string = FL_status_string_terminated_not_nest_eof;
break;
- case F_unterminated_nest_block:
- *string = FL_status_string_unterminated_nest_block;
+ case F_terminated_not_nest_eol:
+ *string = FL_status_string_terminated_not_nest_eol;
break;
- case F_unterminated_nest_eof:
- *string = FL_status_string_unterminated_nest_eof;
+ case F_terminated_not_nest_eos:
+ *string = FL_status_string_terminated_not_nest_eos;
break;
- case F_unterminated_nest_eol:
- *string = FL_status_string_unterminated_nest_eol;
+ case F_terminated_not_nest_stop:
+ *string = FL_status_string_terminated_not_nest_stop;
break;
- case F_unterminated_nest_eos:
- *string = FL_status_string_unterminated_nest_eos;
- break;
- case F_unterminated_nest_stop:
- *string = FL_status_string_unterminated_nest_stop;
+ case F_terminated_not_stop:
+ *string = FL_status_string_terminated_not_stop;
break;
#endif // _di_F_status_buffers_
- #ifndef _di_F_status_allocation_
+ #ifndef _di_F_status_memory_
+ case F_memory:
+ *string = FL_status_string_memory;
+ break;
case F_memory_allocation:
*string = FL_status_string_memory_allocation;
break;
case F_memory_deallocation:
*string = FL_status_string_memory_deallocation;
break;
+ case F_memory_not:
+ *string = FL_status_string_memory_not;
+ break;
case F_memory_reallocation:
*string = FL_status_string_memory_reallocation;
break;
- #endif // _di_F_status_allocation_
+ #endif // _di_F_status_memory_
+
+ #ifndef _di_F_status_process_
+ case F_process:
+ *string = FL_status_string_process;
+ break;
+ case F_process_not:
+ *string = FL_status_string_process_not;
+ break;
+ case F_process_too_many:
+ *string = FL_status_string_process_too_many;
+ break;
+ #endif // _di_F_status_process_
#ifndef _di_F_status_file_
case F_file:
case F_file_found_not:
*string = FL_status_string_file_found_not;
break;
+ case F_file_not:
+ *string = FL_status_string_file_not;
+ break;
case F_file_open:
*string = FL_status_string_file_open;
break;
case F_filesystem:
*string = FL_status_string_filesystem;
break;
+ case F_filesystem_not:
+ *string = FL_status_string_filesystem_not;
+ break;
case F_filesystem_quota_block:
*string = FL_status_string_filesystem_quota_block;
break;
*string = FL_status_string_directory_closed;
break;
case F_directory_descriptor:
- *string =FL_status_string_directory_descriptor;
+ *string = FL_status_string_directory_descriptor;
break;
case F_directory_empty:
*string = FL_status_string_directory_empty;
case F_directory_link_max:
*string = FL_status_string_directory_link_max;
break;
+ case F_directory_not:
+ *string = FL_status_string_directory_not;
+ break;
case F_directory_open:
*string = FL_status_string_directory_open;
break;
case F_socket_client:
*string = FL_status_string_socket_client;
break;
+ case F_socket_not:
+ *string = FL_status_string_socket_not;
+ break;
case F_socket_receive:
*string = FL_status_string_socket_receive;
break;
case F_access_mode:
*string = FL_status_string_access_mode;
break;
+ case F_access_not:
+ *string = FL_status_string_access_not;
+ break;
case F_access_owner:
*string = FL_status_string_access_owner;
break;
#ifndef _di_F_status_basic_
#define FL_status_string_none "F_none"
#define FL_status_string_absolute "F_absolute"
+ #define FL_status_string_absolute_not "F_absolute_not"
#define FL_status_string_address "F_address"
+ #define FL_status_string_address_not "F_address_not"
#define FL_status_string_block "F_block"
- #define FL_status_string_bound_out "F_bound_out"
+ #define FL_status_string_block_not "F_block_not"
+ #define FL_status_string_bound "F_bound"
+ #define FL_status_string_bound_not "F_bound_not"
+ #define FL_status_string_complete "F_complete"
+ #define FL_status_string_complete_not "F_complete_not"
#define FL_status_string_connected "F_connected"
#define FL_status_string_connected_not "F_connected_not"
#define FL_status_string_critical "F_critical"
+ #define FL_status_string_critical_not "F_critical_not"
#define FL_status_string_deadlock "F_deadlock"
+ #define FL_status_string_deadlock_not "F_deadlock_not"
#define FL_status_string_descriptor "F_descriptor"
+ #define FL_status_string_descriptor_not "F_descriptor_not"
#define FL_status_string_device "F_device"
+ #define FL_status_string_device_not "F_device_not"
#define FL_status_string_dummy "F_dummy"
+ #define FL_status_string_dummy_not "F_dummy_not"
#define FL_status_string_encoding "F_encoding"
#define FL_status_string_encoding_not "F_encoding_not"
#define FL_status_string_eof "F_eof"
+ #define FL_status_string_eof_not "F_eof_not"
#define FL_status_string_eol "F_eol"
+ #define FL_status_string_eol_not "F_eol_not"
#define FL_status_string_eos "F_eos"
+ #define FL_status_string_eos_not "F_eos_not"
#define FL_status_string_exist "F_exist"
#define FL_status_string_exist_not "F_exist_not"
#define FL_status_string_failure "F_failure"
+ #define FL_status_string_failure_not "F_failure_not"
#define FL_status_string_fork "F_fork"
+ #define FL_status_string_fork_not "F_fork_not"
#define FL_status_string_found "F_found"
#define FL_status_string_found_not "F_found_not"
- #define FL_status_string_incomplete "F_incomplete"
#define FL_status_string_input "F_input"
+ #define FL_status_string_input_not "F_input_not"
#define FL_status_string_input_output "F_input_output"
- #define FL_status_string_interrupted "F_interrupted"
- #define FL_status_string_invalid "F_invalid"
- #define FL_status_string_output "F_output"
+ #define FL_status_string_interrupt "F_interrupt"
+ #define FL_status_string_interrupt_not "F_interrupt_not"
+ #define FL_status_string_known "F_known"
+ #define FL_status_string_known_not "F_known_not"
#define FL_status_string_link "F_link"
#define FL_status_string_link_not "F_link_not"
#define FL_status_string_lock "F_lock"
#define FL_status_string_lock_not "F_lock_not"
#define FL_status_string_loop "F_loop"
+ #define FL_status_string_loop_not "F_loop_not"
#define FL_status_string_maybe "F_maybe"
- #define FL_status_string_memory "F_memory"
- #define FL_status_string_memory_out "F_memory_not"
+ #define FL_status_string_maybe_not "F_maybe_not"
#define FL_status_string_mount "F_mount"
+ #define FL_status_string_mount_not "F_mount_not"
#define FL_status_string_name "F_name"
+ #define FL_status_string_name_not "F_name_not"
+ #define FL_status_string_output "F_output"
+ #define FL_status_string_output_not "F_output_not"
#define FL_status_string_parameter "F_parameter"
+ #define FL_status_string_parameter_not "F_parameter_not"
#define FL_status_string_pipe "F_pipe"
+ #define FL_status_string_pipe_not "F_pipe_not"
#define FL_status_string_port "F_port"
- #define FL_status_string_process "F_process"
- #define FL_status_string_process_too_many "F_process_too_many"
+ #define FL_status_string_port_not "F_port_not"
#define FL_status_string_prohibited "F_prohibited"
+ #define FL_status_string_prohibited_not "F_prohibited_not"
#define FL_status_string_range "F_range"
#define FL_status_string_range_not "F_range_not"
+ #define FL_status_string_read "F_read"
+ #define FL_status_string_read_not "F_read_not"
#define FL_status_string_read_only "F_read_only"
#define FL_status_string_recurse "F_recurse"
+ #define FL_status_string_recurse_not "F_recurse_not"
#define FL_status_string_relative "F_relative"
+ #define FL_status_string_relative_not "F_relative_not"
#define FL_status_string_resource "F_resource"
#define FL_status_string_resource_not "F_resource_not"
#define FL_status_string_search "F_search"
+ #define FL_status_string_search_not "F_search_not"
#define FL_status_string_signal "F_signal"
+ #define FL_status_string_signal_not "F_signal_not"
#define FL_status_string_space "F_space"
#define FL_status_string_space_not "F_space_not"
#define FL_status_string_stop "F_stop"
+ #define FL_status_string_stop_not "F_stop_not"
+ #define FL_status_string_string "F_string"
+ #define FL_status_string_string_not "F_string_not"
+ #define FL_status_string_string_too_large "F_string_too_large"
+ #define FL_status_string_string_too_small "F_string_too_small"
#define FL_status_string_syntax "F_syntax"
- #define FL_status_string_unknown "F_unknown"
- #define FL_status_string_unsupported "F_unsupported"
+ #define FL_status_string_syntax_not "F_syntax_not"
+ #define FL_status_string_supported "F_supported"
+ #define FL_status_string_supported_not "F_supported_not"
#define FL_status_string_utf "F_utf"
#define FL_status_string_utf_not "F_utf_not"
+ #define FL_status_string_valid "F_valid"
+ #define FL_status_string_valid_not "F_valid_not"
#define FL_status_string_value "F_value"
#define FL_status_string_value_not "F_value_not"
#define FL_status_string_warn "F_warn"
+ #define FL_status_string_warn_not "F_warn_not"
+ #define FL_status_string_write "F_write"
+ #define FL_status_string_write_not "F_write_not"
#define FL_status_string_write_only "F_write_only"
#define FL_status_string_none_length 6
#define FL_status_string_absolute_length 10
+ #define FL_status_string_absolute_not_length 14
#define FL_status_string_address_length 9
+ #define FL_status_string_address_not_length 13
#define FL_status_string_block_length 7
- #define FL_status_string_bound_out_length 11
+ #define FL_status_string_block_not_length 11
+ #define FL_status_string_bound_length 7
+ #define FL_status_string_bound_not_length 11
+ #define FL_status_string_complete_length 10
+ #define FL_status_string_complete_not_length 14
#define FL_status_string_connected_length 11
#define FL_status_string_connected_not_length 15
#define FL_status_string_critical_length 10
+ #define FL_status_string_critical_not_length 14
#define FL_status_string_deadlock_length 10
+ #define FL_status_string_deadlock_not_length 14
#define FL_status_string_descriptor_length 12
+ #define FL_status_string_descriptor_not_length 16
#define FL_status_string_device_length 8
+ #define FL_status_string_device_not_length 12
#define FL_status_string_dummy_length 7
+ #define FL_status_string_dummy_not_length 11
#define FL_status_string_encoding_length 10
#define FL_status_string_encoding_not_length 14
#define FL_status_string_eof_length 5
+ #define FL_status_string_eof_not_length 9
#define FL_status_string_eol_length 5
+ #define FL_status_string_eol_not_length 9
#define FL_status_string_eos_length 5
+ #define FL_status_string_eos_not_length 9
#define FL_status_string_exist_length 7
#define FL_status_string_exist_not_length 11
#define FL_status_string_failure_length 9
+ #define FL_status_string_failure_not_length 13
#define FL_status_string_fork_length 6
+ #define FL_status_string_fork_not_length 10
#define FL_status_string_found_length 7
#define FL_status_string_found_not_length 11
- #define FL_status_string_incomplete_length 12
#define FL_status_string_input_length 7
+ #define FL_status_string_input_not_length 11
#define FL_status_string_input_output_length 14
- #define FL_status_string_interrupted_length 13
- #define FL_status_string_invalid_length 9
- #define FL_status_string_output_length 8
+ #define FL_status_string_interrupt_length 11
+ #define FL_status_string_interrupt_not_length 15
+ #define FL_status_string_known_length 7
+ #define FL_status_string_known_not_length 11
#define FL_status_string_link_length 6
#define FL_status_string_link_not_length 10
#define FL_status_string_lock_length 6
#define FL_status_string_lock_not_length 10
#define FL_status_string_loop_length 6
+ #define FL_status_string_loop_not_length 10
#define FL_status_string_maybe_length 7
- #define FL_status_string_memory_length 8
- #define FL_status_string_memory_out_length 12
+ #define FL_status_string_maybe_not_length 11
#define FL_status_string_mount_length 7
+ #define FL_status_string_mount_not_length 11
#define FL_status_string_name_length 6
+ #define FL_status_string_name_not_length 10
+ #define FL_status_string_output_length 8
+ #define FL_status_string_output_not_length 12
#define FL_status_string_parameter_length 11
+ #define FL_status_string_parameter_not_length 15
#define FL_status_string_pipe_length 6
+ #define FL_status_string_pipe_not_length 10
#define FL_status_string_port_length 6
- #define FL_status_string_process_length 9
- #define FL_status_string_process_too_many_length 18
+ #define FL_status_string_port_not_length 10
#define FL_status_string_prohibited_length 12
+ #define FL_status_string_prohibited_not_length 16
#define FL_status_string_range_length 7
#define FL_status_string_range_not_length 11
+ #define FL_status_string_read_length 6
+ #define FL_status_string_read_not_length 10
#define FL_status_string_read_only_length 11
#define FL_status_string_recurse_length 9
+ #define FL_status_string_recurse_not_length 13
#define FL_status_string_relative_length 10
+ #define FL_status_string_relative_not_length 14
#define FL_status_string_resource_length 10
#define FL_status_string_resource_not_length 14
#define FL_status_string_search_length 8
+ #define FL_status_string_search_not_length 12
#define FL_status_string_signal_length 8
+ #define FL_status_string_signal_not_length 12
#define FL_status_string_space_length 7
#define FL_status_string_space_not_length 11
#define FL_status_string_stop_length 6
+ #define FL_status_string_stop_not_length 10
+ #define FL_status_string_string_length 8
+ #define FL_status_string_string_not_length 12
+ #define FL_status_string_string_too_large_length 18
+ #define FL_status_string_string_too_small_length 18
+ #define FL_status_string_supported_length 11
+ #define FL_status_string_supported_not_length 15
#define FL_status_string_syntax_length 8
- #define FL_status_string_unknown_length 9
- #define FL_status_string_unsupported_length 13
+ #define FL_status_string_syntax_not_length 12
#define FL_status_string_utf_length 5
#define FL_status_string_utf_not_length 9
+ #define FL_status_string_valid_length 7
+ #define FL_status_string_valid_not_length 11
#define FL_status_string_value_length 7
#define FL_status_string_value_not_length 11
#define FL_status_string_warn_length 6
+ #define FL_status_string_warn_not_length 10
+ #define FL_status_string_write_length 7
+ #define FL_status_string_write_not_length 11
#define FL_status_string_write_only_length 12
#endif // _di_F_status_basic_
#ifndef _di_F_status_array_
#define FL_status_string_array "F_array"
+ #define FL_status_string_array_not "F_array_not"
#define FL_status_string_array_too_large "F_array_too_large"
#define FL_status_string_array_too_small "F_array_too_small"
#define FL_status_string_array_length 7
+ #define FL_status_string_array_not_length 11
#define FL_status_string_array_too_large_length 17
#define FL_status_string_array_too_small_length 17
#endif // _di_F_status_array_
+ #ifndef _di_F_status_available_
+ #define FL_status_string_available "F_available"
+ #define FL_status_string_available_not "F_available_not"
+ #define FL_status_string_available_not_address "F_available_not_address"
+ #define FL_status_string_available_not_buffer "F_available_not_buffer"
+ #define FL_status_string_available_not_device "F_available_not_device"
+ #define FL_status_string_available_not_pipe "F_available_not_pipe"
+ #define FL_status_string_available_not_port "F_available_not_port"
+ #define FL_status_string_available_not_process "F_available_not_process"
+ #define FL_status_string_available_not_socket "F_available_not_socket"
+
+ #define FL_status_string_available_length 11
+ #define FL_status_string_available_not_length 15
+ #define FL_status_string_available_not_address_length 23
+ #define FL_status_string_available_not_buffer_length 22
+ #define FL_status_string_available_not_device_length 22
+ #define FL_status_string_available_not_pipe_length 20
+ #define FL_status_string_available_not_port_length 20
+ #define FL_status_string_available_not_process_length 23
+ #define FL_status_string_available_not_socket_length 22
+ #endif // _di_F_status_available_
+
#ifndef _di_F_status_busy_
#define FL_status_string_busy "F_busy"
#define FL_status_string_busy_address "F_busy_address"
#define FL_status_string_busy_buffer "F_busy_buffer"
#define FL_status_string_busy_device "F_busy_device"
+ #define FL_status_string_busy_not "F_busy_not"
#define FL_status_string_busy_pipe "F_busy_pipe"
#define FL_status_string_busy_port "F_busy_port"
#define FL_status_string_busy_process "F_busy_process"
#define FL_status_string_busy_address_length 14
#define FL_status_string_busy_buffer_length 13
#define FL_status_string_busy_device_length 13
+ #define FL_status_string_busy_not_length 10
#define FL_status_string_busy_pipe_length 11
#define FL_status_string_busy_port_length 11
#define FL_status_string_busy_process_length 14
#define FL_status_string_busy_socket_length 13
#endif // _di_F_status_busy_
- #ifndef _di_F_status_unavailable_
- #define FL_status_string_unavailable "F_unavailable"
- #define FL_status_string_unavailable_address "F_unavailable_address"
- #define FL_status_string_unavailable_buffer "F_unavailable_buffer"
- #define FL_status_string_unavailable_device "F_unavailable_device"
- #define FL_status_string_unavailable_pipe "F_unavailable_pipe"
- #define FL_status_string_unavailable_port "F_unavailable_port"
- #define FL_status_string_unavailable_process "F_unavailable_process"
- #define FL_status_string_unavailable_socket "F_unavailable_socket"
-
- #define FL_status_string_unavailable_length 13
- #define FL_status_string_unavailable_address_length 21
- #define FL_status_string_unavailable_buffer_length 20
- #define FL_status_string_unavailable_device_length 20
- #define FL_status_string_unavailable_pipe_length 18
- #define FL_status_string_unavailable_port_length 18
- #define FL_status_string_unavailable_process_length 21
- #define FL_status_string_unavailable_socket_length 20
- #endif // _di_F_status_unavailable_
-
#ifndef _di_F_status_number_
#define FL_status_string_number "F_number"
#define FL_status_string_number_decimal "F_number_decimal"
+ #define FL_status_string_number_decimal_not "F_number_decimal_not"
#define FL_status_string_number_divide_by_zero "F_number_divide_by_zero"
#define FL_status_string_number_negative "F_number_negative"
+ #define FL_status_string_number_negative_not "F_number_negative_not"
+ #define FL_status_string_number_not "F_number_not"
#define FL_status_string_number_overflow "F_number_overflow"
#define FL_status_string_number_positive "F_number_positive"
+ #define FL_status_string_number_positive_not "F_number_positive_not"
#define FL_status_string_number_underflow "F_number_underflow"
#define FL_status_string_number_whole "F_number_whole"
+ #define FL_status_string_number_whole_not "F_number_whole_not"
#define FL_status_string_number_zero "F_number_zero"
+ #define FL_status_string_number_zero_not "F_number_zero_not"
#define FL_status_string_number_length 8
#define FL_status_string_number_decimal_length 16
+ #define FL_status_string_number_decimal_not_length 20
#define FL_status_string_number_divide_by_zero_length 23
#define FL_status_string_number_negative_length 17
+ #define FL_status_string_number_negative_not_length 21
+ #define FL_status_string_number_not_length 12
#define FL_status_string_number_overflow_length 17
#define FL_status_string_number_positive_length 17
+ #define FL_status_string_number_positive_not_length 21
#define FL_status_string_number_underflow_length 18
#define FL_status_string_number_whole_length 14
+ #define FL_status_string_number_whole_not_length 18
#define FL_status_string_number_zero_length 13
+ #define FL_status_string_number_zero_not_length 17
#endif // _di_F_status_number_
#ifndef _di_F_status_buffer_
- #define FL_status_string_buffer "F_buffer"
- #define FL_status_string_buffer_too_small "F_buffer_too_small"
- #define FL_status_string_buffer_too_large "F_buffer_too_large"
- #define FL_status_string_incomplete_utf "F_incomplete_utf"
- #define FL_status_string_incomplete_utf_block "F_incomplete_utf_block"
- #define FL_status_string_incomplete_utf_eof "F_incomplete_utf_eof"
- #define FL_status_string_incomplete_utf_eol "F_incomplete_utf_eol"
- #define FL_status_string_incomplete_utf_eos "F_incomplete_utf_eos"
- #define FL_status_string_incomplete_utf_stop "F_incomplete_utf_stop"
- #define FL_status_string_none_block "F_none_block"
- #define FL_status_string_none_eof "F_none_eof"
- #define FL_status_string_none_eol "F_none_eol"
- #define FL_status_string_none_eos "F_none_eos"
- #define FL_status_string_none_stop "F_none_stop"
- #define FL_status_string_data "F_data"
- #define FL_status_string_data_not "F_data_not"
- #define FL_status_string_data_not_block "F_data_not_block"
- #define FL_status_string_data_not_eof "F_data_not_eof"
- #define FL_status_string_data_not_eol "F_data_not_eol"
- #define FL_status_string_data_not_eos "F_data_not_eos"
- #define FL_status_string_data_not_stop "F_data_not_stop"
- #define FL_status_string_string_too_small "F_string_too_small"
- #define FL_status_string_string_too_large "F_string_too_large"
- #define FL_status_string_unterminated "F_unterminated"
- #define FL_status_string_unterminated_block "F_unterminated_block"
- #define FL_status_string_unterminated_eof "F_unterminated_eof"
- #define FL_status_string_unterminated_eol "F_unterminated_eol"
- #define FL_status_string_unterminated_eos "F_unterminated_eos"
- #define FL_status_string_unterminated_stop "F_unterminated_stop"
- #define FL_status_string_unterminated_group "F_unterminated_group"
- #define FL_status_string_unterminated_group_block "F_unterminated_group_block"
- #define FL_status_string_unterminated_group_eof "F_unterminated_group_eof"
- #define FL_status_string_unterminated_group_eol "F_unterminated_group_eol"
- #define FL_status_string_unterminated_group_eos "F_unterminated_group_eos"
- #define FL_status_string_unterminated_group_stop "F_unterminated_group_stop"
- #define FL_status_string_unterminated_nest "F_unterminated_nest"
- #define FL_status_string_unterminated_nest_block "F_unterminated_nest_block"
- #define FL_status_string_unterminated_nest_eof "F_unterminated_nest_eof"
- #define FL_status_string_unterminated_nest_eol "F_unterminated_nest_eol"
- #define FL_status_string_unterminated_nest_eos "F_unterminated_nest_eos"
- #define FL_status_string_unterminated_nest_stop "F_unterminated_nest_stop"
-
- #define FL_status_string_buffer_length 8
- #define FL_status_string_buffer_too_small_length 18
- #define FL_status_string_buffer_too_large_length 18
- #define FL_status_string_incomplete_utf_length 16
- #define FL_status_string_incomplete_utf_block_length 22
- #define FL_status_string_incomplete_utf_eof_length 20
- #define FL_status_string_incomplete_utf_eol_length 20
- #define FL_status_string_incomplete_utf_eos_length 20
- #define FL_status_string_incomplete_utf_stop_length 21
- #define FL_status_string_none_block_length 12
- #define FL_status_string_none_eof_length 10
- #define FL_status_string_none_eol_length 10
- #define FL_status_string_none_eos_length 10
- #define FL_status_string_none_stop_length 11
- #define FL_status_string_data_length 6
- #define FL_status_string_data_not_length 10
- #define FL_status_string_data_not_block_length 16
- #define FL_status_string_data_not_eof_length 14
- #define FL_status_string_data_not_eol_length 14
- #define FL_status_string_data_not_eos_length 14
- #define FL_status_string_data_not_stop_length 15
- #define FL_status_string_string_too_small_length 18
- #define FL_status_string_string_too_large_length 18
- #define FL_status_string_unterminated_length 14
- #define FL_status_string_unterminated_block_length 20
- #define FL_status_string_unterminated_eof_length 18
- #define FL_status_string_unterminated_eol_length 18
- #define FL_status_string_unterminated_eos_length 18
- #define FL_status_string_unterminated_stop_length 19
- #define FL_status_string_unterminated_group_length 20
- #define FL_status_string_unterminated_group_block_length 26
- #define FL_status_string_unterminated_group_eof_length 23
- #define FL_status_string_unterminated_group_eol_length 23
- #define FL_status_string_unterminated_group_eos_length 23
- #define FL_status_string_unterminated_group_stop_length 24
- #define FL_status_string_unterminated_nest_length 19
- #define FL_status_string_unterminated_nest_block_length 24
- #define FL_status_string_unterminated_nest_eof_length 23
- #define FL_status_string_unterminated_nest_eol_length 23
- #define FL_status_string_unterminated_nest_eos_length 23
- #define FL_status_string_unterminated_nest_stop_length 24
+ #define FL_status_string_buffer "F_buffer"
+ #define FL_status_string_buffer_not "F_buffer_not"
+ #define FL_status_string_buffer_too_large "F_buffer_too_large"
+ #define FL_status_string_buffer_too_small "F_buffer_too_small"
+ #define FL_status_string_complete_not_utf "F_complete_not_utf"
+ #define FL_status_string_complete_not_utf_block "F_complete_not_utf_block"
+ #define FL_status_string_complete_not_utf_eof "F_complete_not_utf_eof"
+ #define FL_status_string_complete_not_utf_eol "F_complete_not_utf_eol"
+ #define FL_status_string_complete_not_utf_eos "F_complete_not_utf_eos"
+ #define FL_status_string_complete_not_utf_stop "F_complete_not_utf_stop"
+ #define FL_status_string_none_block "F_none_block"
+ #define FL_status_string_none_eof "F_none_eof"
+ #define FL_status_string_none_eol "F_none_eol"
+ #define FL_status_string_none_eos "F_none_eos"
+ #define FL_status_string_none_not "F_none_not"
+ #define FL_status_string_none_stop "F_none_stop"
+ #define FL_status_string_data "F_data"
+ #define FL_status_string_data_not "F_data_not"
+ #define FL_status_string_data_not_block "F_data_not_block"
+ #define FL_status_string_data_not_eof "F_data_not_eof"
+ #define FL_status_string_data_not_eol "F_data_not_eol"
+ #define FL_status_string_data_not_eos "F_data_not_eos"
+ #define FL_status_string_data_not_stop "F_data_not_stop"
+ #define FL_status_string_terminated "F_terminated"
+ #define FL_status_string_terminated_not "F_terminated_not"
+ #define FL_status_string_terminated_not_block "F_terminated_not_block"
+ #define FL_status_string_terminated_not_eof "F_terminated_not_eof"
+ #define FL_status_string_terminated_not_eol "F_terminated_not_eol"
+ #define FL_status_string_terminated_not_eos "F_terminated_not_eos"
+ #define FL_status_string_terminated_not_stop "F_terminated_not_stop"
+ #define FL_status_string_terminated_not_group "F_terminated_not_group"
+ #define FL_status_string_terminated_not_group_block "F_terminated_not_group_block"
+ #define FL_status_string_terminated_not_group_eof "F_terminated_not_group_eof"
+ #define FL_status_string_terminated_not_group_eol "F_terminated_not_group_eol"
+ #define FL_status_string_terminated_not_group_eos "F_terminated_not_group_eos"
+ #define FL_status_string_terminated_not_group_stop "F_terminated_not_group_stop"
+ #define FL_status_string_terminated_not_nest "F_terminated_not_nest"
+ #define FL_status_string_terminated_not_nest_block "F_terminated_not_nest_block"
+ #define FL_status_string_terminated_not_nest_eof "F_terminated_not_nest_eof"
+ #define FL_status_string_terminated_not_nest_eol "F_terminated_not_nest_eol"
+ #define FL_status_string_terminated_not_nest_eos "F_terminated_not_nest_eos"
+ #define FL_status_string_terminated_not_nest_stop "F_terminated_not_nest_stop"
+
+ #define FL_status_string_buffer_length 8
+ #define FL_status_string_buffer_not_length 12
+ #define FL_status_string_buffer_too_large_length 18
+ #define FL_status_string_buffer_too_small_length 18
+ #define FL_status_string_complete_not_utf_length 18
+ #define FL_status_string_complete_not_utf_block_length 24
+ #define FL_status_string_complete_not_utf_eof_length 22
+ #define FL_status_string_complete_not_utf_eol_length 22
+ #define FL_status_string_complete_not_utf_eos_length 22
+ #define FL_status_string_complete_not_utf_stop_length 23
+ #define FL_status_string_none_block_length 12
+ #define FL_status_string_none_eof_length 10
+ #define FL_status_string_none_eol_length 10
+ #define FL_status_string_none_eos_length 10
+ #define FL_status_string_none_stop_length 11
+ #define FL_status_string_data_length 6
+ #define FL_status_string_data_not_length 10
+ #define FL_status_string_data_not_block_length 16
+ #define FL_status_string_data_not_eof_length 14
+ #define FL_status_string_data_not_eol_length 14
+ #define FL_status_string_data_not_eos_length 14
+ #define FL_status_string_data_not_stop_length 15
+ #define FL_status_string_terminated_length 12
+ #define FL_status_string_terminated_not_length 16
+ #define FL_status_string_terminated_not_block_length 22
+ #define FL_status_string_terminated_not_eof_length 20
+ #define FL_status_string_terminated_not_eol_length 20
+ #define FL_status_string_terminated_not_eos_length 20
+ #define FL_status_string_terminated_not_stop_length 21
+ #define FL_status_string_terminated_not_group_length 22
+ #define FL_status_string_terminated_not_group_block_length 28
+ #define FL_status_string_terminated_not_group_eof_length 25
+ #define FL_status_string_terminated_not_group_eol_length 25
+ #define FL_status_string_terminated_not_group_eos_length 25
+ #define FL_status_string_terminated_not_group_stop_length 26
+ #define FL_status_string_terminated_not_nest_length 21
+ #define FL_status_string_terminated_not_nest_block_length 26
+ #define FL_status_string_terminated_not_nest_eof_length 25
+ #define FL_status_string_terminated_not_nest_eol_length 25
+ #define FL_status_string_terminated_not_nest_eos_length 25
+ #define FL_status_string_terminated_not_nest_stop_length 26
#endif // _di_F_status_buffer_
#ifndef _di_F_status_memory_
+ #define FL_status_string_memory "F_memory"
#define FL_status_string_memory_allocation "F_memory_allocation"
#define FL_status_string_memory_deallocation "F_memory_deallocation"
+ #define FL_status_string_memory_not "F_memory_not"
#define FL_status_string_memory_reallocation "F_memory_reallocation"
+ #define FL_status_string_memory_length 8
#define FL_status_string_memory_allocation_length 19
#define FL_status_string_memory_deallocation_length 21
+ #define FL_status_string_memory_not_length 12
#define FL_status_string_memory_reallocation_length 21
#endif // _di_F_status_memory_
+ #ifndef _di_F_status_process_
+ #define FL_status_string_process "F_process"
+ #define FL_status_string_process_not "F_process_not"
+ #define FL_status_string_process_too_many "F_process_too_many"
+
+ #define FL_status_string_process_length 9
+ #define FL_status_string_process_not_length 13
+ #define FL_status_string_process_too_many_length 18
+ #endif // _di_F_status_process_
+
#ifndef _di_F_status_file_
#define FL_status_string_file "F_file"
#define FL_status_string_file_allocation "F_file_allocation"
#define FL_status_string_file_flush "F_file_flush"
#define FL_status_string_file_found "F_file_found"
#define FL_status_string_file_found_not "F_file_found_not"
+ #define FL_status_string_file_not "F_file_not"
#define FL_status_string_file_open "F_file_open"
#define FL_status_string_file_open_max "F_file_open_max"
#define FL_status_string_file_opened "F_file_opened"
#define FL_status_string_file_flush_length 12
#define FL_status_string_file_found_length 12
#define FL_status_string_file_found_not_length 16
+ #define FL_status_string_file_not_length 10
#define FL_status_string_file_open_length 11
#define FL_status_string_file_open_max_length 15
#define FL_status_string_file_opened_length 13
#ifndef _di_F_status_filesystem_
#define FL_status_string_filesystem "F_filesystem"
+ #define FL_status_string_filesystem_not "F_filesystem_not"
#define FL_status_string_filesystem_quota_block "F_filesystem_quota_block"
#define FL_status_string_filesystem_quota_reached "F_filesystem_quota_reached"
#define FL_status_string_filesystem_length 12
+ #define FL_status_string_filesystem_not_length 16
#define FL_status_string_filesystem_quota_block_length 24
#define FL_status_string_filesystem_quota_reached_length 26
#endif // _di_F_status_filesystem_
#define FL_status_string_directory_found_not "F_directory_found_not"
#define FL_status_string_directory_flush "F_directory_flush"
#define FL_status_string_directory_link_max "F_directory_link_max"
+ #define FL_status_string_directory_not "F_directory_not"
#define FL_status_string_directory_open "F_directory_open"
#define FL_status_string_directory_purge "F_directory_purge"
#define FL_status_string_directory_read "F_directory_read"
#define FL_status_string_directory_found_not_length 21
#define FL_status_string_directory_flush_length 17
#define FL_status_string_directory_link_max_length 20
+ #define FL_status_string_directory_not_length 15
#define FL_status_string_directory_open_length 16
#define FL_status_string_directory_purge_length 17
#define FL_status_string_directory_read_length 16
#ifndef _di_F_status_socket_
#define FL_status_string_socket "F_socket"
#define FL_status_string_socket_client "F_socket_client"
+ #define FL_status_string_socket_not "F_socket_not"
#define FL_status_string_socket_receive "F_socket_receive"
#define FL_status_string_socket_send "F_socket_send"
#define FL_status_string_socket_target "F_socket_target"
#define FL_status_string_socket_length 8
#define FL_status_string_socket_client_length 15
+ #define FL_status_string_socket_not_length 12
#define FL_status_string_socket_receive_length 16
#define FL_status_string_socket_send_length 13
#define FL_status_string_socket_target_length 15
#define FL_status_string_access_granted_super "F_access_granted_super"
#define FL_status_string_access_group "F_access_group"
#define FL_status_string_access_mode "F_access_mode"
+ #define FL_status_string_access_not "F_access_not"
#define FL_status_string_access_owner "F_access_owner"
#define FL_status_string_access_length 8
#define FL_status_string_access_granted_super_length 22
#define FL_status_string_access_group_length 14
#define FL_status_string_access_mode_length 13
+ #define FL_status_string_access_not_length 12
#define FL_status_string_access_owner_length 14
#endif // _di_F_status_access_
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
if (width == seek_width) {
f_utf_character_t character = 0;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
}
range->start += width;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
}
range->start += width;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
if (width == seek_width) {
f_utf_character_t character = 0;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_eos);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_eos);
if (width == seek_width) {
f_utf_character_t character = 0;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
}
range->start += width;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
}
range->start += width;
}
// Do not operate on UTF-8 fragments that are not the first byte of the character.
else if (width == 1) {
- return F_status_set_error(F_incomplete_utf);
+ return F_status_set_error(F_complete_not_utf);
}
else {
- if (range->start + width > range->stop) return F_status_set_error(F_incomplete_utf_stop);
+ if (range->start + width > range->stop) return F_status_set_error(F_complete_not_utf_stop);
if (width == seek_width) {
f_utf_character_t character = 0;
* F_none_stop on success, but stopped at end of range.
* F_data_not on success, but there was no string data to seek.
* F_data_not_stop on success, but the range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
*
* F_none_stop on success, but stopped at end of range.
* F_data_not on success, but there was no string data to seek.
* F_data_not_stop on success, but the range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success, but stopped at end of range.
* F_data_not on success, but there was no string data to seek.
* F_data_not_stop on success, but the range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success, but stopped at end of range.
* F_data_not on success, but there was no string data to seek.
* F_data_not_stop on success, but the range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_fl_string_dynamic_seek_to_
* F_none_stop on success, but stopped at end of range.
* F_data_not on success, but there was no string data to seek.
* F_data_not_stop on success, but the range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
*
* F_none on success.
* F_none_eol on success, but stopped at EOL.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
*
* F_none on success.
* F_none_eol on success, but stopped at EOL.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_eol on success, but stopped at EOL.
* F_none_stop on success, but stopped stop location.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none on success.
* F_none_stop on success, but stopped stop location.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_fl_string_seek_to_
* F_none on success.
* F_none_stop on success, but stopped stop location.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
*
* F_none_stop on success, but stopped stop location.
* F_data_not_eos if buffer length is 0.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) if character is an invalid UTF-8 character.
*/
* F_none on success.
* F_none_eol on success, but stopped at EOL.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_eol on success, but stopped at EOL.
* F_none_stop on success, but stopped stop location.
* F_data_not_stop if range.start > range.stop.
- * F_incomplete_utf (with error bit) if character is an incomplete UTF-8 fragment.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_allocation (with error bit) on memory allocation error.
* F_memory_reallocation (with error bit) on memory reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
width_written = width;
if (*written + width > write_max) {
- return F_incomplete_utf_stop;
+ return F_complete_not_utf_stop;
}
buffer_write[used] = f_macro_utf_character_t_to_char_1(string[*written + i]);
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
* F_none on success.
* F_none_eos on success but range.stop exceeded buffer.used (only wrote up to buffer.used).
* F_none_stop on success but no data was written (written == 0) (not an error and often happens if file type is not a regular file).
- * F_incomplete_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
+ * F_complete_not_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
* F_block (with error bit) if file descriptor is set to non-block and the write would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_file_closed (with error bit) if file is not open.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see fl_utf_file_write()
if (!size_read) {
if (width != 0) {
- return F_status_set_error(F_incomplete_utf_eof);
+ return F_status_set_error(F_complete_not_utf_eof);
}
return F_none_eof;
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
return F_status_set_error(F_failure);
}
else if (width != 0) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
return F_none;
if (!size_read) {
if (width) {
- return F_status_set_error(F_incomplete_utf_eof);
+ return F_status_set_error(F_complete_not_utf_eof);
}
return F_none_eof;
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
return F_status_set_error(F_failure);
}
else if (width != 0) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
return F_none;
if (!size_read) {
if (width != 0) {
- return F_status_set_error(F_incomplete_utf_eof);
+ return F_status_set_error(F_complete_not_utf_eof);
}
return F_none_eof;
if (errno == EAGAIN || errno == EWOULDBLOCK) return F_status_set_error(F_block);
if (errno == EBADF) return F_status_set_error(F_file_descriptor);
if (errno == EFAULT) return F_status_set_error(F_buffer);
- if (errno == EINTR) return F_status_set_error(F_interrupted);
+ if (errno == EINTR) return F_status_set_error(F_interrupt);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == EISDIR) return F_status_set_error(F_file_type_directory);
return F_status_set_error(F_failure);
}
else if (width != 0) {
- return F_status_set_error(F_incomplete_utf_stop);
+ return F_status_set_error(F_complete_not_utf_stop);
}
return F_none;
* F_file_closed (with error bit) if file is not open.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
- * F_incomplete_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
- * F_incomplete_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
+ * F_complete_not_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
+ * F_complete_not_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
* F_file_closed (with error bit) if file is not open.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
- * F_incomplete_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
- * F_incomplete_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
+ * F_complete_not_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
+ * F_complete_not_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
* F_file_closed (with error bit) if file is not open.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
- * F_incomplete_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
- * F_incomplete_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
+ * F_complete_not_utf_eof (with error bit) if UTF-8 character was incomplete at the end of the file.
+ * F_complete_not_utf_stop (with error bit) if UTF-8 character was incomplete at a stop point (file.size_read).
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see read()
* F_none on success.
* F_none_eos on success but range.stop exceeded buffer.used (only wrote up to buffer.used).
* F_none_stop on success but no data was written (written == 0) (not an error and often happens if file type is not a regular file).
- * F_incomplete_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
+ * F_complete_not_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
* F_block (with error bit) if file descriptor is set to non-block and the write would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_file (with error bit) if file descriptor is in an error state.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_none on success.
* F_none_eos on success but range.stop exceeded buffer.used (only wrote up to buffer.used).
* F_none_stop on success but no data was written (written == 0) (not an error and often happens if file type is not a regular file).
- * F_incomplete_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
+ * F_complete_not_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
* F_block (with error bit) if file descriptor is set to non-block and the write would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_file (with error bit) if file descriptor is in an error state.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_none on success.
* F_none_eos on success but range.stop exceeded buffer.used (only wrote up to buffer.used).
* F_none_stop on success but no data was written (written == 0) (not an error and often happens if file type is not a regular file).
- * F_incomplete_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
+ * F_complete_not_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
* F_block (with error bit) if file descriptor is set to non-block and the write would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_file (with error bit) if file descriptor is in an error state.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
* F_none on success.
* F_none_eos on success but range.stop exceeded buffer.used (only wrote up to buffer.used).
* F_none_stop on success but no data was written (written == 0) (not an error and often happens if file type is not a regular file).
- * F_incomplete_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
+ * F_complete_not_utf_stop if max write was reached but was unable to completely write a given UTF-8 block (incomplete UTF-8 is not written, not even partially).
* F_block (with error bit) if file descriptor is set to non-block and the write would result in a blocking operation.
* F_buffer (with error bit) if the buffer is invalid.
* F_file (with error bit) if file descriptor is in an error state.
* F_file_descriptor (with error bit) if the file descriptor is invalid.
* F_file_type_directory (with error bit) if file descriptor represents a directory.
* F_input_output (with error bit) on I/O error.
- * F_interrupted (with error bit) if interrupt was received.
+ * F_interrupt (with error bit) if interrupt was received.
* F_parameter (with error bit) if a parameter is invalid.
*
* @see write()
return F_false;
}
- if (status == F_incomplete_utf) {
+ if (status == F_complete_not_utf) {
if (error.verbosity != f_console_verbosity_quiet) {
fprintf(error.to.stream, "%c", f_string_eol[0]);
fprintf(error.to.stream, "%s%sInvalid (incomplete) UTF-8 character while calling ", error.context.before->string, error.prefix ? error.prefix : "");
if (F_status_is_error(status)) {
// Do not consider PATH is not available (or valid?) to be an error.
- if (F_status_set_fine(status) == F_invalid || F_status_set_fine(status) == F_failure) {
+ if (F_status_set_fine(status) == F_valid_not || F_status_set_fine(status) == F_failure) {
status = F_none;
}
}
* F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_number_overflow (with error bit) if the maximimum buffer size is reached.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching stopping point.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_number_overflow (with error bit) if the maximimum buffer size is reached.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching stopping point.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
return status;
}
- else if (status == F_unterminated_eos || status == F_unterminated_stop || status == F_unterminated_nest_eos || status == F_unterminated_nest_stop) {
+ else if (status == F_terminated_not_eos || status == F_terminated_not_stop || status == F_terminated_not_nest_eos || status == F_terminated_not_nest_stop) {
// If at least some valid object was found, then return F_none equivalents.
if (nest->depth[0].used > initial_used) {
* F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_number_overflow (with error bit) if the maximimum buffer size is reached.
* F_parameter (with error bit) if a parameter is invalid.
- * F_unterminated_eos (with error bit) if end of buffer is reached before a closing bracket is found (object was found).
- * F_unterminated_nest_eos (with error bit) if end of buffer is reached while inside a nested list before a closing bracket is found (object was found).
- * F_unterminated_nest_stop (with error bit) if stop location is reached while inside a nested list before a closing bracket is found (object was found).
- * F_unterminated_stop (with error bit) if stop location is reached before a closing bracket is found (object was found).
+ * F_terminated_not_eos (with error bit) if end of buffer is reached before a closing bracket is found (object was found).
+ * F_terminated_not_nest_eos (with error bit) if end of buffer is reached while inside a nested list before a closing bracket is found (object was found).
+ * F_terminated_not_nest_stop (with error bit) if stop location is reached while inside a nested list before a closing bracket is found (object was found).
+ * F_terminated_not_stop (with error bit) if stop location is reached before a closing bracket is found (object was found).
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* FL_fss_found_object_content_not on success and object was found but no content was found (start location is at end of object).
*
* F_none_stop on success after reaching stopping point.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
return status;
}
- else if (status == F_data_not_eos || status == F_data_not_stop || status == F_unterminated_group_eos || status == F_unterminated_group_stop) {
+ else if (status == F_data_not_eos || status == F_data_not_stop || status == F_terminated_not_group_eos || status == F_terminated_not_group_stop) {
// If at least some valid object was found, then return F_none equivelents.
if (objects->used > initial_used) {
return status;
}
- else if (status != FL_fss_found_object && status != FL_fss_found_content && status != FL_fss_found_content_not && status != FL_fss_found_object_content_not && status != F_unterminated_group) {
+ else if (status != FL_fss_found_object && status != FL_fss_found_content && status != FL_fss_found_content_not && status != FL_fss_found_object_content_not && status != F_terminated_not_group) {
return status;
}
// When content is found, the range->start is incremented, if content is found at range->stop, then range->start will be > range.stop.
else if (range->start >= range->stop || range->start >= buffer.used) {
- if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not || status == F_unterminated_group) {
+ if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not || status == F_terminated_not_group) {
objects->used++;
contents->used++;
}
if (range->start >= buffer.used) {
- if (status == F_unterminated_group) return F_unterminated_group_eos;
+ if (status == F_terminated_not_group) return F_terminated_not_group_eos;
return F_none_eos;
}
- if (status == F_unterminated_group) return F_unterminated_group_stop;
+ if (status == F_terminated_not_group) return F_terminated_not_group_stop;
return F_none_stop;
}
* F_data_not_stop no data to write due start location being greater than stop location.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_none_stop on success after reaching stopping point.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
- * F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
- * F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
+ * F_complete_not_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_memory_reallocation (with error bit) on reallocation error.
* F_number_overflow (with error bit) if the maximimum buffer size is reached.
* F_parameter (with error bit) if a parameter is invalid.
- * F_unterminated_eos (with error bit) if end of buffer is reached before a closing bracket is found (object was found).
- * F_unterminated_nest_eos (with error bit) if end of buffer is reached while inside a nested list before a closing bracket is found (object was found).
- * F_unterminated_nest_stop (with error bit) if stop location is reached while inside a nested list before a closing bracket is found (object was found).
- * F_unterminated_stop (with error bit) if stop location is reached before a closing bracket is found (object was found).
+ * F_terminated_not_eos (with error bit) if end of buffer is reached before a closing bracket is found (object was found).
+ * F_terminated_not_nest_eos (with error bit) if end of buffer is reached while inside a nested list before a closing bracket is found (object was found).
+ * F_terminated_not_nest_stop (with error bit) if stop location is reached while inside a nested list before a closing bracket is found (object was found).
+ * F_terminated_not_stop (with error bit) if stop location is reached before a closing bracket is found (object was found).
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* FL_fss_found_object_content_not on success and object was found but no content was found (start location is at end of object).
*
* F_none_stop on success after reaching stopping point.
* F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_data_not_stop no data to write due start location being greater than stop location.
- * F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
+ * F_complete_not_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_memory_reallocation (with error bit) on reallocation error.
* F_parameter (with error bit) if a parameter is invalid.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_absolute_not, length, FL_status_string_absolute_not_length) == F_equal_to) {
+ *code = F_absolute_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_address, length, FL_status_string_address_length) == F_equal_to) {
*code = F_address;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_address_not, length, FL_status_string_address_not_length) == F_equal_to) {
+ *code = F_address_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_block, length, FL_status_string_block_length) == F_equal_to) {
*code = F_block;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_bound_out, length, FL_status_string_bound_out_length) == F_equal_to) {
- *code = F_bound_out;
+ if (fl_string_compare(string, FL_status_string_block_not, length, FL_status_string_block_not_length) == F_equal_to) {
+ *code = F_block_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_bound, length, FL_status_string_bound_length) == F_equal_to) {
+ *code = F_bound;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_bound_not, length, FL_status_string_bound_not_length) == F_equal_to) {
+ *code = F_bound_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_complete, length, FL_status_string_complete_length) == F_equal_to) {
+ *code = F_complete;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_complete_not, length, FL_status_string_complete_not_length) == F_equal_to) {
+ *code = F_complete_not;
return F_none;
}
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_critical_not, length, FL_status_string_critical_not_length) == F_equal_to) {
+ *code = F_critical_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_deadlock, length, FL_status_string_deadlock_length) == F_equal_to) {
*code = F_deadlock;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_deadlock_not, length, FL_status_string_deadlock_not_length) == F_equal_to) {
+ *code = F_deadlock_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_descriptor, length, FL_status_string_descriptor_length) == F_equal_to) {
*code = F_descriptor;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_descriptor_not, length, FL_status_string_descriptor_not_length) == F_equal_to) {
+ *code = F_descriptor_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_device, length, FL_status_string_device_length) == F_equal_to) {
*code = F_device;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_device_not, length, FL_status_string_device_not_length) == F_equal_to) {
+ *code = F_device_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_dummy, length, FL_status_string_dummy_length) == F_equal_to) {
*code = F_dummy;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_dummy_not, length, FL_status_string_dummy_not_length) == F_equal_to) {
+ *code = F_dummy_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_encoding, length, FL_status_string_encoding_length) == F_equal_to) {
*code = F_encoding;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_eof_not, length, FL_status_string_eof_not_length) == F_equal_to) {
+ *code = F_eof_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_eol, length, FL_status_string_eol_length) == F_equal_to) {
*code = F_eol;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_eol_not, length, FL_status_string_eol_not_length) == F_equal_to) {
+ *code = F_eol_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_eos, length, FL_status_string_eos_length) == F_equal_to) {
*code = F_eos;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_eos_not, length, FL_status_string_eos_not_length) == F_equal_to) {
+ *code = F_eos_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_exist, length, FL_status_string_exist_length) == F_equal_to) {
*code = F_exist;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_failure_not, length, FL_status_string_failure_not_length) == F_equal_to) {
+ *code = F_failure_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_fork, length, FL_status_string_fork_length) == F_equal_to) {
*code = F_fork;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_fork_not, length, FL_status_string_fork_not_length) == F_equal_to) {
+ *code = F_fork_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_found, length, FL_status_string_found_length) == F_equal_to) {
*code = F_found;
return F_none;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete, length, FL_status_string_incomplete_length) == F_equal_to) {
- *code = F_incomplete;
+ if (fl_string_compare(string, FL_status_string_input, length, FL_status_string_input_length) == F_equal_to) {
+ *code = F_input;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_input, length, FL_status_string_input_length) == F_equal_to) {
- *code = F_input;
+ if (fl_string_compare(string, FL_status_string_input_not, length, FL_status_string_input_not_length) == F_equal_to) {
+ *code = F_input_not;
return F_none;
}
return F_none;
}
- if (fl_string_compare(string, FL_status_string_interrupted, length, FL_status_string_interrupted_length) == F_equal_to) {
- *code = F_interrupted;
+ if (fl_string_compare(string, FL_status_string_interrupt, length, FL_status_string_interrupt_length) == F_equal_to) {
+ *code = F_interrupt;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_invalid, length, FL_status_string_invalid_length) == F_equal_to) {
- *code = F_invalid;
+ if (fl_string_compare(string, FL_status_string_interrupt_not, length, FL_status_string_interrupt_not_length) == F_equal_to) {
+ *code = F_interrupt_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_output, length, FL_status_string_output_length) == F_equal_to) {
- *code = F_output;
+ if (fl_string_compare(string, FL_status_string_known, length, FL_status_string_known_length) == F_equal_to) {
+ *code = F_known;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_known_not, length, FL_status_string_known_not_length) == F_equal_to) {
+ *code = F_known_not;
return F_none;
}
return F_none;
}
- if (fl_string_compare(string, FL_status_string_maybe, length, FL_status_string_maybe_length) == F_equal_to) {
- *code = F_maybe;
+ if (fl_string_compare(string, FL_status_string_loop_not, length, FL_status_string_loop_not_length) == F_equal_to) {
+ *code = F_loop_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_memory, length, FL_status_string_memory_length) == F_equal_to) {
- *code = F_memory;
+ if (fl_string_compare(string, FL_status_string_maybe, length, FL_status_string_maybe_length) == F_equal_to) {
+ *code = F_maybe;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_memory_out, length, FL_status_string_memory_out_length) == F_equal_to) {
- *code = F_memory_not;
+ if (fl_string_compare(string, FL_status_string_maybe_not, length, FL_status_string_maybe_not_length) == F_equal_to) {
+ *code = F_maybe_not;
return F_none;
}
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_mount_not, length, FL_status_string_mount_not_length) == F_equal_to) {
+ *code = F_mount_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_name, length, FL_status_string_name_length) == F_equal_to) {
*code = F_name;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_name_not, length, FL_status_string_name_not_length) == F_equal_to) {
+ *code = F_name_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_output, length, FL_status_string_output_length) == F_equal_to) {
+ *code = F_output;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_output_not, length, FL_status_string_output_not_length) == F_equal_to) {
+ *code = F_output_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_parameter, length, FL_status_string_parameter_length) == F_equal_to) {
*code = F_parameter;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_parameter_not, length, FL_status_string_parameter_not_length) == F_equal_to) {
+ *code = F_parameter_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_pipe, length, FL_status_string_pipe_length) == F_equal_to) {
*code = F_pipe;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_port, length, FL_status_string_port_length) == F_equal_to) {
- *code = F_port;
+ if (fl_string_compare(string, FL_status_string_pipe_not, length, FL_status_string_pipe_not_length) == F_equal_to) {
+ *code = F_pipe_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_process, length, FL_status_string_process_length) == F_equal_to) {
- *code = F_process;
+ if (fl_string_compare(string, FL_status_string_port, length, FL_status_string_port_length) == F_equal_to) {
+ *code = F_port;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_process_too_many, length, FL_status_string_process_too_many_length) == F_equal_to) {
- *code = F_process_too_many;
+ if (fl_string_compare(string, FL_status_string_port_not, length, FL_status_string_port_not_length) == F_equal_to) {
+ *code = F_port_not;
return F_none;
}
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_prohibited_not, length, FL_status_string_prohibited_not_length) == F_equal_to) {
+ *code = F_prohibited_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_range, length, FL_status_string_range_length) == F_equal_to) {
*code = F_range;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_read, length, FL_status_string_read_length) == F_equal_to) {
+ *code = F_read;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_read_not, length, FL_status_string_read_not_length) == F_equal_to) {
+ *code = F_read_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_read_only, length, FL_status_string_read_only_length) == F_equal_to) {
*code = F_read_only;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_recurse_not, length, FL_status_string_recurse_not_length) == F_equal_to) {
+ *code = F_recurse_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_relative, length, FL_status_string_relative_length) == F_equal_to) {
*code = F_relative;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_relative_not, length, FL_status_string_relative_not_length) == F_equal_to) {
+ *code = F_relative_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_resource, length, FL_status_string_resource_length) == F_equal_to) {
*code = F_resource;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_search_not, length, FL_status_string_search_not_length) == F_equal_to) {
+ *code = F_search_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_signal, length, FL_status_string_signal_length) == F_equal_to) {
*code = F_signal;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_signal_not, length, FL_status_string_signal_not_length) == F_equal_to) {
+ *code = F_signal_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_space, length, FL_status_string_space_length) == F_equal_to) {
*code = F_space;
return F_none;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_syntax, length, FL_status_string_syntax_length) == F_equal_to) {
- *code = F_syntax;
+ if (fl_string_compare(string, FL_status_string_stop_not, length, FL_status_string_stop_not_length) == F_equal_to) {
+ *code = F_stop_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unknown, length, FL_status_string_unknown_length) == F_equal_to) {
- *code = F_unknown;
+ if (fl_string_compare(string, FL_status_string_string, length, FL_status_string_string_length) == F_equal_to) {
+ *code = F_string;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unsupported, length, FL_status_string_unsupported_length) == F_equal_to) {
- *code = F_unsupported;
+ if (fl_string_compare(string, FL_status_string_string_not, length, FL_status_string_string_not_length) == F_equal_to) {
+ *code = F_string_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_string_too_large, length, FL_status_string_string_too_large_length) == F_equal_to) {
+ *code = F_string_too_large;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_string_too_small, length, FL_status_string_string_too_small_length) == F_equal_to) {
+ *code = F_string_too_small;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_supported, length, FL_status_string_supported_length) == F_equal_to) {
+ *code = F_supported;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_supported_not, length, FL_status_string_supported_not_length) == F_equal_to) {
+ *code = F_supported_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_syntax, length, FL_status_string_syntax_length) == F_equal_to) {
+ *code = F_syntax;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_syntax_not, length, FL_status_string_syntax_not_length) == F_equal_to) {
+ *code = F_syntax_not;
return F_none;
}
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_valid, length, FL_status_string_valid_length) == F_equal_to) {
+ *code = F_valid;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_valid_not, length, FL_status_string_valid_not_length) == F_equal_to) {
+ *code = F_valid_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_value, length, FL_status_string_value_length) == F_equal_to) {
*code = F_value;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_warn_not, length, FL_status_string_warn_not_length) == F_equal_to) {
+ *code = F_warn_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_write, length, FL_status_string_write_length) == F_equal_to) {
+ *code = F_write;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_write_not, length, FL_status_string_write_not_length) == F_equal_to) {
+ *code = F_write_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_write_only, length, FL_status_string_write_only_length) == F_equal_to) {
*code = F_write_only;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_array_not, length, FL_status_string_array_not_length) == F_equal_to) {
+ *code = F_array_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_array_too_large, length, FL_status_string_array_too_large_length) == F_equal_to) {
*code = F_array_too_large;
return F_none;
}
#endif // _di_F_status_array_
- #ifndef _di_F_status_busy_
- if (fl_string_compare(string, FL_status_string_busy, length, FL_status_string_busy_length) == F_equal_to) {
- *code = F_busy;
+ #ifndef _di_F_status_available_
+ if (fl_string_compare(string, FL_status_string_available, length, FL_status_string_available_length) == F_equal_to) {
+ *code = F_available;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_address, length, FL_status_string_busy_address_length) == F_equal_to) {
- *code = F_busy_address;
+ if (fl_string_compare(string, FL_status_string_available_not, length, FL_status_string_available_not_length) == F_equal_to) {
+ *code = F_available_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_buffer, length, FL_status_string_busy_buffer_length) == F_equal_to) {
- *code = F_busy_buffer;
+ if (fl_string_compare(string, FL_status_string_available_not_address, length, FL_status_string_available_not_address_length) == F_equal_to) {
+ *code = F_available_not_address;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_device, length, FL_status_string_busy_device_length) == F_equal_to) {
- *code = F_busy_device;
+ if (fl_string_compare(string, FL_status_string_available_not_buffer, length, FL_status_string_available_not_buffer_length) == F_equal_to) {
+ *code = F_available_not_buffer;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_pipe, length, FL_status_string_busy_pipe_length) == F_equal_to) {
- *code = F_busy_pipe;
+ if (fl_string_compare(string, FL_status_string_available_not_device, length, FL_status_string_available_not_device_length) == F_equal_to) {
+ *code = F_available_not_device;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_port, length, FL_status_string_busy_port_length) == F_equal_to) {
- *code = F_busy_port;
+ if (fl_string_compare(string, FL_status_string_available_not_pipe, length, FL_status_string_available_not_pipe_length) == F_equal_to) {
+ *code = F_available_not_pipe;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_process, length, FL_status_string_busy_process_length) == F_equal_to) {
- *code = F_busy_process;
+ if (fl_string_compare(string, FL_status_string_available_not_port, length, FL_status_string_available_not_port_length) == F_equal_to) {
+ *code = F_available_not_port;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_busy_socket, length, FL_status_string_busy_socket_length) == F_equal_to) {
- *code = F_busy_socket;
+ if (fl_string_compare(string, FL_status_string_available_not_process, length, FL_status_string_available_not_process_length) == F_equal_to) {
+ *code = F_available_not_process;
return F_none;
}
- #endif // _di_F_status_busy_
- #ifndef _di_F_status_unavailable_
- if (fl_string_compare(string, FL_status_string_unavailable, length, FL_status_string_unavailable_length) == F_equal_to) {
- *code = F_unavailable;
+ if (fl_string_compare(string, FL_status_string_available_not_socket, length, FL_status_string_available_not_socket_length) == F_equal_to) {
+ *code = F_available_not_socket;
return F_none;
}
+ #endif // _di_F_status_available_
- if (fl_string_compare(string, FL_status_string_unavailable_address, length, FL_status_string_unavailable_address_length) == F_equal_to) {
- *code = F_unavailable_address;
+ #ifndef _di_F_status_busy_
+ if (fl_string_compare(string, FL_status_string_busy, length, FL_status_string_busy_length) == F_equal_to) {
+ *code = F_busy;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_buffer, length, FL_status_string_unavailable_buffer_length) == F_equal_to) {
- *code = F_unavailable_buffer;
+ if (fl_string_compare(string, FL_status_string_busy_address, length, FL_status_string_busy_address_length) == F_equal_to) {
+ *code = F_busy_address;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_device, length, FL_status_string_unavailable_device_length) == F_equal_to) {
- *code = F_unavailable_device;
+ if (fl_string_compare(string, FL_status_string_busy_buffer, length, FL_status_string_busy_buffer_length) == F_equal_to) {
+ *code = F_busy_buffer;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_pipe, length, FL_status_string_unavailable_pipe_length) == F_equal_to) {
- *code = F_unavailable_pipe;
+ if (fl_string_compare(string, FL_status_string_busy_device, length, FL_status_string_busy_device_length) == F_equal_to) {
+ *code = F_busy_device;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_port, length, FL_status_string_unavailable_port_length) == F_equal_to) {
- *code = F_unavailable_port;
+ if (fl_string_compare(string, FL_status_string_busy_not, length, FL_status_string_busy_not_length) == F_equal_to) {
+ *code = F_busy_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_process, length, FL_status_string_unavailable_process_length) == F_equal_to) {
- *code = F_unavailable_process;
+ if (fl_string_compare(string, FL_status_string_busy_pipe, length, FL_status_string_busy_pipe_length) == F_equal_to) {
+ *code = F_busy_pipe;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_busy_port, length, FL_status_string_busy_port_length) == F_equal_to) {
+ *code = F_busy_port;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_busy_process, length, FL_status_string_busy_process_length) == F_equal_to) {
+ *code = F_busy_process;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unavailable_socket, length, FL_status_string_unavailable_socket_length) == F_equal_to) {
- *code = F_unavailable_socket;
+ if (fl_string_compare(string, FL_status_string_busy_socket, length, FL_status_string_busy_socket_length) == F_equal_to) {
+ *code = F_busy_socket;
return F_none;
}
- #endif // _di_F_status_unavailable_
+ #endif // _di_F_status_busy_
#ifndef _di_F_status_number_
if (fl_string_compare(string, FL_status_string_number, length, FL_status_string_number_length) == F_equal_to) {
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_number_decimal_not, length, FL_status_string_number_decimal_not_length) == F_equal_to) {
+ *code = F_number_decimal_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_number_divide_by_zero, length, FL_status_string_number_divide_by_zero_length) == F_equal_to) {
*code = F_number_divide_by_zero;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_number_negative_not, length, FL_status_string_number_negative_not_length) == F_equal_to) {
+ *code = F_number_negative_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_number_not, length, FL_status_string_number_not_length) == F_equal_to) {
+ *code = F_number_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_number_overflow, length, FL_status_string_number_overflow_length) == F_equal_to) {
*code = F_number_overflow;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_number_positive_not, length, FL_status_string_number_positive_not_length) == F_equal_to) {
+ *code = F_number_positive_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_number_underflow, length, FL_status_string_number_underflow_length) == F_equal_to) {
*code = F_number_underflow;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_number_whole_not, length, FL_status_string_number_whole_not_length) == F_equal_to) {
+ *code = F_number_whole_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_number_zero, length, FL_status_string_number_zero_length) == F_equal_to) {
*code = F_number_zero;
return F_none;
}
+
+ if (fl_string_compare(string, FL_status_string_number_zero_not, length, FL_status_string_number_zero_not_length) == F_equal_to) {
+ *code = F_number_zero_not;
+ return F_none;
+ }
#endif // _di_F_status_number_
#ifndef _di_F_status_buffer_
return F_none;
}
- if (fl_string_compare(string, FL_status_string_buffer_too_small, length, FL_status_string_buffer_too_small_length) == F_equal_to) {
- *code = F_buffer_too_small;
+ if (fl_string_compare(string, FL_status_string_buffer_not, length, FL_status_string_buffer_not_length) == F_equal_to) {
+ *code = F_buffer_not;
return F_none;
}
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf, length, FL_status_string_incomplete_utf_length) == F_equal_to) {
- *code = F_incomplete_utf;
+ if (fl_string_compare(string, FL_status_string_buffer_too_small, length, FL_status_string_buffer_too_small_length) == F_equal_to) {
+ *code = F_buffer_too_small;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_complete_not_utf, length, FL_status_string_complete_not_utf_length) == F_equal_to) {
+ *code = F_complete_not_utf;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf_block, length, FL_status_string_incomplete_utf_block_length) == F_equal_to) {
- *code = F_incomplete_utf_block;
+ if (fl_string_compare(string, FL_status_string_complete_not_utf_block, length, FL_status_string_complete_not_utf_block_length) == F_equal_to) {
+ *code = F_complete_not_utf_block;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf_eof, length, FL_status_string_incomplete_utf_eof_length) == F_equal_to) {
- *code = F_incomplete_utf_eof;
+ if (fl_string_compare(string, FL_status_string_complete_not_utf_eof, length, FL_status_string_complete_not_utf_eof_length) == F_equal_to) {
+ *code = F_complete_not_utf_eof;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf_eol, length, FL_status_string_incomplete_utf_eol_length) == F_equal_to) {
- *code = F_incomplete_utf_eol;
+ if (fl_string_compare(string, FL_status_string_complete_not_utf_eol, length, FL_status_string_complete_not_utf_eol_length) == F_equal_to) {
+ *code = F_complete_not_utf_eol;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf_eos, length, FL_status_string_incomplete_utf_eos_length) == F_equal_to) {
- *code = F_incomplete_utf_eos;
+ if (fl_string_compare(string, FL_status_string_complete_not_utf_eos, length, FL_status_string_complete_not_utf_eos_length) == F_equal_to) {
+ *code = F_complete_not_utf_eos;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_incomplete_utf_stop, length, FL_status_string_incomplete_utf_stop_length) == F_equal_to) {
- *code = F_incomplete_utf_stop;
+ if (fl_string_compare(string, FL_status_string_complete_not_utf_stop, length, FL_status_string_complete_not_utf_stop_length) == F_equal_to) {
+ *code = F_complete_not_utf_stop;
return F_none;
}
return F_none;
}
- if (fl_string_compare(string, FL_status_string_string_too_small, length, FL_status_string_string_too_small_length) == F_equal_to) {
- *code = F_string_too_small;
+ if (fl_string_compare(string, FL_status_string_terminated, length, FL_status_string_terminated_length) == F_equal_to) {
+ *code = F_terminated;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_string_too_large, length, FL_status_string_string_too_large_length) == F_equal_to) {
- *code = F_string_too_large;
+ if (fl_string_compare(string, FL_status_string_terminated_not, length, FL_status_string_terminated_not_length) == F_equal_to) {
+ *code = F_terminated_not;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated, length, FL_status_string_unterminated_length) == F_equal_to) {
- *code = F_unterminated;
+ if (fl_string_compare(string, FL_status_string_terminated_not_block, length, FL_status_string_terminated_not_block_length) == F_equal_to) {
+ *code = F_terminated_not_block;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_block, length, FL_status_string_unterminated_block_length) == F_equal_to) {
- *code = F_unterminated_block;
+ if (fl_string_compare(string, FL_status_string_terminated_not_eof, length, FL_status_string_terminated_not_eof_length) == F_equal_to) {
+ *code = F_terminated_not_eof;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_eof, length, FL_status_string_unterminated_eof_length) == F_equal_to) {
- *code = F_unterminated_eof;
+ if (fl_string_compare(string, FL_status_string_terminated_not_eol, length, FL_status_string_terminated_not_eol_length) == F_equal_to) {
+ *code = F_terminated_not_eol;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_eol, length, FL_status_string_unterminated_eol_length) == F_equal_to) {
- *code = F_unterminated_eol;
+ if (fl_string_compare(string, FL_status_string_terminated_not_eos, length, FL_status_string_terminated_not_eos_length) == F_equal_to) {
+ *code = F_terminated_not_eos;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_eos, length, FL_status_string_unterminated_eos_length) == F_equal_to) {
- *code = F_unterminated_eos;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group, length, FL_status_string_terminated_not_group_length) == F_equal_to) {
+ *code = F_terminated_not_group;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_stop, length, FL_status_string_unterminated_stop_length) == F_equal_to) {
- *code = F_unterminated_stop;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group_block, length, FL_status_string_terminated_not_group_block_length) == F_equal_to) {
+ *code = F_terminated_not_group_block;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group, length, FL_status_string_unterminated_group_length) == F_equal_to) {
- *code = F_unterminated_group;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group_eof, length, FL_status_string_terminated_not_group_eof_length) == F_equal_to) {
+ *code = F_terminated_not_group_eof;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group_block, length, FL_status_string_unterminated_group_block_length) == F_equal_to) {
- *code = F_unterminated_group_block;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group_eol, length, FL_status_string_terminated_not_group_eol_length) == F_equal_to) {
+ *code = F_terminated_not_group_eol;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group_eof, length, FL_status_string_unterminated_group_eof_length) == F_equal_to) {
- *code = F_unterminated_group_eof;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group_eos, length, FL_status_string_terminated_not_group_eos_length) == F_equal_to) {
+ *code = F_terminated_not_group_eos;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group_eol, length, FL_status_string_unterminated_group_eol_length) == F_equal_to) {
- *code = F_unterminated_group_eol;
+ if (fl_string_compare(string, FL_status_string_terminated_not_group_stop, length, FL_status_string_terminated_not_group_stop_length) == F_equal_to) {
+ *code = F_terminated_not_group_stop;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group_eos, length, FL_status_string_unterminated_group_eos_length) == F_equal_to) {
- *code = F_unterminated_group_eos;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest, length, FL_status_string_terminated_not_nest_length) == F_equal_to) {
+ *code = F_terminated_not_nest;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_group_stop, length, FL_status_string_unterminated_group_stop_length) == F_equal_to) {
- *code = F_unterminated_group_stop;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest_block, length, FL_status_string_terminated_not_nest_block_length) == F_equal_to) {
+ *code = F_terminated_not_nest_block;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_nest, length, FL_status_string_unterminated_nest_length) == F_equal_to) {
- *code = F_unterminated_nest;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest_eof, length, FL_status_string_terminated_not_nest_eof_length) == F_equal_to) {
+ *code = F_terminated_not_nest_eof;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_nest_block, length, FL_status_string_unterminated_nest_block_length) == F_equal_to) {
- *code = F_unterminated_nest_block;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest_eol, length, FL_status_string_terminated_not_nest_eol_length) == F_equal_to) {
+ *code = F_terminated_not_nest_eol;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_nest_eof, length, FL_status_string_unterminated_nest_eof_length) == F_equal_to) {
- *code = F_unterminated_nest_eof;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest_eos, length, FL_status_string_terminated_not_nest_eos_length) == F_equal_to) {
+ *code = F_terminated_not_nest_eos;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_nest_eol, length, FL_status_string_unterminated_nest_eol_length) == F_equal_to) {
- *code = F_unterminated_nest_eol;
+ if (fl_string_compare(string, FL_status_string_terminated_not_nest_stop, length, FL_status_string_terminated_not_nest_stop_length) == F_equal_to) {
+ *code = F_terminated_not_nest_stop;
return F_none;
}
- if (fl_string_compare(string, FL_status_string_unterminated_nest_eos, length, FL_status_string_unterminated_nest_eos_length) == F_equal_to) {
- *code = F_unterminated_nest_eos;
+ if (fl_string_compare(string, FL_status_string_terminated_not_stop, length, FL_status_string_terminated_not_stop_length) == F_equal_to) {
+ *code = F_terminated_not_stop;
return F_none;
}
+ #endif // _di_F_status_buffer_
- if (fl_string_compare(string, FL_status_string_unterminated_nest_stop, length, FL_status_string_unterminated_nest_stop_length) == F_equal_to) {
- *code = F_unterminated_nest_stop;
+ #ifndef _di_F_status_memory_
+ if (fl_string_compare(string, FL_status_string_memory, length, FL_status_string_memory_length) == F_equal_to) {
+ *code = F_memory;
return F_none;
}
- #endif // _di_F_status_buffer_
- #ifndef _di_F_status_memory_
if (fl_string_compare(string, FL_status_string_memory_allocation, length, FL_status_string_memory_allocation_length) == F_equal_to) {
*code = F_memory_allocation;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_memory_not, length, FL_status_string_memory_not_length) == F_equal_to) {
+ *code = F_memory_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_memory_reallocation, length, FL_status_string_memory_reallocation_length) == F_equal_to) {
*code = F_memory_reallocation;
return F_none;
}
#endif // _di_F_status_memory_
+ #ifndef _di_F_status_process_
+ if (fl_string_compare(string, FL_status_string_process, length, FL_status_string_process_length) == F_equal_to) {
+ *code = F_process;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_process_not, length, FL_status_string_process_not_length) == F_equal_to) {
+ *code = F_process_not;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_process_too_many, length, FL_status_string_process_too_many_length) == F_equal_to) {
+ *code = F_process_too_many;
+ return F_none;
+ }
+ #endif // _di_F_status_process_
+
#ifndef _di_F_status_file_
if (fl_string_compare(string, FL_status_string_file, length, FL_status_string_file_length) == F_equal_to) {
*code = F_file;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_file_not, length, FL_status_string_file_not_length) == F_equal_to) {
+ *code = F_file_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_file_open, length, FL_status_string_file_open_length) == F_equal_to) {
*code = F_file_open;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_filesystem_not, length, FL_status_string_filesystem_not_length) == F_equal_to) {
+ *code = F_filesystem_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_filesystem_quota_block, length, FL_status_string_filesystem_quota_block_length) == F_equal_to) {
*code = F_filesystem_quota_block;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_directory_not, length, FL_status_string_directory_not_length) == F_equal_to) {
+ *code = F_directory_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_directory_open, length, FL_status_string_directory_open_length) == F_equal_to) {
*code = F_directory_open;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_socket_not, length, FL_status_string_socket_not_length) == F_equal_to) {
+ *code = F_socket_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_socket_receive, length, FL_status_string_socket_receive_length) == F_equal_to) {
*code = F_socket_receive;
return F_none;
return F_none;
}
+ if (fl_string_compare(string, FL_status_string_access_not, length, FL_status_string_access_not_length) == F_equal_to) {
+ *code = F_access_not;
+ return F_none;
+ }
+
if (fl_string_compare(string, FL_status_string_access_owner, length, FL_status_string_access_owner_length) == F_equal_to) {
*code = F_access_owner;
return F_none;
return F_status_set_error(F_access);
}
- if (status == F_incomplete_utf || status == F_incomplete_utf_block || status == F_incomplete_utf_eof || status == F_incomplete_utf_eol || status == F_incomplete_utf_eos || status == F_incomplete_utf_stop) {
+ if (status == F_complete_not_utf || status == F_complete_not_utf_block || status == F_complete_not_utf_eof || status == F_complete_not_utf_eol || status == F_complete_not_utf_eos || status == F_complete_not_utf_stop) {
return F_status_set_error(F_encoding);
}
return F_status_set_error(F_number);
}
- if (status == F_parameter || status == F_found_not || status == F_interrupted) {
+ if (status == F_parameter || status == F_found_not || status == F_interrupt) {
return F_status_set_error(status);
}
- return F_status_set_error(F_invalid);
+ return F_status_set_error(F_valid_not);
}
#endif // _di_controller_status_simplify_
#define controller_rule_action_t_initialize \
{ \
0, \
- F_unknown, \
+ F_known_not, \
f_string_dynamics_t_initialize, \
}
#define controller_rule_t_initialize \
{ \
- F_unknown, \
+ F_known_not, \
f_string_dynamic_t_initialize, \
f_string_dynamic_t_initialize, \
f_string_dynamic_t_initialize, \
0, \
0, \
0, \
- F_unknown, \
+ F_known_not, \
f_string_dynamics_t_initialize, \
}
#define controller_entry_t_initialize \
{ \
- F_unknown, \
+ F_known_not, \
controller_entry_items_t_initialize, \
}
action->code = 0;
action->line = cache->line_action;
action->timeout = 0;
- action->status = F_unknown;
+ action->status = F_known_not;
action->parameters.used = 0;
status = f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->line_action);
}
else {
if (action->status == F_none) {
- action->status = F_status_set_error(F_unsupported);
+ action->status = F_status_set_error(F_supported_not);
if (F_status_is_error_not(status_action)) {
status_action = action->status;
if (fl_string_dynamic_compare_string(controller_string_kill, action->parameters.array[0], controller_string_kill_length) == F_equal_to_not) {
if (fl_string_dynamic_compare_string(controller_string_start, action->parameters.array[0], controller_string_start_length) == F_equal_to_not) {
if (fl_string_dynamic_compare_string(controller_string_stop, action->parameters.array[0], controller_string_stop_length) == F_equal_to_not) {
- action->status = F_status_set_error(F_unsupported);
+ action->status = F_status_set_error(F_supported_not);
if (F_status_is_error_not(status_action)) {
status_action = action->status;
f_return_status controller_entry_read(const controller_data_t data, const controller_setting_t setting, const f_string_static_t entry_name, controller_entry_cache_t *cache, controller_entry_t *entry) {
f_status_t status = F_none;
- entry->status = F_unknown;
+ entry->status = F_known_not;
entry->items.used = 0;
cache->line_action = 0;
actions->array[actions->used].line += item->line;
actions->array[actions->used].parameters.used = 0;
- actions->array[actions->used].status = F_unknown;
+ actions->array[actions->used].status = F_known_not;
status = fl_string_dynamics_increase(&actions->array[actions->used].parameters);
else {
actions->array[0].line += item->line;
actions->array[0].parameters.used = 0;
- actions->array[0].status = F_unknown;
+ actions->array[0].status = F_known_not;
status = controller_rule_action_read(data, cache->buffer_item, 0, &cache->content_action, &actions->array[0]);
fprintf(data.error.to.stream, "%s%sFSS Extended List is not allowed for this rule item action type.%s%c", data.error.context.before->string, data.error.prefix ? data.error.prefix : "", data.error.context.after->string, f_string_eol[0]);
}
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
bool for_item = F_true;
- rule->status = F_unknown;
+ rule->status = F_known_not;
rule->id.used = 0;
rule->name.used = 0;
controller_rule_error_print(data.error, *cache, F_false);
if (F_status_is_error_not(status_return)) {
- status_return = F_status_set_error(F_invalid);
+ status_return = F_status_set_error(F_valid_not);
}
continue;
controller_rule_error_print(data.error, *cache, F_false);
if (F_status_is_error_not(status_return)) {
- status_return = F_status_set_error(F_invalid);
+ status_return = F_status_set_error(F_valid_not);
}
continue;
status = controller_validate_has_graph(*setting_value);
- if (status == F_false || F_status_set_fine(status) == F_incomplete_utf) {
+ if (status == F_false || F_status_set_fine(status) == F_complete_not_utf) {
if (status == F_false) {
fprintf(data.error.to.stream, "%c", f_string_eol[0]);
fprintf(data.error.to.stream, "%s%sRule setting has an invalid name '", data.error.context.before->string, data.error.prefix ? data.error.prefix : "");
controller_rule_error_print(data.error, *cache, F_false);
if (F_status_is_error_not(status_return)) {
- status_return = F_status_set_error(F_invalid);
+ status_return = F_status_set_error(F_valid_not);
}
}
else {
- // this function should only return F_incomplete_utf on error.
- fll_error_print(data.error, F_incomplete_utf, "controller_validate_has_graph", F_true);
+ // this function should only return F_complete_not_utf on error.
+ fll_error_print(data.error, F_complete_not_utf, "controller_validate_has_graph", F_true);
if (F_status_is_error_not(status_return)) {
status_return = status;
status = controller_validate_environment_name(setting_values->array[setting_values->used]);
- if (status == F_false || F_status_set_fine(status) == F_incomplete_utf) {
+ if (status == F_false || F_status_set_fine(status) == F_complete_not_utf) {
if (status == F_false) {
fprintf(data.error.to.stream, "%c", f_string_eol[0]);
fprintf(data.error.to.stream, "%s%sRule setting has an invalid environment variable name '", data.error.context.before->string, data.error.prefix ? data.error.prefix : "");
controller_rule_error_print(data.error, *cache, F_false);
if (F_status_is_error_not(status_return)) {
- status_return = F_status_set_error(F_invalid);
+ status_return = F_status_set_error(F_valid_not);
}
}
else {
- // this function should only return F_incomplete_utf on error.
- fll_error_print(data.error, F_incomplete_utf, "controller_validate_environment_name", F_true);
+ // this function should only return F_complete_not_utf on error.
+ fll_error_print(data.error, F_complete_not_utf, "controller_validate_environment_name", F_true);
if (F_status_is_error_not(status_return)) {
status_return = status;
controller_rule_error_print(data.error, *cache, F_false);
if (F_status_is_error_not(status_return)) {
- status_return = F_status_set_error(F_invalid);
+ status_return = F_status_set_error(F_valid_not);
}
continue;
*
* @return
* F_none on success.
- * F_invalid (with error bit) on success but there were one or more invalid settings encountered.
+ * F_valid_not (with error bit) on success but there were one or more invalid settings encountered.
*
* Errors (with error bit) from: fl_string_dynamic_partial_append_nulless().
* Errors (with error bit) from: fl_string_dynamic_rip_nulless().
status = f_utf_is_word_dash_plus(arguments.argv[location] + j, width_max, F_false);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word_dash_plus", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word_dash_plus", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fake_long_process);
status = fl_console_parameter_to_string_dynamic_directory(arguments.argv[data->parameters[parameters_id[i]].values.array[0]], parameters_value[i]);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "fl_console_parameter_to_string_dynamic_directory", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "fl_console_parameter_to_string_dynamic_directory", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, parameters_name[i]);
f_macro_string_dynamic_t_new(status, (*parameters_value[i]), parameter_default_lengths[i]);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "f_macro_string_dynamic_t_new", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "f_macro_string_dynamic_t_new", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to load default for the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, parameters_name[i]);
status = fll_program_parameter_additional_rip(arguments.argv, data->parameters[fake_parameter_define].values, &data->define);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "fll_program_parameter_additional_rip", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "fll_program_parameter_additional_rip", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fake_long_define);
status = f_utf_is_word(data->define.array[i].string + j, width_max, F_false);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fake_long_define);
status = fll_program_parameter_additional_rip(arguments.argv, data->parameters[fake_parameter_mode].values, &data->mode);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "fll_program_parameter_additional_rip", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "fll_program_parameter_additional_rip", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fake_long_mode);
status = f_utf_is_word_dash_plus(data->mode.array[i].string + j, width_max, F_false);
if (F_status_is_error(status)) {
- if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word_dash_plus", F_false) == F_unknown && data->error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data->error, F_status_set_fine(status), "f_utf_is_word_dash_plus", F_false) == F_known_not && data->error.verbosity != f_console_verbosity_quiet) {
fprintf(data->error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data->error.to.stream, data->context.set.error, "%sFailed to process the parameter '", fll_error_print_error);
fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fake_long_mode);
if (!operation) {
fake_print_message_section_operation_unknown(data, data_make->error, data_make->buffer, section->name, section->objects.array[i]);
- *status = F_status_set_error(F_invalid);
+ *status = F_status_set_error(F_valid_not);
}
else if (operation == fake_make_operation_type_operate) {
if (section_stack->used == fake_make_section_stack_max) {
* @param status
* The return status.
*
- * F_invalid (with error bit set) is returned if any part of the section is invalid, such as an invalid operation name.
+ * F_valid_not (with error bit set) is returned if any part of the section is invalid, such as an invalid operation name.
* F_recurse (with error bit set) is returned if unable to recurse to another operation section (usually max stack depth reached).
*/
#ifndef _di_fake_make_operate_section_
return F_false;
}
- if (fll_error_print(data.error, status, function, F_false) == F_unknown && fallback && data.error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data.error, status, function, F_false) == F_known_not && fallback && data.error.verbosity != f_console_verbosity_quiet) {
fprintf(data.error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data.error.to.stream, data.context.set.error, "UNKNOWN %s(", fll_error_print_error);
fl_color_print(data.error.to.stream, data.context.set.notable, "%llu", status);
return F_false;
}
- if (status == F_status_set_error(F_incomplete_utf_stop)) {
+ if (status == F_status_set_error(F_complete_not_utf_stop)) {
if (data.error.verbosity != f_console_verbosity_quiet) {
fprintf(data.error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data.error.to.stream, data.context.set.error, "%serror occurred on invalid UTF-8 character at end of string (at ", fll_error_print_error);
return F_false;
}
- if (fll_error_print(data.error, status, function, F_false) == F_unknown && fallback && data.error.verbosity != f_console_verbosity_quiet) {
+ if (fll_error_print(data.error, status, function, F_false) == F_known_not && fallback && data.error.verbosity != f_console_verbosity_quiet) {
fprintf(data.error.to.stream, "%c", f_string_eol[0]);
fl_color_print(data.error.to.stream, data.context.set.error, "UNKNOWN %s(", fll_error_print_error);
fl_color_print(data.error.to.stream, data.context.set.notable, "%llu", status);
if (F_status_set_fine(status) == F_none_eol) {
fss_basic_list_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
fl_color_print(data.error.to.stream, data.context.set.error, "%sThis standard only supports one content per object.%c", fll_error_print_error, f_string_eol[0]);
}
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
if (F_status_set_fine(status) == F_none_eol) {
fss_basic_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
if (F_status_set_fine(status) == F_none_eol) {
fss_basic_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
fl_color_print(data.error.to.stream, data.context.set.error, "%sThis standard only supports one content per object.%c", fll_error_print_error, f_string_eol[0]);
}
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
if (F_status_set_fine(status) == F_none_eol) {
fss_basic_write_error_parameter_unsupported_eol_print(data);
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
if (F_status_set_fine(status) == F_none_eol) {
fss_embedded_list_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
fl_color_print(data.error.to.stream, data.context.set.error, "%sThis standard only supports one content per object.%c", fll_error_print_error, f_string_eol[0]);
}
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
if (F_status_set_fine(status) == F_none_eol) {
fss_extended_list_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
fl_color_print(data.error.to.stream, data.context.set.error, "%sThis standard only supports one content per object.%c", fll_error_print_error, f_string_eol[0]);
}
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
if (F_status_set_fine(status) == F_none_eol) {
fss_extended_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
if (F_status_set_fine(status) == F_none_eol) {
fss_extended_write_error_parameter_unsupported_eol_print(data);
- return F_status_set_error(F_unsupported);
+ return F_status_set_error(F_supported_not);
}
if (F_status_is_error(status)) {
if (F_status_set_fine(status) == F_none_eol) {
fss_extended_write_error_parameter_unsupported_eol_print(data);
- status = F_status_set_error(F_unsupported);
+ status = F_status_set_error(F_supported_not);
break;
}
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
*
* Errors (with error bit) from: fss_status_code_convert_number().
*
* @return
* F_none on success.
* F_data_not if string starts wth a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* @return
* F_none on success.
* F_data_not if string starts wth a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
*
* Errors (with error bit) from: fss_status_code_convert_number().
*
* @return
* F_none on success.
* F_data_not if string starts wth a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* @return
* F_none on success.
* F_data_not if string starts wth a null (length is 0).
- * F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
+ * F_complete_not_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
projects / fll / commitdiff