- Extract the `Variable`'s `Type` object and pass it into the instruction constructor
Instruction
- `VariableDeclaration` instruction now takes in an instance of `Type` upon construction
Dependency
- Fixed null pointer exception where Function did not have its `context` set
DGen
- Added `typeTransform(Type)` to transform the given types into the C equivalent
- Variable declarations use `typeTransform()` now
- Casting instructions use `typeTransform()` now
- Added `emitStdint()` to emit `#include<stdint.h>` as part of header in generated C code
- `generateSignature(Function)` now uses `typeTransform()` for the return type emit
- Implemented new instruction `CastedValueInstruction`
- Added import for `Type`
DGen
- Implemented primitive type casting code generation in `transform()`
- Added import for `Type` and `Primitive`
Parser
- Implemented `parseCast()` which is called by `parseExpression()`
Check
- Added new symbol type `SymbolType.CAST`
Expressions
- Implemented new expression type `CastedExpression`
Typechecker
- Implemented processing of `CastedExpression` in the expression section, along with correct type/instruction pushes and pops
Dependency
- Implemented dependency generation of `CastedExpression` in `expressionPass()`
Test cases
- Added test file `simple_cast.t`
- Added new instruction `DiscardInstruction`
DGen
- Added ability to transform `DiscardInstruction`
Parser
- Implemented `parseDiscard()`
- Removed a TODO
- Added a unittest testing the new `parseDiscard()`
- Typo fixes here and there in unittests
Data
- Added new parser node `DiscardStatement`
Typechecker
- Added codegen for `DiscardStatement` type
Dependency
- Added dependency processing for `DiscardStatement` type
Tests
- Added new test case `simple_discard.t`
- Added `getOperator()` and `getOperand()` methods to `UnaryOpInstr`
- Added new instruction `PointerDereferenceAssignmentInstruction` for pointer support
DGen
- Updated `transform()` to emit code for instruction type `UnaryOpInstr`
- Updated `transform()` to emit code for instruction type `PointerDereferenceAssignmentInstruction`
- Added testing emit code in `emitEntryPoint()` for pointer testing
Parser
- Updated `parseName()` to trigger `parseTypedDeclaration()` on occurene of `SymbolType.STAR` (for pointer type declarations)
- Added pointer-type support for function parameters (so far only single) in `parseFuncDef()`
- `parseExpression()` terminates on occurence of a single `=` (ASSIGN) operator
- Declaring of pointers of any depth implemented in `parseTypedDeclaration()`
- Added support for pointer dereferncing assignments with the addition of `parseDerefAssignment()`
- `parseStatement()` will now call `parseDerefAssignment()` on occurence of a `SymbolType.STAR`
- Added a unittest for testing pointers
- Finished unittest for for loops
Check
- Added backmapping for `SymbolType.ASSIGN` -> `&`
Data
- Added new parser node type `PointerDereferenceAssignment` for pointer support in the parser
TypeChecker
- Because function parameters are type che cked upon function call I had to add typechecking code for pointer support in the `UnaryOperatorExpression` case
- Added code generation support for `PointerDereferenceAssignment` type
Dependency
- Added support for `PointerDereferenceAssignment` type (pointer support) to `generalStatement()`
Tests
- Added pointer test `simple_pointer.t`
- Added a new instruction, `ForLoop`, which contains a pre-run Instruction and a `Branch` instruction, coupled with some flags
DGen
- Added a TODO for WhileLoops (we need to implement do-while loops)
- Implemented C code emitting in `emit()` for `ForLoop` instruction
Check
- Added missing back-mapping for `SymbolType.SMALLER_THAN`
Data
- Added new parser node type `ForLoop`
Parser
- Fixed typo in `parseWhile()`
- Implemented `parseDoWhile()` for do-while loops
- Implemented `parseFor()` for for-loops
- Implemented `parseStatement()` for singular statement parsing
- `parseStatement()` can now have the terminating symbol specified, defaults to `SymbolType.SEMICOLON`
- `parseName()` and `parseAssignment()` now also accept a terminating symbol parameter as per `parseStatement()`'s behavior
- `parseBody()` now makes multiple calls to `parseStatement()` for singular Statement parsing (dead code below still to be removed)
- Removed commented-out unittests
- Unittests that read from files now have the file source code embedded
- Added unit test for while loops, for-loops (unfinished) and some other smaller language constructs (roughly 70% coverage)
TypeChecker (CodeGen)
- Do-while loops will fail if used (for now)
- Added for-loop code generation
Dependency
- Implemented `generalStatement()` for statement processing
- `generalPass()` now makes calls to `generalStatement()`
Tests
- Added `simple_for_loops.t` to test for-loops
- Added `simple_do_while.t` to test do-while loops
- Added new instruction `WhileLoopInstruction`
DGen
- Added support for emitting while-loops (so far just plain while loops) (`WhileLoopInstruction` in `emit()`)
- Added baked-in entry point testing code for while loops in `emitEntryPoint()`
Parsing
- Added missing plumbing for while loop parser nodes in `parseWhile()`
Data
- Fixed some typos
- Removed dead/unused "deps" code from `Entity`
- Added some documentation comments
- Added `WhileLoop` type for parser nodes
TypeChecker
- Removed TODO in comment for already-implemented/completed if-statements
- Added while-loop code generation support (only while-loops, no do-whiles)
Dependency
- Added while-loop dependency generation support (so far only while-loops, no do-whiles)
Tests
- Added new test case `simple_while.t` for testing while loops
- Fixed missing flushing for issue #65 (see "Flushing fix ✅")
- Added unit test for flushing fix
VariableDeclaration (Instruction)
- Added support for the embedding of a VariableAssignmentInstr inside (added a getter too) (a part of issue #66)
- Conditional support for if statements: Added two new instructions (IfStatementInstruction and BranchInstruction). See issue #64
DGen
- Added depth increment/decrement on enter/leave scope of `transform()`
- Correct tabbing for nested if-statements using new method `genTabs(ulong)` (which uses the above mechanism). Makes code emitted for if statements (issue #64) look nicer.
- Updated VariableDeclarations (with assignments) handling in `transform()` in the manner similar to BinOpInstr (see issue #66)
- Added a TODO for formatting BinOpInstr's `transform()` a little more aesthetically nicer
- Added code emitting support for if statements (the `IfStatementInstruction` instruction) (see issue #64)
- Updated `emitEntryPoint()` to only emit testing C code for the correct input test file
Parser
- `parseIf()` now returns an instance of IfStatement which couples multiple `Branch` objects consisting of `Statement[]` and `Expression`
- Ensured that each `Statement` of the generated `Statement[]` from `parseBody()` for a given `Branch` is parented to said Branch using `parentToContainer()`
- Ensured each generated `Branch` in `Branch[]` is parented to the generated `IfStatement` using `parentToContainer()`
- `parseBody()` now adds to its `Statement[]` build-up array the generated `IfStatement` from the call to `parseIf()`
Check
- Added support for back-mapping `SymbolType.EQUALS` to `getCharacter(SymbolType)`
Data
- Added `Branch` parser node which is a Container for body statements (`Statement[]`)
- Added `IfStatement` parser node which is a Container of `Statement[]` which are actually `Branch[]`
TypeChecker
- Moved import for `reverse` to top of module
- Implemented `tailPopInstr()` method which will pop from the back of the `codeQueue` "scratchpad"
- Fixes handling of `StaticVariableDeclaration` and `VariableAssignmentNode` (fixes issue #66)
- Added handling for IfStatement entities (if statement support #64)
Resolution
- Added a debug statement to `resolveUp(Container, string)` to print out the container to lookup from and the name being looked up
Dependency
- Added a default `toString()` to the DNode class which prints `[DNode: <entity toString()]`
- Added a TODO and debug print related to issues #9
- Disabled InitScope.STATIC check for now as it caused issues with if statement parsing (probably due to VIRTUAL being default and therefore skipping if statment processing) - issue #69
- Cleaned up handling of Entity type `Variable` (variable declarations) - removed repeated code
- Undid the VarAss->(depends on)->VarDec, reverted back to VarDec->(depends on)->VarAss, fixed by #66 (and closes it and #11)
- Added support for `IfStatement` (if statements) in `generalPass(Container, Context)`
Test cases
- Added new test case testing nested if statements (`nested_conditions.t`)
- Added another test case for if statements, `simple_conditions.t`
- Added new instruction type `ReturnInstruction`
Data
- Adjusted return statement parser node weighting to 2 (makes it on the same level as normal body statements)
Dependency
- Added dependency generation for return statements
- Removed old commented-out code in the function-definition generation section of `generalPass()`
TypeChecker/Codegen
- Added code generation for return statements
DGen
- Added code emitting for return statements (`ReturnInstruction`)
Test cases
- Updated test case `simple_functions.t` to test return statements
- Make the name of the function const and public for FuncCallInstr
CodeEmitter
- Added methods `getCursor()`, `getSelectedQueueLength()` and `getQueueLength()`
- Removed old queue-specific methods
DGen
- Added emitting for FuncCallInstr instruction (function call support)
- Now emit globals first BEFORE function definitions
- Added debug prints per instruction to know what instruction is currently being transform()'d
- After emitting sections add newlines between each to make for neater C code
- `emitEntryPoint()` now adds a test for `simple_function_decls.t` (This should be removed soon)
- Removed incorrect TODO in `finalize()`
Dependency
- Make the `nodePool` static, to ensure pooling carries over across multiple `DNodeGenerator` instances
- Fixed handling of function calls in `expressionPass()` - do NOT add a so-called `FunctionDefNode` (remember functions are defined by `addFuncDef()`)
- Set the Context of standalone variable assignments to the Context of the Variable entity representing the variable being assigned to
TypeChecker
- Assign the Context object stored in the `FunctionCall` statement to the `FuncCallInstr`
Test cases
- Updated test case `simple_function_decls.t`
- Removed all `emit()` methods (this is now done in the language-specific emitter - DGen)
CoreEmitter
- Added docstrings
- Added required `transform(Instruction)` method which must transform each provided Instruction into a string (a.k.a. do the actual emit()-ting)
DGen
- Migrated C-emit code into the overrided `transform(Instruction)` method
- VariableAssignment entity now has its Context object set to the current Context (of the Variable being declared) (so this is a declare assignment case only (so far)) (fixes#36)
TypeChecker
- Extract the Context object from the VariableAssignment entity and then set it as the Context for the VariableAssigmnetInstr instruction (fixes#36)
VariableAssigmnentInstr
- The `emit()` method will now emit the assignment code
Check
- Added `getCharacter(SymbolType)` which maps a SymbolType to a maths operator (WIP)
- Implemented the correct emit for this instruction (just emits the string version of the ulong `data`
BinOpInstr
- Emit is almost correct, just missing a mapping from SymbolType to the maths operator required
- Added new SymbolMapper class with a static method which will take a Container and an entity name, resolve the Entity and then generate the hash of the absolute path to said entity and return this as the `symbol name`
TypeChecker
- Set the static field to refer to this instance of the TypeChecker (in the SymbolMapper class)
VariableDeclaration
- Use the `symbolLookup()` method to transform the name
- Added `finalize()` method, this is to be called whenever the emitting is done and a compiler is to be called on the code
DGen
- Implemented a gcc-based finalization method
- Added `emitEntryPoint()` to emit a main() function which is to be called in libc's `_start` symbol
VariableDeclaration
- Added note we may need a symbol table lookup system actually, rather than just a simple `symbolRename`
Compiler
- Call the `finalize()` method on the DGen code emitter
----
Test cases
- Added `simple_variables_only_decs.t` to test code generation
- Added a method which will replace the `.`s in a symbol with underscores
Instruction
- The symbol names need to be valid in C so let's just make it a rule they will only have _'s (underscores) to replace any characters like `.`s
- Pass in the type of the variable being declared to the `VariableDeclaration` instruction
VariableDeclaration
- Emitted code now contains the type of the variable being declared
- Added float constant support to the lexer
- Added float support to the typechecker to build the correct Instruction type
Unit tests
- Added unit test for a bad example of a malformed encoded floating point to test out the lexer
This then generates code to allocate space for the class, once done we can be assured the declarations (placed after it now) will be assigning to properly allocated space (paged and maped for example)