diff --git a/stdme/gen.list b/stdme/gen.list index 50cb8a64..e71784aa 100644 --- a/stdme/gen.list +++ b/stdme/gen.list @@ -17,6 +17,9 @@ convert/str_to_u8_utils vec/vec_buf_str vec/vec_buf_str_functions2 vec/vec_buf_str_functions3 +vec/vec_str +vec/vec_str_functions2 +vec/vec_str_functions3 vec/vec_u8 vec/vec_u8_functions2 vec/vec_u8_functions3 diff --git a/stdme/include/me/os/pipe.h b/stdme/include/me/os/pipe.h new file mode 100644 index 00000000..14cf3239 --- /dev/null +++ b/stdme/include/me/os/pipe.h @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* pipe.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/04 17:57:29 by maiboyer #+# #+# */ +/* Updated: 2024/01/04 17:59:30 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef PIPE_H +# define PIPE_H + +# include "me/types.h" + +typedef struct s_pipe +{ + t_file read; + t_file write; +} t_pipe; + +t_error create_pipe(t_pipe *out); + +#endif /* PIPE_H */ diff --git a/stdme/include/me/os/process.h b/stdme/include/me/os/process.h new file mode 100644 index 00000000..cccb65c8 --- /dev/null +++ b/stdme/include/me/os/process.h @@ -0,0 +1,145 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* process.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */ +/* Updated: 2024/01/06 18:39:58 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef PROCESS_H +# define PROCESS_H + +# include "me/types.h" +# include "me/vec/vec_str.h" +# include "me/vec/vec_u8.h" + +typedef t_i32 t_pid; +typedef t_i32 t_exit_code; + +enum e_redirection +{ + R_INHERITED = 0, + R_PIPED = 1, + R_FD = 2, +}; + +union u_redirection +{ + struct s_fd + { + t_file value; + } fd; + struct s_piped + { + } piped; + struct s_inherited + { + } inherited; +}; + +typedef struct s_redirection +{ + enum e_redirection tag; + union u_redirection vals; +} t_redirection; + +static inline t_redirection piped(void) +{ + return ((t_redirection){ + .tag = R_PIPED, + }); +} + +static inline t_redirection inherited(void) +{ + return ((t_redirection){ + .tag = R_INHERITED, + }); +} + +static inline t_redirection fd(t_file fd) +{ + return ((t_redirection){.tag = R_FD, \ + .vals = (union u_redirection){.fd = {.value = fd},}}); +} + +enum e_wrapped_fd_tag +{ + READ_ONLY, + WRITE_ONLY, + READ_WRITE, + INVALID, +}; + +union u_wrapped_fd +{ + struct s_read_only + { + t_file fd; + } ro; + struct s_write_only + { + t_file fd; + } wo; + struct s_read_write + { + t_file fd; + } rw; +}; + +typedef struct s_wrapped_fd +{ + enum e_wrapped_fd_tag tag; + union u_wrapped_fd vals; +} t_wrapped_fd; + +static inline t_wrapped_fd ro(t_file fd) +{ + return ((t_wrapped_fd){.tag = READ_ONLY, + .vals = (union u_wrapped_fd){ + .ro = {.fd = fd}, + }}); +} + +static inline t_wrapped_fd wo(t_file fd) +{ + return ((t_wrapped_fd){.tag = WRITE_ONLY, + .vals = (union u_wrapped_fd){.wo = {.fd = fd}}}); +} + +typedef struct s_spawn_info +{ + t_redirection stdin; + t_redirection stdout; + t_redirection stderr; + t_vec_str arguments; + t_vec_str environement; + t_str binary_path; + void (*forked_free)(void *); + void *forked_free_args; +} t_spawn_info; + +typedef struct s_process +{ + t_wrapped_fd stdin; + t_wrapped_fd stdout; + t_wrapped_fd stderr; + t_pid pid; +} t_process; + +typedef struct s_process_output +{ + t_pid pid; + t_vec_u8 stdout; + t_vec_u8 stderr; + t_exit_code exit_code; +} t_process_output; + +t_error spawn_process(t_spawn_info info, + t_process *process); + +#endif /* PROCESS_H */ diff --git a/stdme/input.toml b/stdme/input.toml index e51674ea..0077675f 100644 --- a/stdme/input.toml +++ b/stdme/input.toml @@ -135,6 +135,14 @@ replace.C__TYPEHEADER__ = '' replace.C__PREFIX__ = "u8" replace.C__PREFIXUP__ = "U8" +[[create.vec]] +sources_output = "src/vec/" +headers_output = "include/me/vec/" +replace.C__TYPENAME__ = "t_str" +replace.C__TYPEHEADER__ = '' +replace.C__PREFIX__ = "str" +replace.C__PREFIXUP__ = "STR" + [[create.vec]] sources_output = "src/vec/" headers_output = "include/me/vec/" diff --git a/stdme/output/include/me/vec/vec_buf_str.h b/stdme/output/include/me/vec/vec_buf_str.h index 083cb24e..fe01b85a 100644 --- a/stdme/output/include/me/vec/vec_buf_str.h +++ b/stdme/output/include/me/vec/vec_buf_str.h @@ -11,50 +11,47 @@ /* ************************************************************************** */ #ifndef VEC_BUF_STR_H -# define VEC_BUF_STR_H +#define VEC_BUF_STR_H -# include "me/buffered_str/buf_str.h" -# include "me/types.h" +#include "me/buffered_str/buf_str.h" +#include "me/types.h" -typedef bool (*t_vec_buf_str_sort_fn)(t_buffer_str *, - t_buffer_str *); -typedef void (*t_free_buf_str_item)(t_buffer_str); +typedef bool (*t_vec_buf_str_sort_fn)(t_buffer_str *, t_buffer_str *); +typedef void (*t_free_buf_str_item)(t_buffer_str); typedef struct s_vec_buf_str { - t_free_buf_str_item free_func; - t_usize len; - t_usize capacity; - t_buffer_str *buffer; -} t_vec_buf_str; + t_free_buf_str_item free_func; + t_usize len; + t_usize capacity; + t_buffer_str *buffer; +} t_vec_buf_str; -t_vec_buf_str vec_buf_str_new(t_usize capacity, - t_free_buf_str_item free_function); -t_error vec_buf_str_push(t_vec_buf_str *vec, - t_buffer_str element); -t_error vec_buf_str_push_front(t_vec_buf_str *vec, - t_buffer_str element); -t_error vec_buf_str_pop(t_vec_buf_str *vec, - t_buffer_str *value); -t_error vec_buf_str_pop_front(t_vec_buf_str *vec, - t_buffer_str *value); -void vec_buf_str_free(t_vec_buf_str vec); -t_error vec_buf_str_reserve(t_vec_buf_str *vec, - t_usize wanted_capacity); -t_error vec_buf_str_find(t_vec_buf_str *vec, - bool (*fn)(const t_buffer_str *), t_usize *index); -t_error vec_buf_str_find_starting(t_vec_buf_str *vec, - bool (*fn)(const t_buffer_str *), - t_usize starting_index, t_usize *index); -t_error vec_buf_str_all(t_vec_buf_str *vec, +t_vec_buf_str vec_buf_str_new(t_usize capacity, + t_free_buf_str_item free_function); +t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element); +t_error vec_buf_str_push_front(t_vec_buf_str *vec, + t_buffer_str element); +t_error vec_buf_str_pop(t_vec_buf_str *vec, t_buffer_str *value); +t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_buffer_str *value); +void vec_buf_str_free(t_vec_buf_str vec); +t_error vec_buf_str_reserve(t_vec_buf_str *vec, + t_usize wanted_capacity); +t_error vec_buf_str_find(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), t_usize *index); +t_error vec_buf_str_find_starting(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), + t_usize starting_index, t_usize *index); +t_error vec_buf_str_all(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), bool *result); -t_error vec_buf_str_any(t_vec_buf_str *vec, +t_error vec_buf_str_any(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), bool *result); -void vec_buf_str_iter(t_vec_buf_str *vec, - void (*fn)(t_usize index, t_buffer_str *value, - void *state), void *state); -void vec_buf_str_reverse(t_vec_buf_str *vec); -void vec_buf_str_sort(t_vec_buf_str *vec, - t_vec_buf_str_sort_fn is_sorted); +void vec_buf_str_iter(t_vec_buf_str *vec, + void (*fn)(t_usize index, t_buffer_str *value, + void *state), + void *state); +void vec_buf_str_reverse(t_vec_buf_str *vec); +void vec_buf_str_sort(t_vec_buf_str *vec, + t_vec_buf_str_sort_fn is_sorted); #endif diff --git a/stdme/output/include/me/vec/vec_str.h b/stdme/output/include/me/vec/vec_str.h new file mode 100644 index 00000000..d8d11fc3 --- /dev/null +++ b/stdme/output/include/me/vec/vec_str.h @@ -0,0 +1,57 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_str.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/04 18:46:53 by maiboyer #+# #+# */ +/* Updated: 2023/12/09 17:53:00 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef VEC_STR_H +#define VEC_STR_H + + +#include "me/types.h" + +typedef bool (*t_vec_str_sort_fn)(t_str *, t_str *); +typedef void (*t_free_str_item)(t_str); + +typedef struct s_vec_str +{ + t_free_str_item free_func; + t_usize len; + t_usize capacity; + t_str *buffer; +} t_vec_str; + +t_vec_str vec_str_new(t_usize capacity, + t_free_str_item free_function); +t_error vec_str_push(t_vec_str *vec, t_str element); +t_error vec_str_push_front(t_vec_str *vec, + t_str element); +t_error vec_str_pop(t_vec_str *vec, t_str *value); +t_error vec_str_pop_front(t_vec_str *vec, t_str *value); +void vec_str_free(t_vec_str vec); +t_error vec_str_reserve(t_vec_str *vec, + t_usize wanted_capacity); +t_error vec_str_find(t_vec_str *vec, + bool (*fn)(const t_str *), t_usize *index); +t_error vec_str_find_starting(t_vec_str *vec, + bool (*fn)(const t_str *), + t_usize starting_index, t_usize *index); +t_error vec_str_all(t_vec_str *vec, + bool (*fn)(const t_str *), bool *result); +t_error vec_str_any(t_vec_str *vec, + bool (*fn)(const t_str *), bool *result); +void vec_str_iter(t_vec_str *vec, + void (*fn)(t_usize index, t_str *value, + void *state), + void *state); +void vec_str_reverse(t_vec_str *vec); +void vec_str_sort(t_vec_str *vec, + t_vec_str_sort_fn is_sorted); + +#endif diff --git a/stdme/output/include/me/vec/vec_u8.h b/stdme/output/include/me/vec/vec_u8.h index fe8ec03c..7eaa06dd 100644 --- a/stdme/output/include/me/vec/vec_u8.h +++ b/stdme/output/include/me/vec/vec_u8.h @@ -11,40 +11,47 @@ /* ************************************************************************** */ #ifndef VEC_U8_H -# define VEC_U8_H +#define VEC_U8_H -# include "me/types.h" -typedef bool (*t_vec_u8_sort_fn)(t_u8 *, t_u8 *); -typedef void (*t_free_u8_item)(t_u8); +#include "me/types.h" + +typedef bool (*t_vec_u8_sort_fn)(t_u8 *, t_u8 *); +typedef void (*t_free_u8_item)(t_u8); typedef struct s_vec_u8 { - t_free_u8_item free_func; - t_usize len; - t_usize capacity; - t_u8 *buffer; -} t_vec_u8; + t_free_u8_item free_func; + t_usize len; + t_usize capacity; + t_u8 *buffer; +} t_vec_u8; -t_vec_u8 vec_u8_new(t_usize capacity, t_free_u8_item free_function); -t_error vec_u8_push(t_vec_u8 *vec, t_u8 element); -t_error vec_u8_push_front(t_vec_u8 *vec, t_u8 element); -t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value); -t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value); -void vec_u8_free(t_vec_u8 vec); -t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity); -t_error vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *), - t_usize *index); -t_error vec_u8_find_starting(t_vec_u8 *vec, - bool (*fn)(const t_u8 *), t_usize starting_index, - t_usize *index); -t_error vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *), - bool *result); -t_error vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *), - bool *result); -void vec_u8_iter(t_vec_u8 *vec, void (*fn)(t_usize index, - t_u8 *value, void *state), void *state); -void vec_u8_reverse(t_vec_u8 *vec); -void vec_u8_sort(t_vec_u8 *vec, t_vec_u8_sort_fn is_sorted); +t_vec_u8 vec_u8_new(t_usize capacity, + t_free_u8_item free_function); +t_error vec_u8_push(t_vec_u8 *vec, t_u8 element); +t_error vec_u8_push_front(t_vec_u8 *vec, + t_u8 element); +t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value); +t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value); +void vec_u8_free(t_vec_u8 vec); +t_error vec_u8_reserve(t_vec_u8 *vec, + t_usize wanted_capacity); +t_error vec_u8_find(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), t_usize *index); +t_error vec_u8_find_starting(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), + t_usize starting_index, t_usize *index); +t_error vec_u8_all(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), bool *result); +t_error vec_u8_any(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), bool *result); +void vec_u8_iter(t_vec_u8 *vec, + void (*fn)(t_usize index, t_u8 *value, + void *state), + void *state); +void vec_u8_reverse(t_vec_u8 *vec); +void vec_u8_sort(t_vec_u8 *vec, + t_vec_u8_sort_fn is_sorted); #endif diff --git a/stdme/output/src/convert/str_to_i16.c b/stdme/output/src/convert/str_to_i16.c index b1d2bc8a..64355c98 100644 --- a/stdme/output/src/convert/str_to_i16.c +++ b/stdme/output/src/convert/str_to_i16.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); -t_error checked_sub_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); -t_error checked_mul_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); +t_error checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); +t_error checked_sub_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); +t_error checked_mul_i16(t_i16 lhs, t_i16 rhs, t_i16 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_i16) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_i16) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_i16 digit, t_u8 op, t_i16 *result) +static inline t_error do_operation(t_i16 digit, t_u8 op, t_i16 *result) { - t_i16 rhs; - t_i16 res; + t_i16 rhs; + t_i16 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_i16 digit, t_u8 op, t_i16 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_i16 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_i16 *out) { - t_u32 digit; - t_i16 result; + t_u32 digit; + t_i16 result; result = 0; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_i16(t_const_str s, t_u32 radix, t_i16 *out) +t_error str_to_i16(t_const_str s, t_u32 radix, t_i16 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_i16_utils.c b/stdme/output/src/convert/str_to_i16_utils.c index 6186cad9..6d6b30af 100644 --- a/stdme/output/src/convert/str_to_i16_utils.c +++ b/stdme/output/src/convert/str_to_i16_utils.c @@ -1,22 +1,23 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* str_to_i16_utils.c :+: :+: :+: */ +/* str_to_i64.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/02/01 21:15:19 by maiboyer #+# #+# */ -/* Updated: 2024/03/07 15:24:57 by maiboyer ### ########.fr */ +/* Updated: 2024/02/01 23:18:52 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) +t_error checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) { if (rhs > 0 && (lhs > 32767 - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) return (NO_ERROR); } -t_error checked_sub_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) +t_error checked_sub_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) { - if ((((rhs & (1 << (sizeof(t_i16) - 1)) || rhs == 0) || !true) && (lhs \ - < -32768 + rhs))) + if ((((rhs & (1 << (sizeof(t_i16) - 1)) || rhs == 0) || !true) && (lhs < -32768 + rhs))) return (ERROR); *out = (t_i16)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) +t_error checked_mul_i16(t_i16 lhs, t_i16 rhs, t_i16 *out) { - t_i16 mul; + t_i16 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_i32.c b/stdme/output/src/convert/str_to_i32.c index 49560291..cbbd6865 100644 --- a/stdme/output/src/convert/str_to_i32.c +++ b/stdme/output/src/convert/str_to_i32.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); -t_error checked_sub_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); -t_error checked_mul_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); +t_error checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); +t_error checked_sub_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); +t_error checked_mul_i32(t_i32 lhs, t_i32 rhs, t_i32 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_i32) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_i32) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_i32 digit, t_u8 op, t_i32 *result) +static inline t_error do_operation(t_i32 digit, t_u8 op, t_i32 *result) { - t_i32 rhs; - t_i32 res; + t_i32 rhs; + t_i32 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_i32 digit, t_u8 op, t_i32 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_i32 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_i32 *out) { - t_u32 digit; - t_i32 result; + t_u32 digit; + t_i32 result; result = 0; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_i32(t_const_str s, t_u32 radix, t_i32 *out) +t_error str_to_i32(t_const_str s, t_u32 radix, t_i32 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_i32_utils.c b/stdme/output/src/convert/str_to_i32_utils.c index 0d741ec1..d6522527 100644 --- a/stdme/output/src/convert/str_to_i32_utils.c +++ b/stdme/output/src/convert/str_to_i32_utils.c @@ -1,22 +1,23 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* str_to_i32_utils.c :+: :+: :+: */ +/* str_to_i64.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/02/01 21:15:19 by maiboyer #+# #+# */ -/* Updated: 2024/03/07 15:24:49 by maiboyer ### ########.fr */ +/* Updated: 2024/02/01 23:18:52 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) +t_error checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) { if (rhs > 0 && (lhs > 2147483647 - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) return (NO_ERROR); } -t_error checked_sub_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) +t_error checked_sub_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) { - if ((((rhs & (1 << (sizeof(t_i32) - 1)) || rhs == 0) || !true) && (lhs \ - < -2147483648 + rhs))) + if ((((rhs & (1 << (sizeof(t_i32) - 1)) || rhs == 0) || !true) && (lhs < -2147483648 + rhs))) return (ERROR); *out = (t_i32)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) +t_error checked_mul_i32(t_i32 lhs, t_i32 rhs, t_i32 *out) { - t_i32 mul; + t_i32 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_i64.c b/stdme/output/src/convert/str_to_i64.c index 56a48cc8..d0c50c69 100644 --- a/stdme/output/src/convert/str_to_i64.c +++ b/stdme/output/src/convert/str_to_i64.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); -t_error checked_sub_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); -t_error checked_mul_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); +t_error checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); +t_error checked_sub_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); +t_error checked_mul_i64(t_i64 lhs, t_i64 rhs, t_i64 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_i64) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_i64) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_i64 digit, t_u8 op, t_i64 *result) +static inline t_error do_operation(t_i64 digit, t_u8 op, t_i64 *result) { - t_i64 rhs; - t_i64 res; + t_i64 rhs; + t_i64 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_i64 digit, t_u8 op, t_i64 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_i64 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_i64 *out) { - t_u32 digit; - t_i64 result; + t_u32 digit; + t_i64 result; result = 0ll; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_i64(t_const_str s, t_u32 radix, t_i64 *out) +t_error str_to_i64(t_const_str s, t_u32 radix, t_i64 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_i64_utils.c b/stdme/output/src/convert/str_to_i64_utils.c index 30244077..df9e4de1 100644 --- a/stdme/output/src/convert/str_to_i64_utils.c +++ b/stdme/output/src/convert/str_to_i64_utils.c @@ -1,22 +1,23 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* str_to_i64_utils.c :+: :+: :+: */ +/* str_to_i64.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/02/01 21:15:19 by maiboyer #+# #+# */ -/* Updated: 2024/03/07 15:24:38 by maiboyer ### ########.fr */ +/* Updated: 2024/02/01 23:18:52 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) +t_error checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) { if (rhs > 0 && (lhs > 9223372036854775807ll - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) return (NO_ERROR); } -t_error checked_sub_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) +t_error checked_sub_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) { - if ((((rhs & (1 << (sizeof(t_i64) - 1)) || rhs == 0) || !true) && (lhs \ - < -(~9223372036854775807ll + 1) + rhs))) + if ((((rhs & (1 << (sizeof(t_i64) - 1)) || rhs == 0) || !true) && (lhs < -(~9223372036854775807ll + 1) + rhs))) return (ERROR); *out = (t_i64)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) +t_error checked_mul_i64(t_i64 lhs, t_i64 rhs, t_i64 *out) { - t_i64 mul; + t_i64 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_i8.c b/stdme/output/src/convert/str_to_i8.c index 80f91a0e..c45f66ec 100644 --- a/stdme/output/src/convert/str_to_i8.c +++ b/stdme/output/src/convert/str_to_i8.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); -t_error checked_sub_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); -t_error checked_mul_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); +t_error checked_add_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); +t_error checked_sub_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); +t_error checked_mul_i8(t_i8 lhs, t_i8 rhs, t_i8 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_i8) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_i8) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_i8 digit, t_u8 op, t_i8 *result) +static inline t_error do_operation(t_i8 digit, t_u8 op, t_i8 *result) { - t_i8 rhs; - t_i8 res; + t_i8 rhs; + t_i8 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_i8 digit, t_u8 op, t_i8 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_i8 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_i8 *out) { - t_u32 digit; - t_i8 result; + t_u32 digit; + t_i8 result; result = 0; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_i8(t_const_str s, t_u32 radix, t_i8 *out) +t_error str_to_i8(t_const_str s, t_u32 radix, t_i8 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_i8_utils.c b/stdme/output/src/convert/str_to_i8_utils.c index 2073dd67..0b9be619 100644 --- a/stdme/output/src/convert/str_to_i8_utils.c +++ b/stdme/output/src/convert/str_to_i8_utils.c @@ -10,13 +10,14 @@ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) +t_error checked_add_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) { if (rhs > 0 && (lhs > 127 - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) return (NO_ERROR); } -t_error checked_sub_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) +t_error checked_sub_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) { - if ((((rhs & (1 << (sizeof(t_i8) - 1)) || rhs == 0) || !true) && (lhs < -128 - + rhs))) + if ((((rhs & (1 << (sizeof(t_i8) - 1)) || rhs == 0) || !true) && (lhs < -128 + rhs))) return (ERROR); *out = (t_i8)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) +t_error checked_mul_i8(t_i8 lhs, t_i8 rhs, t_i8 *out) { - t_i8 mul; + t_i8 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_u16.c b/stdme/output/src/convert/str_to_u16.c index 7c5bbaa3..4e3414b3 100644 --- a/stdme/output/src/convert/str_to_u16.c +++ b/stdme/output/src/convert/str_to_u16.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); -t_error checked_sub_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); -t_error checked_mul_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); +t_error checked_add_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); +t_error checked_sub_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); +t_error checked_mul_u16(t_u16 lhs, t_u16 rhs, t_u16 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_u16) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_u16) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_u16 digit, t_u8 op, t_u16 *result) +static inline t_error do_operation(t_u16 digit, t_u8 op, t_u16 *result) { - t_u16 rhs; - t_u16 res; + t_u16 rhs; + t_u16 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_u16 digit, t_u8 op, t_u16 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_u16 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_u16 *out) { - t_u32 digit; - t_u16 result; + t_u32 digit; + t_u16 result; result = 0u; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_u16(t_const_str s, t_u32 radix, t_u16 *out) +t_error str_to_u16(t_const_str s, t_u32 radix, t_u16 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_u16_utils.c b/stdme/output/src/convert/str_to_u16_utils.c index 85fd7b26..45b6d039 100644 --- a/stdme/output/src/convert/str_to_u16_utils.c +++ b/stdme/output/src/convert/str_to_u16_utils.c @@ -10,13 +10,14 @@ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) +t_error checked_add_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) { if (rhs > 0 && (lhs > 65535u - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) return (NO_ERROR); } -t_error checked_sub_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) +t_error checked_sub_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) { - if ((((rhs & (1 << (sizeof(t_u16) - 1)) || rhs == 0) || !false) && (lhs < 0u - + rhs))) + if ((((rhs & (1 << (sizeof(t_u16) - 1)) || rhs == 0) || !false) && (lhs < 0u + rhs))) return (ERROR); *out = (t_u16)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) +t_error checked_mul_u16(t_u16 lhs, t_u16 rhs, t_u16 *out) { - t_u16 mul; + t_u16 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_u32.c b/stdme/output/src/convert/str_to_u32.c index 1b625d19..0fa2ff2b 100644 --- a/stdme/output/src/convert/str_to_u32.c +++ b/stdme/output/src/convert/str_to_u32.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); -t_error checked_sub_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); -t_error checked_mul_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); +t_error checked_add_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); +t_error checked_sub_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); +t_error checked_mul_u32(t_u32 lhs, t_u32 rhs, t_u32 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_u32) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_u32) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_u32 digit, t_u8 op, t_u32 *result) +static inline t_error do_operation(t_u32 digit, t_u8 op, t_u32 *result) { - t_u32 rhs; - t_u32 res; + t_u32 rhs; + t_u32 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_u32 digit, t_u8 op, t_u32 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_u32 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_u32 *out) { - t_u32 digit; - t_u32 result; + t_u32 digit; + t_u32 result; result = 0u; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_u32(t_const_str s, t_u32 radix, t_u32 *out) +t_error str_to_u32(t_const_str s, t_u32 radix, t_u32 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_u32_utils.c b/stdme/output/src/convert/str_to_u32_utils.c index 3a929d5e..c7fdc795 100644 --- a/stdme/output/src/convert/str_to_u32_utils.c +++ b/stdme/output/src/convert/str_to_u32_utils.c @@ -10,13 +10,14 @@ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) +t_error checked_add_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) { if (rhs > 0 && (lhs > 4294967295u - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) return (NO_ERROR); } -t_error checked_sub_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) +t_error checked_sub_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) { - if ((((rhs & (1 << (sizeof(t_u32) - 1)) || rhs == 0) || !false) && (lhs < 0u - + rhs))) + if ((((rhs & (1 << (sizeof(t_u32) - 1)) || rhs == 0) || !false) && (lhs < 0u + rhs))) return (ERROR); *out = (t_u32)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) +t_error checked_mul_u32(t_u32 lhs, t_u32 rhs, t_u32 *out) { - t_u32 mul; + t_u32 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_u64.c b/stdme/output/src/convert/str_to_u64.c index b744be80..9c676dcd 100644 --- a/stdme/output/src/convert/str_to_u64.c +++ b/stdme/output/src/convert/str_to_u64.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); -t_error checked_sub_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); -t_error checked_mul_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); +t_error checked_add_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); +t_error checked_sub_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); +t_error checked_mul_u64(t_u64 lhs, t_u64 rhs, t_u64 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_u64) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_u64) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_u64 digit, t_u8 op, t_u64 *result) +static inline t_error do_operation(t_u64 digit, t_u8 op, t_u64 *result) { - t_u64 rhs; - t_u64 res; + t_u64 rhs; + t_u64 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_u64 digit, t_u8 op, t_u64 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_u64 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_u64 *out) { - t_u32 digit; - t_u64 result; + t_u32 digit; + t_u64 result; result = 0llu; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_u64(t_const_str s, t_u32 radix, t_u64 *out) +t_error str_to_u64(t_const_str s, t_u32 radix, t_u64 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_u64_utils.c b/stdme/output/src/convert/str_to_u64_utils.c index f2bb77fc..cfa335d0 100644 --- a/stdme/output/src/convert/str_to_u64_utils.c +++ b/stdme/output/src/convert/str_to_u64_utils.c @@ -10,13 +10,14 @@ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) +t_error checked_add_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) { if (rhs > 0 && (lhs > 18446744073709551615llu - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) return (NO_ERROR); } -t_error checked_sub_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) +t_error checked_sub_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) { - if ((((rhs & (1 << (sizeof(t_u64) - 1)) || rhs == 0) || !false) - && (lhs < 0llu + rhs))) + if ((((rhs & (1 << (sizeof(t_u64) - 1)) || rhs == 0) || !false) && (lhs < 0llu + rhs))) return (ERROR); *out = (t_u64)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) +t_error checked_mul_u64(t_u64 lhs, t_u64 rhs, t_u64 *out) { - t_u64 mul; + t_u64 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/convert/str_to_u8.c b/stdme/output/src/convert/str_to_u8.c index 8fac9fae..1aa862f3 100644 --- a/stdme/output/src/convert/str_to_u8.c +++ b/stdme/output/src/convert/str_to_u8.c @@ -20,20 +20,20 @@ #define OP_MUL 0b0100 #define OP_CHK 0b1000 -t_error checked_add_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); -t_error checked_sub_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); -t_error checked_mul_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); +t_error checked_add_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); +t_error checked_sub_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); +t_error checked_mul_u8(t_u8 lhs, t_u8 rhs, t_u8 *out); -static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, - t_usize digits_len) +static inline bool can_not_overflow(t_u32 radix, bool is_signed_type, + t_usize digits_len) { - return (radix <= 16 && digits_len <= sizeof(t_u8) * 2 - - (t_usize)is_signed_type); + return (radix <= 16 && + digits_len <= sizeof(t_u8) * 2 - (t_usize)is_signed_type); } -static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) +static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) { - t_u32 digit; + t_u32 digit; if (radix < 2 || radix > 36) return (ERROR); @@ -50,10 +50,10 @@ static inline t_error to_digit(t_u8 ascii, t_u32 radix, t_u32 *out) return (NO_ERROR); } -static inline t_error do_operation(t_u8 digit, t_u8 op, t_u8 *result) +static inline t_error do_operation(t_u8 digit, t_u8 op, t_u8 *result) { - t_u8 rhs; - t_u8 res; + t_u8 rhs; + t_u8 res; rhs = *result; res = *result; @@ -79,13 +79,14 @@ static inline t_error do_operation(t_u8 digit, t_u8 op, t_u8 *result) return (NO_ERROR); } -static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, - t_u8 *out) +static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, + t_u8 *out) { - t_u32 digit; - t_u8 result; + t_u32 digit; + t_u8 result; result = 0u; + while (*s) { if (do_operation(radix, (op & OP_CHK) | OP_MUL, &result)) @@ -101,9 +102,9 @@ static inline t_error loop_inner(t_const_str s, t_u32 radix, t_u8 op, return (NO_ERROR); } -t_error str_to_u8(t_const_str s, t_u32 radix, t_u8 *out) +t_error str_to_u8(t_const_str s, t_u32 radix, t_u8 *out) { - t_usize digits_len; + t_usize digits_len; bool is_positive; t_u8 op; diff --git a/stdme/output/src/convert/str_to_u8_utils.c b/stdme/output/src/convert/str_to_u8_utils.c index 14a4a04e..9b5e2665 100644 --- a/stdme/output/src/convert/str_to_u8_utils.c +++ b/stdme/output/src/convert/str_to_u8_utils.c @@ -10,13 +10,14 @@ /* */ /* ************************************************************************** */ + #include "me/char/isalpha.h" #include "me/convert/str_to_numbers.h" -#include "me/printf/printf.h" #include "me/string/str_len.h" #include "me/types.h" +#include "me/printf/printf.h" -t_error checked_add_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) +t_error checked_add_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) { if (rhs > 0 && (lhs > 128u - rhs)) return (ERROR); @@ -24,18 +25,17 @@ t_error checked_add_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) return (NO_ERROR); } -t_error checked_sub_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) +t_error checked_sub_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) { - if ((((rhs & (1 << (sizeof(t_u8) - 1)) || rhs == 0) || !false) && (lhs < 0u - + rhs))) + if ((((rhs & (1 << (sizeof(t_u8) - 1)) || rhs == 0) || !false) && (lhs < 0u + rhs))) return (ERROR); *out = (t_u8)(lhs - rhs); return (NO_ERROR); } -t_error checked_mul_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) +t_error checked_mul_u8(t_u8 lhs, t_u8 rhs, t_u8 *out) { - t_u8 mul; + t_u8 mul; mul = lhs * rhs; if (lhs != 0 && mul / lhs != rhs) diff --git a/stdme/output/src/vec/vec_buf_str.c b/stdme/output/src/vec/vec_buf_str.c index 281433a1..8dd32251 100644 --- a/stdme/output/src/vec/vec_buf_str.c +++ b/stdme/output/src/vec/vec_buf_str.c @@ -17,10 +17,10 @@ #include "me/vec/vec_buf_str.h" #include -t_vec_buf_str vec_buf_str_new(t_usize capacity, - t_free_buf_str_item free_function) +t_vec_buf_str vec_buf_str_new(t_usize capacity, + t_free_buf_str_item free_function) { - t_vec_buf_str out; + t_vec_buf_str out; out = (t_vec_buf_str){0}; out.free_func = free_function; @@ -31,10 +31,10 @@ t_vec_buf_str vec_buf_str_new(t_usize capacity, } /// Return true in case of an error -t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element) +t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element) { - t_buffer_str *temp_buffer; - size_t new_capacity; + t_buffer_str *temp_buffer; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -57,10 +57,10 @@ t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element) } /// Return true in case of an error -t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity) +t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity) { - t_buffer_str *temp_buffer; - size_t new_capacity; + t_buffer_str *temp_buffer; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -82,10 +82,10 @@ t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_buf_str_pop(t_vec_buf_str *vec, t_buffer_str *value) +t_error vec_buf_str_pop(t_vec_buf_str *vec, t_buffer_str *value) { - t_buffer_str temp_value; - t_buffer_str *ptr; + t_buffer_str temp_value; + t_buffer_str *ptr; if (vec == NULL) return (ERROR); @@ -101,7 +101,7 @@ t_error vec_buf_str_pop(t_vec_buf_str *vec, t_buffer_str *value) } /// This function is safe to call with `free_elem` being NULL -void vec_buf_str_free(t_vec_buf_str vec) +void vec_buf_str_free(t_vec_buf_str vec) { if (vec.free_func) { diff --git a/stdme/output/src/vec/vec_buf_str_functions2.c b/stdme/output/src/vec/vec_buf_str_functions2.c index 6bee346d..6d7fa65c 100644 --- a/stdme/output/src/vec/vec_buf_str_functions2.c +++ b/stdme/output/src/vec/vec_buf_str_functions2.c @@ -17,10 +17,10 @@ #include "me/vec/vec_buf_str.h" #include -t_error vec_buf_str_find(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), - t_usize *index) +t_error vec_buf_str_find(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +37,11 @@ t_error vec_buf_str_find(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), return (ERROR); } -t_error vec_buf_str_find_starting(t_vec_buf_str *vec, - bool (*fn)(const t_buffer_str *), t_usize starting_index, - t_usize *index) +t_error vec_buf_str_find_starting(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), + t_usize starting_index, t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +58,10 @@ t_error vec_buf_str_find_starting(t_vec_buf_str *vec, return (ERROR); } -t_error vec_buf_str_all(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), - bool *result) +t_error vec_buf_str_all(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +76,10 @@ t_error vec_buf_str_all(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), return (ERROR); } -t_error vec_buf_str_any(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), - bool *result) +t_error vec_buf_str_any(t_vec_buf_str *vec, + bool (*fn)(const t_buffer_str *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,13 +94,15 @@ t_error vec_buf_str_any(t_vec_buf_str *vec, bool (*fn)(const t_buffer_str *), return (ERROR); } -void vec_buf_str_iter(t_vec_buf_str *vec, void (*fn)(t_usize index, - t_buffer_str *value, void *state), void *state) +void vec_buf_str_iter(t_vec_buf_str *vec, + void (*fn)(t_usize index, t_buffer_str *value, + void *state), + void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return ; + return; idx = 0; while (idx < vec->len) { diff --git a/stdme/output/src/vec/vec_buf_str_functions3.c b/stdme/output/src/vec/vec_buf_str_functions3.c index 2b51c44e..b468dac1 100644 --- a/stdme/output/src/vec/vec_buf_str_functions3.c +++ b/stdme/output/src/vec/vec_buf_str_functions3.c @@ -17,15 +17,16 @@ #include "me/vec/vec_buf_str.h" #include -t_error vec_buf_str_push_front(t_vec_buf_str *vec, t_buffer_str element) +t_error vec_buf_str_push_front(t_vec_buf_str *vec, + t_buffer_str element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_buf_str_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && vec_buf_str_reserve(vec, 3 * vec->len - / 2 + 1)) + if (vec->capacity < vec->len + 1 && + vec_buf_str_reserve(vec, 3 * vec->len / 2 + 1)) return (ERROR); while (i > 0) { @@ -38,9 +39,9 @@ t_error vec_buf_str_push_front(t_vec_buf_str *vec, t_buffer_str element) return (NO_ERROR); } -t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_buffer_str *value) +t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_buffer_str *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_buf_str_pop(vec, value)); @@ -56,10 +57,10 @@ t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_buffer_str *value) return (NO_ERROR); } -void vec_buf_str_reverse(t_vec_buf_str *vec) +void vec_buf_str_reverse(t_vec_buf_str *vec) { - t_buffer_str temporary; - t_usize i; + t_buffer_str temporary; + t_usize i; i = 0; while (i < vec->len / 2) diff --git a/stdme/output/src/vec/vec_str.c b/stdme/output/src/vec/vec_str.c new file mode 100644 index 00000000..5b377023 --- /dev/null +++ b/stdme/output/src/vec/vec_str.c @@ -0,0 +1,115 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_str.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/05 18:46:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/09 17:54:11 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_str.h" +#include + +t_vec_str vec_str_new(t_usize capacity, + t_free_str_item free_function) +{ + t_vec_str out; + + out = (t_vec_str){0}; + out.free_func = free_function; + out.buffer = mem_alloc_array(capacity, sizeof(t_str)); + if (out.buffer) + out.capacity = capacity; + return (out); +} + +/// Return true in case of an error +t_error vec_str_push(t_vec_str *vec, t_str element) +{ + t_str *temp_buffer; + size_t new_capacity; + + if (vec == NULL) + return (ERROR); + if (vec->len + 1 > vec->capacity) + { + new_capacity = (vec->capacity * 3) / 2 + 1; + while (vec->len + 1 > new_capacity) + new_capacity = (new_capacity * 3) / 2 + 1; + temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str)); + free(vec->buffer); + vec->buffer = temp_buffer; + vec->capacity = new_capacity; + } + vec->buffer[vec->len] = element; + vec->len += 1; + return (NO_ERROR); +} + +/// Return true in case of an error +t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity) +{ + t_str *temp_buffer; + size_t new_capacity; + + if (vec == NULL) + return (ERROR); + if (wanted_capacity > vec->capacity) + { + new_capacity = (vec->capacity * 3) / 2 + 1; + while (wanted_capacity > new_capacity) + new_capacity = (new_capacity * 3) / 2 + 1; + temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str)); + free(vec->buffer); + vec->buffer = temp_buffer; + vec->capacity = new_capacity; + } + return (NO_ERROR); +} + +/// Return true if the vector is empty +/// This function is safe to call with value being NULL +t_error vec_str_pop(t_vec_str *vec, t_str *value) +{ + t_str temp_value; + t_str *ptr; + + if (vec == NULL) + return (ERROR); + ptr = value; + if (vec->len == 0) + return (ERROR); + if (value == NULL) + ptr = &temp_value; + vec->len--; + *ptr = vec->buffer[vec->len]; + mem_set_zero(&vec->buffer[vec->len], sizeof(t_str)); + return (NO_ERROR); +} + +/// This function is safe to call with `free_elem` being NULL +void vec_str_free(t_vec_str vec) +{ + if (vec.free_func) + { + while (vec.len) + { + vec.free_func(vec.buffer[vec.len - 1]); + vec.len--; + } + } + free(vec.buffer); +} diff --git a/stdme/output/src/vec/vec_str_functions2.c b/stdme/output/src/vec/vec_str_functions2.c new file mode 100644 index 00000000..0b3a88bb --- /dev/null +++ b/stdme/output/src/vec/vec_str_functions2.c @@ -0,0 +1,112 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_str.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_str.h" +#include + +t_error vec_str_find(t_vec_str *vec, + bool (*fn)(const t_str *), t_usize *index) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || index == NULL) + return (ERROR); + idx = 0; + while (idx < vec->len) + { + if (fn(&vec->buffer[idx])) + { + *index = idx; + return (NO_ERROR); + } + idx++; + } + return (ERROR); +} + +t_error vec_str_find_starting(t_vec_str *vec, + bool (*fn)(const t_str *), + t_usize starting_index, t_usize *index) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || index == NULL) + return (ERROR); + idx = starting_index; + while (idx < vec->len) + { + if (fn(&vec->buffer[idx])) + { + *index = idx; + return (NO_ERROR); + } + idx++; + } + return (ERROR); +} + +t_error vec_str_all(t_vec_str *vec, + bool (*fn)(const t_str *), bool *result) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || result == NULL) + return (ERROR); + idx = 0; + *result = true; + while (*result && idx < vec->len) + { + if (!fn(&vec->buffer[idx])) + *result = false; + idx++; + } + return (ERROR); +} + +t_error vec_str_any(t_vec_str *vec, + bool (*fn)(const t_str *), bool *result) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || result == NULL) + return (ERROR); + idx = 0; + *result = false; + while (*result && idx < vec->len) + { + if (fn(&vec->buffer[idx])) + *result = true; + idx++; + } + return (ERROR); +} + +void vec_str_iter(t_vec_str *vec, + void (*fn)(t_usize index, t_str *value, + void *state), + void *state) +{ + t_usize idx; + + if (vec == NULL || fn == NULL) + return; + idx = 0; + while (idx < vec->len) + { + fn(idx, &vec->buffer[idx], state); + idx++; + } +} diff --git a/stdme/output/src/vec/vec_str_functions3.c b/stdme/output/src/vec/vec_str_functions3.c new file mode 100644 index 00000000..0ac7153f --- /dev/null +++ b/stdme/output/src/vec/vec_str_functions3.c @@ -0,0 +1,73 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_str.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_str.h" +#include + +t_error vec_str_push_front(t_vec_str *vec, + t_str element) +{ + t_usize i; + + if (vec->len == 0) + return (vec_str_push(vec, element)); + i = vec->len - 1; + if (vec->capacity < vec->len + 1 && + vec_str_reserve(vec, 3 * vec->len / 2 + 1)) + return (ERROR); + while (i > 0) + { + vec->buffer[i + 1] = vec->buffer[i]; + i--; + } + vec->buffer[1] = vec->buffer[0]; + vec->buffer[0] = element; + vec->len++; + return (NO_ERROR); +} + +t_error vec_str_pop_front(t_vec_str *vec, t_str *value) +{ + t_usize i; + + if (vec->len <= 1) + return (vec_str_pop(vec, value)); + i = 0; + *value = vec->buffer[0]; + vec->len--; + while (i < vec->len) + { + vec->buffer[i] = vec->buffer[i + 1]; + i++; + } + mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer)); + return (NO_ERROR); +} + +void vec_str_reverse(t_vec_str *vec) +{ + t_str temporary; + t_usize i; + + i = 0; + while (i < vec->len / 2) + { + temporary = vec->buffer[vec->len - 1 - i]; + vec->buffer[vec->len - 1 - i] = vec->buffer[i]; + vec->buffer[i] = temporary; + i++; + } +} diff --git a/stdme/output/src/vec/vec_u8.c b/stdme/output/src/vec/vec_u8.c index 74ff9a0e..8a4bfc5b 100644 --- a/stdme/output/src/vec/vec_u8.c +++ b/stdme/output/src/vec/vec_u8.c @@ -17,9 +17,10 @@ #include "me/vec/vec_u8.h" #include -t_vec_u8 vec_u8_new(t_usize capacity, t_free_u8_item free_function) +t_vec_u8 vec_u8_new(t_usize capacity, + t_free_u8_item free_function) { - t_vec_u8 out; + t_vec_u8 out; out = (t_vec_u8){0}; out.free_func = free_function; @@ -30,10 +31,10 @@ t_vec_u8 vec_u8_new(t_usize capacity, t_free_u8_item free_function) } /// Return true in case of an error -t_error vec_u8_push(t_vec_u8 *vec, t_u8 element) +t_error vec_u8_push(t_vec_u8 *vec, t_u8 element) { - t_u8 *temp_buffer; - size_t new_capacity; + t_u8 *temp_buffer; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -56,10 +57,10 @@ t_error vec_u8_push(t_vec_u8 *vec, t_u8 element) } /// Return true in case of an error -t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity) +t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity) { - t_u8 *temp_buffer; - size_t new_capacity; + t_u8 *temp_buffer; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -81,10 +82,10 @@ t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value) +t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value) { - t_u8 temp_value; - t_u8 *ptr; + t_u8 temp_value; + t_u8 *ptr; if (vec == NULL) return (ERROR); @@ -100,7 +101,7 @@ t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value) } /// This function is safe to call with `free_elem` being NULL -void vec_u8_free(t_vec_u8 vec) +void vec_u8_free(t_vec_u8 vec) { if (vec.free_func) { diff --git a/stdme/output/src/vec/vec_u8_functions2.c b/stdme/output/src/vec/vec_u8_functions2.c index 3358623c..bb567f29 100644 --- a/stdme/output/src/vec/vec_u8_functions2.c +++ b/stdme/output/src/vec/vec_u8_functions2.c @@ -17,9 +17,10 @@ #include "me/vec/vec_u8.h" #include -t_error vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *), t_usize *index) +t_error vec_u8_find(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -36,10 +37,11 @@ t_error vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *), t_usize *index) return (ERROR); } -t_error vec_u8_find_starting(t_vec_u8 *vec, bool (*fn)(const t_u8 *), - t_usize starting_index, t_usize *index) +t_error vec_u8_find_starting(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), + t_usize starting_index, t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -56,9 +58,10 @@ t_error vec_u8_find_starting(t_vec_u8 *vec, bool (*fn)(const t_u8 *), return (ERROR); } -t_error vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result) +t_error vec_u8_all(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -73,9 +76,10 @@ t_error vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result) return (ERROR); } -t_error vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result) +t_error vec_u8_any(t_vec_u8 *vec, + bool (*fn)(const t_u8 *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -90,13 +94,15 @@ t_error vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result) return (ERROR); } -void vec_u8_iter(t_vec_u8 *vec, void (*fn)(t_usize index, t_u8 *value, - void *state), void *state) +void vec_u8_iter(t_vec_u8 *vec, + void (*fn)(t_usize index, t_u8 *value, + void *state), + void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return ; + return; idx = 0; while (idx < vec->len) { diff --git a/stdme/output/src/vec/vec_u8_functions3.c b/stdme/output/src/vec/vec_u8_functions3.c index 3167ba25..32994a01 100644 --- a/stdme/output/src/vec/vec_u8_functions3.c +++ b/stdme/output/src/vec/vec_u8_functions3.c @@ -17,15 +17,16 @@ #include "me/vec/vec_u8.h" #include -t_error vec_u8_push_front(t_vec_u8 *vec, t_u8 element) +t_error vec_u8_push_front(t_vec_u8 *vec, + t_u8 element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_u8_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && vec_u8_reserve(vec, 3 * vec->len / 2 - + 1)) + if (vec->capacity < vec->len + 1 && + vec_u8_reserve(vec, 3 * vec->len / 2 + 1)) return (ERROR); while (i > 0) { @@ -38,9 +39,9 @@ t_error vec_u8_push_front(t_vec_u8 *vec, t_u8 element) return (NO_ERROR); } -t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value) +t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_u8_pop(vec, value)); @@ -56,10 +57,10 @@ t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value) return (NO_ERROR); } -void vec_u8_reverse(t_vec_u8 *vec) +void vec_u8_reverse(t_vec_u8 *vec) { - t_u8 temporary; - t_usize i; + t_u8 temporary; + t_usize i; i = 0; while (i < vec->len / 2) diff --git a/stdme/src.list b/stdme/src.list index 0ea8567f..a36af7c7 100644 --- a/stdme/src.list +++ b/stdme/src.list @@ -72,6 +72,10 @@ num/u64/from_bytes num/u64/rotate num/u8/rotate num/usize/rotate +os/pipe +os/process +os/process_inner +os/process_inner2 printf/formatter/char printf/formatter/decimal printf/formatter/hex diff --git a/stdme/src/os/pipe.c b/stdme/src/os/pipe.c new file mode 100644 index 00000000..c046fdf7 --- /dev/null +++ b/stdme/src/os/pipe.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* pipe.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/04 17:59:48 by maiboyer #+# #+# */ +/* Updated: 2024/01/04 18:01:42 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/os/pipe.h" + +t_error create_pipe(t_pipe *out) +{ + t_file fds[2]; + + if (pipe(fds)) + return (ERROR); + out->read = fds[0]; + out->write = fds[1]; + return (NO_ERROR); +} diff --git a/stdme/src/os/process.c b/stdme/src/os/process.c new file mode 100644 index 00000000..55e0d394 --- /dev/null +++ b/stdme/src/os/process.c @@ -0,0 +1,141 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* process.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/03 16:22:41 by maiboyer #+# #+# */ +/* Updated: 2024/01/06 17:50:47 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/buffered_str/buf_str.h" +#include "me/os/pipe.h" +#include "me/os/process.h" +#include "me/string/str_find_chr.h" +#include "me/string/str_n_compare.h" +#include "me/string/str_split.h" +#include "me/types.h" +#include "me/vec/vec_str.h" +#include +#include +#include + +bool find_path(const t_str *s); +bool find_null(const t_str *s); +bool str_start_with(t_const_str s, t_const_str prefix); +t_error handle_redirections(t_spawn_info *info, t_process *process); + +t_error spawn_process_exec(t_spawn_info info, t_process *process) +{ + bool res; + + if (info.forked_free) + info.forked_free(info.forked_free_args); + dup2(info.stdin.vals.fd.value, 0); + dup2(info.stdout.vals.fd.value, 1); + dup2(info.stderr.vals.fd.value, 2); + close(process->stdin.vals.ro.fd); + close(process->stdout.vals.ro.fd); + close(process->stderr.vals.ro.fd); + close(info.stdin.vals.fd.value); + close(info.stdout.vals.fd.value); + close(info.stderr.vals.fd.value); + if (!vec_str_any(&info.arguments, find_null, &res) && res) + vec_str_push(&info.arguments, NULL); + res = false; + if (!vec_str_any(&info.environement, find_null, &res) && res) + vec_str_push(&info.environement, NULL); + execve(info.binary_path, info.arguments.buffer, info.environement.buffer); + return (NO_ERROR); +} + +t_error in_path(t_spawn_info *info, t_process *process, t_const_str path, + t_buffer_str *s) +{ + t_str *splitted_path; + t_usize sp_index; + + splitted_path = str_split(path + 5, ':'); + if (splitted_path == NULL) + return (str_free(*s), ERROR); + sp_index = 0; + while (splitted_path[sp_index]) + { + ((void)(process), str_clear(s)); + push_str_buffer(s, splitted_path[sp_index]); + push_str_buffer(s, "/"); + push_str_buffer(s, info->binary_path); + sp_index++; + if (access(s->buf, X_OK | R_OK) == 0) + break ; + } + sp_index = 0; + while (splitted_path[sp_index]) + free(splitted_path[sp_index++]); + free(splitted_path); + return (NO_ERROR); +} + +t_error find_binary(t_spawn_info *info, t_process *process) +{ + t_usize p_idx; + t_str *splitted_path; + t_buffer_str s; + + (void)(process); + splitted_path = NULL; + s = alloc_new_buffer(256); + if (str_start_with(info->binary_path, "/") + || str_find_chr(info->binary_path, '/') != NULL) + push_str_buffer(&s, info->binary_path); + else + { + if (vec_str_find(&info->environement, find_path, &p_idx)) + return (str_free(s), ERROR); + if (in_path(info, process, info->environement.buffer[p_idx], &s)) + return (ERROR); + } + if (access(s.buf, X_OK | R_OK) == 0) + { + free(info->binary_path); + info->binary_path = s.buf; + return (NO_ERROR); + } + return (str_free(s), ERROR); +} + +static void cleanup(t_spawn_info info, t_process *process, bool cleanup_process) +{ + if (cleanup_process && process->stdin.tag != INVALID) + close(process->stdin.vals.ro.fd); + if (cleanup_process && process->stdout.tag != INVALID) + close(process->stdout.vals.ro.fd); + if (cleanup_process && process->stderr.tag != INVALID) + close(process->stderr.vals.ro.fd); + close(info.stdin.vals.fd.value); + close(info.stdout.vals.fd.value); + close(info.stderr.vals.fd.value); + vec_str_free(info.arguments); + vec_str_free(info.environement); + free(info.binary_path); +} + +t_error spawn_process(t_spawn_info info, t_process *process) +{ + if (handle_redirections(&info, process)) + return (cleanup(info, process, true), ERROR); + if (find_binary(&info, process)) + return (cleanup(info, process, true), ERROR); + process->pid = fork(); + if (process->pid == 0) + (spawn_process_exec(info, process), exit(1)); + else + { + cleanup(info, process, false); + if (process->pid == -1) + return (printf("pid\n"), ERROR); + } + return (NO_ERROR); +} diff --git a/stdme/src/os/process_inner.c b/stdme/src/os/process_inner.c new file mode 100644 index 00000000..25fec826 --- /dev/null +++ b/stdme/src/os/process_inner.c @@ -0,0 +1,33 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* process_inner.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/04 22:25:44 by maiboyer #+# #+# */ +/* Updated: 2024/01/04 22:26:10 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/types.h" + +bool find_null(const t_str *s) +{ + return (s == NULL); +} + +bool str_start_with(t_const_str s, t_const_str prefix) +{ + while (*prefix && *s) + { + if (*prefix++ != *s++) + return (false); + } + return (*prefix == '\0'); +} + +bool find_path(const t_str *s) +{ + return (str_start_with(*s, "PATH=")); +} diff --git a/stdme/src/os/process_inner2.c b/stdme/src/os/process_inner2.c new file mode 100644 index 00000000..dfaf016d --- /dev/null +++ b/stdme/src/os/process_inner2.c @@ -0,0 +1,92 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* process_inner2.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/04 22:27:00 by maiboyer #+# #+# */ +/* Updated: 2024/01/04 23:01:03 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/types.h" +#include "me/os/process.h" +#include "me/os/pipe.h" + +void handle_redirections_second(t_spawn_info *info, t_process *process) +{ + (void)(process); + if (info->stdin.tag == R_INHERITED) + { + info->stdin = fd(dup(0)); + process->stdin = ro(dup(0)); + } + if (info->stdout.tag == R_INHERITED) + { + info->stdout = fd(dup(1)); + process->stdout = wo(dup(1)); + } + if (info->stderr.tag == R_INHERITED) + { + info->stderr = fd(dup(2)); + process->stderr = wo(dup(2)); + } +} + +void handle_redirections_fds(t_spawn_info *info, t_process *process) +{ + if (info->stdin.tag == R_FD) + { + info->stdin = fd(dup(info->stdin.vals.fd.value)); + process->stdin = wo(dup(info->stdin.vals.fd.value)); + } + if (info->stdout.tag == R_FD) + { + info->stdout = fd(dup(info->stdout.vals.fd.value)); + process->stdout = ro(dup(info->stdout.vals.fd.value)); + } + if (info->stderr.tag == R_FD) + { + info->stderr = fd(dup(info->stderr.vals.fd.value)); + process->stderr = ro(dup(info->stderr.vals.fd.value)); + } +} + +static inline void redirection_inner(t_spawn_info *info, t_process *process) +{ + process->stderr.tag = INVALID; + process->stdout.tag = INVALID; + process->stdin.tag = INVALID; + handle_redirections_fds(info, process); + handle_redirections_second(info, process); +} + +t_error handle_redirections(t_spawn_info *info, t_process *process) +{ + t_pipe pipe_fd; + + redirection_inner(info, process); + if (info->stdin.tag == R_PIPED) + { + if (create_pipe(&pipe_fd)) + return (ERROR); + process->stdin = wo(pipe_fd.write); + info->stdin = fd(pipe_fd.read); + } + if (info->stdout.tag == R_PIPED) + { + if (create_pipe(&pipe_fd)) + return (ERROR); + process->stdout = ro(pipe_fd.read); + info->stdout = fd(pipe_fd.write); + } + if (info->stderr.tag == R_PIPED) + { + if (create_pipe(&pipe_fd)) + return (ERROR); + process->stderr = ro(pipe_fd.read); + info->stderr = fd(pipe_fd.write); + } + return (NO_ERROR); +}