checkpoint commit

attempted to implement TDOP

attempted to implement precedence climbing

implemented expression parsing based on precedence climbing / pratt parsing

added beginnings of pratt parser

rework ast constructors

setup test framework and added first test

simplified AST datatype

rename source folder and add inc folder

started structuring parser to support inheritance and instrumented tracing for debug

added total hack version of struct member access and UFCS

added array initialization

reworked error location translator function to find the file by path in list of open and closed files

removed old flex based lexer

removed erroneously checked in files and fleshed out parser and pretty printer to dump the fully parsed AST

resolve merge conflict

added new nodes to AST and updated parser to build the AST

rework makefile

added api for lambda ast nodes

removed typing from initial AST creation process. Will be done from the type checker/inferrer instead.

started building and printing the AST nodes in the parser

updated parser to record requires and provides

call new lexer from parser

added custom handcoded lexer

added function and type to support lexing multiple files

combined integer fields in the token union

updated token printing to reflect new token types

Removed vector implementation

added hooks for building in-memory package description

added recognition of method call syntax for functions

added support for nested functions to the grammar

added a default main function to runtime to store off the stack bottom

sketched out gc api

switched to expression based syntax with no statements

fixed if statement parsing

first attempt at if statement parsing

removed symbols from the AST and pprint module

sketch out interface for package API

support parsing multiple files for binary and library targets

attempted to add logic to parse multiple files into a library or binary

added parsing logic for function arguments on function definitions

added parsing rule for function calls and stubbed out hooks for if/for/while/do-while statements

whoops.

added primitive line tracking to lexer

don't define tokens for real characters. just use them directly

added struct, union, array, and pointer syntax to type expressions

merge changes

stubbed out struct and union parsing

tweak top-level syntax

added semicolons and = to type and value definitions

renamed variable definitions in example source

fixed first pass at function parsing

added line comments and fleshed out parser a bit more

sketched out parser for new file structure

added float types

added primitive type cehcking

added codegen module and code to register bindings with symbol table

added symbol table implementation and registered builtins

stubbed out basic symtable api

Added type node constructors

sketch out additional top-level constructs

added support for constant and variable bindings at the top level

added typedef and prototypes for data type definitions

minor refactoring and added = token

removed unused functions

checkpoint commit

rework identifier parsing

stripped down parser

minor refactoring

minor refactoring of parser context and helper functions

fixed segfault in parser

attempted handling token parsing with a single token struct instead of heap allocating each one

stripped down grammar. ignoring broken specs for now

refactored

changed parser to disallow expressions at topelevel

removed remnants of GC

removed gc stuff. opting for a lack of memory management in general

disable function literal tests

remove unused files and rework headers

removed anf and C code generation

Added basic recognition of types and type annotations

Added token type for ':' in preparation for type annotations

Makefile  cleanup

Remove vim project file from repo

commented out problematic tests. investigate later

Added deep comparison of values to the check functions

Added preliminary attempt at lua version of rspec tests

Added tokens to the lexer in order to eliminnate the *_str parser functions

Converted handwritten lexer to flex based lexer

Added basic unit test framework to allow more invasive and targeted testing

checkpoint commit. stuff's broke. Add some tests before attempting to fix it

First attempt at generating code for if statements. horribly broken.

Started working on preliminary code generation

Finished anf transformation

Half-implemented ANF transformation

Implemented ANF transformation for function applications

Started implementing the anf conversion phase

Started laying the groundwork for a-normalization pass

Updated readme

Removed commented out code and cleaned up some odds and ends