Use `uint8_t` to both enforce a specific byte size as well as provide the ability for it to be converted into a set of bits if need be, without breaking API or ABI.
Update the tests to use `uint8_t` as well.
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
int __wrap_getpwnam_r(const char * const name, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getpwuid_r(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getgrnam_r(const char * const name, struct group *grp, char *buf, size_t buflen, struct group **result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getgrgid_r(uid_t uid, struct group *grp, char *buf, size_t buflen, struct group **result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
#endif // _di_f_capability_size_
#ifndef _di_f_capability_supported_
- bool f_capability_supported(void) {
+ uint8_t f_capability_supported(void) {
return F_false;
}
#endif // _di_f_capability_supported_
#if defined(_di_libcap_) || defined(_libcap_legacy_only_)
#ifndef _di_f_capability_supported_ambient_
- bool f_capability_supported_ambient(void) {
+ uint8_t f_capability_supported_ambient(void) {
return F_false;
}
#endif // _di_f_capability_supported_ambient_
#ifdef _di_libcap_
#ifndef _di_f_capability_supported_code_
- bool f_capability_supported_code(const f_capability_value_t code) {
+ uint8_t f_capability_supported_code(const f_capability_value_t code) {
return F_false;
}
#endif // _di_f_capability_supported_code_
#endif // _di_f_capability_size_
#ifndef _di_f_capability_supported_
- bool f_capability_supported(void) {
+ uint8_t f_capability_supported(void) {
return F_true;
}
#endif // _di_f_capability_supported_
#if !defined(_di_libcap_) && !defined(_libcap_legacy_only_)
#ifndef _di_f_capability_supported_ambient_
- bool f_capability_supported_ambient(void) {
+ uint8_t f_capability_supported_ambient(void) {
return CAP_AMBIENT_SUPPORTED() ? F_true : F_false;
}
#ifndef _di_libcap_
#ifndef _di_f_capability_supported_code_
- bool f_capability_supported_code(const f_capability_value_t code) {
+ uint8_t f_capability_supported_code(const f_capability_value_t code) {
return CAP_IS_SUPPORTED(code) ? F_true : F_false;
}
* F_false otherwise.
*/
#ifndef _di_f_capability_supported_
- extern bool f_capability_supported(void);
+ extern uint8_t f_capability_supported(void);
#endif // _di_f_capability_supported_
/**
* @see CAP_IS_SUPPORTED()
*/
#ifndef _di_f_capability_supported_code_
- extern bool f_capability_supported_code(f_capability_value_t code);
+ extern uint8_t f_capability_supported_code(f_capability_value_t code);
#endif // _di_f_capability_supported_code_
/**
* @see CAP_AMBIENT_SUPPORTED()
*/
#ifndef _di_f_capability_supported_ambient_
- extern bool f_capability_supported_ambient(void);
+ extern uint8_t f_capability_supported_ambient(void);
#endif // _di_f_capability_supported_ambient_
/**
int __wrap_cap_get_ambient(cap_value_t value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return -1;
int __wrap_cap_clear(cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_clear_flag(cap_t capability, cap_flag_value_t flag_value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_compare(cap_t capability_1, cap_t capability_2) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_cap_copy_ext(void *data, cap_t capability, ssize_t size) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_copy_int(void *data) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_drop_bound(cap_value_t value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_dup(cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_free(void *pointer) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_from_name(const char * const name, cap_value_t *value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_from_text(const char * const text) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_get_bound(cap_value_t value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_get_fd(int descriptor) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_get_file(const char * const path) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_get_flag(cap_t capability, cap_value_t value, cap_flag_t flag, cap_flag_value_t *flag_value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_mode_t __wrap_cap_get_mode(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
uid_t __wrap_cap_get_nsowner(cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_init(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
const char *__wrap_cap_mode_name(cap_mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_get_pid(pid_t pid) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_get_proc(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
unsigned __wrap_cap_get_secbits(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_reset_ambient(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_ambient(cap_value_t value, cap_flag_value_t flag_value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_fd(int descriptor, cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_file(const char * const path, cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_flag(cap_t capability, cap_flag_t flag, int number, const cap_value_t *value, cap_flag_value_t flag_value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_mode(cap_mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_nsowner(cap_t capability, uid_t id) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_proc(cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_secbits(unsigned bits) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_setgroups(gid_t gid, size_t total, const gid_t groups[]) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_setuid(uid_t uid) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_cap_size(cap_t capability) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char * __wrap_cap_to_text(cap_t capability, ssize_t *size) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char * __wrap_cap_to_name(cap_value_t value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char * __wrap_getenv(char *name) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return (char *) 0;
uint8_t type;
uint8_t depth;
uint8_t width;
- bool found;
+ uint8_t found;
f_console_result_t result;
f_state_t *state;
*/
#ifndef _di_f_control_group_t_
typedef struct {
- bool as_new;
+ uint8_t as_new;
f_string_dynamic_t path;
f_string_dynamics_t groups;
size_t __wrap_fwrite_unlocked(const void * const ptr, size_t size, size_t nmemb, FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(size_t);
}
- const bool check_ptr = mock_type(bool);
+ const uint8_t check_ptr = mock_type(uint8_t);
if (check_ptr) {
check_expected(ptr);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
return __real_alphasort(a, b);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_closedir(dirp);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_fdopendir(fd);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_fstatat(dirfd, pathname, statbuf, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_mkdir(pathname, mode);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_mkdirat(dirfd, pathname, mode);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_nftw(dirpath, fn, nopenfd, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_open(pathname, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_openat(dirfd, pathname, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_opendir(name);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_readdir(dirp);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_remove(pathname);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_scandir(dirp, namelist, filter, compar);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_stat(pathname, statbuf);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_telldir(dirp);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_utimensat(dirfd, pathname, times, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
return __real_versionsort(a, b);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
#endif // _di_f_environment_secure_is_
#ifndef _di_f_environment_set_
- f_status_t f_environment_set(const f_string_static_t name, const f_string_static_t value, const bool replace) {
+ f_status_t f_environment_set(const f_string_static_t name, const f_string_static_t value, const uint8_t replace) {
if (!name.used) {
return F_data_not;
* @see setenv()
*/
#ifndef _di_f_environment_set_
- extern f_status_t f_environment_set(const f_string_static_t name, const f_string_static_t value, const bool replace);
+ extern f_status_t f_environment_set(const f_string_static_t name, const f_string_static_t value, const uint8_t replace);
#endif // _di_f_environment_set_
/**
int __wrap_cap_get_flag(cap_t cap_p, cap_value_t cap, cap_flag_t flag, cap_flag_value_t *value_p) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
cap_t __wrap_cap_get_proc(void) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_cap_set_proc(cap_t cap_p) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_setenv(const char *name, const char *value, int overwrite) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_unsetenv(const char *name) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
#endif // _di_f_file_copy_
#ifndef _di_f_file_create_
- f_status_t f_file_create(const f_string_static_t path, const mode_t mode, const bool exclusive) {
+ f_status_t f_file_create(const f_string_static_t path, const mode_t mode, const uint8_t exclusive) {
if (!path.used) return F_data_not;
#endif // _di_f_file_create_
#ifndef _di_f_file_create_at_
- f_status_t f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const bool exclusive) {
+ f_status_t f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const uint8_t exclusive) {
if (directory.id == -1) return F_file_descriptor_not;
if (!path.used) return F_data_not;
#endif // _di_f_file_descriptor_
#ifndef _di_f_file_exists_
- f_status_t f_file_exists(const f_string_static_t path, const bool dereference) {
+ f_status_t f_file_exists(const f_string_static_t path, const uint8_t dereference) {
if (!path.used) return F_data_not;
#endif // _di_f_file_flush_
#ifndef _di_f_file_group_read_
- f_status_t f_file_group_read(const f_string_static_t path, const bool dereference, f_gid_t * const group) {
+ f_status_t f_file_group_read(const f_string_static_t path, const uint8_t dereference, f_gid_t * const group) {
#ifndef _di_level_0_parameter_checking_
if (!group) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_group_read_
#ifndef _di_f_file_is_
- f_status_t f_file_is(const f_string_static_t path, const int type, const bool dereference) {
+ f_status_t f_file_is(const f_string_static_t path, const int type, const uint8_t dereference) {
if (!path.used) return F_data_not;
#endif // _di_f_file_link_hard_at_
#ifndef _di_f_file_link_read_
- f_status_t f_file_link_read(const f_string_static_t path, const bool dereference, f_string_dynamic_t * const target) {
+ f_status_t f_file_link_read(const f_string_static_t path, const uint8_t dereference, f_string_dynamic_t * const target) {
#ifndef _di_level_0_parameter_checking_
if (!target) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_manipulate_
#ifndef _di_f_file_mode_determine_
- f_status_t f_file_mode_determine(const mode_t mode_file, const f_file_mode_t mode_change, const uint8_t mode_replace, const bool directory_is, mode_t *mode) {
+ f_status_t f_file_mode_determine(const mode_t mode_file, const f_file_mode_t mode_change, const uint8_t mode_replace, const uint8_t directory_is, mode_t *mode) {
#ifndef _di_level_0_parameter_checking_
if (!mode) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (syntax == 1) {
uint8_t on = 0; // 1 = user, 2 = group, 4 = world/sticky, 7 = all.
uint8_t how = 0; // 1 = add, 2 = replace, 3 = subtract, 4 = add when no "on", 5 = replace when no "on", and 6 = subtract when no "on".
- bool incomplete = F_true;
+ uint8_t incomplete = F_true;
f_file_mode_t mode_mask = 0;
f_file_mode_t mode_umask = 0;
#endif // _di_f_file_mode_from_string_
#ifndef _di_f_file_mode_read_
- f_status_t f_file_mode_read(const f_string_static_t path, const bool dereference, mode_t * const mode) {
+ f_status_t f_file_mode_read(const f_string_static_t path, const uint8_t dereference, mode_t * const mode) {
#ifndef _di_level_0_parameter_checking_
if (!mode) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_open_at_
#ifndef _di_f_file_owner_read_
- f_status_t f_file_owner_read(const f_string_static_t path, const bool dereference, f_uid_t * const owner) {
+ f_status_t f_file_owner_read(const f_string_static_t path, const uint8_t dereference, f_uid_t * const owner) {
#ifndef _di_level_0_parameter_checking_
if (!owner) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_rename_at_
#ifndef _di_f_file_role_change_
- f_status_t f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference) {
+ f_status_t f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference) {
if ((uid == -1 && gid == -1) || !path.used) return F_data_not;
#endif // _di_f_file_select_signal_
#ifndef _di_f_file_size_
- f_status_t f_file_size(const f_string_static_t path, const bool dereference, off_t * const size) {
+ f_status_t f_file_size(const f_string_static_t path, const uint8_t dereference, off_t * const size) {
#ifndef _di_level_0_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_size_
#ifndef _di_f_file_size_at_
- f_status_t f_file_size_at(const f_file_t directory, const f_string_static_t path, const bool dereference, off_t * const size) {
+ f_status_t f_file_size_at(const f_file_t directory, const f_string_static_t path, const uint8_t dereference, off_t * const size) {
#ifndef _di_level_0_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_size_by_id_
#ifndef _di_f_file_stat_
- f_status_t f_file_stat(const f_string_static_t path, const bool dereference, struct stat * const stat_file) {
+ f_status_t f_file_stat(const f_string_static_t path, const uint8_t dereference, struct stat * const stat_file) {
#ifndef _di_level_0_parameter_checking_
if (!stat_file) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_file_stat_by_id_
#ifndef _di_f_file_touch_
- f_status_t f_file_touch(const f_string_static_t path, const mode_t mode, const bool dereference) {
+ f_status_t f_file_touch(const f_string_static_t path, const mode_t mode, const uint8_t dereference) {
if (!path.used) return F_data_not;
#endif // _di_f_file_touch_at_
#ifndef _di_f_file_type_
- f_status_t f_file_type(const f_string_static_t path, const bool dereference, int * const type) {
+ f_status_t f_file_type(const f_string_static_t path, const uint8_t dereference, int * const type) {
#ifndef _di_level_0_parameter_checking_
if (!type) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* @see open()
*/
#ifndef _di_f_file_create_
- extern f_status_t f_file_create(const f_string_static_t path, const mode_t mode, const bool exclusive);
+ extern f_status_t f_file_create(const f_string_static_t path, const mode_t mode, const uint8_t exclusive);
#endif // _di_f_file_create_
/**
* @see openat()
*/
#ifndef _di_f_file_create_at_
- extern f_status_t f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const bool exclusive);
+ extern f_status_t f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const uint8_t exclusive);
#endif // _di_f_file_create_at_
/**
* @see stat()
*/
#ifndef _di_f_file_exists_
- extern f_status_t f_file_exists(const f_string_static_t path, const bool dereference);
+ extern f_status_t f_file_exists(const f_string_static_t path, const uint8_t dereference);
#endif // _di_f_file_exists_
/**
* @see stat()
*/
#ifndef _di_f_file_group_read_
- extern f_status_t f_file_group_read(const f_string_static_t path, const bool dereference, f_uid_t * const group);
+ extern f_status_t f_file_group_read(const f_string_static_t path, const uint8_t dereference, f_uid_t * const group);
#endif // _di_f_file_group_read_
/**
* @see stat()
*/
#ifndef _di_f_file_is_
- extern f_status_t f_file_is(const f_string_static_t path, const int type, const bool dereference);
+ extern f_status_t f_file_is(const f_string_static_t path, const int type, const uint8_t dereference);
#endif // _di_f_file_is_
/**
* @see f_string_dynamic_terminate_after()
*/
#ifndef _di_f_file_link_read_
- extern f_status_t f_file_link_read(const f_string_static_t path, const bool dereference, f_string_dynamic_t * const target);
+ extern f_status_t f_file_link_read(const f_string_static_t path, const uint8_t dereference, f_string_dynamic_t * const target);
#endif // _di_f_file_link_read_
/**
* @see f_file_mode_from_string()
*/
#ifndef _di_f_file_mode_determine_
- extern f_status_t f_file_mode_determine(const mode_t mode_file, const f_file_mode_t mode_change, const uint8_t mode_replace, const bool directory_is, mode_t * const mode);
+ extern f_status_t f_file_mode_determine(const mode_t mode_file, const f_file_mode_t mode_change, const uint8_t mode_replace, const uint8_t directory_is, mode_t * const mode);
#endif // _di_f_file_mode_determine_
/**
* @see stat()
*/
#ifndef _di_f_file_mode_read_
- extern f_status_t f_file_mode_read(const f_string_static_t path, const bool dereference, mode_t * const mode);
+ extern f_status_t f_file_mode_read(const f_string_static_t path, const uint8_t dereference, mode_t * const mode);
#endif // _di_f_file_mode_read_
/**
* @see stat()
*/
#ifndef _di_f_file_owner_read_
- extern f_status_t f_file_owner_read(const f_string_static_t path, const bool dereference, f_uid_t * const owner);
+ extern f_status_t f_file_owner_read(const f_string_static_t path, const uint8_t dereference, f_uid_t * const owner);
#endif // _di_f_file_owner_read_
/**
* @see lchown()
*/
#ifndef _di_f_file_role_change_
- extern f_status_t f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference);
+ extern f_status_t f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference);
#endif // _di_f_file_role_change_
/**
* @see f_file_stat()
*/
#ifndef _di_f_file_size_
- extern f_status_t f_file_size(const f_string_static_t path, const bool dereference, off_t * const size);
+ extern f_status_t f_file_size(const f_string_static_t path, const uint8_t dereference, off_t * const size);
#endif // _di_f_file_size_
/**
* @see f_file_stat_at()
*/
#ifndef _di_f_file_size_at_
- extern f_status_t f_file_size_at(const f_file_t directory, const f_string_static_t path, const bool dereference, off_t * const size);
+ extern f_status_t f_file_size_at(const f_file_t directory, const f_string_static_t path, const uint8_t dereference, off_t * const size);
#endif // _di_f_file_size_at_
/**
* @see stat()
*/
#ifndef _di_f_file_stat_
- extern f_status_t f_file_stat(const f_string_static_t path, const bool dereference, struct stat * const stat_file);
+ extern f_status_t f_file_stat(const f_string_static_t path, const uint8_t dereference, struct stat * const stat_file);
#endif // _di_f_file_stat_
/**
* @see utimensat()
*/
#ifndef _di_f_file_touch_
- extern f_status_t f_file_touch(const f_string_static_t path, const mode_t mode, const bool dereference);
+ extern f_status_t f_file_touch(const f_string_static_t path, const mode_t mode, const uint8_t dereference);
#endif // _di_f_file_touch_
/**
* @see stat()
*/
#ifndef _di_f_file_type_
- extern f_status_t f_file_type(const f_string_static_t path, const bool dereference, int * const type);
+ extern f_status_t f_file_type(const f_string_static_t path, const uint8_t dereference, int * const type);
#endif // _di_f_file_type_
/**
#endif // !defined(_di_f_file_copy_) || !defined(_di_f_file_clone_)
#if !defined(_di_f_file_create_) || !defined(_di_f_file_copy_)
- f_status_t private_f_file_create(const f_string_static_t path, const mode_t mode, const bool exclusive) {
+ f_status_t private_f_file_create(const f_string_static_t path, const mode_t mode, const uint8_t exclusive) {
f_file_t file = f_file_t_initialize;
#endif // !defined(_di_f_file_create_) || !defined(_di_f_file_copy_)
#if !defined(_di_f_file_create_at_)
- f_status_t private_f_file_create_at(const f_file_t file, const f_string_static_t path, const mode_t mode, const bool exclusive) {
+ f_status_t private_f_file_create_at(const f_file_t file, const f_string_static_t path, const mode_t mode, const uint8_t exclusive) {
f_file_t file_internal = f_file_t_initialize;
#endif // !defined(_di_f_file_create_at_) || !defined(_di_f_file_open_at_)
#if !defined(_di_f_file_role_change_) || !defined(_di_f_file_copy_)
- f_status_t private_f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference) {
+ f_status_t private_f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference) {
int result = 0;
#endif // !defined(_di_f_file_role_change_at_)
#if !defined(_di_f_file_clone_) || !defined(_di_f_file_copy_) || !defined(_di_f_file_exists_) || !defined(_di_f_file_group_read_) || !defined(_di_f_file_is_) || !defined(_di_f_file_link_read_) || !defined(_di_f_file_mode_read_) || !defined(_di_f_file_owner_read_) || !defined(_di_f_file_size_) || !defined(_di_f_file_stat_) || !defined(_di_f_file_touch_) || !defined(_di_f_file_type_)
- f_status_t private_f_file_stat(const f_string_static_t path, const bool dereference, struct stat * const file_stat) {
+ f_status_t private_f_file_stat(const f_string_static_t path, const uint8_t dereference, struct stat * const file_stat) {
if ((dereference ? stat(path.string, file_stat) : lstat(path.string, file_stat)) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
* @see f_file_create()
*/
#if !defined(_di_f_file_create_) || !defined(_di_f_file_copy_)
- extern f_status_t private_f_file_create(const f_string_static_t path, const mode_t mode, const bool exclusive) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_file_create(const f_string_static_t path, const mode_t mode, const uint8_t exclusive) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_file_create_) || !defined(_di_f_file_copy_)
/**
* @see f_file_create_at()
*/
#if !defined(_di_f_file_create_at_)
- extern f_status_t private_f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const bool exclusive) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_file_create_at(const f_file_t directory, const f_string_static_t path, const mode_t mode, const uint8_t exclusive) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_file_create_at_)
/**
* @see f_file_role_change()
*/
#if !defined(_di_f_file_role_change_) || !defined(_di_f_file_copy_)
- extern f_status_t private_f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_file_role_change(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_file_role_change_) || !defined(_di_f_file_copy_)
/**
* @see f_file_type()
*/
#if !defined(_di_f_file_clone_) || !defined(_di_f_file_copy_) || !defined(_di_f_file_exists_) || !defined(_di_f_file_group_read_) || !defined(_di_f_file_is_) || !defined(_di_f_file_link_read_) || !defined(_di_f_file_mode_read_) || !defined(_di_f_file_owner_read_) || !defined(_di_f_file_size_) || !defined(_di_f_file_stat_) || !defined(_di_f_file_touch_) || !defined(_di_f_file_type_)
- extern f_status_t private_f_file_stat(const f_string_static_t file_name, const bool dereference, struct stat * const file_stat) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_file_stat(const f_string_static_t file_name, const uint8_t dereference, struct stat * const file_stat) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_file_clone_) || !defined(_di_f_file_copy_) || !defined(_di_f_file_exists_) || !defined(_di_f_file_group_read_) || !defined(_di_f_file_is_) || !defined(_di_f_file_link_read_) || !defined(_di_f_file_mode_read_) || !defined(_di_f_file_owner_read_) || !defined(_di_f_file_size_) || !defined(_di_f_file_stat_) || !defined(_di_f_file_touch_) || !defined(_di_f_file_type_)
/**
int __wrap_access(const char *pathname, int mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_chmod(const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_chown(const char *pathname, uid_t owner, gid_t group) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_close(int fd) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_faccessat(int dirfd, const char *pathname, int mode, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fchmod(const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fchmodat(int dirfd, const char *pathname, mode_t mode, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fchown(int fd, uid_t owner, gid_t group) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fclose(FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
FILE *__wrap_fopen(const char *pathname, const char *mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
FILE *__wrap_fdopen(int fd, const char *mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
FILE *__wrap_freopen(const char *pathname, const char *mode, FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fflush(FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fcntl(int fd, int cmd, ...) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fstat(int fd, struct stat *statbuf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fsync(int fd) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
size_t __wrap_fwrite_unlocked(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(size_t);
int __wrap_lchown(const char *pathname, uid_t owner, gid_t group) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_link(const char *oldpath, const char *newpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_linkat(const char *oldpath, const char *newpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
off_t __wrap_lseek(int fd, off_t offset, int whence) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_lstat(const char *pathname, struct stat *statbuf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mkdir(const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mkdirat(int dirfd, const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mkfifo(const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mkfifoat(int dirfd, const char *pathname, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mknod(const char *pathname, mode_t mode, dev_t dev) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_mknodat(int dirfd, const char *pathname, mode_t mode, dev_t dev) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_open(const char *pathname, int flags, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_openat(int dirfd, const char *pathname, int flags, mode_t mode) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_read(int fd, void *buf, size_t count) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_readlink(const char *pathname, char *buf, size_t bufsiz) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_rename(const char *oldpath, const char *newpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_renameat2(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_stat(const char *pathname, struct stat *statbuf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_symlink(const char *target, const char *linkpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_symlinkat(const char *target, int newdirfd, const char *linkpath) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_unlink(const char *pathname) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_unlinkat(int dirfd, const char *pathname, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_write(int fd, const void *buf, size_t count) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
int __wrap_prlimit(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
struct hostent *__wrap_gethostbyaddr(const void *addr, socklen_t len, int type) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
h_errno = mock_type(int);
struct hostent *__wrap_gethostbyname(const char *name) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
h_errno = mock_type(int);
const char *__wrap_inet_ntop(int af, const void *src, char *dst, socklen_t size) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_inet_pton(int af, const char *src, void *dst) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
#endif // _di_f_path_change_at_
#ifndef _di_f_path_current_
- f_status_t f_path_current(const bool real, f_string_dynamic_t * const path) {
+ f_status_t f_path_current(const uint8_t real, f_string_dynamic_t * const path) {
#ifndef _di_level_0_parameter_checking_
if (!path) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* @see getcwd()
*/
#ifndef _di_f_path_current_
- extern f_status_t f_path_current(const bool real, f_string_dynamic_t * const path);
+ extern f_status_t f_path_current(const uint8_t real, f_string_dynamic_t * const path);
#endif // _di_f_path_current_
/**
int __wrap_chdir(const char *path) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fchdir(int fd) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char *__wrap_getcwd(char *buf, size_t size) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char *__wrap_realpath(const char *path, char *resolved_path) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_fstat(int fd, struct stat *statbuf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
size_t __wrap_fwrite_unlocked(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(size_t);
ssize_t __wrap_write(int fd, const void *buf, size_t count) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(ssize_t);
return __real_getrandom(buf, buflen, flags);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getpriority(int which, id_t who) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_nice(int inc) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_setaffinity(pid_t pid, size_t cpusetsize, const cpu_set_t *mask) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_setattr(pid_t pid, f_schedule_attribute_t *attr, unsigned int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_getattr(pid_t pid, f_schedule_attribute_t *attr, unsigned int size, unsigned int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_get_priority_max(int policy) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_get_priority_min(int policy) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_getparam(pid_t pid, struct sched_param *param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_getscheduler(pid_t pid) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_rr_get_interval(pid_t pid, struct timespec *tp) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_setparam(pid_t pid, const struct sched_param *param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_setscheduler(pid_t pid, int policy, const struct sched_param *param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_setpriority(int which, id_t who, int prio) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sched_yield() {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_close(int fd) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_kill(pid_t pid, int sig) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_read(int fd, void *buf, size_t count) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigaddset(sigset_t *set, int signum) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigdelset(sigset_t *set, int signum) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigemptyset(sigset_t *set) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigfillset(sigset_t *set) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigismember(const sigset_t *set, int signum) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_signalfd(int fd, const sigset_t *mask, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigprocmask(int how, const sigset_t *set, sigset_t *oldset) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigqueue(pid_t pid, int sig, const union sigval value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigsuspend(const sigset_t *mask) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sigwaitinfo(const sigset_t *set, siginfo_t *info) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
int __wrap_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_close(int fd) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_gethostname(char *name, size_t len) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_listen(int sockfd, int backlog) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_recv(int sockfd, void *buf, size_t len, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_recvmsg(int sockfd, struct msghdr *msg, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_send(int sockfd, const void *buf, size_t len, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_sendmsg(int sockfd, const struct msghdr *msg, int flags) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
ssize_t __wrap_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_shutdown(int sockfd, int how) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_socket(int domain, int type, int protocol) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_socketpair(int domain, int type, int protocol, int sv[2]) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
#endif
#ifndef _di_f_thread_semaphore_create_
- f_status_t f_thread_semaphore_create(const bool shared, const unsigned int value, f_thread_semaphore_t * const semaphore) {
+ f_status_t f_thread_semaphore_create(const uint8_t shared, const unsigned int value, f_thread_semaphore_t * const semaphore) {
#ifndef _di_level_0_parameter_checking_
if (!semaphore) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* @see sem_init()
*/
#ifndef _di_f_thread_semaphore_create_
- extern f_status_t f_thread_semaphore_create(const bool shared, const unsigned int value, f_thread_semaphore_t * const semaphore);
+ extern f_status_t f_thread_semaphore_create(const uint8_t shared, const unsigned int value, f_thread_semaphore_t * const semaphore);
#endif // _di_f_thread_semaphore_create_
/**
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
int __wrap_pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_destroy(pthread_attr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getaffinity_np(const pthread_attr_t *attr, size_t cpusetsize, cpu_set_t *cpuset) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getguardsize(const pthread_attr_t * restrict attr, size_t * restrict guardsize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getinheritsched(const pthread_attr_t * restrict attr, int * restrict inheritsched) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getschedparam(const pthread_attr_t * restrict attr, struct sched_param * restrict param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getschedpolicy(const pthread_attr_t * restrict attr, int * restrict policy) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_init(pthread_attr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setaffinity_np(pthread_t id, size_t cpusetsize, const cpu_set_t *cpuset) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setschedparam(pthread_attr_t * restrict attr, const struct sched_param * restrict param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setscope(pthread_attr_t *attr, int contentionscope) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrier_destroy(pthread_barrier_t *barrier) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned count) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrier_wait(pthread_barrier_t *barrier) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrierattr_destroy(pthread_barrierattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrierattr_init(pthread_barrierattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr, int *pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_cancel(pthread_t pthread) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_cond_broadcast(pthread_cond_t *__cond) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
}
int __wrap_pthread_cond_destroy(pthread_cond_t *__mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
}
int __wrap_pthread_cond_init(pthread_cond_t *__cond, const pthread_condattr_t *__attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_cond_signal(pthread_cond_t *__cond) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_cond_timedwait(pthread_cond_t *__cond, pthread_mutex_t *__mutex, const struct timespec *__abstime) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_cond_wait(pthread_cond_t *__cond, pthread_mutex_t *__mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_destroy(pthread_condattr_t *__attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_getclock(const pthread_condattr_t * restrict attr, clockid_t * restrict clock_id) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_init(pthread_condattr_t *__attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clock_id) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_create(pthread_t *pthread, const pthread_attr_t *attr, void *(*routine)(void *), void *arg) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_detach(pthread_t pthread) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_getattr_default_np(pthread_attr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_getcpuclockid(pthread_t thread, clockid_t *clock_id) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_getname_np(pthread_t thread, char name[], size_t size) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_getschedparam(pthread_t pthread, int *policy, struct sched_param *param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_join(pthread_t pthread, void **value_ptr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_key_create(pthread_key_t *key, void (*destructor)(void *)) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_kill(pthread_t thread, int sig) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_consistent(pthread_mutex_t *mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_getprioceiling(const pthread_mutex_t * restrict mutex, int *prioceiling) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_lock(pthread_mutex_t *mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int prioceiling, int *old_ceiling) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_trylock(pthread_mutex_t *mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutex_unlock(pthread_mutex_t *mutex) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_init(pthread_mutexattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict attr, int *restrict robust) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_destroy(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *abstime) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *abstime) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_unlock(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlockattr_init(pthread_rwlockattr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr, int *pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setattr_default_np(const pthread_attr_t *attr) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setcancelstate(int state, int *oldstate) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setcanceltype(int type, int *oldtype) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setconcurrency(int new_level) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setname_np(pthread_t thread, const char *name) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setschedparam(pthread_t pthread, int policy, const struct sched_param *param) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setschedprio(pthread_t thread, int prio) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_setspecific(pthread_key_t key, const void *value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_sigqueue(pthread_t thread, int sig, const union sigval value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_spin_destroy(pthread_spinlock_t *spinlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_spin_init(pthread_spinlock_t *spinlock, int pshared) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_spin_lock(pthread_spinlock_t *spinlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_spin_trylock(pthread_spinlock_t *spinlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_spin_unlock(pthread_spinlock_t *spinlock) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_timedjoin_np(pthread_t thread, void **retval) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_pthread_tryjoin_np(pthread_t thread, void **retval, const struct timespec *abstime) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
return mock_type(int);
int __wrap_sem_close(sem_t *sem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_destroy(sem_t *sem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_getvalue(sem_t * restrict sem, int * restrict sval) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_init(sem_t *sem, int pshared, unsigned int value) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
sem_t *__wrap_sem_open(const char *name, int oflag, ...) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_post(sem_t *sem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_timedwait(sem_t * restrict sem, const struct timespec * restrict abs_timeout) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_trywait(sem_t *sem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_unlink(const char *name) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_sem_wait(sem_t *sem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
void test__f_thread_semaphore_create__fails(void **state) {
f_thread_semaphore_t semaphore = f_thread_semaphore_t_initialize;
- bool shared = F_false;
+ uint8_t shared = F_false;
unsigned int value = 0;
int errnos[] = {
void test__f_thread_semaphore_create__parameter_checking(void **state) {
- bool shared = F_false;
+ uint8_t shared = F_false;
unsigned int value = 0;
{
void test__f_thread_semaphore_create__works(void **state) {
f_thread_semaphore_t semaphore = f_thread_semaphore_t_initialize;
- bool shared = F_false;
+ uint8_t shared = F_false;
unsigned int value = 0;
{
if (!destination) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
char *__wrap_asctime_r(const struct tm *tm, char *buf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
char *__wrap_ctime_r(const time_t *timep, char *buf) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_gettimeofday(struct timeval *tv, struct timezone *tz) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
struct tm *__wrap_gmtime_r(const time_t *timep, struct tm *result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
struct tm *__wrap_localtime_r(const time_t *timep, struct tm *result) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_nanosleep(const struct timespec *req, struct timespec *rem) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_settimeofday(const struct timeval *tv, const struct timezone *tz) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
time_t __wrap_time(time_t *tloc) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_clock_getres(clockid_t clockid, struct timespec *tp) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_clock_gettime(clockid_t clockid, struct timespec *tp) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
int __wrap_clock_settime(clockid_t clockid, const struct timespec *tp) {
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size || !callback) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
return __real_poll(fds, nfds, timeout);
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
errno = mock_type(int);
#endif
#if !defined(_di_f_utf_character_is_whitespace_) || !defined(_di_f_utf_is_whitespace_)
- f_status_t private_f_utf_character_is_whitespace(const f_utf_char_t sequence, const bool strict) {
+ f_status_t private_f_utf_character_is_whitespace(const f_utf_char_t sequence, const uint8_t strict) {
if (macro_f_utf_char_t_width_is(sequence) == 2) {
* @see f_utf_is_whitespace()
*/
#if !defined(_di_f_utf_character_is_whitespace_) || !defined(_di_f_utf_is_whitespace_)
- extern f_status_t private_f_utf_character_is_whitespace(const f_utf_char_t sequence, const bool strict) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_utf_character_is_whitespace(const f_utf_char_t sequence, const uint8_t strict) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_utf_character_is_whitespace_) || !defined(_di_f_utf_is_whitespace_)
/**
#endif
#if !defined(_di_f_utf_character_is_word_) || !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
- f_status_t private_f_utf_character_is_word(const f_utf_char_t sequence, const bool strict) {
+ f_status_t private_f_utf_character_is_word(const f_utf_char_t sequence, const uint8_t strict) {
if (private_f_utf_character_is_alphabetic_digit(sequence, 0)) {
return F_true;
#endif // !defined(_di_f_utf_character_is_word_) || !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
#if !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
- f_status_t private_f_utf_character_is_word_dash(const f_utf_char_t sequence, const bool strict) {
+ f_status_t private_f_utf_character_is_word_dash(const f_utf_char_t sequence, const uint8_t strict) {
if (private_f_utf_character_is_word(sequence, strict)) {
return F_true;
#endif // !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
#if !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_plus_)
- f_status_t private_f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const bool strict) {
+ f_status_t private_f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const uint8_t strict) {
if (private_f_utf_character_is_word_dash(sequence, strict)) {
return F_true;
* @see f_utf_is_word_dash_plus()
*/
#if !defined(_di_f_utf_character_is_word_) || !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
- extern f_status_t private_f_utf_character_is_word(const f_utf_char_t sequence, const bool strict) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_utf_character_is_word(const f_utf_char_t sequence, const uint8_t strict) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_utf_character_is_word_) || !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
/**
* @see f_utf_is_word_dash_plus()
*/
#if !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
- extern f_status_t private_f_utf_character_is_word_dash(const f_utf_char_t sequence, const bool strict) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_utf_character_is_word_dash(const f_utf_char_t sequence, const uint8_t strict) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_utf_character_is_word_dash_) || !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_) || !defined(_di_f_utf_is_word_dash_plus_)
/**
* @see f_utf_is_word_dash_plus()
*/
#if !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_plus_)
- extern f_status_t private_f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const bool strict) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const uint8_t strict) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_utf_character_is_word_dash_plus_) || !defined(_di_f_utf_is_word_dash_plus_)
#ifdef __cplusplus
#endif // _di_f_utf_is_valid_
#ifndef _di_f_utf_is_whitespace_
- f_status_t f_utf_is_whitespace(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict) {
+ f_status_t f_utf_is_whitespace(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict) {
if (width_max < 1) return F_data_not;
#endif // _di_f_utf_is_wide_
#ifndef _di_f_utf_is_word_
- f_status_t f_utf_is_word(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict) {
+ f_status_t f_utf_is_word(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict) {
if (width_max < 1) return F_data_not;
#endif // _di_f_utf_is_word_
#ifndef _di_f_utf_is_word_dash_
- f_status_t f_utf_is_word_dash(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict) {
+ f_status_t f_utf_is_word_dash(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict) {
if (width_max < 1) return F_data_not;
#endif // _di_f_utf_is_word_dash_
#ifndef _di_f_utf_is_word_dash_plus_
- f_status_t f_utf_is_word_dash_plus(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict) {
+ f_status_t f_utf_is_word_dash_plus(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict) {
if (width_max < 1) return F_data_not;
* @see isspace()
*/
#ifndef _di_f_utf_is_whitespace_
- extern f_status_t f_utf_is_whitespace(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict);
+ extern f_status_t f_utf_is_whitespace(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict);
#endif // _di_f_utf_is_whitespace_
/**
* F_utf_not (with error bit) if Unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_is_word_
- extern f_status_t f_utf_is_word(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict);
+ extern f_status_t f_utf_is_word(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict);
#endif // _di_f_utf_is_word_
/**
* F_utf_not (with error bit) if Unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_is_word_dash_
- extern f_status_t f_utf_is_word_dash(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict);
+ extern f_status_t f_utf_is_word_dash(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict);
#endif // _di_f_utf_is_word_dash_
/**
* F_utf_not (with error bit) if Unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_is_word_dash_plus_
- extern f_status_t f_utf_is_word_dash_plus(const f_string_t sequence, const f_number_unsigned_t width_max, const bool strict);
+ extern f_status_t f_utf_is_word_dash_plus(const f_string_t sequence, const f_number_unsigned_t width_max, const uint8_t strict);
#endif // _di_f_utf_is_word_dash_plus_
/**
#endif // _di_f_utf_character_is_valid_
#ifndef _di_f_utf_character_is_whitespace_
- f_status_t f_utf_character_is_whitespace(const f_utf_char_t sequence, const bool strict) {
+ f_status_t f_utf_character_is_whitespace(const f_utf_char_t sequence, const uint8_t strict) {
if (macro_f_utf_char_t_width_is(sequence)) {
if (macro_f_utf_char_t_width_is(sequence) == 1) return F_status_set_error(F_utf_fragment);
#endif // _di_f_utf_character_is_wide_
#ifndef _di_f_utf_character_is_word_
- f_status_t f_utf_character_is_word(const f_utf_char_t sequence, const bool strict) {
+ f_status_t f_utf_character_is_word(const f_utf_char_t sequence, const uint8_t strict) {
if (macro_f_utf_char_t_width_is(sequence)) {
if (macro_f_utf_char_t_width_is(sequence) == 1) return F_status_set_error(F_utf_fragment);
#endif // _di_f_utf_character_is_word_
#ifndef _di_f_utf_character_is_word_dash_
- f_status_t f_utf_character_is_word_dash(const f_utf_char_t sequence, const bool strict) {
+ f_status_t f_utf_character_is_word_dash(const f_utf_char_t sequence, const uint8_t strict) {
if (macro_f_utf_char_t_width_is(sequence)) {
if (macro_f_utf_char_t_width_is(sequence) == 1) return F_status_set_error(F_utf_fragment);
#endif // _di_f_utf_character_is_word_dash_
#ifndef _di_f_utf_character_is_word_dash_plus_
- f_status_t f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const bool strict) {
+ f_status_t f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const uint8_t strict) {
if (macro_f_utf_char_t_width_is(sequence)) {
if (macro_f_utf_char_t_width_is(sequence) == 1) return F_status_set_error(F_utf_fragment);
* @see isspace()
*/
#ifndef _di_f_utf_character_is_whitespace_
- extern f_status_t f_utf_character_is_whitespace(const f_utf_char_t sequence, const bool strict);
+ extern f_status_t f_utf_character_is_whitespace(const f_utf_char_t sequence, const uint8_t strict);
#endif // _di_f_utf_character_is_whitespace_
/**
* F_utf_not (with error bit) if unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_character_is_word_
- extern f_status_t f_utf_character_is_word(const f_utf_char_t sequence, const bool strict);
+ extern f_status_t f_utf_character_is_word(const f_utf_char_t sequence, const uint8_t strict);
#endif // _di_f_utf_character_is_word_
/**
* F_utf_not (with error bit) if unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_character_is_word_dash_
- extern f_status_t f_utf_character_is_word_dash(const f_utf_char_t sequence, const bool strict);
+ extern f_status_t f_utf_character_is_word_dash(const f_utf_char_t sequence, const uint8_t strict);
#endif // _di_f_utf_character_is_word_dash_
/**
* F_utf_not (with error bit) if unicode is an invalid Unicode character.
*/
#ifndef _di_f_utf_character_is_word_dash_plus_
- extern f_status_t f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const bool strict);
+ extern f_status_t f_utf_character_is_word_dash_plus(const f_utf_char_t sequence, const uint8_t strict);
#endif // _di_f_utf_character_is_word_dash_plus_
/**
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
if (!array || !used || !size) return F_status_set_error(F_parameter_not);
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) return mock_type(f_status_t);
#endif // _di_fl_directory_do_
#ifndef _di_fl_directory_list_
- f_status_t fl_directory_list(const f_string_static_t path, const f_directory_filter_call_t filter, const f_directory_compare_call_t sort, const bool dereference, f_directory_listing_t * const listing) {
+ f_status_t fl_directory_list(const f_string_static_t path, const f_directory_filter_call_t filter, const f_directory_compare_call_t sort, const uint8_t dereference, f_directory_listing_t * const listing) {
#ifndef _di_level_1_parameter_checking_
if (!listing) return F_status_set_error(F_parameter);
#endif // _di_level_1_parameter_checking_
* @see f_memory_array_increase_by()
*/
#ifndef _di_fl_directory_list_
- extern f_status_t fl_directory_list(const f_string_static_t path, const f_directory_filter_call_t filter, const f_directory_compare_call_t sort, const bool dereference, f_directory_listing_t * const listing);
+ extern f_status_t fl_directory_list(const f_string_static_t path, const f_directory_filter_call_t filter, const f_directory_compare_call_t sort, const uint8_t dereference, f_directory_listing_t * const listing);
#endif // _di_fl_directory_list_
/**
#endif // !defined(_di_fl_directory_do_)
#if !defined(_di_fl_directory_do_) || !defined(_di_fl_directory_list_)
- f_status_t private_fl_directory_list(const f_string_static_t path, f_directory_filter_call_t filter, f_directory_compare_call_t sort, const bool dereference, f_directory_listing_t * const listing) {
+ f_status_t private_fl_directory_list(const f_string_static_t path, f_directory_filter_call_t filter, f_directory_compare_call_t sort, const uint8_t dereference, f_directory_listing_t * const listing) {
f_directory_entity_t **entity = 0;
#if !defined(_di_fl_directory_path_push_) || !defined(_di_fl_directory_path_push_dynamic_)
f_status_t private_fl_directory_path_push(const f_string_static_t source, f_string_dynamic_t * const destination) {
- bool terminated_null = F_false;
- bool separator_prepend = F_false;
- bool separator_append = F_false;
+ uint8_t terminated_null = F_false;
+ uint8_t separator_prepend = F_false;
+ uint8_t separator_append = F_false;
f_number_unsigned_t total = 0;
f_number_unsigned_t start = 0;
* @see fl_directory_list()
*/
#if !defined(_di_fl_directory_do_) || !defined(_di_fl_directory_list_)
- extern f_status_t private_fl_directory_list(const f_string_static_t path, f_directory_filter_call_t filter, f_directory_compare_call_t sort, const bool dereference, f_directory_listing_t * const listing) F_attribute_visibility_internal_d;
+ extern f_status_t private_fl_directory_list(const f_string_static_t path, f_directory_filter_call_t filter, f_directory_compare_call_t sort, const uint8_t dereference, f_directory_listing_t * const listing) F_attribute_visibility_internal_d;
#endif // !defined(_di_fl_directory_do_) || !defined(_di_fl_directory_list_)
/**
const f_number_unsigned_t destination_used = destination->used;
f_number_unsigned_t slash_count = 0;
- bool ends_on_space = F_false;
+ uint8_t ends_on_space = F_false;
uint8_t width = 0;
const f_number_unsigned_t destination_used = destination->used;
- bool is_comment = F_false;
- bool ends_on_eol = F_false;
- bool has_graph = F_false;
- bool do_prepend = prepend ? F_true : F_false;
+ uint8_t is_comment = F_false;
+ uint8_t ends_on_eol = F_false;
+ uint8_t has_graph = F_false;
+ uint8_t do_prepend = prepend ? F_true : F_false;
f_number_unsigned_t r = 0;
f_number_unsigned_t slash_count = 0;
f_number_unsigned_t slash_count = 0;
- bool ends_on_space = F_false;
+ uint8_t ends_on_space = F_false;
uint8_t width = 0;
return;
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
state->status = mock_type(f_status_t);
return;
}
- const bool failure = mock_type(bool);
+ const uint8_t failure = mock_type(uint8_t);
if (failure) {
state->status = mock_type(f_status_t);
#endif // !defined(_di_fll_execute_program_)
#if !defined(_di_fll_execute_into_) || !defined(_di_fll_execute_program_)
- void private_fll_execute_path_arguments_fixate(const f_string_static_t program_path, const f_string_statics_t arguments, const f_string_t last_slash, const bool fixated_is, f_string_static_t program_name, f_string_t fixed_arguments[]) {
+ void private_fll_execute_path_arguments_fixate(const f_string_static_t program_path, const f_string_statics_t arguments, const f_string_t last_slash, const uint8_t fixated_is, f_string_static_t program_name, f_string_t fixed_arguments[]) {
memset(program_name.string, 0, sizeof(f_char_t) * (program_name.used + 1));
memset(fixed_arguments, 0, sizeof(f_string_t) * (arguments.used + 2));
* @see fll_execute_program()
*/
#if !defined(_di_fll_execute_into_) || !defined(_di_fll_execute_program_)
- extern void private_fll_execute_path_arguments_fixate(const f_string_static_t program_path, const f_string_statics_t arguments, const f_string_t last_slash, const bool fixated_is, f_string_static_t program_name, f_string_t fixed_arguments[]) F_attribute_visibility_internal_d;
+ extern void private_fll_execute_path_arguments_fixate(const f_string_static_t program_path, const f_string_statics_t arguments, const f_string_t last_slash, const uint8_t fixated_is, f_string_static_t program_name, f_string_t fixed_arguments[]) F_attribute_visibility_internal_d;
#endif // !defined(_di_fll_execute_into_) || !defined(_di_fll_execute_program_)
#ifdef __cplusplus
#endif
#ifndef _di_fll_file_mode_set_all_
- f_status_t fll_file_mode_set_all(const f_string_static_t path, const bool dereference, const mode_t mode, const f_number_unsigned_t depth_max) {
+ f_status_t fll_file_mode_set_all(const f_string_static_t path, const uint8_t dereference, const mode_t mode, const f_number_unsigned_t depth_max) {
if (!path.used) return F_data_not;
#endif // _di_fll_file_mode_set_all_
#ifndef _di_fll_file_role_change_all_
- f_status_t fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference, const f_number_unsigned_t depth_max) {
+ f_status_t fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference, const f_number_unsigned_t depth_max) {
#ifndef _di_level_2_parameter_checking_
if (uid == -1 && gid == -1) return F_status_set_error(F_parameter);
#endif // _di_level_2_parameter_checking_
* Errors (with error bit) from: fl_directory_list().
*/
#ifndef _di_fll_file_mode_set_all_
- extern f_status_t fll_file_mode_set_all(const f_string_static_t path, const bool dereference, const mode_t mode, const f_number_unsigned_t depth_max);
+ extern f_status_t fll_file_mode_set_all(const f_string_static_t path, const uint8_t dereference, const mode_t mode, const f_number_unsigned_t depth_max);
#endif // _di_fll_file_mode_set_all_
/**
* Errors (with error bit) from: fl_directory_list().
*/
#ifndef _di_fll_file_role_change_all_
- extern f_status_t fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference, const f_number_unsigned_t depth_max);
+ extern f_status_t fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference, const f_number_unsigned_t depth_max);
#endif // _di_fll_file_role_change_all_
#ifdef __cplusplus
#endif
#if !defined(_di_fll_file_mode_set_all_)
- f_status_t private_fll_file_mode_set_all(const f_string_static_t path, const bool dereference, const mode_t mode, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) {
+ f_status_t private_fll_file_mode_set_all(const f_string_static_t path, const uint8_t dereference, const mode_t mode, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) {
f_status_t status = F_okay;
#endif // !defined(_di_fll_file_mode_set_all_)
#if !defined(_di_fll_file_role_change_all_)
- f_status_t private_fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) {
+ f_status_t private_fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) {
f_status_t status = F_okay;
* F_failure (with error bit) for any other error.
*/
#if !defined(_di_fll_file_mode_set_all_)
- extern f_status_t private_fll_file_mode_set_all(const f_string_static_t path, const bool dereference, const mode_t mode, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) F_attribute_visibility_internal_d;
+ extern f_status_t private_fll_file_mode_set_all(const f_string_static_t path, const uint8_t dereference, const mode_t mode, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) F_attribute_visibility_internal_d;
#endif // !defined(_di_fll_file_mode_set_all_)
/**
* F_failure (with error bit) for any other error.
*/
#if !defined(_di_fll_file_role_change_all_)
- extern f_status_t private_fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const bool dereference, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) F_attribute_visibility_internal_d;
+ extern f_status_t private_fll_file_role_change_all(const f_string_static_t path, const f_uid_t uid, const f_gid_t gid, const uint8_t dereference, const f_number_unsigned_t depth_max, const f_number_unsigned_t depth) F_attribute_visibility_internal_d;
#endif // !defined(_di_fll_file_role_change_all_)
#ifdef __cplusplus
// in order to determine if a valid FLL Identifier represents a valid FSS identifier, the data must be saved.
f_fll_id_t id = f_fll_id_t_initialize;
- bool found_fss = F_false;
+ uint8_t found_fss = F_false;
do {
if (ids && ids->used + 1 > ids->size) {
#endif // _di_fll_fss_identify_
#ifndef _di_fll_fss_snatch_
- f_status_t fll_fss_snatch(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]) {
+ f_status_t fll_fss_snatch(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
f_number_unsigned_t i = 0;
f_number_unsigned_t j = 0;
- bool matched[size];
+ uint8_t matched[size];
- memset(&matched, 0, sizeof(bool) * size);
+ memset(&matched, 0, sizeof(uint8_t) * size);
for (; i < objects.used; ++i) {
#endif // _di_fll_fss_snatch_
#ifndef _di_fll_fss_snatch_apart_
- f_status_t fll_fss_snatch_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamics_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamics_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
#endif // _di_fll_fss_snatch_apart_
#ifndef _di_fll_fss_snatch_map_
- f_status_t fll_fss_snatch_map(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_map(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
f_number_unsigned_t j = 0;
f_number_unsigned_t k = 0;
- bool matched = F_false;
+ uint8_t matched = F_false;
f_string_map_t *map = 0;
#endif // _di_fll_fss_snatch_map_
#ifndef _di_fll_fss_snatch_map_apart_
- f_status_t fll_fss_snatch_map_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_map_multis_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_map_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_map_multis_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
#endif // _di_fll_fss_snatch_map_apart_
#ifndef _di_fll_fss_snatch_map_mash_
- f_status_t fll_fss_snatch_map_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_map_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
#endif // _di_fll_fss_snatch_map_mash_
#ifndef _di_fll_fss_snatch_map_mash_apart_
- f_status_t fll_fss_snatch_map_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_map_multis_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_map_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_map_multis_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
f_number_unsigned_t j = 0;
f_number_unsigned_t k = 0;
- bool matched = F_false;
+ uint8_t matched = F_false;
f_string_map_multi_t *map_multi = 0;
#endif // _di_fll_fss_snatch_map_mash_apart_
#ifndef _di_fll_fss_snatch_map_together_
- f_status_t fll_fss_snatch_map_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_map_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
f_number_unsigned_t j = 0;
f_number_unsigned_t k = 0;
- bool matched = F_false;
+ uint8_t matched = F_false;
f_string_map_t *map = 0;
#endif // _di_fll_fss_snatch_map_together_
#ifndef _di_fll_fss_snatch_mash_
- f_status_t fll_fss_snatch_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]) {
+ f_status_t fll_fss_snatch_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
f_number_unsigned_t j = 0;
f_number_unsigned_t k = 0;
- bool matched[size];
+ uint8_t matched[size];
- memset(&matched, 0, sizeof(bool) * size);
+ memset(&matched, 0, sizeof(uint8_t) * size);
for (; i < objects.used; ++i) {
#endif // _di_fll_fss_snatch_mash_
#ifndef _di_fll_fss_snatch_mash_apart_
- f_status_t fll_fss_snatch_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamics_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]) {
+ f_status_t fll_fss_snatch_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamics_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
#endif // _di_fll_fss_snatch_mash_apart_
#ifndef _di_fll_fss_snatch_together_
- f_status_t fll_fss_snatch_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]) {
+ f_status_t fll_fss_snatch_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]) {
#ifndef _di_level_2_parameter_checking_
if (!size) return F_status_set_error(F_parameter);
if (objects.used != contents.used) return F_status_set_error(F_parameter);
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_
- extern f_status_t fll_fss_snatch(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]);
+ extern f_status_t fll_fss_snatch(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]);
#endif // _di_fll_fss_snatch_
/**
* @see f_string_dynamic_partial_append_nulless()
*/
#ifndef _di_fll_fss_snatch_apart_
- extern f_status_t fll_fss_snatch_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamics_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_dynamics_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_apart_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_map_
- extern f_status_t fll_fss_snatch_map(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_map(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_map_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_map_apart_
- extern f_status_t fll_fss_snatch_map_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_map_multis_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_map_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, f_string_map_multis_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_map_apart_
/**
* Errors (with error bit) from: f_compare_dynamic_partial_trim_string().
*/
#ifndef _di_fll_fss_snatch_map_mash_
- extern f_status_t fll_fss_snatch_map_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_map_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_map_mash_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_map_mash_apart_
- extern f_status_t fll_fss_snatch_map_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_map_multis_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_map_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_map_multis_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_map_mash_apart_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_map_together_
- extern f_status_t fll_fss_snatch_map_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_map_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_maps_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_map_together_
/**
* Errors (with error bit) from: f_compare_dynamic_partial_trim_string().
*/
#ifndef _di_fll_fss_snatch_mash_
- extern f_status_t fll_fss_snatch_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_mash(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]);
#endif // _di_fll_fss_snatch_mash_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_mash_apart_
- extern f_status_t fll_fss_snatch_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamics_t * const values[], bool matches[], f_number_unsigneds_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_mash_apart(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamics_t * const values[], uint8_t matches[], f_number_unsigneds_t * const indexs[]);
#endif // _di_fll_fss_snatch_mash_apart_
/**
* @see f_compare_trim()
*/
#ifndef _di_fll_fss_snatch_together_
- extern f_status_t fll_fss_snatch_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], bool matches[], f_number_unsigned_t * const indexs[]);
+ extern f_status_t fll_fss_snatch_together(const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, const f_string_static_t names[], const f_number_unsigned_t size, const f_string_static_t glue, f_string_dynamic_t * const values[], uint8_t matches[], f_number_unsigned_t * const indexs[]);
#endif // _di_fll_fss_snatch_together_
#ifdef __cplusplus
f_status_t status = F_okay;
f_number_unsigned_t initial_used = objects->used;
- bool found_data = F_false;
+ uint8_t found_data = F_false;
uint8_t *quoted_object = 0;
f_status_t status = F_okay;
f_number_unsigned_t initial_used = objects->used;
- bool found_data = F_false;
+ uint8_t found_data = F_false;
do {
state->status = f_memory_array_increase(state->step_small, sizeof(f_range_t), (void **) &objects->array, &objects->used, &objects->size);
f_status_t status = F_okay;
f_number_unsigned_t initial_used = objects->used;
- bool found_data = F_false;
+ uint8_t found_data = F_false;
uint8_t *quoted_object = 0;
f_uint8s_t *quoted_content = 0;
#endif // _di_fll_fss_payload_read_
#ifndef _di_fll_fss_payload_write_
- void fll_fss_payload_write(const f_string_static_t object, const f_string_static_t content, const bool trim, const f_string_static_t * const content_prepend, f_string_dynamic_t * const destination, f_state_t * const state) {
+ void fll_fss_payload_write(const f_string_static_t object, const f_string_static_t content, const uint8_t trim, const f_string_static_t * const content_prepend, f_string_dynamic_t * const destination, f_state_t * const state) {
#ifndef _di_level_2_parameter_checking_
if (!state) return;
* @see fl_fss_basic_list_object_write()
*/
#ifndef _di_fll_fss_payload_write_
- extern void fll_fss_payload_write(const f_string_static_t object, const f_string_static_t content, const bool trim, const f_string_static_t * const content_prepend, f_string_dynamic_t * const destination, f_state_t * const state);
+ extern void fll_fss_payload_write(const f_string_static_t object, const f_string_static_t content, const uint8_t trim, const f_string_static_t * const content_prepend, f_string_dynamic_t * const destination, f_state_t * const state);
#endif // _di_fll_fss_payload_write_
#ifdef __cplusplus
#endif
#if !defined(_di_fll_program_parameter_process_context_) || !defined(_di_fll_program_parameter_process_context_standard_)
- f_status_t private_fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const bool right, fll_program_data_t * const main) {
+ f_status_t private_fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const uint8_t right, fll_program_data_t * const main) {
{
if (choices.used) {
* @see f_color_load_context()
*/
#if !defined(_di_fll_program_parameter_process_context_) || !defined(_di_fll_program_parameter_process_context_standard_)
- extern f_status_t private_fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const bool right, fll_program_data_t * const main);
+ extern f_status_t private_fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const uint8_t right, fll_program_data_t * const main);
#endif // !defined(_di_fll_program_parameter_process_context_) || !defined(_di_fll_program_parameter_process_context_standard_)
/**
#endif
#ifndef _di_fll_program_parameter_process_context_
- f_status_t fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const bool right, fll_program_data_t * const main) {
+ f_status_t fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const uint8_t right, fll_program_data_t * const main) {
#ifndef _di_level_2_parameter_checking_
if (!main) return F_status_set_error(F_parameter);
#endif // _di_level_2_parameter_checking_
#endif // _di_fll_program_parameter_process_context_
#ifndef _di_fll_program_parameter_process_context_standard_
- f_status_t fll_program_parameter_process_context_standard(const bool right, fll_program_data_t * const main) {
+ f_status_t fll_program_parameter_process_context_standard(const uint8_t right, fll_program_data_t * const main) {
#ifndef _di_level_2_parameter_checking_
if (!main) return F_status_set_error(F_parameter);
#endif // _di_level_2_parameter_checking_
#endif // _di_fll_program_parameter_process_empty_
#ifndef _di_fll_program_parameter_process_verbosity_
- f_status_t fll_program_parameter_process_verbosity(const f_uint16s_t choices, const uint8_t verbosity[], const bool right, fll_program_data_t * const main) {
+ f_status_t fll_program_parameter_process_verbosity(const f_uint16s_t choices, const uint8_t verbosity[], const uint8_t right, fll_program_data_t * const main) {
#ifndef _di_level_2_parameter_checking_
if (!main) return F_status_set_error(F_parameter);
#endif // _di_level_2_parameter_checking_
#endif // _di_fll_program_parameter_process_verbosity_
#ifndef _di_fll_program_parameter_process_verbosity_standard_
- f_status_t fll_program_parameter_process_verbosity_standard(const bool right, fll_program_data_t * const main) {
+ f_status_t fll_program_parameter_process_verbosity_standard(const uint8_t right, fll_program_data_t * const main) {
#ifndef _di_level_2_parameter_checking_
if (!main) return F_status_set_error(F_parameter);
#endif // _di_level_2_parameter_checking_
* @see f_color_load_context()
*/
#ifndef _di_fll_program_parameter_process_context_
- extern f_status_t fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const bool right, fll_program_data_t * const main);
+ extern f_status_t fll_program_parameter_process_context(const f_uint16s_t choices, const uint8_t modes[], const uint8_t right, fll_program_data_t * const main);
#endif // _di_fll_program_parameter_process_context_
/**
* @see f_color_load_context()
*/
#ifndef _di_fll_program_parameter_process_context_standard_
- extern f_status_t fll_program_parameter_process_context_standard(const bool right, fll_program_data_t * const main);
+ extern f_status_t fll_program_parameter_process_context_standard(const uint8_t right, fll_program_data_t * const main);
#endif // _di_fll_program_parameter_process_context_standard_
/**
* @see f_console_parameter_prioritize_right()
*/
#ifndef _di_fll_program_parameter_process_verbosity_
- extern f_status_t fll_program_parameter_process_verbosity(const f_uint16s_t choices, const uint8_t verbosity[], const bool right, fll_program_data_t * const main);
+ extern f_status_t fll_program_parameter_process_verbosity(const f_uint16s_t choices, const uint8_t verbosity[], const uint8_t right, fll_program_data_t * const main);
#endif // _di_fll_program_parameter_process_verbosity_
/**
* @see f_console_parameter_prioritize_right()
*/
#ifndef _di_fll_program_parameter_process_verbosity_standard_
- extern f_status_t fll_program_parameter_process_verbosity_standard(const bool right, fll_program_data_t * const main);
+ extern f_status_t fll_program_parameter_process_verbosity_standard(const uint8_t right, fll_program_data_t * const main);
#endif // _di_fll_program_parameter_process_verbosity_standard_
/**
byte_dump_main_t * const main = (byte_dump_main_t *) print->custom;
f_char_t byte = 0;
- bool reset = F_false;
+ uint8_t reset = F_false;
f_number_unsigned_t current = sequence.used - 1;
if (byte_current == 1) {
f_char_t c = 0;
uint8_t at = 0;
uint8_t width_utf = 0;
- bool do_print = F_true;
+ uint8_t do_print = F_true;
f_char_t byte[5] = { 0, 0, 0, 0, 0 };
byte_dump_cell_t cell = byte_dump_cell_t_initialize;
byte_dump_previous_t previous = byte_dump_previous_t_initialize;
- bool character_reset = 0;
- bool found_invalid_utf = F_false;
+ uint8_t character_reset = 0;
+ uint8_t found_invalid_utf = F_false;
// Store the current character main until it can be printed.
f_utf_string_dynamic_t sequence = f_utf_string_dynamic_t_initialize;
#endif // _di_fake_build_load_environment_
#ifndef _di_fake_build_load_setting_
- void fake_build_load_setting(fake_data_t * const data, const f_string_statics_t * const build_arguments, const bool process_pipe, fake_build_setting_t * const setting) {
+ void fake_build_load_setting(fake_data_t * const data, const f_string_statics_t * const build_arguments, const uint8_t process_pipe, fake_build_setting_t * const setting) {
if (!data || !data->main || !setting) return;
if (F_status_is_error(data->main->setting.state.status)) return;
#endif // _di_fake_build_load_setting_
#ifndef _di_fake_build_load_setting_process_
- void fake_build_load_setting_process(fake_data_t * const data, const bool checks, const f_string_static_t path_file, const f_string_statics_t * const modes_custom, const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, fake_build_setting_t * const setting) {
+ void fake_build_load_setting_process(fake_data_t * const data, const uint8_t checks, const f_string_static_t path_file, const f_string_statics_t * const modes_custom, const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, fake_build_setting_t * const setting) {
if (!data || !data->main || !setting) return;
if (F_status_is_error(data->main->setting.state.status) && buffer.used) return;
&version_target,
};
- bool settings_matches[] = {
+ uint8_t settings_matches[] = {
F_false, // build_compiler
F_false, // setting->build_compiler_arguments
F_false, // setting->build_compiler_arguments_shared
0, // version_target
};
- const bool settings_single_matches[] = {
+ const uint8_t settings_single_matches[] = {
settings_matches[0], // build_compiler
settings_matches[13], // build_indexer
settings_matches[15], // build_language
* @see fake_pipe_buffer()
*/
#ifndef _di_fake_build_load_setting_
- extern void fake_build_load_setting(fake_data_t * const data, const f_string_statics_t * const build_arguments, const bool process_pipe, fake_build_setting_t * const setting);
+ extern void fake_build_load_setting(fake_data_t * const data, const f_string_statics_t * const build_arguments, const uint8_t process_pipe, fake_build_setting_t * const setting);
#endif // _di_fake_build_load_setting_
/**
* @see fll_fss_snatch_apart()
*/
#ifndef _di_fake_build_load_setting_process_
- extern void fake_build_load_setting_process(fake_data_t * const data, const bool checks, const f_string_static_t path_file, const f_string_statics_t * const modes_custom, const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, fake_build_setting_t * const setting);
+ extern void fake_build_load_setting_process(fake_data_t * const data, const uint8_t checks, const f_string_static_t path_file, const f_string_statics_t * const modes_custom, const f_string_static_t buffer, const f_ranges_t objects, const f_rangess_t contents, fake_build_setting_t * const setting);
#endif // _di_fake_build_load_setting_process_
/**
fake_build_print_message_skeleton_build_base(&main->program.message);
- bool created = F_false;
+ uint8_t created = F_false;
f_number_unsigned_t j = 0;
for (uint8_t i = 0; i < 19; ++i) {
*/
#ifndef _di_fake_make_setting_t_
typedef struct {
- bool load_build;
-
+ uint8_t load_build;
uint8_t fail;
f_string_dynamic_t stage;
}
{
- bool check_paths = F_true;
+ uint8_t check_paths = F_true;
for (i = 0; i < main->setting.operations.used; ++i) {
#endif // _di_fake_execute_
#ifndef _di_fake_file_buffer_
- void fake_file_buffer(fake_data_t * const data, const f_string_static_t path_file, const bool required, f_string_dynamic_t * const buffer) {
+ void fake_file_buffer(fake_data_t * const data, const f_string_static_t path_file, const uint8_t required, f_string_dynamic_t * const buffer) {
if (!data || !data->main || !buffer) return;
if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
* @see f_memory_array_increase_by()
*/
#ifndef _di_fake_file_buffer_
- extern void fake_file_buffer(fake_data_t * const data, const f_string_static_t path_file, const bool required, f_string_dynamic_t * const buffer);
+ extern void fake_file_buffer(fake_data_t * const data, const f_string_static_t path_file, const uint8_t required, f_string_dynamic_t * const buffer);
#endif // _di_fake_file_buffer_
/**
#endif // _di_fake_make_assure_inside_project_
#ifndef _di_fake_make_get_id_
- f_number_unsigned_t fake_make_get_id(fake_make_data_t * const data_make, const bool is_owner, const f_string_static_t buffer) {
+ f_number_unsigned_t fake_make_get_id(fake_make_data_t * const data_make, const uint8_t is_owner, const f_string_static_t buffer) {
if (!data_make || !data_make->main) return 0;
* @see fl_conversion_dynamic_to_unsigned_detect()
*/
#ifndef _di_fake_make_get_id_
- extern f_number_unsigned_t fake_make_get_id(fake_make_data_t * const data_make, const bool is_owner, const f_string_static_t buffer);
+ extern f_number_unsigned_t fake_make_get_id(fake_make_data_t * const data_make, const uint8_t is_owner, const f_string_static_t buffer);
#endif // _di_fake_make_get_id_
/**
}
{
- bool missing_main = F_true;
- bool missing_settings = F_true;
+ uint8_t missing_main = F_true;
+ uint8_t missing_settings = F_true;
f_fss_set_t settings = f_fss_set_t_initialize;
fake_main_t * const main = data_make->main;
- bool unmatched = F_true;
+ uint8_t unmatched = F_true;
uint8_t i = 0;
fake_string_dynamic_reset(&main->cache_1);
fake_build_setting_name_search_static_s,
};
- const bool bool_value[] = {
+ const uint8_t bool_value[] = {
data_make->setting_build.build_script,
data_make->setting_build.build_shared,
data_make->setting_build.build_static,
#endif // _di_fake_make_operate_block_prepare_
#ifndef _di_fake_make_operate_block_postprocess_
- void fake_make_operate_block_postprocess(fake_make_data_t * const data_make, const bool last, fake_state_process_t * const state_process) {
+ void fake_make_operate_block_postprocess(fake_make_data_t * const data_make, const uint8_t last, fake_state_process_t * const state_process) {
if (!data_make || !data_make->main || !state_process) return;
* The operation and if-condition states.
*/
#ifndef _di_fake_make_operate_block_postprocess_
- extern void fake_make_operate_block_postprocess(fake_make_data_t * const data_make, const bool last, fake_state_process_t * const state_process);
+ extern void fake_make_operate_block_postprocess(fake_make_data_t * const data_make, const uint8_t last, fake_state_process_t * const state_process);
#endif // _di_fake_make_operate_block_postprocess_
#ifdef __cplusplus
#endif // _di_fake_make_operate_process_buffer_escape_
#ifndef _di_fake_make_operate_process_execute_
- void fake_make_operate_process_execute(fake_make_data_t * const data_make, const f_string_static_t program, const f_string_statics_t arguments, const bool as_shell) {
+ void fake_make_operate_process_execute(fake_make_data_t * const data_make, const f_string_static_t program, const f_string_statics_t arguments, const uint8_t as_shell) {
if (!data_make || !data_make->main) return;
#endif // _di_fake_make_operate_process_return_
#ifndef _di_fake_make_operate_process_run_
- void fake_make_operate_process_run(fake_make_data_t * const data_make, const bool as_shell) {
+ void fake_make_operate_process_run(fake_make_data_t * const data_make, const uint8_t as_shell) {
if (!data_make || !data_make->main) return;
* @see fake_make_operate_process_return()
*/
#ifndef _di_fake_make_operate_process_execute_
- extern void fake_make_operate_process_execute(fake_make_data_t * const data_make, const f_string_static_t program, const f_string_statics_t arguments, const bool as_shell);
+ extern void fake_make_operate_process_execute(fake_make_data_t * const data_make, const f_string_static_t program, const f_string_statics_t arguments, const uint8_t as_shell);
#endif // _di_fake_make_operate_process_execute_
/**
* @see fake_make_operate_process_execute()
*/
#ifndef _di_fake_make_operate_process_run_
- extern void fake_make_operate_process_run(fake_make_data_t * const data_make, const bool as_shell);
+ extern void fake_make_operate_process_run(fake_make_data_t * const data_make, const uint8_t as_shell);
#endif // _di_fake_make_operate_process_run_
#ifdef __cplusplus
#endif // _di_fake_make_operate_process_type_condition_
#ifndef _di_fake_make_operate_process_type_copy_
- void fake_make_operate_process_type_copy(fake_make_data_t * const data_make, const bool clone) {
+ void fake_make_operate_process_type_copy(fake_make_data_t * const data_make, const uint8_t clone) {
if (!data_make || !data_make->main) return;
#endif // _di_fake_make_operate_process_type_define_
#ifndef _di_fake_make_operate_process_type_deletes_
- void fake_make_operate_process_type_deletes(fake_make_data_t * const data_make, const bool all) {
+ void fake_make_operate_process_type_deletes(fake_make_data_t * const data_make, const uint8_t all) {
if (!data_make || !data_make->main) return;
#endif // _di_fake_make_operate_process_type_fail_
#ifndef _di_fake_make_operate_process_type_groups_
- void fake_make_operate_process_type_groups(fake_make_data_t * const data_make, const bool all) {
+ void fake_make_operate_process_type_groups(fake_make_data_t * const data_make, const uint8_t all) {
if (!data_make || !data_make->main) return;
fake_main_t * const main = data_make->main;
f_gid_t id = f_gid_t_initialize;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
f_number_unsigned_t i = 0;
main->setting.state.status = F_okay;
#endif // _di_fake_make_operate_process_type_groups_
#ifndef _di_fake_make_operate_process_type_if_define_
- void fake_make_operate_process_type_if_define(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_define(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
#endif // _di_fake_make_operate_process_type_if_define_
#ifndef _di_fake_make_operate_process_type_if_exist_
- void fake_make_operate_process_type_if_exist(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_exist(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
fake_main_t * const main = data_make->main;
f_number_unsigned_t i = if_not ? 2 : 1;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
main->setting.state.status = F_okay;
#endif // _di_fake_make_operate_process_type_if_exist_
#ifndef _di_fake_make_operate_process_type_if_is_
- void fake_make_operate_process_type_if_is(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_is(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
uint8_t type = 0;
f_number_unsigned_t i = if_not ? 2 : 1;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
main->setting.state.status = F_okay;
f_number_unsigned_t number_left = 0;
f_number_unsigned_t number_right = 0;
- bool is_negative_left = F_false;
- bool is_negative_right = F_false;
+ uint8_t is_negative_left = F_false;
+ uint8_t is_negative_right = F_false;
f_number_unsigned_t i = 1;
#endif // _di_fake_make_operate_process_type_if_greater_if_lesser_
#ifndef _di_fake_make_operate_process_type_if_group_
- void fake_make_operate_process_type_if_group(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_group(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
f_uid_t id = f_uid_t_initialize;
f_number_unsigned_t i = if_not ? 2 : 1;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
main->setting.state.status = F_okay;
#endif // _di_fake_make_operate_process_type_if_group_
#ifndef _di_fake_make_operate_process_type_if_mode_
- void fake_make_operate_process_type_if_mode(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_mode(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
f_file_mode_t mode_rule = 0;
mode_t mode_match = 0;
- bool is = F_false;
+ uint8_t is = F_false;
if (f_compare_dynamic(fake_make_operation_argument_is_s, main->cache_arguments.array[if_not ? 2 : 1]) == F_equal_to) {
is = F_true;
#endif // _di_fake_make_operate_process_type_if_mode_
#ifndef _di_fake_make_operate_process_type_if_owner_
- void fake_make_operate_process_type_if_owner(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_owner(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
f_uid_t id = f_uid_t_initialize;
f_number_unsigned_t i = if_not ? 2 : 1;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
main->setting.state.status = F_okay;
#endif // _di_fake_make_operate_process_type_if_owner_
#ifndef _di_fake_make_operate_process_type_if_parameter_
- void fake_make_operate_process_type_if_parameter(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process) {
+ void fake_make_operate_process_type_if_parameter(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process) {
if (!data_make || !data_make->main || !state_process) return;
fake_make_parameter_variable_value_work_s,
};
- const bool reserved_parameter[] = {
+ const uint8_t reserved_parameter[] = {
main->setting.build.used,
F_true,
main->setting.data.used,
#endif // _di_fake_make_operate_process_type_link_
#ifndef _di_fake_make_operate_process_type_modes_
- void fake_make_operate_process_type_modes(fake_make_data_t * const data_make, const bool all) {
+ void fake_make_operate_process_type_modes(fake_make_data_t * const data_make, const uint8_t all) {
if (!data_make || !data_make->main) return;
const f_number_unsigned_t total = main->cache_arguments.used - 1;
- bool existing = F_true;
+ uint8_t existing = F_true;
// In this case, the destination could be a file, so confirm this.
if (main->cache_arguments.used == 2) {
#endif // _di_fake_make_operate_process_type_operate_
#ifndef _di_fake_make_operate_process_type_owners_
- void fake_make_operate_process_type_owners(fake_make_data_t * const data_make, const bool all) {
+ void fake_make_operate_process_type_owners(fake_make_data_t * const data_make, const uint8_t all) {
if (!data_make || !data_make->main) return;
fake_main_t * const main = data_make->main;
f_uid_t id = f_uid_t_initialize;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
f_number_unsigned_t i = 0;
if (f_compare_dynamic(fake_make_operation_argument_no_dereference_s, main->cache_arguments.array[i]) == F_equal_to) {
fake_main_t * const main = data_make->main;
- bool found = F_false;
+ uint8_t found = F_false;
f_number_unsigned_t i = 0;
for (; i < data_make->setting_make.parameter.used; ++i) {
* @see fake_do_copy_action()
*/
#ifndef _di_fake_make_operate_process_type_copy_
- extern void fake_make_operate_process_type_copy(fake_make_data_t * const data_make, const bool clone);
+ extern void fake_make_operate_process_type_copy(fake_make_data_t * const data_make, const uint8_t clone);
#endif // _di_fake_make_operate_process_type_copy_
/**
* @see f_directory_remove_custom()
*/
#ifndef _di_fake_make_operate_process_type_deletes_
- extern void fake_make_operate_process_type_deletes(fake_make_data_t * const data_make, const bool all);
+ extern void fake_make_operate_process_type_deletes(fake_make_data_t * const data_make, const uint8_t all);
#endif // _di_fake_make_operate_process_type_deletes_
/**
* @see fake_make_get_id()
*/
#ifndef _di_fake_make_operate_process_type_groups_
- extern void fake_make_operate_process_type_groups(fake_make_data_t * const data_make, const bool all);
+ extern void fake_make_operate_process_type_groups(fake_make_data_t * const data_make, const uint8_t all);
#endif // _di_fake_make_operate_process_type_groups_
/**
* The operation process state.
*/
#ifndef _di_fake_make_operate_process_type_if_define_
- extern void fake_make_operate_process_type_if_define(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_define(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_define_
/**
* @see f_file_exists()
*/
#ifndef _di_fake_make_operate_process_type_if_exist_
- extern void fake_make_operate_process_type_if_exist(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_exist(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_exist_
/**
* @see fake_make_get_id()
*/
#ifndef _di_fake_make_operate_process_type_if_group_
- extern void fake_make_operate_process_type_if_group(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_group(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_group_
/**
* @see f_file_mode_read()
*/
#ifndef _di_fake_make_operate_process_type_if_is_
- extern void fake_make_operate_process_type_if_is(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_is(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_is_
/**
* @see fake_make_get_id_mode()
*/
#ifndef _di_fake_make_operate_process_type_if_mode_
- extern void fake_make_operate_process_type_if_mode(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_mode(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_mode_
/**
* @see fake_make_get_id()
*/
#ifndef _di_fake_make_operate_process_type_if_owner_
- extern void fake_make_operate_process_type_if_owner(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_owner(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_owner_
/**
* The operation process state.
*/
#ifndef _di_fake_make_operate_process_type_if_parameter_
- extern void fake_make_operate_process_type_if_parameter(fake_make_data_t * const data_make, const bool if_not, fake_state_process_t *state_process);
+ extern void fake_make_operate_process_type_if_parameter(fake_make_data_t * const data_make, const uint8_t if_not, fake_state_process_t *state_process);
#endif // _di_fake_make_operate_process_type_if_parameter_
/**
* @see fake_make_get_id_mode()
*/
#ifndef _di_fake_make_operate_process_type_modes_
- extern void fake_make_operate_process_type_modes(fake_make_data_t * const data_make, const bool all);
+ extern void fake_make_operate_process_type_modes(fake_make_data_t * const data_make, const uint8_t all);
#endif // _di_fake_make_operate_process_type_modes_
/**
* @see fake_make_get_id()
*/
#ifndef _di_fake_make_operate_process_type_owners_
- extern void fake_make_operate_process_type_owners(fake_make_data_t * const data_make, const bool all);
+ extern void fake_make_operate_process_type_owners(fake_make_data_t * const data_make, const uint8_t all);
#endif // _di_fake_make_operate_process_type_owners_
/**
f_number_unsigned_t j = 0;
f_number_unsigned_t k = 0;
f_string_static_t if_and_or;
- bool dereference = F_true;
+ uint8_t dereference = F_true;
if (state_process->operation == fake_make_operation_type_and_e) {
if_and_or = fake_make_operation_and_s;
#endif // _di_fake_make_print_verbose_operate_break_
#ifndef _di_fake_make_print_verbose_operate_copy_
- f_status_t fake_make_print_verbose_operate_copy(fl_print_t * const print, const bool clone, const f_string_static_t source, const f_string_static_t destination) {
+ f_status_t fake_make_print_verbose_operate_copy(fl_print_t * const print, const uint8_t clone, const f_string_static_t source, const f_string_static_t destination) {
if (!print) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_verbose_e) return F_output_not;
#endif // _di_fake_make_print_verbose_operate_exiting_as_
#ifndef _di_fake_make_print_verbose_operate_file_not_found_
- f_status_t fake_make_print_verbose_operate_file_not_found(fl_print_t * const print, const bool is_directory, const f_string_static_t file) {
+ f_status_t fake_make_print_verbose_operate_file_not_found(fl_print_t * const print, const uint8_t is_directory, const f_string_static_t file) {
if (!print) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_verbose_e) return F_output_not;
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_fake_make_print_verbose_operate_copy_
- extern f_status_t fake_make_print_verbose_operate_copy(fl_print_t * const print, const bool clone, const f_string_static_t source, const f_string_static_t destination);
+ extern f_status_t fake_make_print_verbose_operate_copy(fl_print_t * const print, const uint8_t clone, const f_string_static_t source, const f_string_static_t destination);
#endif // _di_fake_make_print_verbose_operate_copy_
/**
* F_output_not (with error bit) if setting is NULL.
*/
#ifndef _di_fake_make_print_verbose_operate_file_not_found_
- extern f_status_t fake_make_print_verbose_operate_file_not_found(fl_print_t * const print, const bool is_directory, const f_string_static_t file);
+ extern f_status_t fake_make_print_verbose_operate_file_not_found(fl_print_t * const print, const uint8_t is_directory, const f_string_static_t file);
#endif // _di_fake_make_print_verbose_operate_file_not_found_
/**
#endif // _di_fake_print_error_argument_empty_
#ifndef _di_fake_print_error_build_operation_file_
- f_status_t fake_print_error_build_operation_file(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t operation, const f_string_static_t source, const f_string_static_t destination, const f_string_static_t how, const bool fallback) {
+ f_status_t fake_print_error_build_operation_file(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t operation, const f_string_static_t source, const f_string_static_t destination, const f_string_static_t how, const uint8_t fallback) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
#endif // _di_fake_print_error_file_simple_
#ifndef _di_fake_print_error_fss_
- f_status_t fake_print_error_fss(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t path_file, const f_range_t range, const bool fallback) {
+ f_status_t fake_print_error_fss(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t path_file, const f_range_t range, const uint8_t fallback) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
* @see fl_print_format()
*/
#ifndef _di_fake_print_error_build_operation_file_
- extern f_status_t fake_print_error_build_operation_file(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t operation, const f_string_static_t source, const f_string_static_t destination, const f_string_static_t how, const bool fallback);
+ extern f_status_t fake_print_error_build_operation_file(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t operation, const f_string_static_t source, const f_string_static_t destination, const f_string_static_t how, const uint8_t fallback);
#endif // _di_fake_print_error_build_operation_file_
/**
* @see fake_print_error_fss_message()
*/
#ifndef _di_fake_print_error_fss_
- extern f_status_t fake_print_error_fss(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t path_file, const f_range_t range, const bool fallback);
+ extern f_status_t fake_print_error_fss(fl_print_t * const print, const f_string_t debug, const f_string_t function, const f_string_static_t path_file, const f_range_t range, const uint8_t fallback);
#endif // _di_fake_print_error_fss_
/**
#endif // _di_fake_skeleton_operate_directory_create_
#ifndef _di_fake_skeleton_operate_file_create_
- void fake_skeleton_operate_file_create(fake_data_t * const data, const f_string_static_t path, const bool executable, const f_string_static_t content) {
+ void fake_skeleton_operate_file_create(fake_data_t * const data, const f_string_static_t path, const uint8_t executable, const f_string_static_t content) {
if (!data || !data->main || !path.used) return;
* @see f_file_write()
*/
#ifndef _di_fake_skeleton_operate_file_create_
- extern void fake_skeleton_operate_file_create(fake_data_t * const data, const f_string_static_t path, const bool executable, const f_string_static_t content);
+ extern void fake_skeleton_operate_file_create(fake_data_t * const data, const f_string_static_t path, const uint8_t executable, const f_string_static_t content);
#endif // _di_fake_skeleton_operate_file_create_
/**
const f_number_unsigneds_t * const delimits_object = !(main->setting.flag & fss_read_main_flag_original_d) && fss_read_delimit_object_is(main, 0) ? &main->setting.delimits_object : &fss_read_except_none_c;
const f_number_unsigneds_t * const delimits_content = !(main->setting.flag & fss_read_main_flag_original_d) && fss_read_delimit_content_is(main, 0) ? &main->setting.delimits_content : &fss_read_except_none_c;
- bool names[main->setting.objects.used];
+ uint8_t names[main->setting.objects.used];
if (main->call.process_name) {
main->call.process_name(main, names);
else if (main->setting.objects.used) {
// If no processing is enabled, then default to F_true to enable all names.
- memset(names, F_true, sizeof(bool) * main->setting.objects.used);
+ memset(names, F_true, sizeof(uint8_t) * main->setting.objects.used);
}
if (main->setting.flag & fss_read_main_flag_total_d) {
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_read_extended_process_content_
- extern void fss_read_extended_process_content(fss_read_main_t * const main, const bool last);
+ extern void fss_read_extended_process_content(fss_read_main_t * const main, const uint8_t last);
#endif // _di_fss_read_extended_process_content_
/**
*/
#ifndef _di_fss_read_call_t_
typedef void (*fss_read_process_main_call_t) (fss_read_main_t * const main);
- typedef void (*fss_read_process_main_at_call_t) (fss_read_main_t * const main, const bool names[], const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
+ typedef void (*fss_read_process_main_at_call_t) (fss_read_main_t * const main, const uint8_t names[], const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
typedef void (*fss_read_process_main_at_line_call_t) (fss_read_main_t * const main, const f_number_unsigned_t at, const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content, f_number_unsigned_t * const line);
- typedef void (*fss_read_process_main_names_call_t) (fss_read_main_t * const main, bool names[]);
- typedef void (*fss_read_process_main_names_const_call_t) (fss_read_main_t * const main, const bool names[]);
+ typedef void (*fss_read_process_main_names_call_t) (fss_read_main_t * const main, uint8_t names[]);
+ typedef void (*fss_read_process_main_names_const_call_t) (fss_read_main_t * const main, const uint8_t names[]);
typedef f_status_t (*print_at_call_t)(fl_print_t * const print, const f_number_unsigned_t at, const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
typedef f_status_t (*print_object_call_t)(fl_print_t * const print, const f_number_unsigned_t at, const f_number_unsigneds_t delimits);
const f_number_unsigneds_t * const delimits_object = !(main->setting.flag & fss_read_main_flag_original_d) && fss_read_delimit_object_is(main, 0) ? &main->setting.delimits_object : &fss_read_except_none_c;
const f_number_unsigneds_t * const delimits_content = !(main->setting.flag & fss_read_main_flag_original_d) && fss_read_delimit_content_is(main, 0) ? &main->setting.delimits_content : &fss_read_except_none_c;
- bool names[main->setting.objects.used];
+ uint8_t names[main->setting.objects.used];
if (main->call.process_name) {
main->call.process_name(main, names);
else if (main->setting.objects.used) {
// If no processing is enabled, then default to F_true to enable all names.
- memset(names, F_true, sizeof(bool) * main->setting.objects.used);
+ memset(names, F_true, sizeof(uint8_t) * main->setting.objects.used);
}
if (main->setting.flag & fss_read_main_flag_total_d) {
#endif // _di_fss_read_process_
#ifndef _di_fss_read_process_at_
- void fss_read_process_at(fss_read_main_t * const main, const bool names[], const f_number_unsigneds_t delimits_object, f_number_unsigneds_t delimits_content) {
+ void fss_read_process_at(fss_read_main_t * const main, const uint8_t names[], const f_number_unsigneds_t delimits_object, f_number_unsigneds_t delimits_content) {
if (!main) return;
#endif // _di_fss_read_process_at_line_
#ifndef _di_fss_read_process_columns_
- void fss_read_process_columns(fss_read_main_t * const main, const bool names[]) {
+ void fss_read_process_columns(fss_read_main_t * const main, const uint8_t names[]) {
if (!main) return;
#endif // _di_fss_read_process_columns_
#ifndef _di_fss_read_process_name_
- void fss_read_process_name(fss_read_main_t * const main, bool names[]) {
+ void fss_read_process_name(fss_read_main_t * const main, uint8_t names[]) {
if (!main) return;
if (main->setting.depth.index_name) {
f_number_unsigned_t i = 0;
- memset(names, F_false, sizeof(bool) * main->setting.objects.used);
+ memset(names, F_false, sizeof(uint8_t) * main->setting.objects.used);
if ((main->setting.flag & fss_read_main_flag_trim_d) || (main->setting.feature & fss_read_feature_flag_object_trim_d)) {
for (i = 0; i < main->setting.objects.used; ++i) {
}
}
else {
- memset(names, F_true, sizeof(bool) * main->setting.objects.used);
+ memset(names, F_true, sizeof(uint8_t) * main->setting.objects.used);
}
main->setting.state.status = F_okay;
#endif // _di_fss_read_process_name_
#ifndef _di_fss_read_process_total_
- void fss_read_process_total(fss_read_main_t * const main, const bool names[]) {
+ void fss_read_process_total(fss_read_main_t * const main, const uint8_t names[]) {
if (!main) return;
#endif // _di_fss_read_process_total_
#ifndef _di_fss_read_process_total_multiple_
- void fss_read_process_total_multiple(fss_read_main_t * const main, const bool names[]) {
+ void fss_read_process_total_multiple(fss_read_main_t * const main, const uint8_t names[]) {
if (!main) return;
* @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_at_
- extern void fss_read_process_at(fss_read_main_t * const main, const bool names[], const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
+ extern void fss_read_process_at(fss_read_main_t * const main, const uint8_t names[], const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
#endif // _di_fss_read_process_at_
/**
* @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_columns_
- extern void fss_read_process_columns(fss_read_main_t * const main, const bool names[]);
+ extern void fss_read_process_columns(fss_read_main_t * const main, const uint8_t names[]);
#endif // _di_fss_read_process_columns_
/**
* @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_name_
- extern void fss_read_process_name(fss_read_main_t * const main, bool names[]);
+ extern void fss_read_process_name(fss_read_main_t * const main, uint8_t names[]);
#endif // _di_fss_read_process_name_
/**
* @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_total_
- extern void fss_read_process_total(fss_read_main_t * const main, const bool names[]);
+ extern void fss_read_process_total(fss_read_main_t * const main, const uint8_t names[]);
#endif // _di_fss_read_process_total_
/**
* @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_total_multiple_
- extern void fss_read_process_total_multiple(fss_read_main_t * const main, const bool names[]);
+ extern void fss_read_process_total_multiple(fss_read_main_t * const main, const uint8_t names[]);
#endif // _di_fss_read_process_total_multiple_
#ifdef __cplusplus
#endif
#ifndef _di_fss_write_basic_process_content_
- void fss_write_basic_process_content(fss_write_main_t * const main, const bool last) {
+ void fss_write_basic_process_content(fss_write_main_t * const main, const uint8_t last) {
if (!main) return;
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_write_basic_process_content_
- extern void fss_write_basic_process_content(fss_write_main_t * const main, const bool last);
+ extern void fss_write_basic_process_content(fss_write_main_t * const main, const uint8_t last);
#endif // _di_fss_write_basic_process_content_
/**
#endif
#ifndef _di_fss_write_basic_list_process_content_
- void fss_write_basic_list_process_content(fss_write_main_t * const main, const bool last) {
+ void fss_write_basic_list_process_content(fss_write_main_t * const main, const uint8_t last) {
if (!main) return;
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_write_basic_list_process_content_
- extern void fss_write_basic_list_process_content(fss_write_main_t * const main, const bool last);
+ extern void fss_write_basic_list_process_content(fss_write_main_t * const main, const uint8_t last);
#endif // _di_fss_write_basic_list_process_content_
/**
#endif
#ifndef _di_fss_write_embedded_list_process_content_
- void fss_write_embedded_list_process_content(fss_write_main_t * const main, const bool last) {
+ void fss_write_embedded_list_process_content(fss_write_main_t * const main, const uint8_t last) {
if (!main) return;
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_write_embedded_list_process_content_
- extern void fss_write_embedded_list_process_content(fss_write_main_t * const main, const bool last);
+ extern void fss_write_embedded_list_process_content(fss_write_main_t * const main, const uint8_t last);
#endif // _di_fss_write_embedded_list_process_content_
/**
#endif
#ifndef _di_fss_write_extended_process_content_
- void fss_write_extended_process_content(fss_write_main_t * const main, const bool last) {
+ void fss_write_extended_process_content(fss_write_main_t * const main, const uint8_t last) {
if (!main) return;
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_write_extended_process_content_
- extern void fss_write_extended_process_content(fss_write_main_t * const main, const bool last);
+ extern void fss_write_extended_process_content(fss_write_main_t * const main, const uint8_t last);
#endif // _di_fss_write_extended_process_content_
/**
#endif
#ifndef _di_fss_write_extended_list_process_content_
- void fss_write_extended_list_process_content(fss_write_main_t * const main, const bool last) {
+ void fss_write_extended_list_process_content(fss_write_main_t * const main, const uint8_t last) {
if (!main) return;
* If FALSE, then this is not the last Content in the Content set.
*/
#ifndef _di_fss_write_extended_list_process_content_
- extern void fss_write_extended_list_process_content(fss_write_main_t * const main, const bool last);
+ extern void fss_write_extended_list_process_content(fss_write_main_t * const main, const uint8_t last);
#endif // _di_fss_write_extended_list_process_content_
/**
*/
#ifndef _di_fss_write_call_t_
typedef void (*fss_write_process_main_call_t) (fss_write_main_t * const main);
- typedef void (*fss_write_process_content_call_t) (fss_write_main_t * const main, const bool last);
+ typedef void (*fss_write_process_content_call_t) (fss_write_main_t * const main, const uint8_t last);
typedef struct {
fss_write_process_content_call_t process_content;
if (!main) return;
- bool valid_not = F_false;
+ uint8_t valid_not = F_false;
uint32_t codepoint = 0;
if (!main) return;
- bool valid = F_true;
- bool next = F_true;
+ uint8_t valid = F_true;
+ uint8_t next = F_true;
uint8_t mode_codepoint = utf8_codepoint_mode_ready_e;
f_number_unsigned_t i = 0;
main->setting.state.status = F_okay;
- bool valid_not = F_false;
+ uint8_t valid_not = F_false;
if (*mode != utf8_codepoint_mode_end_e) {
main->setting.state.status = f_memory_array_increase_by(unicode.used, sizeof(f_char_t), (void **) &main->setting.text.string, &main->setting.text.used, &main->setting.text.size);
main->setting.state.status = F_okay;
- bool valid_not = F_false;
+ uint8_t valid_not = F_false;
if (*mode != utf8_codepoint_mode_raw_end_e) {
main->setting.state.status = f_memory_array_increase_by(hex.used, sizeof(f_char_t), (void **) &main->setting.text.string, &main->setting.text.used, &main->setting.text.size);
main->setting.state.status = F_okay;
- bool valid = F_true;
- bool next = F_true;
+ uint8_t valid = F_true;
+ uint8_t next = F_true;
uint8_t mode_codepoint = utf8_codepoint_mode_ready_e;
f_number_unsigned_t i = 0;
#endif // _di_utf8_print_error_parameter_file_name_empty_
#ifndef _di_utf8_print_error_parameter_file_not_found_
- f_status_t utf8_print_error_parameter_file_not_found(fl_print_t * const print, const bool from, const f_string_static_t name) {
+ f_status_t utf8_print_error_parameter_file_not_found(fl_print_t * const print, const uint8_t from, const f_string_static_t name) {
if (!print) return F_status_set_error(F_output_not);
if (print->verbosity < f_console_verbosity_error_e) return F_output_not;
* @see fl_print_format()
*/
#ifndef _di_utf8_print_error_parameter_file_not_found_
- extern f_status_t utf8_print_error_parameter_file_not_found(fl_print_t * const print, const bool from, const f_string_static_t name);
+ extern f_status_t utf8_print_error_parameter_file_not_found(fl_print_t * const print, const uint8_t from, const f_string_static_t name);
#endif // _di_utf8_print_error_parameter_file_not_found_
/**
main->setting.state.status = F_okay;
- bool valid = F_true;
+ uint8_t valid = F_true;
uint8_t mode_codepoint = utf8_codepoint_mode_ready_e;
utf8_process_text_width(&text);
projects / fll / commitdiff