Implement red-black tree

This is an untested implementation.

Remove the parent member from t_tree

I see little use for this now. It is trivial to add it later.

Revert back to using separate tree and node

Because the node uses flexible array member it should not be
instantiated on stack. Hence a separate type for t_tree is needed so
that user may use tree on stack (as it is convenient).

Add the ft_tree_set_data function

Rename ft_tree_erase_child to ft_tree_erase_subtree

Harden ft_tree and change it a little

The change is to return t_tree from pointer to t_tree_node to just
t_tree_node. I don't yet have much grasp on ergonomics of this but I
think this is the better choice.

Remove indirection from t_tree_node to data

This (probably) leads to faster access. I wanted to try to implement it
like this.
This is still not hardened and untested.

Add insertion of "empty" elements to t_vec

Add a ft_tree structure

Add a non-hardened naive untested ft_tree structure.

Remove the parsing table generator

It was moved to a separate project because it feels more like a
standalone tool than as a useful part of a library.
The project can be found at
git://ljiriste.work/parsing_table_generator

Make Libft C++ aware and compilable

Though compilation is only possible with the -fpermissive flag.
It is not a great idea to use everything (or even most things) in C++,
but it is better to be consistent and it also makes it easier to migrate
a project using Libft from C to C++.

Fix Norm formatting problem

Improve ft_vec_find and ft_vec_find_index

I have no idea, why I have not allowed the users to provide their own
comparison function for finding an element...

Make parse_tree traversal a little bit easier

The ft_get_node_child function is very simple but may save a lot of
code, because ft_vec_access returns void* which needs to be cast before
further actions can be done.
(And casting to (t_parse_tree_node *) is a lot of code).

Break line in Makefile to fit in 80 chars

Move g_empty_token and g_eof_token definition

This is done so that the actions.c file does not need its own
definition.

Merge parsing_table_constructor into no_crash

Align slashes in Makefile

I really should use spaces instead of tabs for alignment...

Make this branch fully Norm compliant

I needed to split the main file a little yet. The grouping may not make
much sense, I did not want to spend any brain power on this anymore.

Add -fPIE flag to Makefile

The -fPIE flag has something to do with position independent code. I
think I've encountered this problem before when using ft_printf, because
its ability to print pointer values (addresses).

Refactor ft_parsing_table_generate.c

Split functions too large to comply with the Norm

Break long lines, fix indentation and g_var naming

Bring the code closer to compliance with the Norm.

Improve Makefile debug functionality

Makefile now creates .debug file when "make debug" is executed.
This make Makefile able to remember the debug mode for futher builds
and rebuilds. The debug mode can be disabled by removing the .debug file
or by executing "make nodebug" which will also build the project.

Extend the input possibilities for parsing table

This is done so that a parsing table may be included inside a source
file as a string.
Addition new (long) filename to Makefile lead to change of alignment
depth.

Harden ft_split, provide ft_free_split

Fix invalid read in ft_split

This read happens when the last word ends with the terminating '\0'.
After advancing the index to the '\0' it is then increased once more to
regions not accessible. This is fixed by simple skipping the ++i after a
word has been processed.

Add ft_swap_int

Merge some t_vec functions into no_crash

I dont want to merge parsing generator so that I don't have to make it
comply with the Norm yet.

Add a function to save a table as a file

This file is then readable by ft_parsing_table_load.
Some lazy checks are written to check that something was written to the
file, but if only partial write happens, those will not notice.

Fix infinite recursion

The previous commit solved some wierd things around the add_first
function. These were created because of my misunderstanding of the
process but also (almost) prevented infinite recursion.

The infinite recurson is caused when a search for a first (nonterminal)
tokens encounteres the original token, because then it searches for it
again and is able to again find the token along the search.

The solution is to make the algorithm log what nonterminals it already
went through so that it does not try to find their first tokens during
the search for their first tokens.

Repair some oddities in finding the first tokens

Make ft_parse ablle to follow rule to empty token

Remove collapse_closure function and attributes

The collapse_closure is not needed for correct function. It may be added
later on as an memory optimization.

Fix handling if the zeroth rule

Removing the zeroth rule before the translation makes all the items
point one rule ahaed. So instead the rule number is decreased by one
the zeroth rule reduce is converted to accept.

Add empty token recognition in translation to table

Fix initialization of table rows

The initialization was caused by an inappropriate use of
ft_vec_insert_range. I was not sure whether it fills the range with the
single element or whether it insert range and I misread the source code

Fix wrong pointer depth and gotos offset

The translation function accessed t_generator_state * instead of the
correct t_generator_state**.
The gotos vector in the table rows is indexed from 0 but uses the tokens
after the eof_token hence the index needs to be offset.

Add the translation from state graph to table

This compiles but crashes.

Free item copy in fill_closure

Fix segmentation fault in fill_closure

When the add_predictions inside fill_closure has to enlarge closure to
add a new item, the original item pointer points to freed memory.
This is solved by making a copy.

Make the generator count the terminal symbols

Fix double free

Because the goto_tokens used tokens from table instead of their copies
and were freed when generator states were cleared, the table tokens
then contained pointers to freed memory which were to be used.

There are two ways to fix this. Either not free the tokens in
goto_tokens or append copies. I opted for the latter because every part
of the generator code uses copies too. It may be rewritten to use the
table tokens later on to save memory.

Fix function freeing the parsing generator states

This function was made under wrong assumptions.

Fix index reset before new loop

