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

Updated linenoise and printf to better work

Browse source
This commit is contained in:
Maieul BOYER 2024-07-07 19:50:33 +02:00
parent 0e18e20181
commit 8808f81221
No known key found for this signature in database
28 changed files with 657 additions and 579 deletions
Download patch file Download diff file Expand all files Collapse all files

518
line/src/line.c
View file

@ -1,3 +1,14 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/07 16:53:27 by maiboyer #+# #+# */
/* Updated: 2024/07/07 19:22:53 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
@ -20,8 +31,8 @@
#include "me/types.h" #include "me/types.h"
#include "me/vec/vec_str.h" #include "me/vec/vec_str.h"
static t_str linenoiseNoTTY(void); t_raw_mode_state *get_raw_mode_state(void);
static void refreshLineWithFlags(t_line_state *l, int flags); t_vec_str *get_history(void);
t_vec_str *get_history(void) t_vec_str *get_history(void)
{ {
@ -36,75 +47,92 @@ t_vec_str *get_history(void)
return (&history); return (&history);
} }
t_raw_mode_state *get_raw_mode_state(void)
{
static t_raw_mode_state state = {};
return (&state);
}
enum e_key_action enum e_key_action
{ {
KEY_NULL = 0, /* NULL */ K_KEY_NULL = 0, /* NULL */
CTRL_A = 1, /* Ctrl+a */ K_CTRL_A = 1, /* Ctrl+a */
CTRL_B = 2, /* Ctrl-b */ K_CTRL_B = 2, /* Ctrl-b */
CTRL_C = 3, /* Ctrl-c */ K_CTRL_C = 3, /* Ctrl-c */
CTRL_D = 4, /* Ctrl-d */ K_CTRL_D = 4, /* Ctrl-d */
CTRL_E = 5, /* Ctrl-e */ K_CTRL_E = 5, /* Ctrl-e */
CTRL_F = 6, /* Ctrl-f */ K_CTRL_F = 6, /* Ctrl-f */
CTRL_H = 8, /* Ctrl-h */ K_CTRL_H = 8, /* Ctrl-h */
TAB = 9, /* Tab */ K_TAB = 9, /* Tab */
CTRL_K = 11, /* Ctrl+k */ K_CTRL_K = 11, /* Ctrl+k */
CTRL_L = 12, /* Ctrl+l */ K_CTRL_L = 12, /* Ctrl+l */
ENTER = 13, /* Enter */ K_ENTER = 13, /* Enter */
CTRL_N = 14, /* Ctrl-n */ K_CTRL_N = 14, /* Ctrl-n */
CTRL_P = 16, /* Ctrl-p */ K_CTRL_P = 16, /* Ctrl-p */
CTRL_T = 20, /* Ctrl-t */ K_CTRL_T = 20, /* Ctrl-t */
CTRL_U = 21, /* Ctrl+u */ K_CTRL_U = 21, /* Ctrl+u */
CTRL_W = 23, /* Ctrl+w */ K_CTRL_W = 23, /* Ctrl+w */
ESC = 27, /* Escape */ K_ESC = 27, /* Escape */
BACKSPACE = 127 /* Backspace */ K_BACKSPACE = 127 /* Backspace */
}; };
#define REFRESH_CLEAN (1 << 0) // Clean the old prompt from the screen enum e_line_flags
#define REFRESH_WRITE (1 << 1) // Rewrite the prompt on the screen. {
#define REFRESH_ALL (REFRESH_CLEAN | REFRESH_WRITE) // Do both. REFRESH_CLEAN = 1 << 0, // Clean the old prompt from the screen
REFRESH_WRITE = 1 << 1, // Rewrite the prompt on the screen.
REFRESH_ALL = REFRESH_CLEAN | REFRESH_WRITE, // Do both.
};
int linenoiseHistoryAdd(const char *line); typedef enum e_line_flags t_line_flags;
static void linenoise_uninit_lib(void);
static void refreshLine(t_line_state *l); void linenoise_clear_screen(t_fd *output);
void linenoise_disable_raw_mode(t_fd *fd);
t_error linenoise_enable_raw_mode(t_fd *fd);
t_u32 linenoise_get_columns(t_fd *input, t_fd *output);
t_error linenoise_get_cursor_position(t_fd *input, t_fd *output, t_u32 *column_out);
t_error linenoise_history_add(t_const_str line);
t_str linenoise_no_tty_impl(void);
void linenoise_refresh_line(t_line_state *l);
void linenoise_refresh_line_with_flags(t_line_state *l, t_line_flags flags);
void linenoise_uninit_lib(void);
/* Free the history, but does not reset it. Only used when we have to
* exit() to avoid memory leaks are reported by valgrind & co. */
void free_history(void)
{
t_vec_str *history = get_history();
vec_str_free(*history);
}
/* At exit we'll try to fix the terminal to the initial conditions. */
__attribute__((destructor)) void linenoise_uninit_lib(void)
{
linenoise_disable_raw_mode(get_stdin());
free_history();
}
/* Debugging macro. */
#if 0
FILE *lndebug_fp = NULL;
# define lndebug(...) \
do \
{ \
if (lndebug_fp == NULL) \
{ \
lndebug_fp = fopen("/tmp/lndebug.txt", "a"); \
fprintf(lndebug_fp, "[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", (int)l->len, (int)l->pos, (int)l->oldpos, \
plen, rows, rpos, (int)l->oldrows, old_rows); \
} \
fprintf(lndebug_fp, ", " __VA_ARGS__); \
fflush(lndebug_fp); \
} while (0)
#else
#define lndebug(fmt, ...) #define lndebug(fmt, ...)
#endif
/* ======================= Low level terminal handling ====================== */ /* ======================= Low level terminal handling ====================== */
/* Use the ESC [6n escape sequence to query the horizontal cursor position /* Use the ESC [6n escape sequence to query the horizontal cursor position
* and return it. On error -1 is returned, on success the position of the * and return it. On error -1 is returned, on success the position of the
* cursor. */ * cursor. */
static int getCursorPosition(int ifd, int ofd) t_error linenoise_get_cursor_position(t_fd *input, t_fd *output, t_u32 *column_out)
{ {
char buf[32]; char buf[32];
int cols, rows; int cols, rows;
unsigned int i = 0; unsigned int i = 0;
/* Report cursor location */ /* Report cursor location */
if (write(ofd, "\x1b[6n", 4) != 4) if (write(output->fd, "\x1b[6n", 4) != 4)
return -1; return (ERROR);
/* Read the response: ESC [ rows ; cols R */ /* Read the response: ESC [ rows ; cols R */
while (i < sizeof(buf) - 1) while (i < sizeof(buf) - 1)
{ {
if (read(ifd, buf + i, 1) != 1) if (read(input->fd, buf + i, 1) != 1)
break; break;
if (buf[i] == 'R') if (buf[i] == 'R')
break; break;
@ -113,77 +141,63 @@ static int getCursorPosition(int ifd, int ofd)
buf[i] = '\0'; buf[i] = '\0';
/* Parse it. */ /* Parse it. */
if (buf[0] != ESC || buf[1] != '[') if (buf[0] != K_ESC || buf[1] != '[')
return -1; return (ERROR);
if (sscanf(buf + 2, "%d;%d", &rows, &cols) != 2) if (sscanf(buf + 2, "%d;%d", &rows, &cols) != 2)
return -1; return (ERROR);
return cols; return (*column_out = cols, NO_ERROR);
} }
/* Try to get the number of columns in the current terminal, or assume 80 /* Try to get the number of columns in the current terminal, or assume 80
* if it fails. */ * if it fails. */
static t_u32 getColumns(int ifd, int ofd) t_u32 linenoise_get_columns(t_fd *input, t_fd *output)
{ {
struct winsize ws; struct winsize ws;
t_u32 start, cols; t_u32 cols;
t_u32 start;
if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0)
{ {
/* ioctl() failed. Try to query the terminal itself. */ /* ioctl() failed. Try to query the terminal itself. */
/* Get the initial position so we can restore it later. */ /* Get the initial position so we can restore it later. */
start = getCursorPosition(ifd, ofd); if (linenoise_get_cursor_position(input, output, &start))
if (start == -1) return (80);
return 80;
/* Go to right margin and get position. */ /* Go to right margin and get position. */
if (write(ofd, "\x1b[999C", 6) != 6) me_eprintf("going to the right;\n");
return 80; me_printf_fd(output, "\x1b[999C");
cols = getCursorPosition(ifd, ofd); if (linenoise_get_cursor_position(input, output, &cols))
if (cols == -1) return (80);
return 80;
/* Restore position. */
if (cols > start) if (cols > start)
{ {
t_u8 seq[32]; me_eprintf("reseting col;\n");
me_printf(seq, 32, "\x1b[%dD", cols - start); me_printf_fd(output, "\x1b[%dD", cols - start);
(void)!(write(ofd, seq, strlen(seq)) == -1);
} }
return cols; return (cols);
} }
else else
{ return (ws.ws_col);
return ws.ws_col;
}
failed:
} }
/* Clear the screen. Used to handle ctrl+l */ /* Clear the screen. Used to handle ctrl+l */
void linenoiseClearScreen(void) void linenoise_clear_screen(t_fd *output)
{ {
(void)!write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7); me_eprintf("clear screen;\n");
} me_printf_fd(output, "\x1b[H\x1b[2J");
t_raw_mode_state *get_raw_mode_state(void)
{
static t_raw_mode_state state = {};
return (&state);
} }
/* Raw mode: 1960 magic shit. */ /* Raw mode: 1960 magic shit. */
static t_error enableRawMode(int fd) t_error linenoise_enable_raw_mode(t_fd *fd)
{ {
struct termios raw; struct termios raw;
t_raw_mode_state *raw_state; t_raw_mode_state *raw_state;
raw_state = get_raw_mode_state(); raw_state = get_raw_mode_state();
if (!isatty(STDIN_FILENO)) if (!isatty(fd->fd))
return (errno = ENOTTY, ERROR); return (errno = ENOTTY, ERROR);
if (tcgetattr(fd, &raw_state->state) == -1) if (tcgetattr(fd->fd, &raw_state->state) == -1)
return (errno = ENOTTY, ERROR); return (errno = ENOTTY, ERROR);
raw = raw_state->state; /* modify the original mode */ raw = raw_state->state; /* modify the original mode */
@ -203,18 +217,18 @@ static t_error enableRawMode(int fd)
raw.c_cc[VTIME] = 0; /* 1 byte, no timer */ raw.c_cc[VTIME] = 0; /* 1 byte, no timer */
/* put terminal in raw mode after flushing */ /* put terminal in raw mode after flushing */
if (tcsetattr(fd, TCSAFLUSH, &raw) < 0) if (tcsetattr(fd->fd, TCSAFLUSH, &raw) < 0)
return (errno = ENOTTY, ERROR); return (errno = ENOTTY, ERROR);
raw_state->enabled = true; raw_state->enabled = true;
return (NO_ERROR); return (NO_ERROR);
} }
static void disableRawMode(int fd) void linenoise_disable_raw_mode(t_fd *fd)
{ {
t_raw_mode_state *state; t_raw_mode_state *state;
state = get_raw_mode_state(); state = get_raw_mode_state();
if (state->enabled && tcsetattr(fd, TCSAFLUSH, &state->state) != -1) if (state->enabled && tcsetattr(fd->fd, TCSAFLUSH, &state->state) != -1)
state->enabled = false; state->enabled = false;
} }
@ -224,33 +238,6 @@ static void disableRawMode(int fd)
* allocated string where we can append to. This is useful in order to * allocated string where we can append to. This is useful in order to
* write all the escape sequences in a buffer and flush them to the standard * write all the escape sequences in a buffer and flush them to the standard
* output in a single call, to avoid flickering effects. */ * output in a single call, to avoid flickering effects. */
struct abuf
{
char *b;
int len;
};
static void abInit(struct abuf *ab)
{
ab->b = NULL;
ab->len = 0;
}
static void abAppend(struct abuf *ab, const char *s, int len)
{
char *new = mem_realloc(ab->b, ab->len + len);
if (new == NULL)
return;
memcpy(new + ab->len, s, len);
ab->b = new;
ab->len += len;
}
static void abFree(struct abuf *ab)
{
mem_free(ab->b);
}
/* Single line low level line refresh. /* Single line low level line refresh.
* *
@ -259,85 +246,76 @@ static void abFree(struct abuf *ab)
* *
* Flags is REFRESH_* macros. The function can just remove the old * Flags is REFRESH_* macros. The function can just remove the old
* prompt, just write it, or both. */ * prompt, just write it, or both. */
static void refreshSingleLine(struct s_line_state *l, int flags) void linenoise_refresh_single_line(t_line_state *l, t_line_flags flags)
{ {
char seq[64]; size_t prompt_len = strlen(l->prompt);
size_t plen = strlen(l->prompt); t_str input_buf = l->buf;
int fd = l->output_fd; size_t input_len = l->len;
char *buf = l->buf; size_t cursor_pos = l->pos;
size_t len = l->len; t_string str;
size_t pos = l->pos;
struct abuf ab;
while ((plen + pos) >= l->columns) while ((prompt_len + cursor_pos) >= l->columns)
{ {
buf++; input_buf++;
len--; input_len--;
pos--; cursor_pos--;
}
while (plen + len > l->columns)
{
len--;
} }
while (prompt_len + input_len > l->columns)
input_len--;
abInit(&ab); str = string_new(16);
/* Cursor to left edge */ string_push_char(&str, '\r');
snprintf(seq, sizeof(seq), "\r");
abAppend(&ab, seq, strlen(seq));
if (flags & REFRESH_WRITE) if (flags & REFRESH_WRITE)
{ {
/* Write the prompt and the current buffer content */ /* Write the prompt and the current buffer content */
abAppend(&ab, l->prompt, strlen(l->prompt)); string_push(&str, l->prompt);
abAppend(&ab, buf, len); string_push(&str, input_buf); // , len);
} }
string_push(&str, "\x1b[0K");
/* Erase to right */ /* Erase to right */
snprintf(seq, sizeof(seq), "\x1b[0K");
abAppend(&ab, seq, strlen(seq));
if (flags & REFRESH_WRITE) if (flags & REFRESH_WRITE)
{ {
/* Move cursor to original position. */ /* Move cursor to original position. */
snprintf(seq, sizeof(seq), "\r\x1b[%dC", (int)(pos + plen)); // TODO: finish this line with me_printf_str
abAppend(&ab, seq, strlen(seq)); me_printf_str(&str, "\r\x1b[%dC", (int)(cursor_pos + prompt_len));
} }
if (write(fd, ab.b, ab.len) == -1) me_eprintf("refresh single line;\n");
{ me_printf_fd(l->output_fd, "%s", str.buf);
} /* Can't recover from write error. */ string_free(str);
abFree(&ab);
} }
/* Calls the two low level functions refreshSingleLine() or /* Calls the two low level functions refreshSingleLine() or
* refreshMultiLine() according to the selected mode. */ * refreshMultiLine() according to the selected mode. */
static void refreshLineWithFlags(struct s_line_state *l, int flags) void linenoise_refresh_line_with_flags(t_line_state *l, t_line_flags flags)
{ {
refreshSingleLine(l, flags); linenoise_refresh_single_line(l, flags);
} }
/* Utility function to avoid specifying REFRESH_ALL all the times. */ /* Utility function to avoid specifying REFRESH_ALL all the times. */
static void refreshLine(struct s_line_state *l) void linenoise_refresh_line(t_line_state *l)
{ {
refreshLineWithFlags(l, REFRESH_ALL); linenoise_refresh_line_with_flags(l, REFRESH_ALL);
} }
/* Hide the current line, when using the multiplexing API. */ /* Hide the current line, when using the multiplexing API. */
void linenoiseHide(struct s_line_state *l) void linenoise_hide(t_line_state *l)
{ {
refreshSingleLine(l, REFRESH_CLEAN); linenoise_refresh_single_line(l, REFRESH_CLEAN);
} }
/* Show the current line, when using the multiplexing API. */ /* Show the current line, when using the multiplexing API. */
void linenoiseShow(struct s_line_state *l) void linenoise_show(t_line_state *l)
{ {
refreshLineWithFlags(l, REFRESH_WRITE); linenoise_refresh_line_with_flags(l, REFRESH_WRITE);
} }
/* Insert the character 'c' at cursor current position. /* Insert the character 'c' at cursor current position.
* *
* On error writing to the terminal -1 is returned, otherwise 0. */ * On error writing to the terminal -1 is returned, otherwise 0. */
int linenoiseEditInsert(struct s_line_state *l, char c) t_error linenoise_edit_insert(t_line_state *l, char c)
{ {
if (l->len < l->buflen) if (l->len < l->buflen)
{ {
@ -347,7 +325,7 @@ int linenoiseEditInsert(struct s_line_state *l, char c)
l->pos++; l->pos++;
l->len++; l->len++;
l->buf[l->len] = '\0'; l->buf[l->len] = '\0';
refreshLine(l); linenoise_refresh_line(l);
} }
else else
{ {
@ -356,49 +334,49 @@ int linenoiseEditInsert(struct s_line_state *l, char c)
l->len++; l->len++;
l->pos++; l->pos++;
l->buf[l->len] = '\0'; l->buf[l->len] = '\0';
refreshLine(l); linenoise_refresh_line(l);
} }
} }
return 0; return (NO_ERROR);
} }
/* Move cursor on the left. */ /* Move cursor on the left. */
void linenoiseEditMoveLeft(struct s_line_state *l) void linenoise_edit_move_left(t_line_state *l)
{ {
if (l->pos > 0) if (l->pos > 0)
{ {
l->pos--; l->pos--;
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Move cursor on the right. */ /* Move cursor on the right. */
void linenoiseEditMoveRight(struct s_line_state *l) void linenoise_edit_move_right(t_line_state *l)
{ {
if (l->pos != l->len) if (l->pos != l->len)
{ {
l->pos++; l->pos++;
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Move cursor to the start of the line. */ /* Move cursor to the start of the line. */
void linenoiseEditMoveHome(struct s_line_state *l) void linenoiseEditMoveHome(t_line_state *l)
{ {
if (l->pos != 0) if (l->pos != 0)
{ {
l->pos = 0; l->pos = 0;
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Move cursor to the end of the line. */ /* Move cursor to the end of the line. */
void linenoiseEditMoveEnd(struct s_line_state *l) void linenoise_edit_move_end(t_line_state *l)
{ {
if (l->pos != l->len) if (l->pos != l->len)
{ {
l->pos = l->len; l->pos = l->len;
refreshLine(l); linenoise_refresh_line(l);
} }
} }
@ -406,7 +384,7 @@ void linenoiseEditMoveEnd(struct s_line_state *l)
* entry as specified by 'dir'. */ * entry as specified by 'dir'. */
#define LINENOISE_HISTORY_NEXT 0 #define LINENOISE_HISTORY_NEXT 0
#define LINENOISE_HISTORY_PREV 1 #define LINENOISE_HISTORY_PREV 1
void linenoiseEditHistoryNext(struct s_line_state *l, int dir) void linenoise_edit_history_next(t_line_state *l, int dir)
{ {
t_vec_str *history; t_vec_str *history;
@ -425,7 +403,7 @@ void linenoiseEditHistoryNext(struct s_line_state *l, int dir)
l->history_index = 0; l->history_index = 0;
return; return;
} }
else if (l->history_index >= history->len) else if ((t_usize)l->history_index >= history->len)
{ {
l->history_index = history->len - 1; l->history_index = history->len - 1;
return; return;
@ -433,25 +411,25 @@ void linenoiseEditHistoryNext(struct s_line_state *l, int dir)
strncpy(l->buf, history->buffer[history->len - 1 - l->history_index], l->buflen); strncpy(l->buf, history->buffer[history->len - 1 - l->history_index], l->buflen);
l->buf[l->buflen - 1] = '\0'; l->buf[l->buflen - 1] = '\0';
l->len = l->pos = strlen(l->buf); l->len = l->pos = strlen(l->buf);
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Delete the character at the right of the cursor without altering the cursor /* Delete the character at the right of the cursor without altering the cursor
* position. Basically this is what happens with the "Delete" keyboard key. */ * position. Basically this is what happens with the "Delete" keyboard key. */
void linenoiseEditDelete(struct s_line_state *l) void linenoise_edit_delete(t_line_state *l)
{ {
if (l->len > 0 && l->pos < l->len) if (l->len > 0 && l->pos < l->len)
{ {
memmove(l->buf + l->pos, l->buf + l->pos + 1, l->len - l->pos - 1); memmove(l->buf + l->pos, l->buf + l->pos + 1, l->len - l->pos - 1);
l->len--; l->len--;
l->buf[l->len] = '\0'; l->buf[l->len] = '\0';
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Backspace implementation. */ /* Backspace implementation. */
void linenoiseEditBackspace(struct s_line_state *l) void linenoise_edit_backspace(t_line_state *l)
{ {
if (l->pos > 0 && l->len > 0) if (l->pos > 0 && l->len > 0)
{ {
@ -459,13 +437,13 @@ void linenoiseEditBackspace(struct s_line_state *l)
l->pos--; l->pos--;
l->len--; l->len--;
l->buf[l->len] = '\0'; l->buf[l->len] = '\0';
refreshLine(l); linenoise_refresh_line(l);
} }
} }
/* Delete the previosu word, maintaining the cursor at the start of the /* Delete the previosu word, maintaining the cursor at the start of the
* current word. */ * current word. */
void linenoiseEditDeletePrevWord(struct s_line_state *l) void linenoise_edit_delete_prev_word(t_line_state *l)
{ {
size_t old_pos = l->pos; size_t old_pos = l->pos;
size_t diff; size_t diff;
@ -477,7 +455,7 @@ void linenoiseEditDeletePrevWord(struct s_line_state *l)
diff = old_pos - l->pos; diff = old_pos - l->pos;
memmove(l->buf + l->pos, l->buf + old_pos, l->len - old_pos + 1); memmove(l->buf + l->pos, l->buf + old_pos, l->len - old_pos + 1);
l->len -= diff; l->len -= diff;
refreshLine(l); linenoise_refresh_line(l);
} }
/* This function is part of the multiplexed API of Linenoise, that is used /* This function is part of the multiplexed API of Linenoise, that is used
@ -504,25 +482,24 @@ void linenoiseEditDeletePrevWord(struct s_line_state *l)
* fails. If stdin_fd or stdout_fd are set to -1, the default is to use * fails. If stdin_fd or stdout_fd are set to -1, the default is to use
* STDIN_FILENO and STDOUT_FILENO. * STDIN_FILENO and STDOUT_FILENO.
*/ */
int linenoiseEditStart(struct s_line_state *l, int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) t_error linenoise_edit_start(t_line_state *l, t_fd *stdin_fd, t_fd *stdout_fd, char *buf, size_t buflen, t_const_str prompt)
{ {
/* Populate the linenoise state that we pass to functions implementing /* Populate the linenoise state that we pass to functions implementing
* specific editing functionalities. */ * specific editing functionalities. */
l->in_completion = 0; l->input_fd = stdin_fd;
l->input_fd = stdin_fd != -1 ? stdin_fd : STDIN_FILENO; l->output_fd = stdout_fd;
l->output_fd = stdout_fd != -1 ? stdout_fd : STDOUT_FILENO;
l->buf = buf; l->buf = buf;
l->buflen = buflen; l->buflen = buflen;
l->prompt = prompt; l->prompt = prompt;
l->prompt_len = strlen(prompt); l->prompt_len = strlen(prompt);
l->oldpos = l->pos = 0; l->old_pos = l->pos = 0;
l->len = 0; l->len = 0;
// /* Enter raw mode. */ // /* Enter raw mode. */
// if (enableRawMode(l->ifd) == -1) // if (enableRawMode(l->ifd) == -1)
// return -1; // return -1;
l->columns = getColumns(stdin_fd, stdout_fd); l->columns = linenoise_get_columns(stdin_fd, stdout_fd);
l->old_rows = 0; l->old_rows = 0;
l->history_index = 0; l->history_index = 0;
@ -533,16 +510,16 @@ int linenoiseEditStart(struct s_line_state *l, int stdin_fd, int stdout_fd, char
/* If stdin is not a tty, stop here with the initialization. We /* If stdin is not a tty, stop here with the initialization. We
* will actually just read a line from standard input in blocking * will actually just read a line from standard input in blocking
* mode later, in linenoiseEditFeed(). */ * mode later, in linenoiseEditFeed(). */
if (!isatty(l->input_fd)) if (!isatty(l->input_fd->fd))
return 0; return 0;
/* The latest history entry is always our current buffer, that /* The latest history entry is always our current buffer, that
* initially is just an empty string. */ * initially is just an empty string. */
linenoise_history_add(""); linenoise_history_add("");
if (write(l->output_fd, prompt, l->prompt_len) == -1) if (write_fd(l->output_fd, (t_u8 *)prompt, l->prompt_len, NULL))
return -1; return (ERROR);
return 0; return (NO_ERROR);
} }
char *linenoiseEditMore = "If you see this, you are misusing the API: when linenoiseEditFeed() is called, if it returns linenoiseEditMore " char *linenoiseEditMore = "If you see this, you are misusing the API: when linenoiseEditFeed() is called, if it returns linenoiseEditMore "
@ -566,79 +543,64 @@ char *linenoiseEditMore = "If you see this, you are misusing the API: when linen
* *
* Some other errno: I/O error. * Some other errno: I/O error.
*/ */
char *linenoiseEditFeed(struct s_line_state *l) t_str linenoise_edit_feed(t_line_state *l)
{ {
/* Not a TTY, pass control to line reading without character /* Not a TTY, pass control to line reading without character
* count limits. */ * count limits. */
if (!isatty(l->input_fd)) if (!isatty(l->input_fd->fd))
return linenoiseNoTTY(); return linenoise_no_tty_impl();
char c; char c;
int nread; t_isize nread;
char seq[3]; char seq[3];
t_vec_str *history = get_history(); t_vec_str *history = get_history();
if (read_fd(l->input_fd, (t_u8 *)&c, 1, &nread))
nread = read(l->input_fd, &c, 1); return (printf("null1\n"), NULL);
if (nread <= 0)
return NULL;
switch (c) switch (c)
{ {
case ENTER: /* enter */ case K_ENTER: /* enter */
history->len--; history->len--;
mem_free(history->buffer[history->len]); mem_free(history->buffer[history->len]);
return strdup(l->buf); return strdup(l->buf);
case CTRL_C: /* ctrl-c */ case K_CTRL_C: /* ctrl-c */
errno = EAGAIN; errno = EAGAIN;
return NULL; return NULL;
case BACKSPACE: /* backspace */ case K_BACKSPACE: /* backspace */
case 8: /* ctrl-h */ case 8: /* ctrl-h */
linenoiseEditBackspace(l); linenoise_edit_backspace(l);
break; break;
case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the case K_CTRL_D: /* ctrl-d, remove char at right of cursor, or if the
line is empty, act as end-of-file. */ line is empty, act as end-of-file. */
if (l->len > 0) if (l->len > 0)
{ linenoise_edit_delete(l);
linenoiseEditDelete(l);
}
else else
{ {
history->len--; history->len--;
mem_free(history->buffer[history->len]); mem_free(history->buffer[history->len]);
errno = ENOENT; errno = ENOENT;
return NULL; return (NULL);
} }
break; break;
case CTRL_T: /* ctrl-t, swaps current character with previous. */ case K_CTRL_B: /* ctrl-b */
if (l->pos > 0 && l->pos < l->len) linenoise_edit_move_left(l);
{
int aux = l->buf[l->pos - 1];
l->buf[l->pos - 1] = l->buf[l->pos];
l->buf[l->pos] = aux;
if (l->pos != l->len - 1)
l->pos++;
refreshLine(l);
}
break; break;
case CTRL_B: /* ctrl-b */ case K_CTRL_F: /* ctrl-f */
linenoiseEditMoveLeft(l); linenoise_edit_move_right(l);
break; break;
case CTRL_F: /* ctrl-f */ case K_CTRL_P: /* ctrl-p */
linenoiseEditMoveRight(l); linenoise_edit_history_next(l, LINENOISE_HISTORY_PREV);
break; break;
case CTRL_P: /* ctrl-p */ case K_CTRL_N: /* ctrl-n */
linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV); linenoise_edit_history_next(l, LINENOISE_HISTORY_NEXT);
break; break;
case CTRL_N: /* ctrl-n */ case K_ESC: /* escape sequence */
linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT);
break;
case ESC: /* escape sequence */
/* Read the next two bytes representing the escape sequence. /* Read the next two bytes representing the escape sequence.
* Use two calls to handle slow terminals returning the two * Use two calls to handle slow terminals returning the two
* chars at different times. */ * chars at different times. */
if (read(l->input_fd, seq, 1) == -1) if (read_fd(l->input_fd, (t_u8 *)seq, 1, NULL))
break; break;
if (read(l->input_fd, seq + 1, 1) == -1) if (read_fd(l->input_fd, (t_u8 *)(seq + 1), 1, NULL))
break; break;
/* ESC [ sequences. */ /* ESC [ sequences. */
@ -647,39 +609,32 @@ char *linenoiseEditFeed(struct s_line_state *l)
if (seq[1] >= '0' && seq[1] <= '9') if (seq[1] >= '0' && seq[1] <= '9')
{ {
/* Extended escape, read additional byte. */ /* Extended escape, read additional byte. */
if (read(l->input_fd, seq + 2, 1) == -1) if (read_fd(l->input_fd, (t_u8 *)(seq + 2), 1, NULL))
break; break;
if (seq[2] == '~') if (seq[1] == '3' && seq[2] == '~')
{ linenoise_edit_delete(l);
switch (seq[1])
{
case '3': /* Delete key. */
linenoiseEditDelete(l);
break;
}
}
} }
else else
{ {
switch (seq[1]) switch (seq[1])
{ {
case 'A': /* Up */ case 'A': /* Up */
linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV); linenoise_edit_history_next(l, LINENOISE_HISTORY_PREV);
break; break;
case 'B': /* Down */ case 'B': /* Down */
linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT); linenoise_edit_history_next(l, LINENOISE_HISTORY_NEXT);
break; break;
case 'C': /* Right */ case 'C': /* Right */
linenoiseEditMoveRight(l); linenoise_edit_move_right(l);
break; break;
case 'D': /* Left */ case 'D': /* Left */
linenoiseEditMoveLeft(l); linenoise_edit_move_left(l);
break; break;
case 'H': /* Home */ case 'H': /* Home */
linenoiseEditMoveHome(l); linenoiseEditMoveHome(l);
break; break;
case 'F': /* End*/ case 'F': /* End*/
linenoiseEditMoveEnd(l); linenoise_edit_move_end(l);
break; break;
} }
} }
@ -694,37 +649,37 @@ char *linenoiseEditFeed(struct s_line_state *l)
linenoiseEditMoveHome(l); linenoiseEditMoveHome(l);
break; break;
case 'F': /* End*/ case 'F': /* End*/
linenoiseEditMoveEnd(l); linenoise_edit_move_end(l);
break; break;
} }
} }
break; break;
default: default:
if (linenoiseEditInsert(l, c)) if (linenoise_edit_insert(l, c))
return NULL; return NULL;
break; break;
case CTRL_U: /* Ctrl+u, delete the whole line. */ case K_CTRL_U: /* Ctrl+u, delete the whole line. */
l->buf[0] = '\0'; l->buf[0] = '\0';
l->pos = l->len = 0; l->pos = l->len = 0;
refreshLine(l); linenoise_refresh_line(l);
break; break;
case CTRL_K: /* Ctrl+k, delete from current to end of line. */ case K_CTRL_K: /* Ctrl+k, delete from current to end of line. */
l->buf[l->pos] = '\0'; l->buf[l->pos] = '\0';
l->len = l->pos; l->len = l->pos;
refreshLine(l); linenoise_refresh_line(l);
break; break;
case CTRL_A: /* Ctrl+a, go to the start of the line */ case K_CTRL_A: /* Ctrl+a, go to the start of the line */
linenoiseEditMoveHome(l); linenoiseEditMoveHome(l);
break; break;
case CTRL_E: /* ctrl+e, go to the end of the line */ case K_CTRL_E: /* ctrl+e, go to the end of the line */
linenoiseEditMoveEnd(l); linenoise_edit_move_end(l);
break; break;
case CTRL_L: /* ctrl+l, clear screen */ case K_CTRL_L: /* ctrl+l, clear screen */
linenoiseClearScreen(); linenoise_clear_screen(l->output_fd);
refreshLine(l); linenoise_refresh_line(l);
break; break;
case CTRL_W: /* ctrl+w, delete previous word */ case K_CTRL_W: /* ctrl+w, delete previous word */
linenoiseEditDeletePrevWord(l); linenoise_edit_delete_prev_word(l);
break; break;
} }
return linenoiseEditMore; return linenoiseEditMore;
@ -734,33 +689,30 @@ char *linenoiseEditFeed(struct s_line_state *l)
* for more information. This function is called when linenoiseEditFeed() * for more information. This function is called when linenoiseEditFeed()
* returns something different than NULL. At this point the user input * returns something different than NULL. At this point the user input
* is in the buffer, and we can restore the terminal in normal mode. */ * is in the buffer, and we can restore the terminal in normal mode. */
void linenoiseEditStop(struct s_line_state *l) void linenoiseEditStop(t_line_state *l)
{ {
if (!isatty(l->input_fd)) if (!isatty(l->input_fd->fd))
return; return;
// disableRawMode(l->ifd); linenoise_disable_raw_mode(l->input_fd);
printf("\n"); me_printf_fd(l->output_fd, "\n");
} }
/* This just implements a blocking loop for the multiplexed API. /* This just implements a blocking loop for the multiplexed API.
* In many applications that are not event-drivern, we can just call * In many applications that are not event-drivern, we can just call
* the blocking linenoise API, wait for the user to complete the editing * the blocking linenoise API, wait for the user to complete the editing
* and return the buffer. */ * and return the buffer. */
static char *linenoiseBlockingEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) char *linenoise_blocking_edit(t_fd *stdin_fd, t_fd *stdout_fd, char *buf, size_t buflen, t_const_str prompt)
{ {
t_line_state l; t_line_state l;
/* Editing without a buffer is invalid. */ /* Editing without a buffer is invalid. */
if (buflen == 0) if (buflen == 0)
{ return (errno = EINVAL, NULL);
errno = EINVAL;
return (NULL);
}
linenoiseEditStart(&l, stdin_fd, stdout_fd, buf, buflen, prompt); linenoise_edit_start(&l, stdin_fd, stdout_fd, buf, buflen, prompt);
char *res; char *res;
while ((res = linenoiseEditFeed(&l)) == linenoiseEditMore) while ((res = linenoise_edit_feed(&l)) == linenoiseEditMore)
; ; // printf("edit\n");
linenoiseEditStop(&l); linenoiseEditStop(&l);
return res; return res;
} }
@ -802,7 +754,7 @@ void linenoisePrintKeyCodes(void)
* program using linenoise is called in pipe or with a file redirected * program using linenoise is called in pipe or with a file redirected
* to its standard input. In this case, we want to be able to return the * to its standard input. In this case, we want to be able to return the
* line regardless of its length (by default we are limited to 4k). */ * line regardless of its length (by default we are limited to 4k). */
static t_str linenoiseNoTTY(void) t_str linenoise_no_tty_impl(void)
{ {
t_string line; t_string line;
t_isize ret; t_isize ret;
@ -812,8 +764,7 @@ static t_str linenoiseNoTTY(void)
while (true) while (true)
{ {
chr = '\n'; chr = '\n';
ret = read(STDIN_FILENO, &chr, 1); if (read_fd(get_stdin(), (t_u8 *)&chr, 1, &ret))
if (ret < 0)
return (string_free(line), NULL); return (string_free(line), NULL);
if (ret == 0 || chr == '\n') if (ret == 0 || chr == '\n')
return (line.buf); return (line.buf);
@ -827,20 +778,21 @@ static t_str linenoiseNoTTY(void)
* for a blacklist of stupid terminals, and later either calls the line * for a blacklist of stupid terminals, and later either calls the line
* editing function or uses dummy fgets() so that you will be able to type * editing function or uses dummy fgets() so that you will be able to type
* something even in the most desperate of the conditions. */ * something even in the most desperate of the conditions. */
char *linenoise(const char *prompt) t_str linenoise(const char *prompt)
{ {
char buf[4096]; char buf[4096];
t_str retval;
if (!isatty(STDIN_FILENO)) if (!isatty(get_stdin()->fd))
{ {
printf("not_tty\n");
/* Not a tty: read from file / pipe. In this mode we don't want any /* Not a tty: read from file / pipe. In this mode we don't want any
* limit to the line size, so we call a function to handle that. */ * limit to the line size, so we call a function to handle that. */
return linenoiseNoTTY(); return linenoise_no_tty_impl();
}
{
char *retval = linenoiseBlockingEdit(STDIN_FILENO, STDOUT_FILENO, buf, 4096, prompt);
return retval;
} }
printf("is_tty\n");
retval = linenoise_blocking_edit(get_stdin(), get_stdout(), buf, 4096, prompt);
return (retval);
} }
/* This is just a wrapper the user may want to call in order to make sure /* This is just a wrapper the user may want to call in order to make sure
@ -856,21 +808,6 @@ void linenoise_free(void *ptr)
/* ================================ History ================================= */ /* ================================ History ================================= */
/* Free the history, but does not reset it. Only used when we have to
* exit() to avoid memory leaks are reported by valgrind & co. */
static void free_history(void)
{
t_vec_str *history = get_history();
vec_str_free(*history);
}
/* At exit we'll try to fix the terminal to the initial conditions. */
static void linenoise_uninit_lib(void)
{
// disableRawMode(STDIN_FILENO);
free_history();
}
/* This is the API call to add a new entry in the linenoise history. /* This is the API call to add a new entry in the linenoise history.
* It uses a fixed array of char pointers that are shifted (memmoved) * It uses a fixed array of char pointers that are shifted (memmoved)
* when the history max length is reached in order to remove the older * when the history max length is reached in order to remove the older
@ -945,6 +882,7 @@ t_error linenoise_history_load(t_str name)
fd = open_fd(name, FD_READ, FD_CLOSE_ON_EXEC, FP_ALL_READ); fd = open_fd(name, FD_READ, FD_CLOSE_ON_EXEC, FP_ALL_READ);
if (fd == NULL) if (fd == NULL)
return (ERROR); return (ERROR);
history = get_history();
while (!gnl_wrapper(fd, &tmp)) while (!gnl_wrapper(fd, &tmp))
{ {
while (tmp.len != 0 && (tmp.buf[tmp.len - 1] == '\n' || tmp.buf[tmp.len - 1] == '\r')) while (tmp.len != 0 && (tmp.buf[tmp.len - 1] == '\n' || tmp.buf[tmp.len - 1] == '\r'))

5
sources/main.c
View file

@ -6,13 +6,14 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */ /* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */ /* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */
/* Updated: 2024/07/03 21:23:17 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 18:25:43 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "app/env.h" #include "app/env.h"
#include "app/node.h" #include "app/node.h"
#include "app/signal_handler.h" #include "app/signal_handler.h"
#include "line/line.h"
#include "me/hashmap/hashmap_env.h" #include "me/hashmap/hashmap_env.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/types.h" #include "me/types.h"
@ -128,7 +129,7 @@ void ft_take_args(t_utils *shcat)
while (1) while (1)
{ {
shcat->str_input = NULL; shcat->str_input = NULL;
cmd = readline((t_const_str)shcat->name_shell); cmd = linenoise((t_const_str)shcat->name_shell);
if (cmd == NULL) if (cmd == NULL)
ft_exit(shcat, 0); ft_exit(shcat, 0);
shcat->str_input = str_clone(cmd); shcat->str_input = str_clone(cmd);

34
stdme/include/me/fs/fs.h
View file

@ -6,14 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/19 15:12:18 by maiboyer #+# #+# */ /* Created: 2024/05/19 15:12:18 by maiboyer #+# #+# */
/* Updated: 2024/05/24 15:03:40 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:50:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef FS_H #ifndef FS_H
#define FS_H #define FS_H
#include "me/fs/read_to_vec.h"
#include "me/types.h" #include "me/types.h"
#include <dirent.h> #include <dirent.h>
#include <fcntl.h> #include <fcntl.h>
@ -78,8 +77,8 @@ typedef enum e_file_open_option
/// `G` means group /// `G` means group
/// `U` means user /// `U` means user
/// `ALL` means all /// `ALL` means all
/// There are the raw permission, you can combine them to get the permission you want /// There are the raw permission, you can combine them to get the permission you
/// And there are "aliases" that are common permission set /// want And there are "aliases" that are common permission set
/// @note you can combine them with the `|` operator /// @note you can combine them with the `|` operator
typedef enum e_file_perm typedef enum e_file_perm
{ {
@ -139,7 +138,6 @@ union u_file_slot {
t_file file; t_file file;
}; };
/// @brief File slot structure /// @brief File slot structure
/// ty: the type of the slot /// ty: the type of the slot
/// slot: the slot itself /// slot: the slot itself
@ -164,9 +162,9 @@ typedef t_const_str t_mode;
/// @note this is a simple typedef because I hate the struct keyword /// @note this is a simple typedef because I hate the struct keyword
typedef struct stat t_stat; typedef struct stat t_stat;
/// @brief Directory entry structure /// @brief Directory entry structure
/// @note this is a simple typedef because I hate the struct keyword and it is always behind a pointer /// @note this is a simple typedef because I hate the struct keyword and it is
/// always behind a pointer
typedef struct dirent *t_dir_entry; typedef struct dirent *t_dir_entry;
/*_____ _ _ _______ ______ _____ _ _ _ /*_____ _ _ _______ ______ _____ _ _ _
@ -187,7 +185,6 @@ t_fd_array *get_fd_arrays(void);
/// @note Will abort if no slot is available /// @note Will abort if no slot is available
struct s_file_slot *get_unused_fd_slot(void); struct s_file_slot *get_unused_fd_slot(void);
/// @brief Close all slots /// @brief Close all slots
/// @note This is probably NOT what you want /// @note This is probably NOT what you want
void close_all_slots(void); void close_all_slots(void);
@ -197,7 +194,6 @@ void close_all_slots(void);
/// @note this is probably NOT what you want /// @note this is probably NOT what you want
void close_slot(struct s_file_slot *slot); void close_slot(struct s_file_slot *slot);
/* ______ _____ /* ______ _____
| ____| __ \ | ____| __ \
| |__ | | | | | |__ | | | |
@ -263,7 +259,6 @@ void put_char_fd(t_fd *fd, t_u8 c);
|_____/_____|_| \_\______\_____| |_| \____/|_| \_\ |_| |_____/_____|_| \_\______\_____| |_| \____/|_| \_\ |_|
*/ */
/// @brief Open a file /// @brief Open a file
/// @param[in] name the name of the file /// @param[in] name the name of the file
/// @param[out] dir the file structure to fill /// @param[out] dir the file structure to fill
@ -304,7 +299,8 @@ t_error open_file(t_str name, t_mode mode, t_file **file);
/// @param[in] size the size of the buffer /// @param[in] size the size of the buffer
/// @param[out] read_count the number of bytes read /// @param[out] read_count the number of bytes read
/// @return true on error, false otherwise /// @return true on error, false otherwise
t_error read_file(t_file *file, t_u8 *buffer, t_usize size, t_isize *read_count); t_error read_file(t_file *file, t_u8 *buffer, t_usize size,
t_isize *read_count);
/// @brief Write to a file /// @brief Write to a file
/// @param[in] file the file to write to /// @param[in] file the file to write to
@ -313,11 +309,25 @@ t_error read_file(t_file *file, t_u8 *buffer, t_usize size, t_isize *read_count)
/// @param[out] write_count the number of bytes written /// @param[out] write_count the number of bytes written
/// @return true on error, false otherwise /// @return true on error, false otherwise
/// @note write_count can be NULL /// @note write_count can be NULL
t_error write_file(t_file *file, t_u8 *buffer, t_usize size, t_isize *write_count); t_error write_file(t_file *file, t_u8 *buffer, t_usize size,
t_isize *write_count);
/// @brief Close the underlying file stream /// @brief Close the underlying file stream
/// @param[in] file the file to close /// @param[in] file the file to close
/// @note Will close the file and free the slot /// @note Will close the file and free the slot
void close_file(t_file *file); void close_file(t_file *file);
/* _____ ______ _______ _______ ______ _____ _____
/ ____| ____|__ __|__ __| ____| __ \ / ____|
| | __| |__ | | | | | |__ | |__) | (___
| | |_ | __| | | | | | __| | _ / \___ \
| |__| | |____ | | | | | |____| | \ \ ____) |
\_____|______| |_| |_| |______|_| \_\_____/
*/
//TODO: Documentation!
t_fd *get_stdin(void);
t_fd *get_stdout(void);
t_fd *get_stderr(void);
#endif /* FS_H */ #endif /* FS_H */

8
stdme/include/me/os/process.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */ /* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */
/* Updated: 2024/01/06 18:39:58 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 18:25:23 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -29,14 +29,14 @@ enum e_redirection
union u_redirection union u_redirection
{ {
struct s_fd struct s_fd_redirection
{ {
int value; int value;
} fd; } fd;
struct s_piped struct s_piped_redirection
{ {
} piped; } piped;
struct s_inherited struct s_inherited_redirection
{ {
} inherited; } inherited;
}; };

81
stdme/include/me/printf/_internal_printf.h Normal file
View file

@ -0,0 +1,81 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* _internal_printf.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/07 17:36:38 by maiboyer #+# #+# */
/* Updated: 2024/07/07 18:01:17 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef _INTERNAL_PRINTF_H
#define _INTERNAL_PRINTF_H
#include "me/fs/fs.h"
#include "me/string/string.h"
#include "me/types.h"
typedef enum e_printf_flags t_printf_flags;
typedef enum e_printf_type t_printf_type;
typedef struct s_fprintf_arg t_fprintf_arg;
typedef struct s_printf_args t_printf_arg;
typedef struct s_printf_extra_args t_printf_extra_args;
typedef struct s_sprintf_arg t_sprintf_arg;
typedef void (*t_printf_func)(t_const_str to_write, t_usize to_write_len,
void *p_args);
struct s_fprintf_arg
{
t_usize total_print;
t_fd *fd;
};
struct s_sprintf_arg
{
t_usize total_print;
t_string *buffer;
};
enum e_printf_flags
{
PRECISION = 1 << 1,
ALIGN = 1 << 2,
ZERO_ALIGN = 1 << 3,
SIGN = 1 << 4,
};
enum e_printf_type
{
CHAR = 1 << 0,
STR = 1 << 1,
U64 = 1 << 2,
I64 = 1 << 3,
VOID_PTR = 1 << 4,
I32 = 1 << 5,
U32 = 1 << 6,
};
struct s_printf_extra_args
{
t_u64 precision;
t_u64 align;
bool left_align;
bool space_align;
bool pretty;
};
struct s_printf_args
{
void *argument;
void *p_args;
t_printf_extra_args extra;
t_printf_flags flags;
};
void me_printf_write(t_const_str to_write, t_usize to_write_len, void *p_args);
void me_printf_append_string(t_const_str to_write, t_usize to_write_len,
void *p_args);
#endif /* _INTERNAL_PRINTF_H */

5
stdme/include/me/printf/formatter/formatter.h
View file

@ -6,14 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:18:19 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:18:19 by maiboyer #+# #+# */
/* Updated: 2023/11/18 19:11:23 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:38:52 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef FORMATTER_H #ifndef FORMATTER_H
# define FORMATTER_H # define FORMATTER_H
# include "me/printf/printf.h" # include "me/printf/_internal_printf.h"
# include "me/types.h"
void printf_x_low(t_printf_arg data, t_printf_func f); void printf_x_low(t_printf_arg data, t_printf_func f);
void printf_x_up(t_printf_arg data, t_printf_func f); void printf_x_up(t_printf_arg data, t_printf_func f);

4
stdme/include/me/printf/formatter/utils.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 17:58:41 by maiboyer #+# #+# */ /* Created: 2023/11/16 17:58:41 by maiboyer #+# #+# */
/* Updated: 2023/12/01 21:24:21 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:38:49 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -14,7 +14,7 @@
# define UTILS_H # define UTILS_H
# include "me/printf/matchers/matchers.h" # include "me/printf/matchers/matchers.h"
# include "me/printf/printf.h" # include "me/printf/_internal_printf.h"
# include "me/types.h" # include "me/types.h"
# include <stdarg.h> # include <stdarg.h>

4
stdme/include/me/printf/matchers/matchers.h
View file

@ -6,14 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:09:07 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:09:07 by maiboyer #+# #+# */
/* Updated: 2023/11/18 18:10:33 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:38:46 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef MATCHERS_H #ifndef MATCHERS_H
# define MATCHERS_H # define MATCHERS_H
# include "me/printf/printf.h" # include "me/printf/_internal_printf.h"
# include "me/types.h" # include "me/types.h"
# include <stdarg.h> # include <stdarg.h>
# define PRINTF_BUFFER_CHUNK 20 # define PRINTF_BUFFER_CHUNK 20

64
stdme/include/me/printf/printf.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:10:27 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:10:27 by maiboyer #+# #+# */
/* Updated: 2024/07/05 19:54:25 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:37:02 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -20,50 +20,9 @@
typedef struct s_fd t_fd; typedef struct s_fd t_fd;
#endif #endif
typedef struct s_fprintf_arg #ifndef STRING_H
{ typedef struct s_string t_string;
t_usize total_print; #endif
int fd;
} t_fprintf_arg;
typedef enum e_printf_flags
{
PRECISION = 1 << 1,
ALIGN = 1 << 2,
ZERO_ALIGN = 1 << 3,
SIGN = 1 << 4,
} t_printf_flags;
typedef enum e_printf_type
{
CHAR = 1 << 0,
STR = 1 << 1,
U64 = 1 << 2,
I64 = 1 << 3,
VOID_PTR = 1 << 4,
I32 = 1 << 5,
U32 = 1 << 6,
} t_printf_type;
typedef struct s_printf_extra_args
{
t_u64 precision;
t_u64 align;
bool left_align;
bool space_align;
bool pretty;
} t_printf_extra_args;
typedef struct s_printf_args
{
void *argument;
void *p_args;
t_printf_extra_args extra;
t_printf_flags flags;
} t_printf_arg;
typedef void (*t_printf_func)(t_const_str to_write,
t_usize to_write_len, void *p_args);
/// @brief Print a formatted string to stdout /// @brief Print a formatted string to stdout
/// @param fmt the format string /// @param fmt the format string
@ -89,7 +48,6 @@ t_usize me_vprintf(t_const_str fmt, va_list *args);
/// @return the number of characters printed /// @return the number of characters printed
t_usize me_veprintf(t_const_str fmt, va_list *args); t_usize me_veprintf(t_const_str fmt, va_list *args);
/// @brief Print a formatted string to the given fd /// @brief Print a formatted string to the given fd
/// @param fmt the format string /// @param fmt the format string
/// @param ... the arguments to format /// @param ... the arguments to format
@ -102,4 +60,18 @@ t_usize me_printf_fd(t_fd *, t_const_str fmt, ...);
/// @return the number of characters printed /// @return the number of characters printed
t_usize me_vprintf_fd(t_fd *, t_const_str fmt, va_list *args); t_usize me_vprintf_fd(t_fd *, t_const_str fmt, va_list *args);
/// @brief print a formatted string to a buffer
/// @param buffer the buffer to append to
/// @param fmt the format string
/// @param ... the arguments to format
/// @return the number of characters printed
t_usize me_printf_str(t_string *buffer, t_const_str fmt, ...);
/// @brief print a formatted string to a buffer
/// @param buffer the buffer to append to
/// @param fmt the format string
/// @param args the arguments to format
/// @return the number of characters printed
t_usize me_vprintf_str(t_string *buffer, t_const_str fmt, va_list *args);
#endif #endif

3
stdme/src.list
View file

@ -73,6 +73,7 @@ os/pipe
os/process os/process
os/process_inner os/process_inner
os/process_inner2 os/process_inner2
printf/callbacks
printf/formatter/char printf/formatter/char
printf/formatter/decimal printf/formatter/decimal
printf/formatter/hex printf/formatter/hex
@ -85,6 +86,8 @@ printf/formatter/utils3
printf/formatter/utils_numbers printf/formatter/utils_numbers
printf/matchers printf/matchers
printf/printf printf/printf
printf/printf_fd
printf/printf_str
printf/vprintf printf/vprintf
str/str_clone str/str_clone
str/str_compare str/str_compare

91
stdme/src/fs/fs_internal.c
View file

@ -6,19 +6,20 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/19 15:53:50 by maiboyer #+# #+# */ /* Created: 2024/05/19 15:53:50 by maiboyer #+# #+# */
/* Updated: 2024/05/30 16:02:12 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 19:17:05 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/types.h"
#include "me/fs/fs.h" #include "me/fs/fs.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/types.h"
#include "unistd.h"
#include <stdio.h>
#include <dirent.h> #include <dirent.h>
#include <sys/stat.h>
#include <errno.h> #include <errno.h>
#include <stdio.h>
#include <sys/stat.h>
t_fd_array *get_fd_arrays(void) t_fd_array *get_fd_arrays(void)
{ {
@ -45,7 +46,7 @@ struct s_file_slot *get_unused_fd_slot(void)
return (NULL); return (NULL);
} }
void close_all_slots(void) __attribute__((destructor(201))) void close_all_slots(void)
{ {
t_usize i; t_usize i;
t_fd_array *arr; t_fd_array *arr;
@ -63,11 +64,11 @@ void close_slot(struct s_file_slot *slot)
if (slot->ty == SLOT_UNUSED) if (slot->ty == SLOT_UNUSED)
; ;
else if (slot->ty == SLOT_FD) else if (slot->ty == SLOT_FD)
close_fd(&slot->slot.fd); (mem_free(slot->slot.fd.name), close_fd(&slot->slot.fd));
else if (slot->ty == SLOT_DIR) else if (slot->ty == SLOT_DIR)
close_dir(&slot->slot.dir); (mem_free(slot->slot.dir.name), close_dir(&slot->slot.dir));
else if (slot->ty == SLOT_FILE) else if (slot->ty == SLOT_FILE)
close_file(&slot->slot.file); (mem_free(slot->slot.file.name), close_file(&slot->slot.file));
else else
(void)!write(2, "Unknown SLOT type", 17); (void)!write(2, "Unknown SLOT type", 17);
mem_set_zero(slot, sizeof(*slot)); mem_set_zero(slot, sizeof(*slot));
@ -113,7 +114,8 @@ t_error read_fd(t_fd *fd, t_u8 *buffer, t_usize size, t_isize *read_count)
{ {
t_isize ret; t_isize ret;
if (fd == NULL || buffer == NULL || read_count == NULL || fd->fd == -1 || !(fd->perms & FD_READ)) if (fd == NULL || buffer == NULL || read_count == NULL || fd->fd == -1 ||
!(fd->perms & FD_READ))
return (ERROR); return (ERROR);
ret = read(fd->fd, buffer, size); ret = read(fd->fd, buffer, size);
if (ret == -1) if (ret == -1)
@ -260,7 +262,8 @@ t_error open_file(t_str name, t_mode mode, t_file **file)
return (NO_ERROR); return (NO_ERROR);
} }
t_error write_file(t_file *file, t_u8 *buffer, t_usize size, t_isize *write_count) t_error write_file(t_file *file, t_u8 *buffer, t_usize size,
t_isize *write_count)
{ {
t_isize ret; t_isize ret;
t_isize fake_ret; t_isize fake_ret;
@ -280,7 +283,8 @@ t_error read_file(t_file *file, t_u8 *buffer, t_usize size, t_isize *read_count)
{ {
t_isize ret; t_isize ret;
if (file == NULL || buffer == NULL || read_count == NULL || file->ptr == NULL) if (file == NULL || buffer == NULL || read_count == NULL ||
file->ptr == NULL)
return (ERROR); return (ERROR);
ret = fread(buffer, size, 1, file->ptr); ret = fread(buffer, size, 1, file->ptr);
if (ret == -1) if (ret == -1)
@ -300,3 +304,68 @@ void close_file(t_file *file)
slot = (void *)(file)-offsetof(struct s_file_slot, slot.file); slot = (void *)(file)-offsetof(struct s_file_slot, slot.file);
mem_set_zero(slot, sizeof(*slot)); mem_set_zero(slot, sizeof(*slot));
} }
/* _____ ______ _______ _______ ______ _____ _____
/ ____| ____|__ __|__ __| ____| __ \ / ____|
| | __| |__ | | | | | |__ | |__) | (___
| | |_ | __| | | | | | __| | _ / \___ \
| |__| | |____ | | | | | |____| | \ \ ____) |
\_____|______| |_| |_| |______|_| \_\_____/
*/
t_fd *get_stdin(void)
{
t_fd *out;
struct s_file_slot *slot;
static t_fd *value = NULL;
if (value == NULL)
{
slot = get_unused_fd_slot();
out = &slot->slot.fd;
out->fd = STDIN_FILENO;
out->perms = FD_READ;
out->name = str_clone("<stdin>");
slot->ty = SLOT_FD;
value = out;
}
return (value);
}
t_fd *get_stdout(void)
{
t_fd *out;
struct s_file_slot *slot;
static t_fd *value = NULL;
if (value == NULL)
{
slot = get_unused_fd_slot();
out = &slot->slot.fd;
out->fd = STDOUT_FILENO;
out->perms = FD_WRITE;
out->name = str_clone("<stdout>");
slot->ty = SLOT_FD;
value = out;
}
return (value);
}
t_fd *get_stderr(void)
{
t_fd *out;
struct s_file_slot *slot;
static t_fd *value = NULL;
if (value == NULL)
{
slot = get_unused_fd_slot();
out = &slot->slot.fd;
out->fd = STDERR_FILENO;
out->perms = FD_WRITE;
out->name = str_clone("<stderr>");
slot->ty = SLOT_FD;
value = out;
}
return (value);
}

10
stdme/src/mem/allocator.c
View file

@ -6,17 +6,16 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/14 18:26:27 by maiboyer #+# #+# */ /* Created: 2024/05/14 18:26:27 by maiboyer #+# #+# */
/* Updated: 2024/05/22 15:21:28 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 19:10:07 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "aq/internal_vg_funcs.h"
#include "me/types.h"
#include "aq/allocator.h" #include "aq/allocator.h"
#include "aq/internal_vg_funcs.h"
#include "aq/libc_wrapper.h" #include "aq/libc_wrapper.h"
#include "aq/melloc.h" #include "aq/melloc.h"
#include "me/types.h"
#include <stdio.h>
t_allocator *global_allocator(void) t_allocator *global_allocator(void)
{ {
@ -31,6 +30,7 @@ t_allocator *global_allocator(void)
return (&global_alloc); return (&global_alloc);
} }
__attribute__((destructor(200)))
void uninit_global_allocator(void) void uninit_global_allocator(void)
{ {
t_allocator *allocator; t_allocator *allocator;

9
stdme/src/os/exit.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/07 13:08:52 by maiboyer #+# #+# */ /* Created: 2024/05/07 13:08:52 by maiboyer #+# #+# */
/* Updated: 2024/05/22 15:05:19 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 19:11:39 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -15,9 +15,12 @@
#include "me/types.h" #include "me/types.h"
#include <stdlib.h> #include <stdlib.h>
// If you are looking at why some stuff aren't closed, they are using the
// __attribute__((dtor)) to be run at exit for example:
// - close_all_slots
// - uninit global allocator
void me_exit(t_i32 exit_code) void me_exit(t_i32 exit_code)
{ {
close_all_slots(); (get_stdin(), get_stdout(), get_stderr());
uninit_global_allocator();
exit(exit_code); exit(exit_code);
} }

35
stdme/src/printf/callbacks.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* callbacks.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/07 18:01:52 by maiboyer #+# #+# */
/* Updated: 2024/07/07 18:03:28 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/fs/fs.h"
#include "me/printf/_internal_printf.h"
#include "me/string/string.h"
#include "me/types.h"
void me_printf_append_string(t_const_str to_write, t_usize to_write_len,
void *p_args)
{
t_sprintf_arg *arg;
arg = p_args;
arg->total_print += to_write_len;
string_push(arg->buffer, to_write);
}
void me_printf_write(t_const_str to_write, t_usize to_write_len, void *p_args)
{
t_fprintf_arg *arg;
arg = (t_fprintf_arg *)p_args;
write_fd(arg->fd, (t_u8 *)to_write, to_write_len, NULL);
arg->total_print += to_write_len;
}

3
stdme/src/printf/formatter/char.c
View file

@ -6,13 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/18 18:12:11 by maiboyer #+# #+# */ /* Created: 2023/11/18 18:12:11 by maiboyer #+# #+# */
/* Updated: 2024/05/14 18:43:13 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:39:40 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/str/str.h" #include "me/str/str.h"
#include <stdlib.h> #include <stdlib.h>

3
stdme/src/printf/formatter/decimal.c
View file

@ -6,14 +6,13 @@
/* By: maix <marvin@42.fr> +#+ +:+ +#+ */ /* By: maix <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/18 01:44:35 by maix #+# #+# */ /* Created: 2023/11/18 01:44:35 by maix #+# #+# */
/* Updated: 2024/05/14 18:43:24 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:39:44 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/str/str.h" #include "me/str/str.h"
#include <stdio.h> #include <stdio.h>

3
stdme/src/printf/formatter/hex.c
View file

@ -6,13 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:16:16 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:16:16 by maiboyer #+# #+# */
/* Updated: 2023/12/11 19:19:03 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#define HEX_INLINE_BUF 17 #define HEX_INLINE_BUF 17

3
stdme/src/printf/formatter/oct.c
View file

@ -6,13 +6,12 @@
/* By: maix <marvin@42.fr> +#+ +:+ +#+ */ /* By: maix <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/18 01:19:18 by maix #+# #+# */ /* Created: 2023/11/18 01:19:18 by maix #+# #+# */
/* Updated: 2023/12/11 19:17:23 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#include <stdio.h> #include <stdio.h>
#define OCT_INLINE_BUF 23 #define OCT_INLINE_BUF 23

3
stdme/src/printf/formatter/ptr.c
View file

@ -6,13 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:16:16 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:16:16 by maiboyer #+# #+# */
/* Updated: 2023/12/11 19:20:42 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#define PTR_INLINE_BUF 17 #define PTR_INLINE_BUF 17

3
stdme/src/printf/formatter/unsigned_decimal.c
View file

@ -6,14 +6,13 @@
/* By: maix <marvin@42.fr> +#+ +:+ +#+ */ /* By: maix <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/18 01:44:35 by maix #+# #+# */ /* Created: 2023/11/18 01:44:35 by maix #+# #+# */
/* Updated: 2024/05/14 18:43:39 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/str/str.h" #include "me/str/str.h"
#include <stdio.h> #include <stdio.h>

4
stdme/src/printf/formatter/utils.c
View file

@ -6,16 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 17:57:04 by maiboyer #+# #+# */ /* Created: 2023/11/16 17:57:04 by maiboyer #+# #+# */
/* Updated: 2024/05/14 18:43:44 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/string/string.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/convert/atoi.h" #include "me/convert/atoi.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/matchers/matchers.h" #include "me/printf/matchers/matchers.h"
#include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/types.h" #include "me/types.h"

4
stdme/src/printf/formatter/utils2.c
View file

@ -6,14 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:00:07 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:00:07 by maiboyer #+# #+# */
/* Updated: 2023/12/01 21:48:22 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:18 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/string/string.h"
#include "me/char/char.h" #include "me/char/char.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/types.h" #include "me/types.h"
void set_var_for_pad_and_stuff(t_pad_and_stuff_args *a, t_printf_arg *d) void set_var_for_pad_and_stuff(t_pad_and_stuff_args *a, t_printf_arg *d)

5
stdme/src/printf/formatter/utils_numbers.c
View file

@ -6,13 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/01 21:05:47 by maiboyer #+# #+# */ /* Created: 2023/12/01 21:05:47 by maiboyer #+# #+# */
/* Updated: 2024/05/14 18:43:56 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:40:12 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/utils.h"
void handle_weird_precision_stuff(t_printf_arg *data, t_prec_strs strs, void handle_weird_precision_stuff(t_printf_arg *data, t_prec_strs strs,
t_usize value) t_usize value)

3
stdme/src/printf/matchers.c
View file

@ -6,14 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 18:07:40 by maiboyer #+# #+# */ /* Created: 2023/11/16 18:07:40 by maiboyer #+# #+# */
/* Updated: 2023/12/11 19:11:51 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 17:39:37 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/formatter/formatter.h" #include "me/printf/formatter/formatter.h"
#include "me/printf/matchers/matchers.h" #include "me/printf/matchers/matchers.h"
#include "me/printf/printf.h"
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

68
stdme/src/printf/printf.c
View file

@ -6,85 +6,37 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/11 17:50:56 by maiboyer #+# #+# */ /* Created: 2023/11/11 17:50:56 by maiboyer #+# #+# */
/* Updated: 2024/02/09 14:58:10 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 18:01:58 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/string/string.h"
#include "me/fs/write.h"
#include "me/printf/formatter/formatter.h"
#include "me/printf/formatter/utils.h"
#include "me/printf/matchers/matchers.h"
#include "me/printf/printf.h" #include "me/printf/printf.h"
#include "me/str/str.h" #include "me/fs/fs.h"
#include "me/fs/write.h"
#include "me/printf/_internal_printf.h"
#include "me/types.h" #include "me/types.h"
#include <limits.h>
#include <stdarg.h> #include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
// p_args is an t_string;
static void me_printf_add_to_string(t_const_str to_write, t_usize to_write_len,
void *p_args)
{
t_string *out_buf;
out_buf = (t_string *)p_args;
(void)(to_write_len);
string_push(out_buf, to_write);
}
t_str me_printf_str(t_const_str fmt, va_list *arguments)
{
t_string out;
out = string_new(str_len(fmt));
if (out.buf == NULL)
{
return (NULL);
}
me_printf_str_inner(fmt, &me_printf_add_to_string, arguments, (void *)&out);
return (out.buf);
}
void me_printf_write(t_const_str to_write, t_usize to_write_len,
void *p_args)
{
t_fprintf_arg *arg;
arg = (t_fprintf_arg *)p_args;
me_write(arg->fd, (t_u8 *)to_write, to_write_len);
arg->total_print += to_write_len;
}
t_usize me_printf(t_const_str fmt, ...) t_usize me_printf(t_const_str fmt, ...)
{ {
va_list args; va_list args;
t_fprintf_arg passthru; t_usize res;
passthru = (t_fprintf_arg){
.fd = 1,
.total_print = 0,
};
va_start(args, fmt); va_start(args, fmt);
me_printf_str_inner(fmt, &me_printf_write, &args, (void *)&passthru); res = me_vprintf(fmt, &args);
va_end(args); va_end(args);
return (passthru.total_print); return (res);
} }
t_usize me_eprintf(t_const_str fmt, ...) t_usize me_eprintf(t_const_str fmt, ...)
{ {
va_list args; va_list args;
t_fprintf_arg passthru; t_usize res;
passthru = (t_fprintf_arg){
.fd = 2,
.total_print = 0,
};
va_start(args, fmt); va_start(args, fmt);
me_printf_str_inner(fmt, &me_printf_write, &args, (void *)&passthru); res = me_veprintf(fmt, &args);
va_end(args); va_end(args);
return (passthru.total_print); return (res);
} }
/* /*

20
stdme/src/printf/printf_fd.c
View file

@ -17,16 +17,14 @@
#include "me/types.h" #include "me/types.h"
#include <stdarg.h> #include <stdarg.h>
void me_printf_write(t_const_str to_write, t_usize to_write_len, void *p_args);
t_usize me_vprintf_fd(t_fd *fd, t_const_str fmt, va_list *args) t_usize me_vprintf_fd(t_fd *fd, t_const_str fmt, va_list *args)
{ {
t_fprintf_arg passthru; t_fprintf_arg passthru;
passthru = (t_fprintf_arg){ if (fd == NULL || fmt == NULL || args == NULL)
.fd = fd->fd, return (0);
.total_print = 0, passthru.fd = fd;
}; passthru.total_print = 0;
me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru); me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru);
return (passthru.total_print); return (passthru.total_print);
} }
@ -34,14 +32,10 @@ t_usize me_vprintf_fd(t_fd *fd, t_const_str fmt, va_list *args)
t_usize me_printf_fd(t_fd *fd, t_const_str fmt, ...) t_usize me_printf_fd(t_fd *fd, t_const_str fmt, ...)
{ {
va_list args; va_list args;
t_fprintf_arg passthru; t_usize res;
passthru = (t_fprintf_arg){
.fd = fd->fd,
.total_print = 0,
};
va_start(args, fmt); va_start(args, fmt);
me_printf_str_inner(fmt, &me_printf_write, &args, (void *)&passthru); res = me_vprintf_fd(fd, fmt, &args);
va_end(args); va_end(args);
return (passthru.total_print); return (res);
} }

41
stdme/src/printf/printf_str.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* printf_str.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/07 17:27:50 by maiboyer #+# #+# */
/* Updated: 2024/07/07 18:03:40 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/printf/_internal_printf.h"
#include "me/printf/formatter/utils.h"
#include "me/printf/printf.h"
#include "me/string/string.h"
#include "me/types.h"
#include <stdarg.h>
t_usize me_vprintf_str(t_string *buf, t_const_str fmt, va_list *args)
{
t_sprintf_arg passthru;
if (buf == NULL || fmt == NULL || args == NULL)
return (0);
passthru.buffer = buf;
passthru.total_print = 0;
me_printf_str_inner(fmt, &me_printf_append_string, args, &passthru);
return (passthru.total_print);
}
t_usize me_printf_str(t_string *buf, t_const_str fmt, ...)
{
t_usize res;
va_list args;
va_start(args, fmt);
res = me_vprintf_str(buf, fmt, &args);
va_end(args);
return (res);
}

30
stdme/src/printf/vprintf.c
View file

@ -6,34 +6,26 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/09 14:57:28 by maiboyer #+# #+# */ /* Created: 2024/02/09 14:57:28 by maiboyer #+# #+# */
/* Updated: 2024/02/09 15:00:39 by maiboyer ### ########.fr */ /* Updated: 2024/07/07 18:00:14 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/string/string.h" #include "me/fs/fs.h"
#include "me/fs/write.h"
#include "me/printf/formatter/formatter.h"
#include "me/printf/formatter/utils.h" #include "me/printf/formatter/utils.h"
#include "me/printf/matchers/matchers.h"
#include "me/printf/printf.h" #include "me/printf/printf.h"
#include "me/str/str.h"
#include "me/types.h" #include "me/types.h"
#include <limits.h>
#include <stdarg.h> #include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
void me_printf_write(t_const_str to_write, t_usize to_write_len, void me_printf_write(t_const_str to_write, t_usize to_write_len, void *p_args);
void *p_args);
t_usize me_vprintf(t_const_str fmt, va_list *args) t_usize me_vprintf(t_const_str fmt, va_list *args)
{ {
t_fprintf_arg passthru; t_fprintf_arg passthru;
passthru = (t_fprintf_arg){ if (fmt == NULL || args == NULL)
.fd = 1, return (0);
.total_print = 0, passthru.fd = get_stdout();
}; passthru.total_print = 0;
me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru); me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru);
return (passthru.total_print); return (passthru.total_print);
} }
@ -42,10 +34,10 @@ t_usize me_veprintf(t_const_str fmt, va_list *args)
{ {
t_fprintf_arg passthru; t_fprintf_arg passthru;
passthru = (t_fprintf_arg){ if (fmt == NULL || args == NULL)
.fd = 2, return (0);
.total_print = 0, passthru.fd = get_stderr();
}; passthru.total_print = 0;
me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru); me_printf_str_inner(fmt, &me_printf_write, args, (void *)&passthru);
return (passthru.total_print); return (passthru.total_print);
} }