• from the line get all the commands and the args for that command
• link next / prev command
• if there is an operator put it in the operator field in the sctruct

(no input validation -> when it get to the code which puts it into the structs the input is already valid. Doesnt mean the command exists tho)

• ich wuerde mir erst den segfault anschauen und probieren zu fixxen (segfault kommt von commands/command_handler erste if condition im while loop, hab ich also erstmal ausgecommented) ✅
• dann checken ob das erste struct richtig befuellt wird (ja wird es mehr oder minder, wenn wir das Issue mit echo fixxen!!)✅
• dann die weiteren structs befuellen ❌

ValgrindKatrin`s work is to valgrind the shit out of minishell.

Put the object files in separate folders so as not to lose the overall overview

• echo hi | wc -l
• leaks

reverse the shunting and run it right the commands

• Leaks fixxen
• Segv fixxen
• unnoetiges aussortieren

Need a new requirement to split with spaces.

• when a quote is in a quote then dont remove those inside
• when encountering open or close parens just remove them when splitting (only if they are not in quotes ofc)
• figure out how to correctly handle heredoc because as an example echo << EOF should just print a nl and cat << EOF the content of the heredoc. right now both just print the heredoc output because its saved inside an echo cmd
• other stuff that were issues before...

• fix segv in input validations
• add relative path to minishell prompt

cat | cat | ls isnt working cause we wait with waitpid() which is half right...

Handles Commands and Operators like:
echo, ls, cd etc. pp.

Fill up the struct with the other commands and arguments from the command.

Rewriting ft_split cause it is not fullfilling the requirements we have.

Every command is doing what it is supposed to do except echo.
Problem:
In utils/make_cmds -> allocate cmd everything is read correctly in the 2D Array of char **args but if you try to read the same piece of memory in the function make_cmds the first word(s) are complete bs.

Example1 (works):
minishell ➜ echo "hello there"

allocate_cmds[0]: "hello
allocate_cmds[1]: there"

make_cmds[0]: "hello
make_cmds[1]: there"

OUTPUT: "hello there"

Example2(does not work):
minishell ➜ echo "hello there how are you doing"

allocate_cmds[0]: "hello
allocate_cmds[1]: there
allocate_cmds[2]: how
allocate_cmds[3]: are
allocate_cmds[4]: you
allocate_cmds[5]: doing"

make_cmds[0]: P��įU
make_cmds[1]: there
make_cmds[2]: how
make_cmds[3]: are
make_cmds[4]: you
make_cmds[5]: doing"

OUTPUT: P��įU there how are you doing"

letzz go doing AST!!!!

• redirection

Rewriting the Cmd-Handler.

always save the last exit code in the shell every time when running a command and then check for that

test.

• pipes
• redirections
• heredoc

functions when to use when having an operator like >>

What?

• detect variables
• valid input (VARNAME=CONTENT) -> doesnt matter how many = signs there are as long as there is one all the following count towards the COTENT
• if variable is already in the variable list then just replace the value
• strdup the value into the struct
• free all the split or whatever

Structs

typedef struct s_variable
{
	char				*name;
	char				*value;
	struct s_variable	*next;
	struct s_variable	*prev;
}			t_variable;

typedef struct s_shell
{
	bool		run;
	char		*path;
	char		**env;
	char		**envp;
	t_variable	*variables;
}			t_shell;

typedef struct s_command
{
	char				*command;
	char				**args;
	int					*operator_type;
	int					priority;
	struct s_command	*next;
	struct s_command	*prev;
	t_shell				*shell;
}			t_command;

!!!EVERYTHING THAT IS MALLOCED IS REFERENCED IN A STRUCT!!!

apply the shunting yard algo on the shunting yard strucut array

• check if input is valid (cmd args operator cmd args ...) -> no operator in the end or beginnging
• display quote> prompt to let the user finish their input when they forgot a quote and then append it to the line so that split can split it right after

Do redirect out.
Take the output from a command copy that in a struct and give that struct into the redirects

loop which displays the promt with and runs all the time and displays promt again when pressing enter

instead of using our command structs we build an AST with tokens and priorities

Priorities from high to low

1. Parentheses ()
2. Unary operators (e.g., -, !)
3. Multiplicative operators (*, /, %)
4. Additive operators (+, -)
5. Comparison operators (<, <=, >, >=)
6. Equality operators (==, !=)
7. Logical AND (&&)
8. Logical OR (||)
9. Assignment operators (=, +=, -=)

these are not happy tears.

Cleaning up the shit we did wrong. Rewriting code to make it compatible with our new code/ideas. Satisfy Norminette and most important test it.

• Handle single and double quotes that all that is inside them is one argv
• Make variables

• Make Pipes and redirections not stop the parent process aka the actual minishell
• Env variables (with $ and unset function which removes one of them)
• cd work with cd - which is the same as cd ..?

maybe

• wildcards