much scaffolding for SSA

started modifying parser to generate ssa directly

sketched out new ssa-based API

removed distinction between unop and binop in API

cleaned up module entries in the symbol file

minor cleanup and update of TODO list

added type cache output to symbol file

reorganized file

started writing rudimentary symbol export logic

implemented first pass at module coped identifiers. Still need to add symbol file genration and loading

sketched out strategy for module importing and aliasing as well as symbol resolution

implemented function calls

Got If statements and procedure definitions working. AST creation now self optimizes by performing constant folding, block coalescing and dead code removal during creation. This will result in less work for the optimizer.

tweaked ast printing

sketched out really rough logic for array indexing

re-enabled variable and type declarations

non-record type definitions are working now.

got basic expression parsing back up and running. Verified using constant evaluation logic

cleanup dead code from old architecture.

added constant operations for binary operators

unary constant operations are working

started integrating AST generation. Null pointer making its way into printing or generation. haven't tracked it down yet

push ast.c

created ast.c

added very basic AST definition. Considering ditching ssa-like IR for simpler AST format

fixed up constants and constant unary ops

commented out a bunch of code in preparation for IR overhaul

attempted to flesh out ssa backend. Considering scrapping it and moving to a tree form instead...

added new backend

got rid of next pointer for Symbol type

started sketching API for intermediate language implementation

fixed up function calls

fixed up code generation with new symbol table approach.

reworked function definitions and scoping with new symbol table

new symbol table functioning

reworking symbol table...very broken

checkpoint commit

partial fix-up of array access. Need to generate index calculations

moved TODO to dedicated file. removed offset from item type. Defined types for possible SSA form

cleaned up record access code

wrapped up initial record support

implemented record types and record member access

reworked field addition to records

added some helpful info

implemented alignment and size calculation on records and arrays. Also added a list of undefined behaviors in C to keep in mind.

segfaults everywhere

added export bit for fields

initial record pass using symbols. Added a field type, should convert to using that over the symbol type when specifying record fields

Merge branch 'master' of mdlowis.com:~/git/proto/obnc

commented out broken stuff...really gotta get it working...

Merge branch 'master' of mdlowis.com:~/git/proto/obnc

minor cleanup

added grammar rule for record fields. adding fields doesnt work yet though

fully implemented first pass at array indexing with range checks

added array temporaries but assignment is still busted

added some error checking to array indexing

started adding array indexing

started implementing array subscripting

functions and function calls fully working now

function calls are almost working....

removed dead code

Added logic for parsing args and adding them to symbol table

mostly fixed symbol table. Need to fix the procedure code generation

partial overhaul of symbol table...

restructured parser for readability

started working on argument parsing

Added declarations section to procedure declarations

started parsing procedure declarations

checkpoint commit

reworked  global generation to take into account export marker

added array base type handling

implemented code generation for if statements. Only the C backend for now

cleaned up loops

added parsing rules for array types

split up and reorganized files

added if statement to parser. need to add codegen hooks

added handling of most operators

started fleshing out a C backend

reorganized folder strcuture to allow fo rmultipl backends

added more operations

fleshed out more kinds of operations

added a single case of code generation for binary operators using variables

tweaked module code generation. global var references don't work yet

add calls to module init functions

added code to define variables

got primitive code generation working for assignments

scaffolding is in place for assignment statements. Need to decipher level handling and generate the proper code for the assignments (and expressions)

added scaffolding to generate assembly code

reformatted OSP.mod for readability. Started building parser rules for statements. Focusing on if statements, assignments, and function calls first

added module-level variable declarations

condensed constant declaration tests

rearranged grammar to minimize need for forward declarations

implemented constant identifier lookups

constant expressions are almost completely implemented. need to add identifier lookups

added scaffolding for arithmetic operators. will fill in details later for constant calculations

started implementing item based transformation based on oberon0 compiler

Add oberon0 code from wirth for reference

implemented basic constant folding ops..

added global and local symbol list

added scaffolding for constant expression evaluation and code generation