Change the way tokens are compared for zeroth rule

The zeroth rule contains a token which has NULL at type. Because the
function cmp_token_type is used when comparing rules (items) it has to
be able to handle this NULL.

Fix accessing generator states

This part was written under the assumption that t_vec states holds
t_generator_state instead of the t_generator_state*

Fix wrong element insertion

Instead of a copy the original token was inserted. This caused the
elements sharing a token to be changed when only one shoud have been
changed.

Fix infinite loop

Fix some aspects of fill_closure function

Fix wrong malloc and infinite loop in ft_vec

Change the code to accommodate the zeroth rule

Implement is_at_mark

I've probably just forgotten to implement this function earlier.

Implement token_categorize

This function fills the tokens t_vec with the language tokens.
It first lists terminal tokens, then end of file token, then
nonterminal tokens.

Add first kernel construction and its support

The supporting changes consist of changing the ft_token_dup function to
take pointer to token as input. Taking global static token caused some
error but was solved by passing pointer.
Function to free structs now handle NULL gracefully. This was
encountered because not all used structures are initialized yet.

The zeroth rule is added to generate a table, that returns the original
first token as a root of the table. The type of NULL cannot be achieved
any other way inside the table.rules.

Implement another part of the generator

This commit mainly concerns itself with the construction of the closure
table - the closures and the "first" tokens.
The first tokens could be precalculated but I did not want to do that
as that would require to either have a function with some static
variable (which is meh to clean up) or I would have create another
structure and pass it everywhere. It can be added later on.

Implement a big part of the parsing table generator

Add the ft_vec_setinsert

This function could have been named ft_vec_insert_unique,
but that would invoke the need for insertion index which
I wanted to avoid because of the usage a set.

Harden the ft_strchr and ft_strrchr functions

This makes them return NULL when the haystack is NULL.

Adapt the transplanted ft_split to libft

Transplant a better split function to Libft

This function was created during the 42 Piscine.

Remove structure comments that offend the Norm

Add function for equating two t_vecs

Add some set functions defined on t_vec

The functions are defined on t_vec instead of implementing t_set
because the t_set struct would not be very useful. The lack of
structure is easy to emulate wth t_vec. The only advantage would be
uniqueness of elements.

Add a function to deep copy a t_vec

Print also the contents of tokens

This makes debugging easier, though the output is harder to read

Change function names to prevent naming colision

Add tags to .gitignore

Improve the documentation of limitations

Refactor ft_parse.c to comply with the Norm

Fix indentation

Refactor functions to comply with the Norm

Refactor to better comply with the Norm

Make ft_parse_tree_print comply with the Norm

Improve formatting of ft_parsing_table_printf

The token names in the output header are now limitedr
to the column width.

Make ft_parse inputs const, move token_free

After playing a little with the functions I thought it stupid to have
all tokens have their own memory for types that repeat so much.
The token_free function I implemented frees both members of token
which leads to multi-frees when reusing a string for type.

This is why I think it will be better to hide token_free again
and the user can decide what to allocate and what to free.

For this to be possible I have guarantee the tokens vector is not
changed inside the ft_parse function, so I've rewriten it a little
to use const.

Add const version of ft_vec_access

Fix memory leak

This leak was caused by carelessness when working with malloc and t_vec
at the same time.

Make ft_parse_tree_print handle NULLs gracefully

Fix bug, where NULLs appear inside tree

This bug was caused because the tree nodes are filled from the end
when reducing. Instead of just inserting to the start it was inserting
at the final position.
When inserting to vector outside of range all the nonexistent entries
are initialized to 0. If another insertion happes after that, the
0 entries are not filled but moved to make space for the new entry.

Implement printing function for parsing tree

This is mainly done for debugging. This does not scale to arbitrary
large trees automatically - the output will be garbled.

Fix forward declaration to be usable by user

Fix the code to actually produce a tree

As the previous commit was only checked to compile there were some
minor defects. Notably the parser stack was not initialized properly.
It has to return state_num 0 when empty, which was solved by inserting
a dummy state 0 wih no node attached.

Implement the ft_parse function

I did not yet try whether it actually functions (it probably does not).
Because managing ft_parse_inner.h was harder than I imagined
and I wanted to focus on the ft_parse function, I returned
almost everything to ft_parse.h.

Add a stack structure

Add a classic FILO stack with push, top, pop and some other functions.
It is basically just a wrapper for t_vec.

It is added into a new directory ft_struct. I should have made it
instead of the ft_arr dir. I may later move t_vec and t_mat to
ft_struct.

Fix indentation

Refactor parsing table loading

Align the ft_parse style with that of f_arr

Add comment about the parsing table structure

Parsing table shoud not contain any non-ASCII whitespace as
getting rid of multi-character whitespace is more challeging.

I mention it as I have encountered this problem and it was
somewhat difficult to find the cause.

Fix logic bug

Fix initialization and formatting of output

Refactor to make functions comply with 42 Norm

Add printing for parsing table, fix formatting

The ft_print_parsing_table is useful for debugging.

Fix interpretting the end of row as 0

Fix some bugs

These bugs include:
 infinite loop
 not freeing alocated memory
 not initializing a struct before it may be returned

Fix a logic bug

Implement parse_header, minor fixes

Implement ft_remove_space function

Implement most of parsing table loading

Also change Makefile to include ft_parse.c in compilation.
Minor changes to ft_parse.h.

Add description of the format of parsing table