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

added codegen module

added rule macro to automatically add tracing code

added parser scaffolding ofr expressions

Added module and import list rules

implemented basic module skeleton parsing

optimized  lexer table

implemented lexer based on oberon spec

removed unused builtins

added build script, removed unnecessary files, and changed name

plopped in code for a simple compiler based on sclpl. Will start reworking it into an Oberon/Cerise compiler

ignore generated files

removed generated files

updated wording of terminal symbols

removed remnants of removed binaries

updated spec to match current compiler

reworked logical operators

updated spec based on current implementation

updated documentation

change not equal operator from # to !=

updated docs

removed set types from the language

removed set type and set operators

remove invalid documentation

remove unused stuff from install scripts

INCL EXCL to Include Exclude

ABS to Abs

FLOOR to Floor

INC DEC to Increment and Decrement

FLT ORD CHR to AsReal AsInt AsChar

removed ASR and LSL

Removed PACK ROR and UNPK

changed LEN to Length

changed ASSERT to Assert and NEW to New

removed ODD()

Changed SET to Set

removed extra tools to minimize things in need of updates in the future

changed case of some builtin types

reformatted predefined types. Broken, but close

updated tests

change all keywords to lowercase

initial commit