Add a string concatenation operator

Added list literals

Added if expression statements

Make "do" a keyword

Remove TODO with unclear reasoning

Normalize function expressions

Normalize symbol expressions

Fixed some TODOs

Added some todos

Normalize symbol expressions

Normalize literal expressions

Prevent assignment to a builtin variable

Allow the results of function calls to be immediately called

Add support for parenthesized functions

Just pass through the internals of parentheses, unwrapped

Closures (and garbage collection for environments, which is required by closures) (#1)

* Add proper reference counting to environments

* It has become clear we need a garbage collector for environments before we can implement closures

* Allow line comments starting with #

* Allocate Environments from a garbage-collected EnvironmentPool

* Wrap closure functions in a struct in preparation for storing the defining environment with them

* Move the instantiation of closures into where they are created

* Fixed a bug in the mark/sweep algorithm:

* It would infinitely recurse in the case of cycles, because nothing was
  checking that Environments had already been marked.
* Simply exiting on self->mark == mark would fix this, but introduce a
  separate, worse bug where recursion wouldn't reach some live objects,
  since some objects might already be marked with the current mark due
  to previous cycles.
* To fix, I introduced a pass over the pool that marks everything false
  so we can reliably assume that self->mark == true means that the
  environment has been marked in the current GC round. It's slower than
  I wanted, but it's better to do the correct thing slowly than the
  wrong thing quickly.

* Store the defining environment on closures and GC it appropriately

* Test a simple case of closures and fix the discovered errors

* Add a test that explicitly demonstrates freeing a cycle

* Allow user-defined functions to take arguments

* Another closure example

Ignore symbol folders

Add a suite of memory leak tests

Finish conditional compilation of operators

Don't compile in some unused operators

Clean up expression transformation a bit

Appease -Wall

Go back to constructors and destructors

Go back to allocating environments on the heap

A featureful commit:

* Added support for a few new kinds of expression statements
* Cleaned up the generated C code a bit
* Pass through calling environments to functions

Allow users to define new zero-argument functions

License under the GPL 3

Get called functions from the environment

Store functions as objects

Added variable-length args to function calls

Normalize parenthesized and negated expressions

Normalized all infix expression statements

variable assignment renamed to variable initialization for accuracy

Normalize comparison expressions, even ternary comparison expressions

Start playing out the normalization of other infix operations

Use order instead of operator to normalize infix expressions

Normalize infix operators

Normalize all the arguments to functions

Minor refactor

Add a CExpressionStatement to wrap expressions instead of passing them into statement functions

Some minor refactoring and added a (currently trivial) normalization step

Better names

Removed not-yet-relevant runtime

Removed not-yet-relevant string type

Slightly better naming

Combined accumulators into one namedtuple

Add newlines to the parsing of statements

Add boolean operators

Add support for ternary comparison operators

Store all Fur infix operator expressions in the same type

Get function names for operators in transformation phase rather than generation phase

Use composition rather than inheritance to differentiate between different operators of the same level in parsing

Removed duplication in left recursive infix operator parsers

Added support for comparison operators

Some comments

Added parenthesized expressions

Added a boolean type

Add constant symbol list, which solves all the symbol allocation problems

Parse function call names using the symbol expression

Add the ability to assign to and retrieve variables

Add a negation operator

A pretty featureful commit:

* New builtin pow()
* Support for multiple arguments to functions
* Support for the results of function calls being passed to functions

Add an integration test to ensure left recursive parsing of math works

Added integration test to ensure that order of operations is correct

Add basic math

Handle multiple statements

Added support for integers

Use an actual string type

Clean up after integration tests

Add a .gitignore

Add integration tests

Added a very rudimentary fur-to-c compiler