Change watch_for_starvation to not print after end

This change may prevent some printing but I am not sure whther it stops
it all. Further testing (or thinking) needed.

Add and fix error messaging, stop removal of files

The philo program checks whether it created the semaphores.
When not, it assumes another instance is running and errors out.
Until this commit it would erase the semaphore files nontheless
because the unlinking was not conditional.

Get rid of philo_pids array as it is not needed

Make semaphores lose conditionally

This is done to make helgrind stop emitting an error about closing
non-existent semaphore hence saving me some explaining during
evaluation.

Fix well fed message not printing by initializing

Further improve philos memory, make 1 philo work

1 philo did not ever exit because he did not ever get out of waiting
for a fork. This is rectified by main posting new forks at the end.

Philo cleanup has been refactored to ease with the error printing.

Handle philo errors better, fix philo "leaks"

Implement the philo side of the protocol

The protocol is drafted in previous commit (commit 6980661).
The program now produces the correct output but needs to be checked
for bugs and races.

The hunger_watcher.c is renamed due to it containing more than
just the hunger watcher.

Implement waiting for death/fed in the main

This is only half the protocol implementation. It is complicated
because I cannot use signal handlers to clean after the philosopers.

The basic idea is that an end condition posts the death semaphore.
It is that used and posted imediately by the threads waiting for it.

In main thread waiting for death this ends the thread_fed.
The thread then waits for all philosophers to switch to not alive
so that it can post the term semaphore without any printing.
The term semaphore has to be posted because philosophers may be waiting
for it and would be stuck there forever.

To be implemented in next commit:
In philosopher thread the death semahore couses the alive var to switch
to 0. Additionally the philosopher posts the end semaphore
which (when all philos do so) signals to the main process it can post
the term semaphore.

Rewrite semaphore initialization, add end semaphore

It is better to create semaphores at 0 than at some value and then
subtracting them to 0.

The end semaphore will be used to signal to philosophers they should
end. This mechanism was chosen instead of kill function, because the
philosophers have to clean after themselves and signal
handlers cannot be used.

Add terminating null to name of philo's semaphore

Otherwise the program may reach memory it should not.

Fix the hunger_watcher loop

The hunger_watcher should exit its loop when philo has no time left.

Fix philosopher initialization

Add "empty" handle_philosophers for testing

Change semaphores array for a structure

This change is mainly done because norminette sees the old declaration
of semaphores[sem_num] as VLA. Instead of changing the enum, it may be
better to reimplement semaphores as a structure.
This may make a little bit more sense syntactically also?
(compare semaphores[forks] with semaphores.forks)

Add create_philo_sem_name and supporting functions

Implement the hunger watcher, rename function

The hunger watcher watches for starvation in calling philo
making him die when he starves (is hungry for too long).
The function print_timestamp is split to make it possible to
ensure the "philo died" message is the last one.

Rename philo attribute lives to alive, minor fixes

The attribute has not been initialized in previous commits.
It has aso not been a part of the philosopher structure...
This has been rectified.

Add fcntl.h as depedency for macros (eg. O_CREAT)

Implement is_alive function

Also use it in print_timestamp so that the "philosopher died" message
is the last one.

Add semaphore to each philo

To react fast to starving philosopher, there has to be another thread
checking the state of the philo. Because of this there has to be
a mechanism to prevent data race. Because mutexes are forbidden
it has to be a semaphore.
This commit contains the semaphore and some code that dictates
its usage.

Clear mutex.c as dependency from Makefile

Make semaphores close properly, fix array access

Fix most of compilation issues.

I didn't want to make all the changes in a single commit so I split the
work. The project could not be built because of the partial changes
hence I didn't think about trying to make.
I've tried to build today and found many minor problems with the code
produced since commit 60f1edc (the copy to bonus).

I don't have much time and strength today but I wanted to be productive
so I've at least done this.

Implement be_a_philosopher and its helpers

Also implement kill_philosophers and other minor changes.

Implement seat_philosophers function

The terminal semaphore is held to be able to exit without philosophers
outputing in case of an error.
Mae some minor changes, fix minor problems, remove unneeded (?) code.

Change main, parsing and mem_management

Switch from mutexes to semaphores in the functions main, init and
cleanup.

In addition change parsing a little. As semaphores can only
handle unsigned int value, philo_count should only be unsigned int
as well.

Change philo to guide the future changes

Reorganize the structures to reflect how I think the bonus should
be approached. Add comments to explain he thinking behind the changes.
Also remove mutex.c as mutexes are forbidden.

Copy the philo as a base for the bonus

It may be easier to repurpose the code for the bonus.

Remove whitespace from end of lines in Makefile

Further change cleanup order

To make helgrind errors disappear, delete every mutex shared between
threads only after joining all the threads. This ensures that
no thread can access a mutex after the removal of the mutex because
no thread exists then.

Add the check for well fed philosophers

Format to comply with the 42 Norm

Add missing index increment, change cleanup order

The program only checked the forst philo for starvation.

The change in the cleanup order is needed because without the change
(forks) mutexes were deinitialized before joining the (philo) threads.
This could lead to a philo waiting for a fork, which has just been
cleared, leading to undefined behavior (endless wait). When the main
thread joins all the threads it gets gets stuck in the one waitin for
a fork.

Join the threads for valgrind not to complain

Fix discrepancy caused by confusing ms and us

Implement checking for the death of philosopher

Also minor refactoring

Implement the philo actions

Implement seat_philosophers

Thanks to the change of how the program keeps track of time
it is possible to set the "last_eaten" member of philo in advance
(to zero - the start) without slowing the seating.

Thanks to this, no delay is necessary before the program checks whether
philos died of hunger. (It was needed in old branch, because
philosophers initialized their own time at the start of their
existance, and the check could happen before the time was set)

Add initialization of some members of philos

Fix allocation of wrong size

The way the allocation was written, it allocated space for pointer
instead of the structure pointed to. This has been corrected.

Fix logic bug

Implement conditional compilation

Before this commit, compilation would stop at file parsing.c
with error (warning + -Werror) caused by -Wtype-limits.
Conditional compilation is added so that the offending if statement
is not present, when not needed.

The #if directive could have only been set up around the problematic
if statement. The 42 Norm however forbids using macros anywhere but
the global scope.

This made me write the the affected functions twice, which then broke
the 5 function limit per .c file. Hence this commit is quite large
for such a small change.

Implement initialization, cleanup and mutex struct

The mutex struct is implemented because pthread_mutex_destroy
produces undefined behaviour when supplied with uninitialized mutex.
The struct holds information whether the mutex has been initialized
succesfully.

The header file philo.h has also been filled with declarations of
functions used in main so that Makefiles compiles every file to object.
This is done for easier checking of compile errors.

Remove unnecessary include

Implement parsing of input

Add Makefile (doesn't compile yet)

Change the context of the time variables

This change is preliminary as the code that handles this is yet to be
written. I decided to do this because I think it will not add any
complexity but will make the code more portable (as useconds_t needs
not be huge this way)?

Create outline of the solution

Add .gitignore as an initial commit