Add crossplatform IR generation for if/else statements

Add crossplatform IR generation up to the point of if/else statements

Make it easier to run the tests without memory leak tests

Make it easier to run without memory leak tests

Update Jinja

Update the README

Add support for nested functions with the same name in different contexts

Desugar function definitions to assignments to lambda

Added lambda expressions

Remove list get expression

Added a CPS conversion pass (which currently does not actually convert)

Desugaring pass (#9)

* Implemented the desugaring pass, except for exception support; also badly needs cleanup of dead code

* Pass through metadata to end of desugaring phase (for error reporting)

* Pass through more metadata, package it at tokenization phase

* Added error handling to desugared code

* Add line numbers to function call errors, clean up

* Delete dead code

Removed one more test using ternary comparison

Remove support for ternary comparison operators

Added two more compiler passes

Visual cleanup

Reuse the parent stack in current stack frame

Use snapshots of the stack to restore stack to its previous state

Allocate Fur stacks on the C heap

Set the environment to the same variable name

Change parent_jump to parentJump to conform to previously used code style

Clean up stacks in the case of an exception

Added a shell script that can be used to run Valgrind on Fur programs

Add very rudimentary line numbers to exceptions

Simple exceptions (#6)

* Added basic exceptions

Move .output.txt to .stdout.txt to reflect which output stream the files contain

Capture stderr in integration tests

Start passing around a jump buffer to handle errors

Pass arguments to infix operators via the stack

Reuse normalize_basic_infix_operation in implementation of normalize_comparison_expression

Move desugaring ternary comparison operators into the normalization step

Add a stack, and use that for function call arguments

Added a future folder to examples

Fix link

Add structures, fix link

One more thing it supports

Added basic README

Added structs

Add double-quoted strings

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