I think that there are no segfaults in this code

--You can't just use a variable for its value without setting it what
the hell examples/test.ff
--Variables and strings need their own char buffers just like function
names do.
--The linked list implementation didn't properly add shit to the
beginning of a list with NULL for the data and next. Lists which
evaluate to NULL obviously have a length of 0.
--Move some stuff around the yacc file for better organization.
--There is a falsevalue global Value* so that conditional stuff whose
condition fails have something that they can return.
--All of the variable names are held in a linked list but there are no
repeats. Maybe I should exploit that in the getVarValByName code. Meh.
--Add code so that given a char* the local variable whose name matches
can be found.
--I shoved all the constant char*'s that I need to run the builtin
stuff into one large buffer. It is kind of neat.
--Fix off-by-one bug in the getFunction method for the hash table
--All the builtins exist now (well the ones from the python
implementation) so the function call evaluation function has to
actually call those functions.
--There is no integer data type, just numbers which I'm representing
with doubles so when evaluating booleans, the numerical values used
for true and false should be 1.0 and 0.0 not 1 and 0.
--I noticed I was casting the result of evaluateBoolExpr to a BoolExpr
most of the time anyways since I'm after lasteval which is not in the
Value* struct so I made it return a BoolExpr* and reverse where the
casts go.
--I made the evaluateBoolExpr funtion actually do something
useful. The stub that was there looked kind of OK until I realized
that it didn't work at all and I hadn't gotten past the first operator
--When a NULL gets returned as a Value* -- everything stops because
that was an ERROR which has been reported and now we can't do anything
for risk of Bad Things.
--There is a bunch of refcount increments and free function calls in
an effort to plug all of the memory leaks. It is kind of hard to
reason about when it is basically a giant recursive function split up
into five or so functions which are all calling each other in a chain
--There are functions to turn any value into a double and any value
into a char* which will then need to be freed because C is like that.
--I realized that NULL is a valid value for List* and that the
NullList was a really confusing thing I didn't want to deal with. Now
I have NULL checks all over the place but I'd need them anyways. This
way there is one less indirection for NULLs
--Looping over a char* [] which holds stack allocated constants to
allocate the giant buffer for the constants that I need is kind of
cool.
--I would manually free the ParseTree and function table but parts of
it are already freed by reference counting and I'm not sure which
parts.
--I think the neatest thing about this implementation is that the
amount of memory that its memory usage seems roughly proportional to
the size of the program. I suppose using flex and yacc help though.