Merge pull request #43 from CompilerProgramming/son21

dibyendumajumdar · web-flow · commit 87ee25e824eb · 2025-04-06T14:41:54.000+01:00
Various fixes:
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java
@@ -90,7 +90,12 @@ public TypeDictionary createAST(String src) {
 
 
     private void populateDefaultTypes(Map<String,SONType> types) {
+        // Pre-create int, [int] and *[int] types
         types.put(typeDictionary.INT.name(), SONTypeInteger.BOT);
+        var intArrayType = SONTypeStruct.makeAry(SONTypeInteger.U32, _code.getALIAS(), SONTypeInteger.BOT, _code.getALIAS());
+        var ptrIntArrayType = SONTypeMemPtr.make(intArrayType);
+        types.put("[" + typeDictionary.INT.name() + "]", ptrIntArrayType);
+        // Also get the types created by default
         for (SONType t: SONType.gather()) {
             types.put(t.str(), t);
         }
@@ -145,26 +150,31 @@ private void createSONStructType(Map<String, SONType> structTypes, String typeNa
             Type type = typeStruct.getField(name); // FIXME
             fs.push(new Field(name,getSONType(structTypes,type),_code.getALIAS(),false));
         }
+        // A Struct type may have been created before because of
+        // reference from itself; in which case we need to update that
         SONType fref = structTypes.get(typeName);
         if (fref != null) {
-            if (fref instanceof SONTypeStruct ts) {
+            if (fref instanceof SONTypeMemPtr ptr &&
+                ptr._obj instanceof SONTypeStruct ts) {
+                assert ts._fields.length == 0;
+                // Add the fields to the existing type
                 ts._fields = fs.asAry();
             }
-            else throw new CompilerException("");
+            else throw new CompilerException("Expected struct type " + typeName + " but got " + fref);
         }
         else {
-            structTypes.put(typeName, new SONTypeStruct(typeName, fs.asAry()));
+            var ts = SONTypeStruct.make(typeName, fs.asAry());
+            var ptr = SONTypeMemPtr.make((byte)2,ts);
+            structTypes.put(typeName,ptr);
         }
-//        SONTypeStruct ts = SONTypeStruct.make(typeName, fs.asAry());
-//        TYPES.put(typeName, SONTypeMemPtr.make(ts));
     }
 
     private String getSONTypeName(Type type) {
         if (type instanceof Type.TypeFunction typeFunction) {
             return typeFunction.name;
         }
         else if (type instanceof Type.TypeArray typeArray) {
-            return typeArray.name();
+            return "*[" + getSONTypeName(typeArray.getElementType()) + "]";
         }
         else if (type instanceof Type.TypeStruct typeStruct) {
             return "*" + typeStruct.name;
@@ -183,36 +193,25 @@ else if (type instanceof Type.TypeNullable typeNullable) {
     }
 
     private SONType getSONType(Map<String, SONType> structTypes, Type type) {
-        String tname = getSONTypeName(type);
-        SONType t = structTypes.get(tname);
+        SONType t = structTypes.get(type.name());
         if (t != null) return t;
         if (type instanceof Type.TypeStruct) {
-            SONType existing = structTypes.get(type.name);
-            SONTypeStruct ts;
-            if (existing instanceof SONTypeStruct tsExisting)
-                ts = tsExisting;
-            else {
-                ts = new SONTypeStruct(type.name, new Field[0]);
-                structTypes.put(ts.str(), ts);
-            }
-            SONTypeMemPtr ptr = new SONTypeMemPtr((byte)2,ts);
-            if (type.name().equals(ts.str())) {
-                structTypes.put(ptr.str(), ptr);
-                return ptr;
-            }
-            else throw new CompilerException("Unexpected error");
+            // For struct types in EeZee language a reference
+            // to T means *T in SoN
+            // Create SON struct type
+            SONTypeStruct ts = SONTypeStruct.make(type.name, new Field[0]);
+            // Now create *T
+            SONTypeMemPtr ptr = SONTypeMemPtr.make((byte)2,ts);
+            // EeZee T maps to SoN *T
+            structTypes.put(type.name(), ptr);
+            return ptr;
         }
         else if (type instanceof Type.TypeArray typeArray) {
+            // A reference to array in EeZee means
+            // *array in SoN
             SONType elementType = getSONType(structTypes,typeArray.getElementType());
-            SONTypeStruct ts = null;
-            SONType existing = structTypes.get(typeArray.name());
-            if (existing instanceof SONTypeStruct tsExisting)
-                ts = tsExisting;
-            else {
-                ts = SONTypeStruct.makeArray(SONTypeInteger.U32, _code.getALIAS(), elementType, _code.getALIAS());
-                structTypes.put(ts.str(), ts);
-            }
-            SONTypeMemPtr ptr = new SONTypeMemPtr((byte)2,ts);
+            SONTypeStruct ts = SONTypeStruct.makeArray(SONTypeInteger.U32, _code.getALIAS(), elementType, _code.getALIAS());
+            SONTypeMemPtr ptr = SONTypeMemPtr.make((byte)2,ts);
             structTypes.put(typeArray.name(), ptr); // Array type name is not same as ptr str()
             return ptr;
         }
@@ -223,11 +222,11 @@ else if (type instanceof Type.TypeNullable typeNullable) {
                 if (ptr1.nullable())
                     ptr = ptr1;
                 else
-                    ptr = new SONTypeMemPtr((byte)3,ptr1._obj);
+                    ptr = SONTypeMemPtr.make((byte)3,ptr1._obj);
             }
             else
-                ptr = new SONTypeMemPtr((byte)2,(SONTypeStruct) baseType);
-            structTypes.put(ptr.str(), ptr);
+                ptr = SONTypeMemPtr.make((byte)2,(SONTypeStruct) baseType);
+            structTypes.put(typeNullable.name(), ptr);
             return ptr;
         }
         else if (type instanceof Type.TypeVoid) {
@@ -241,13 +240,13 @@ else if (type instanceof Type.TypeVoid) {
 
     // TODO because first two slots are MEM and RPC
     private int REGNUM = 2;
-    private void setVarIds(Scope scope, ScopeNode scopeNode, FunNode fun) {
+    private void defineScopedVars(Scope scope, ScopeNode scopeNode, FunNode fun) {
         for (Symbol symbol: scope.getLocalSymbols()) {
             if (symbol instanceof Symbol.VarSymbol varSymbol) {
                 varSymbol.regNumber = REGNUM++;
-                String sonTypeName = getSONTypeName(varSymbol.type);
-                SONType sonType = TYPES.get(sonTypeName);
-                if (sonType == null) throw new CompilerException("Unknown SON Type "+sonTypeName);
+                SONType sonType = TYPES.get(varSymbol.type.name());
+                if (sonType == null)
+                    throw new CompilerException("Unknown SON Type "+varSymbol.type.name());
                 Node init = null;
 
                 if (varSymbol instanceof Symbol.ParameterSymbol) {
@@ -256,9 +255,6 @@ private void setVarIds(Scope scope, ScopeNode scopeNode, FunNode fun) {
                 scopeNode.define(makeVarName(varSymbol), sonType, false, init);
             }
         }
-        for (Scope childScope: scope.children) {
-            setVarIds(childScope, scopeNode, fun);
-        }
     }
 
     private void generateFunction(Symbol.FunctionTypeSymbol functionTypeSymbol) {
@@ -338,7 +334,8 @@ private ReturnNode generateFunctionBody(Symbol.FunctionTypeSymbol functionTypeSy
         _scope.mem(mem);
         // All args, "as-if" called externally
         AST.FuncDecl funcDecl = (AST.FuncDecl) functionTypeSymbol.functionDecl;
-        setVarIds(funcDecl.scope,_scope,fun);
+        REGNUM = 2;
+        defineScopedVars(funcDecl.scope,_scope,fun);
 
         // Parse the body
         Node last = compileStatement(funcDecl.block);
@@ -556,12 +553,12 @@ private Node newStruct( SONTypeStruct obj, Node size) {
     private Node compileNewExpr(AST.NewExpr newExpr) {
         Type type = newExpr.type;
         if (type instanceof Type.TypeArray typeArray) {
-            SONTypeMemPtr tarray = (SONTypeMemPtr) TYPES.get(getSONTypeName(typeArray));
+            SONTypeMemPtr tarray = (SONTypeMemPtr) TYPES.get(typeArray.name());
             return newArray(tarray._obj,ZERO);
         }
         else if (type instanceof Type.TypeStruct typeStruct) {
-            SONTypeStruct tstruct = (SONTypeStruct) TYPES.get(typeStruct.name());
-            return newStruct(tstruct,con(tstruct.offset(tstruct._fields.length)));
+            SONTypeMemPtr tptr = (SONTypeMemPtr) TYPES.get(typeStruct.name());
+            return newStruct(tptr._obj,con(tptr._obj.offset(tptr._obj._fields.length)));
         }
         else
             throw new CompilerException("Unexpected type: " + type);
@@ -701,7 +698,7 @@ private Node compileCallExpr(AST.CallExpr callExpr) {
     }
 
     private String makeVarName(Symbol.VarSymbol varSymbol) {
-        return varSymbol.name + "$" + varSymbol.regNumber;
+        return varSymbol.name; // + "$" + varSymbol.regNumber;
     }
 
     private Node compileStatement(AST.Stmt statement) {
@@ -955,9 +952,12 @@ private Node compileReturn(AST.ReturnStmt returnStmt) {
 
     private Node compileBlock(AST.BlockStmt block) {
         Node last = ZERO;
+        _scope.push(ScopeNode.Kind.Block);
+        defineScopedVars(block.scope, _scope, _fun);
         for (AST.Stmt stmt: block.stmtList) {
             last = compileStatement(stmt);
         }
+        _scope.pop();
         return last;
     }
 
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java
@@ -41,10 +41,10 @@ public SONTypeFunPtr(byte nil, SONTypeTuple sig, SONType ret, long fidxs) {
     public SONTypeFunPtr makeFrom(int fidx ) { return make((byte)2, _sig,_ret,1L<<fidx ); }
 
     public static SONTypeFunPtr BOT   = make((byte)3, SONTypeTuple.BOT, SONType.BOTTOM,-1);
-    public static SONTypeFunPtr TEST  = make((byte)2, SONTypeTuple.TEST, SONTypeInteger.BOT,1);
-    public static SONTypeFunPtr TEST0 = make((byte)3, SONTypeTuple.TEST, SONTypeInteger.BOT,3);
+//    public static SONTypeFunPtr TEST  = make((byte)2, SONTypeTuple.TEST, SONTypeInteger.BOT,1);
+//    public static SONTypeFunPtr TEST0 = make((byte)3, SONTypeTuple.TEST, SONTypeInteger.BOT,3);
     public static SONTypeFunPtr MAIN  = make((byte)3, SONTypeTuple.MAIN, SONTypeInteger.BOT,-1);
-    public static void gather(ArrayList<SONType> ts) { ts.add(TEST); ts.add(TEST0); ts.add(BOT); ts.add(MAIN); }
+    public static void gather(ArrayList<SONType> ts) { /* ts.add(TEST); ts.add(TEST0); */ ts.add(BOT); ts.add(MAIN); }
 
     @Override
     SONType xmeet(SONType t) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeMemPtr.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeMemPtr.java
@@ -31,7 +31,7 @@ public SONTypeMemPtr(byte nil, SONTypeStruct obj) {
         assert obj!=null;
         _obj = obj;
     }
-    static SONTypeMemPtr make(byte nil, SONTypeStruct obj) { return new SONTypeMemPtr(nil, obj).intern(); }
+    public static SONTypeMemPtr make(byte nil, SONTypeStruct obj) { return new SONTypeMemPtr(nil, obj).intern(); }
     public static SONTypeMemPtr makeNullable(SONTypeStruct obj) { return make((byte)3, obj); }
     public static SONTypeMemPtr make(SONTypeStruct obj) { return new SONTypeMemPtr((byte)2, obj).intern(); }
     public SONTypeMemPtr makeFrom(SONTypeStruct obj) { return obj==_obj ? this : make(_nil, obj); }
@@ -47,8 +47,8 @@ public SONTypeMemPtr(byte nil, SONTypeStruct obj) {
     public static SONTypeMemPtr TOP = BOT.dual();
     public static SONTypeMemPtr NOTBOT = make((byte)2, SONTypeStruct.BOT);
 
-    public static SONTypeMemPtr TEST= make((byte)2, SONTypeStruct.TEST);
-    public static void gather(ArrayList<SONType> ts) { ts.add(NOTBOT); ts.add(BOT); ts.add(TEST); }
+    //public static SONTypeMemPtr TEST= make((byte)2, SONTypeStruct.TEST);
+    public static void gather(ArrayList<SONType> ts) { ts.add(NOTBOT); ts.add(BOT); /* ts.add(TEST); */ }
 
     @Override
     public SONTypeNil xmeet(SONType t) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeStruct.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeStruct.java
@@ -35,7 +35,7 @@ public SONTypeStruct(String name, Field[] fields) {
     public static SONTypeStruct make(String name, Field... fields) { return new SONTypeStruct(name, fields).intern(); }
     public static final SONTypeStruct TOP = make("$TOP",new Field[0]);
     public static final SONTypeStruct BOT = make("$BOT",new Field[0]);
-    public static final SONTypeStruct TEST = make("test",new Field[]{Field.TEST});
+    //public static final SONTypeStruct TEST = make("test",new Field[]{Field.TEST});
     // Forward-ref version
     public static SONTypeStruct makeFRef(String name) { return make(name, (Field[])null); }
     // Make a read-only version
@@ -66,14 +66,14 @@ public static SONTypeStruct makeArray(SONTypeInteger len, int lenAlias, SONType
     }
 
     // A pair of self-cyclic types
-    private static final SONTypeStruct S1F = makeFRef("S1");
-    private static final SONTypeStruct S2F = makeFRef("S2");
-    public  static final SONTypeStruct S1  = make("S1", Field.make("a", SONTypeInteger.BOT, -1, false), Field.make("s2", SONTypeMemPtr.make((byte)2,S2F),-2, false) );
-    private static final SONTypeStruct S2  = make("S2", Field.make("b", SONTypeFloat.F64, -3, false), Field.make("s1", SONTypeMemPtr.make((byte)2,S1F),-4, false) );
+//    private static final SONTypeStruct S1F = makeFRef("S1");
+//    private static final SONTypeStruct S2F = makeFRef("S2");
+//    public  static final SONTypeStruct S1  = make("S1", Field.make("a", SONTypeInteger.BOT, -1, false), Field.make("s2", SONTypeMemPtr.make((byte)2,S2F),-2, false) );
+//    private static final SONTypeStruct S2  = make("S2", Field.make("b", SONTypeFloat.F64, -3, false), Field.make("s1", SONTypeMemPtr.make((byte)2,S1F),-4, false) );
+//
+//    private static final SONTypeStruct ARY = makeAry(SONTypeInteger.U32,-1, SONTypeInteger.BOT,-2);
 
-    private static final SONTypeStruct ARY = makeAry(SONTypeInteger.U32,-1, SONTypeInteger.BOT,-2);
-
-    public static void gather(ArrayList<SONType> ts) { ts.add(TEST); ts.add(BOT); ts.add(S1); ts.add(S2); ts.add(ARY); }
+    public static void gather(ArrayList<SONType> ts) { /* ts.add(TEST); ts.add(BOT); ts.add(S1); ts.add(S2); ts.add(ARY); */ }
 
     // Find field index by name
     public int find(String fname) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeTuple.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeTuple.java
@@ -13,7 +13,7 @@ public class SONTypeTuple extends SONType {
     public static final SONTypeTuple BOT = new SONTypeTuple(new SONType[0]).intern();
     public static final SONTypeTuple TOP = new SONTypeTuple(null).intern();
 
-    public static final SONTypeTuple TEST = make(SONTypeInteger.BOT, SONTypeMemPtr.TEST);
+    //public static final SONTypeTuple TEST = make(SONTypeInteger.BOT, SONTypeMemPtr.TEST);
     public static final SONTypeTuple START= make(SONType.CONTROL, SONTypeMem.TOP, SONTypeInteger.BOT);
     public static final SONTypeTuple MAIN = make(SONTypeInteger.BOT);
     public static final SONTypeTuple RET  = make(SONType.CONTROL, SONTypeMem.BOT, SONType.BOTTOM);
@@ -23,7 +23,7 @@ public class SONTypeTuple extends SONType {
     public static final SONTypeTuple IF_TRUE    = make(new SONType[]{SONType. CONTROL, SONType.XCONTROL});
     public static final SONTypeTuple IF_FALSE   = make(new SONType[]{SONType.XCONTROL, SONType. CONTROL});
 
-    public  static void gather(ArrayList<SONType> ts) { ts.add(BOT); ts.add(TEST); ts.add(START); ts.add(MAIN); ts.add(IF_TRUE); }
+    public  static void gather(ArrayList<SONType> ts) { ts.add(BOT); /* ts.add(TEST); */ ts.add(START); ts.add(MAIN); ts.add(IF_TRUE); }
 
     @Override
     SONType xmeet(SONType other) {
diff --git a/seaofnodes/src/test/cases/fib/fib.ez b/seaofnodes/src/test/cases/fib/fib.ez
@@ -0,0 +1,18 @@
+func fib(n: Int)->Int {
+    var i: Int;
+    var temp=0;
+    var f1=1;
+    var f2=1;
+    i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+}
+
+func foo()->Int {
+    return fib(10);
+}
diff --git a/seaofnodes/src/test/cases/fib/fib.ir b/seaofnodes/src/test/cases/fib/fib.ir
@@ -0,0 +1,46 @@
+START:                            [[   ]]
+   1 Start   ____ ____ ____       [[     3    4    9   16   18    8    5   46  ]]  [  Ctrl, #TOP, int]
+
+L8:                               [[  START      ]]
+   8 fib     ____    1            [[    10   17   19   20   22  ]]  Ctrl
+  10 $rpc       8    9            [[    14       ]]  $[ALL]
+  17 $mem       8   16            [[    14       ]]  #BOT
+  19 n$2        8   18            [[    25       ]]  int
+  20 #1         8                 [[    37   39   26   41  ]]  1
+
+L46:                              [[  START      ]]
+  46 foo     ____    1            [[    48   55   56   57   59  ]]  Ctrl
+  48 $rpc      46    9            [[    52       ]]  $[ALL]
+  55 $mem      46   16            [[    59       ]]  #BOT
+  57 #10       46                 [[    59       ]]  10
+  56 #{ int    46                 [[    59       ]]  { int -> int #1}
+  59 Call      46   55   57   56  [[    60       ]]  Ctrl
+
+LOOP22:                           [[  L8        L29        ]]
+  22 Loop    ____    8   29       [[    39   25   37   26   28  ]]  Ctrl
+  39 Phi_f2$   22   20   38       [[    37   14   38  ]]  int
+  25 Phi_i$3   22   19   41       [[    26   41  ]]  int
+  37 Phi_f1$   22   20   39       [[    38       ]]  int
+  26 LT        22   20   25       [[    28       ]]  bool
+  28 If        22   26            [[    29   30  ]]  [  Ctrl, Ctrl]
+
+L60:                              [[  L46        ]]
+  60 CallEnd   59                 [[    61   63   64  ]]  [  Ctrl, #BOT, int]
+  63 $mem      60                 [[    52       ]]  #BOT
+  64 #2        60                 [[    52       ]]  int
+
+L30:                              [[  LOOP22     ]]
+  30 False     28                 [[    14       ]]  Ctrl
+  14 Return    30   17   39   10  [[     2       ]]  [  Ctrl, #BOT, int]
+
+L29:                              [[  LOOP22     ]]
+  29 True      28                 [[    38   41   22  ]]  Ctrl
+  41 Sub       29   25   20       [[    25       ]]  int
+  38 Add       29   39   37       [[    39       ]]  int
+
+L61:                              [[  L60        ]]
+  61 $ctrl     60                 [[    52       ]]  Ctrl
+  52 Return    61   63   64   48  [[     2       ]]  [  Ctrl, #BOT, int]
+
+L2:                               [[   ]]
+   2 Stop      14   52            [[             ]]  Bot
diff --git a/seaofnodes/src/test/cases/fib/fib.simple b/seaofnodes/src/test/cases/fib/fib.simple
@@ -0,0 +1,15 @@
+val fib = {int n ->
+    int temp=0;
+    int f1=1;
+    int f2=1;
+    int i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+};
+
+fib(10);
diff --git a/seaofnodes/src/test/cases/fib/fib.simple_ir b/seaofnodes/src/test/cases/fib/fib.simple_ir
diff --git a/seaofnodes/src/test/cases/hello/hello.ez b/seaofnodes/src/test/cases/hello/hello.ez
diff --git a/seaofnodes/src/test/cases/mergsort/sort.ez b/seaofnodes/src/test/cases/mergsort/sort.ez
diff --git a/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/TestSONTypes.java b/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/TestSONTypes.java
