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 some aspects of fill_closure function

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

Fix infinite loop

Fix wrong malloc and infinite loop in ft_vec

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.

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

An draft of some parsing functions and structures

Make ft_strlen return 0 when NULL is an argument

Fix ft_mat_insert_col by switching comparison sign

The function has to increase capacity in the case the matrix has
insufficient capacity (not the other way around...).

Fix ft_mat_fill by swapping rows and columns

Add ft_strcat_alloc

This function behaves in similar way to ft_strncat_alloc. The difference
is that it concatenates the whole (null terminated) src string.

Fix for "0" input to be recognized as valid int

Merge branch 'isint' into no_crash

I've forgotten to pull the repo and made changes.
Then I was lazy to recreate them after pull and I thought
it would be easier to merge the changes.

Add ft_isint function

Add function for filling a matrix

Add function for filling matrix with zeros

It has to be handed an empty (just initialized) matrix as I did not
think about non-empty matrices.

Change string writting functions to accept const

This change is done because the writting functions do not (to my
knowledge) change the input string so it can as well be const.

Add ft_dprintf for outputing to file descriptor

Fix incorect memmove

Add ft_min and ft_max functions for int and size_t

Make get_next_line able to free all its memory

Passing negative fd to get_next_line now signalizes to it that it should
close (free) every buffer.

Fix indentation of ft_sgn

Add ft_sgn signum function

Improve matrix handling, remove VEC_INIT macro

Improve matrix insertion by patching bugs and adding bounds checking.
Insert VEC_INIT macro as it is forbidden by the Norm.
Add ft_mat_access as matrix analog to ft_vec_access.

Add a macro for t_vec initialization

Add macro for static t_vec initialization, because it needs a
compilation-time constant, which functions cannot (?) achieve.
This macro resolves to compound literal and lacks a check but should
be good enough.

Patch the issues of previous commit.

Patch ft_strcmp.c so that it actually compiles...
Add ft_strcmp to header file and the Makefile so that it is usable and
compiles to libft.a.

Add ft_strcmp function.

Add ft_strcmp as it may be more ergonomic than ft_strncmp.
Add *.swp rule to .gitignore so that those won't bother me while vim is
opened.

Add functions for finding element in vector

Implement matrix t_mat as a wrapper around t_vec

Implement new struct for matrix and some basic utilities. Everything
passes strict compilation and norminette, but may contain bugs in logic.
Testing recommended (though it will probably happen when this is
needed).
Extract ft_vec_forget from ft_vec_erase which functions as ft_vec_erase
with free_el = NULL.

Remove void* arithmetic, conform to the Norm

Add -Wpedantic option for compilation to Makefile to catch all mistakes.
Cast void* to char* for any arithmetic done.
Split lines that are too long to fit the 80 char limit of the 42 Norm.

Add some t_vec functions and change name

Add functions for inserting and erasing multiple elements.
Rename dir ft_vec to ft_arr and rename ft_vec.h to ft_arr.h for future
implementation of other array structures (matrices).

Improve ft_vec_erase and ft_vec_free

Add function for freeing element to ft_vec_erase and ft_vec_free for the
ability to handle advanced elements (elements which may point to heap).

Add a ft_vec module for vector struct

Add vector struct and operations on it that are somewhat similar to C++
std::vector.

Move all "public" header files to ./inc directory

This makes compiling easier, as only one directory has to be given
through the -I compiler option.

Enforce header inclusion rules

The following rules are (to be) used:
 -Sort header inclusion from local to global
 -Always include header which declares the functions in file
 -Only include header when it is neccesary for compilation

Set e-mail in the 42 header to the correct one

Change e-mail address in 42 header to ljiriste@student.42prague.com
instead of marvin@42.fr that was the default.

Change file structure of this library

Separate source files (functions) to folders by topic.
Create separate header file each folder.
Adjust Makefile and libft.h accordingly.

Patch ft_lst_sorted_insert to actually insert

Add long and long long versions of ft_atoi.

Add the functions ft_atol and ft_atoll to the file ft_atoi.c.
Add prototypes of these functions to libft.h.

Change permissions of files added in previous commit

Remove execute permission from ft_strncat_alloc.c and get_next_line.c as
source files are not executable.