WIP TypeState compiler will have type information in the IR and use this to build typestate per basic block

Set max local reg and max stack size

Rename FunctionBuilder to BytecodeFunction

Revised call instruction

Revised temp register assignment to start from maxLocalReg rather than 0 so that we have a single set of registers per function

Initial work on Interpreter

Generate more specific array store/load and field set/get instructions rather than move.

More specific instructions for creating new instances of arrays and structs

Revised handling of call instruction -- copy args to new frame and copy result back
unary op in interpreter

Revised handling of call instruction -- copy args to new frame and copy result back
unary op in interpreter

Fix issue with return a[1]
Add support for arrays and structs in the interpreter.

Renames in stackvm module

Register type

fix refactor

fix refactor

Update README

Update README

Update README

Author: dibyendumajumdar

README.md

@@ -2,5 +2,45 @@
 
 This project is part of the https://compilerprogramming.github.io/ project.
 
-The EZ (pronounced EeeZee) programming language is designed to allow us to learn various compiler techniques.
+The EZ (pronounced EeZee) programming language is designed to allow us to learn various compiler techniques.
+
+## The EZ Language
+
+The EZ programming language is a tiny statically typed language with syntax inspired by Swift.
+The language has the following features:
+
+* Integer, Struct and 1-Dimensional Array types
+* If and While statements
+* Functions
+
+The language syntax is described [ANTLR Grammar](antlr-parser/src/main/antlr4/com/compilerprogramming/ezlang/antlr/EZLanguage.g4).
+The language is intentionally very simple and is meant to have just enough functionality to experiment with compiler implementation techniques.
+
+## Modules
+
+The project is under development and subject to change. At this point in time, we have following initial implementations:
+
+* lexer - a simple tokenizer
+* parser - a recursive descent parser and AST
+* types - the type definitions
+* semantic - semantic analyzer
+* stackvm - a bytecode compiler that generates stack IR (bytecode interpreter not yet available)
+* registervm - a bytecode compiler that generates a linear register IR and a bytecode interpreter that can execute the IR
+
+## How can you contribute?
+
+Obviously firstly any contributes that improve and fix bugs are welcome. I am not keen on language extensions at this stage, but eventually
+we will be extending the language to explore more advanced features.
+
+I am also interested in creating implementations of this project in C++, Go, Rust, swift, D, C, etc. If you are interested in working on such a 
+port please contact me via [Discussions](https://github.com/orgs/CompilerProgramming/discussions).
+
+## Community Discussions
+
+There is a [community discussion forum](https://github.com/orgs/CompilerProgramming/discussions).
+
+## What's next
+
+The project has only just got started, there is lots to do!. See the plan in the [website](https://compilerprogramming.github.io/).
 More documentation to follow, but for now please refer to the source code and the site above.
+

common/src/main/java/com/compilerprogramming/ezlang/exceptions/InterpreterException.java

@@ -0,0 +1,8 @@
+package com.compilerprogramming.ezlang.exceptions;
+
+public class InterpreterException extends RuntimeException {
+    public InterpreterException(String message) {super(message);}
+    public InterpreterException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

registervm/src/main/java/com/compilerprogramming/ezlang/bytecode/RegisterVMCompiler.java renamed to registervm/src/main/java/com/compilerprogramming/ezlang/bytecode/BytecodeCompiler.java

@@ -1,14 +1,16 @@
 package com.compilerprogramming.ezlang.bytecode;
 
 import com.compilerprogramming.ezlang.types.Symbol;
+import com.compilerprogramming.ezlang.types.Type;
 import com.compilerprogramming.ezlang.types.TypeDictionary;
 
-public class RegisterVMCompiler {
+public class BytecodeCompiler {
 
     public void compile(TypeDictionary typeDictionary) {
         for (Symbol symbol: typeDictionary.getLocalSymbols()) {
             if (symbol instanceof Symbol.FunctionTypeSymbol functionSymbol) {
-                functionSymbol.code = new FunctionBuilder(functionSymbol);
+                Type.TypeFunction functionType = (Type.TypeFunction) functionSymbol.type;
+                functionType.code = new BytecodeFunction(functionSymbol);
             }
         }
     }

registervm/src/main/java/com/compilerprogramming/ezlang/bytecode/FunctionBuilder.java renamed to registervm/src/main/java/com/compilerprogramming/ezlang/bytecode/BytecodeFunction.java

@@ -9,10 +9,12 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class FunctionBuilder {
+public class BytecodeFunction {
 
     public BasicBlock entry;
     public BasicBlock exit;
+    public int maxLocalReg;
+    public int maxStackSize;
     private int bid = 0;
     private BasicBlock currentBlock;
     private BasicBlock currentBreakTarget;
@@ -28,7 +30,7 @@ public class FunctionBuilder {
      */
     private List<Operand> virtualStack = new ArrayList<>();
 
-    public FunctionBuilder(Symbol.FunctionTypeSymbol functionSymbol) {
+    public BytecodeFunction(Symbol.FunctionTypeSymbol functionSymbol) {
         AST.FuncDecl funcDecl = (AST.FuncDecl) functionSymbol.functionDecl;
         setVirtualRegisters(funcDecl.scope);
         this.bid = 0;
@@ -40,6 +42,10 @@ public FunctionBuilder(Symbol.FunctionTypeSymbol functionSymbol) {
         exitBlockIfNeeded();
     }
 
+    public int frameSize() {
+        return maxLocalReg+maxStackSize;
+    }
+
     private void exitBlockIfNeeded() {
         if (currentBlock != null &&
                 currentBlock != exit) {
@@ -57,6 +63,8 @@ private void setVirtualRegisters(Scope scope) {
             }
         }
         scope.maxReg = reg;
+        if (maxLocalReg < scope.maxReg)
+            maxLocalReg = scope.maxReg;
         for (Scope childScope: scope.children) {
             setVirtualRegisters(childScope);
         }
@@ -78,9 +86,11 @@ private void compileBlock(AST.BlockStmt block) {
 
     private void compileReturn(AST.ReturnStmt returnStmt) {
         if (returnStmt.expr != null) {
-            compileExpr(returnStmt.expr);
+            boolean isIndexed = compileExpr(returnStmt.expr);
+            if (isIndexed)
+                codeIndexedLoad();
             if (virtualStack.size() == 1)
-                code(new Instruction.Move(pop(), new Operand.ReturnRegisterOperand()));
+                code(new Instruction.Return(pop()));
             else if (virtualStack.size() > 1)
                 throw new CompilerException("Virtual stack has more than one item at return");
         }
@@ -269,32 +279,35 @@ private boolean compileExpr(AST.Expr expr) {
 
     private boolean compileCallExpr(AST.CallExpr callExpr) {
         compileExpr(callExpr.callee);
-        var callee = top();
-        if (!(callee instanceof Operand.TempRegisterOperand) ) {
-            var origCallee = pop();
-            callee = createTemp();
-            code(new Instruction.Move(origCallee, callee));
-        }
-        List<Operand> args = new ArrayList<>();
+        var callee = pop();
+        Type.TypeFunction calleeType = null;
+        if (callee instanceof Operand.LocalFunctionOperand functionOperand)
+            calleeType = functionOperand.functionType;
+        else throw new CompilerException("Cannot call a non function type");
+        var returnStackPos = virtualStack.size();
+        List<Operand.RegisterOperand> args = new ArrayList<>();
         for (AST.Expr expr: callExpr.args) {
             boolean indexed = compileExpr(expr);
             if (indexed)
                 codeIndexedLoad();
             var arg = top();
             if (!(arg instanceof Operand.TempRegisterOperand) ) {
                 var origArg = pop();
-                arg = createTemp();
+                arg = createTemp(origArg.type);
                 code(new Instruction.Move(origArg, arg));
             }
-            args.add(arg);
+            args.add((Operand.RegisterOperand) arg);
         }
-        code(new Instruction.Call(callee, args.toArray(new Operand[args.size()])));
-        // Similute the actions on the stack
-        for (int i = 0; i < args.size()+1; i++)
+        // Simulate the actions on the stack
+        for (int i = 0; i < args.size(); i++)
             pop();
+        Operand.TempRegisterOperand ret = null;
         if (callExpr.callee.type instanceof Type.TypeFunction tf &&
-            tf.returnType != null)
-            createTemp();
+                !(tf.returnType instanceof Type.TypeVoid)) {
+            ret = createTemp(tf.returnType);
+            assert ret.regnum-maxLocalReg == returnStackPos;
+        }
+        code(new Instruction.Call(returnStackPos, ret, calleeType, args.toArray(new Operand.RegisterOperand[args.size()])));
         return false;
     }
 
@@ -347,13 +360,20 @@ private boolean compileSetFieldExpr(AST.SetFieldExpr setFieldExpr) {
     }
 
     private void codeNew(Type type) {
-        var temp = createTemp();
-        code(new Instruction.Move(new Operand.NewTypeOperand(type), temp));
+        var temp = createTemp(type);
+        if (type instanceof Type.TypeArray typeArray) {
+            code(new Instruction.NewArray(typeArray, temp));
+        }
+        else if (type instanceof Type.TypeStruct typeStruct) {
+            code(new Instruction.NewStruct(typeStruct, temp));
+        }
+        else
+            throw new CompilerException("Unexpected type: " + type);
     }
 
     private void codeStoreAppend() {
         var operand = pop();
-        code(new Instruction.AStoreAppend(top(), operand));
+        code(new Instruction.AStoreAppend((Operand.RegisterOperand) top(), operand));
     }
 
     private boolean compileNewExpr(AST.NewExpr newExpr) {
@@ -399,7 +419,7 @@ private boolean compileBinaryExpr(AST.BinaryExpr binaryExpr) {
         Operand right = pop();
         Operand left = pop();
         if (left instanceof Operand.ConstantOperand leftconstant &&
-            right instanceof Operand.ConstantOperand rightconstant) {
+                right instanceof Operand.ConstantOperand rightconstant) {
             long value = 0;
             switch (opCode) {
                 case "+": value = leftconstant.value + rightconstant.value; break;
@@ -415,11 +435,11 @@ private boolean compileBinaryExpr(AST.BinaryExpr binaryExpr) {
                 case ">=": value = leftconstant.value <= rightconstant.value ? 1 : 0; break;
                 default: throw new CompilerException("Invalid binary op");
             }
-            pushConstant(value);
+            pushConstant(value, leftconstant.type);
         }
         else {
-            var temp = createTemp();
-            code(new Instruction.BinaryInstruction(opCode, temp, left, right));
+            var temp = createTemp(binaryExpr.type);
+            code(new Instruction.Binary(opCode, temp, left, right));
         }
         return false;
     }
@@ -433,35 +453,38 @@ private boolean compileUnaryExpr(AST.UnaryExpr unaryExpr) {
         Operand top = pop();
         if (top instanceof Operand.ConstantOperand constant) {
             switch (opCode) {
-                case "-": pushConstant(-constant.value); break;
-                case "!": pushConstant(constant.value == 0?1:0); break;
+                case "-": pushConstant(-constant.value, constant.type); break;
+                // Maybe below we should explicitly set Int
+                case "!": pushConstant(constant.value == 0?1:0, constant.type); break;
                 default: throw new CompilerException("Invalid unary op");
             }
         }
         else {
-            var temp = createTemp();
-            code(new Instruction.UnaryInstruction(opCode, temp, top));
+            var temp = createTemp(unaryExpr.type);
+            code(new Instruction.Unary(opCode, temp, top));
         }
         return false;
     }
 
     private boolean compileConstantExpr(AST.LiteralExpr constantExpr) {
-        pushConstant(constantExpr.value.num.intValue());
+        pushConstant(constantExpr.value.num.intValue(), constantExpr.type);
         return false;
     }
 
-    private void pushConstant(long value) {
-        virtualStack.add(new Operand.ConstantOperand(value));
+    private void pushConstant(long value, Type type) {
+        pushOperand(new Operand.ConstantOperand(value, type));
     }
 
-    private Operand.TempRegisterOperand createTemp() {
-        var tempRegister = new Operand.TempRegisterOperand(virtualStack.size());
-        virtualStack.add(tempRegister);
+    private Operand.TempRegisterOperand createTemp(Type type) {
+        var tempRegister = new Operand.TempRegisterOperand(virtualStack.size()+maxLocalReg, type);
+        pushOperand(tempRegister);
+        if (maxStackSize < virtualStack.size())
+            maxStackSize = virtualStack.size();
         return tempRegister;
     }
 
     private void pushLocal(int regnum, String varName) {
-        virtualStack.add(new Operand.LocalRegisterOperand(regnum, varName));
+        pushOperand(new Operand.LocalRegisterOperand(regnum, varName));
     }
 
     private void pushOperand(Operand operand) {
@@ -478,14 +501,28 @@ private Operand top() {
 
     private void codeIndexedLoad() {
         Operand indexed = pop();
-        var temp = createTemp();
-        code(new Instruction.Move(indexed, temp));
+        var temp = createTemp(indexed.type);
+        if (indexed instanceof Operand.LoadIndexedOperand loadIndexedOperand) {
+            code(new Instruction.ArrayLoad(loadIndexedOperand, temp));
+        }
+        else if (indexed instanceof Operand.LoadFieldOperand loadFieldOperand) {
+            code(new Instruction.GetField(loadFieldOperand, temp));
+        }
+        else
+            code(new Instruction.Move(indexed, temp));
     }
 
     private void codeIndexedStore() {
         Operand value = pop();
         Operand indexed = pop();
-        code(new Instruction.Move(value, indexed));
+        if (indexed instanceof Operand.LoadIndexedOperand loadIndexedOperand) {
+            code(new Instruction.ArrayStore(value, loadIndexedOperand));
+        }
+        else if (indexed instanceof Operand.LoadFieldOperand loadFieldOperand) {
+            code(new Instruction.SetField(value, loadFieldOperand));
+        }
+        else
+            code(new Instruction.Move(value, indexed));
     }
 
     private boolean vstackEmpty() {