Start implementing functions

Implement variable length arguments, but really only for print

Implement and/or, introducing jumps and labels

Implemented integer comparison

Added booleans

Implement negatives, use typedef

Implement pow

Variables and basic math

Generate a C program (which has a memory error after completion, but still)

Remove dead namedtuple

Handle anonymous lambdas

Generate structures

Simplify list construction

Add support for lists to IR, clean up

Add environments

Handle arguments to functions

Fix/simplify the generation of if/else statements

Fix the generation of function CIR

Add Rope_length (mostly as a way to add __attribute__((pure)) to the codebase

Begin adding some C code

Better TODOs

Add a very basic optimization pass

Remove unnecessary pushing/popping for integer literal expressions

Remove unecessary pushing/popping for function calls

Remove unecessary pushing/popping for function arguments

Remove unecessary pushing/popping for string literals

Generate lambda expressions

Use flatten()

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