raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update: stdme/os module

Browse source
This commit is contained in:
Maieul BOYER 2024-04-29 15:12:51 +02:00
parent dfb10f3390
commit 16f49181b5
No known key found for this signature in database
37 changed files with 1201 additions and 345 deletions
Download patch file Download diff file Expand all files Collapse all files

71
stdme/output/include/me/vec/vec_buf_str.h
View file

@ -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

57
stdme/output/include/me/vec/vec_str.h Normal file
View file

@ -0,0 +1,57 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_str.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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

65
stdme/output/include/me/vec/vec_u8.h
View file

@ -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

37
stdme/output/src/convert/str_to_i16.c
View file

@ -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;

18
stdme/output/src/convert/str_to_i16_utils.c
View file

@ -1,22 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* str_to_i16_utils.c :+: :+: :+: */
/* str_to_i64.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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)

37
stdme/output/src/convert/str_to_i32.c
View file

@ -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;

18
stdme/output/src/convert/str_to_i32_utils.c
View file

@ -1,22 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* str_to_i32_utils.c :+: :+: :+: */
/* str_to_i64.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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)

37
stdme/output/src/convert/str_to_i64.c
View file

@ -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;

18
stdme/output/src/convert/str_to_i64_utils.c
View file

@ -1,22 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* str_to_i64_utils.c :+: :+: :+: */
/* str_to_i64.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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)

37
stdme/output/src/convert/str_to_i8.c
View file

@ -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;

14
stdme/output/src/convert/str_to_i8_utils.c
View file

@ -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)

37
stdme/output/src/convert/str_to_u16.c
View file

@ -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;

14
stdme/output/src/convert/str_to_u16_utils.c
View file

@ -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)

37
stdme/output/src/convert/str_to_u32.c
View file

@ -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;

14
stdme/output/src/convert/str_to_u32_utils.c
View file

@ -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)

37
stdme/output/src/convert/str_to_u64.c
View file

@ -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;

14
stdme/output/src/convert/str_to_u64_utils.c
View file

@ -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)

37
stdme/output/src/convert/str_to_u8.c
View file

@ -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;

14
stdme/output/src/convert/str_to_u8_utils.c
View file

@ -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)

26
stdme/output/src/vec/vec_buf_str.c
View file

@ -17,10 +17,10 @@
#include "me/vec/vec_buf_str.h"
#include <stdlib.h>
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)
{

36
stdme/output/src/vec/vec_buf_str_functions2.c
View file

@ -17,10 +17,10 @@
#include "me/vec/vec_buf_str.h"
#include <stdlib.h>
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)
{

19
stdme/output/src/vec/vec_buf_str_functions3.c
View file

@ -17,15 +17,16 @@
#include "me/vec/vec_buf_str.h"
#include <stdlib.h>
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)

115
stdme/output/src/vec/vec_str.c Normal file
View file

@ -0,0 +1,115 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_str.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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);
}

112
stdme/output/src/vec/vec_str_functions2.c Normal file
View file

@ -0,0 +1,112 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_str.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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++;
}
}

73
stdme/output/src/vec/vec_str_functions3.c Normal file
View file

@ -0,0 +1,73 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_str.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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++;
}
}

25
stdme/output/src/vec/vec_u8.c
View file

@ -17,9 +17,10 @@
#include "me/vec/vec_u8.h"
#include <stdlib.h>
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)
{

32
stdme/output/src/vec/vec_u8_functions2.c
View file

@ -17,9 +17,10 @@
#include "me/vec/vec_u8.h"
#include <stdlib.h>
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)
{

19
stdme/output/src/vec/vec_u8_functions3.c
View file

@ -17,15 +17,16 @@
#include "me/vec/vec_u8.h"
#include <stdlib.h>
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)