diff --git a/AstBuilding.py b/AstBuilding.py
index 177b623cc98260a8686862ff177e63ff86d1bd16..dbf919b220c100236f64e714c2d6dfc4035cb5b9 100644
--- a/AstBuilding.py
+++ b/AstBuilding.py
@@ -71,7 +71,7 @@ def arrayClassMemory(types):
# Label for SIT pointer: "I_SIT_spot_typeName_array"
# Label for method pointers: "V_typeName_methodName_param_array"
code = "section .data\n"
- code += "; Start of class memory layout\n"
+ code += "; Start of class memory layout\n"
code += pLabel(name=t, type="array") + \
pLabel("SIT_spot_"+ t + "_array", "inter") + \
p(instruction="dd", arg1=64)
@@ -104,28 +104,38 @@ def arrayClassMemory(types):
# Preparation before code Gen:
# 1. Calculating the size of the object from each class
# (also simultaneosly creating fieldOffset because fieldOffset table is required to generate size)
-# 2. SIT building
+# 2. SIT building
# 3. Creating class memory layout for every possible array types
def codeGenPrep(ASTs):
interM = []
types = ['boolean', 'byte', 'char', 'int', 'short'] # All possible types
+ j = 0
for t in ASTs:
classInterNode = t[1].typeDcl
- if classInterNode and classInterNode.__class__.__name__ == "ClassNode":
+ types.append(classInterNode)
+
+ # assign each type a position in the subtype testing table
+ classInterNode.subTypeOffset = j * 4
+ j += 1
+
+ if classInterNode.__class__.__name__ == "ClassNode":
classInterNode.populateSizeAndFieldOffset()
classInterNode.populateMethodOffset()
types.append(classInterNode.name)
else: # interfaceNode, get their methods to prep for SIT
interM += classInterNode.methods
- if interM: # prep SIT
- for i in range(len(interM)):
- interM[i].methodOffset = i * 4
- interM[i].isInterM = True
- for t in ASTs:
- classInterNode = t[1].typeDcl
- if classInterNode and classInterNode.__class__.__name__ == "ClassNode":
- classInterNode.SITsize = len(interM)
+ # prep SIT
+ for i in range(len(interM)):
+ interM[i].methodOffset = i * 4
+ interM[i].isInterM = True
+
+ # store SIT and subtype table size
+ for t in ASTs:
+ classInterNode = t[1].typeDcl
+ if classInterNode.__class__.__name__ == "ClassNode":
+ classInterNode.SITsize = len(interM)
+ classInterNode.subTypeSize = len(types) - 5 # no primitive types in subtype table
return arrayClassMemory(types)
diff --git a/CodeGenUtils.py b/CodeGenUtils.py
index 4ea67d398fd23676abec5e7f6c63604a11585701..2602d677848c95e45ad71421eff47de512618fee 100644
--- a/CodeGenUtils.py
+++ b/CodeGenUtils.py
@@ -103,7 +103,7 @@ def iffalse(cond, label):
result += cond.code
result += p("jz", label)
return result
-
+
val = cond.getConstant()
if val != None:
if val == True:
@@ -135,11 +135,8 @@ def genericHelperFunctions():
# Note: using jle instead of calling the function since we don't need to preserve eip upon calling the exception function (?)
# saving and restoring ebx, a callee-save register
code += pLabel(name="_Null_Check", type="helper", comment="helper function for null check") + \
- p(instruction="push", arg1="ebx", comment="saving ebx") + \
- p(instruction="mov", arg1="ebx", arg2="[G__Zero]") + \
- p(instruction="cmp", arg1="eax", arg2="ebx") + \
+ p(instruction="cmp", arg1="eax", arg2="[G__Zero]") + \
p(instruction="jle", arg1="H__Throw_Exception") + \
- p(instruction="pop", arg1="ebx", comment="restoring ebx") + \
p(instruction="ret", arg1="")
# Helper function to perform bounds check on array
diff --git a/ExprPrimaryNodes.py b/ExprPrimaryNodes.py
index 43399ec5a704914e041aa62bb4e33b728606bce0..875443891797d24426f33b1e1bfaed15477aae94 100644
--- a/ExprPrimaryNodes.py
+++ b/ExprPrimaryNodes.py
@@ -367,7 +367,6 @@ class CastNode(ASTNode):
def checkType(self):
self.left.checkType()
- from pprint import pprint
self.right.disambigName()
self.right.checkType()
if (self.left.myType.isNum() and self.right.myType.isNum()) \
@@ -377,6 +376,29 @@ class CastNode(ASTNode):
return
raise Exception("ERROR: Cannot cast type {} to type {}.".format(self.right.myType.name, self.left.myType.name))
+ def codeGen(self):
+ if hasattr(self, "code") and self.code != "":
+ return
+ self.code = ""
+
+ # get object at right
+ self.code += "; casting\n"
+ self.right.codeGen()
+ self.code += self.right.code
+
+ # subtype test:
+ if not self.left.myType.isPrimitive:
+ # only test if right is not primitive (primitive types would be correctly static tested already)
+ offset = self.left.myType.typePointer.subTypeOffset
+ self.code += p("mov", "ebx", "[eax]", "start subtype test") # access class tag of left object
+ self.code += p("mov", "ebx", "[ebx + 4]") # access subtype testing column
+ self.code += p("mov", "ebx", "[ebx + " + str(offset) + "]") # ebx has isSubtype
+
+ # exception if not subtype, else do nothing (object is already in eax)
+ self.code += p("cmp", "[G__Zero]", "ebx")
+ self.code += p("je", "H__Throw_Exception")
+ self.code += "; end of casting\n"
+
###################################################################################
# unqualCreate NEW name LPAREN args RPAREN
class ClassCreateNode(ASTNode):
@@ -549,6 +571,28 @@ class ExprNode(ASTNode):
return
self.code = ""
+ # instanceOf
+ if self.op == "instanceof":
+
+ self.code += ("; evaluate instanceof\n")
+ self.left.codeGen()
+ self.code += self.left.code
+
+ # only test if non-primitive
+ if not self.right.myType.isPrimitive:
+ offset = self.right.myType.typePointer.subTypeOffset
+ self.code += p("mov", "eax", "[eax]") # access class tag of left object
+ self.code += p("mov", "eax", "[eax + 4]") # access subtype testing column
+ self.code += p("mov", "eax", "[eax + " + str(offset) + "]") # subType column stores 0 or 1 already
+ else: # primitive type can be staticly evaluated
+ if self.right.myType.assignable(self.left.myType):
+ self.code += p("mov", "eax", "1")
+ else:
+ self.code += p("mov", "eax", "0")
+
+ self.code += ("; end of instanceof\n")
+ return
+
# Unary operations:
if not self.left:
# get right output
@@ -651,8 +695,6 @@ class ExprNode(ASTNode):
self.code += p('pop', 'edx') # restore edx
return
- # if self.op == 'instanceof': TODO
- # return
# generate shorter code if self.op = comparison
def getIfFalse(self, label):
diff --git a/TypeNodes.py b/TypeNodes.py
index 4a8d262de7247764b7a3daed3d668175d08a5e9e..71c91b7b13ed435a4c4a8a936410f05a9c31687e 100644
--- a/TypeNodes.py
+++ b/TypeNodes.py
@@ -17,6 +17,8 @@ class ClassInterNode(ASTNode):
self.children = []
self.canonName = ''
self.SITsize = 0
+ self.subTypeSize = 0
+ self.subTypeOffset = 0
# sets
self.inherits = []
@@ -309,6 +311,8 @@ class ClassNode(ClassInterNode):
def populateMethodOffset(self):
if hasattr(self, "data"):
return
+
+ self.code = "" # For read-only section
self.data = "" # For writeable data section
if self.canonName == "java.lang.Object":
self.data += p("global", "I_SIT_" + self.name)
@@ -319,10 +323,12 @@ class ClassNode(ClassInterNode):
self.data += self.label
# SIT
- self.data += pLabel("SIT_spot_"+ self.name, "inter") # type 'inter' for interface methods
+ self.data += pLabel("SIT_spot_"+ self.name, "inter") # type 'inter' for internal usage
self.data += p("dd", "42")
- # TODO: subtype testing tables
+ # subtype testing table
+ self.data += pLabel("subT_spot_"+ self.name, "inter") # type 'inter' for internal usage
+ self.data += p("dd", "42")
####### ADDING METHODS TO CLASS MEMORY LAYOUT AND FIELDS TO FIELD OFFSET TABLE #########
# Copying over the offsets of methods from superclass and DECLARING memory segment for the methods
@@ -378,6 +384,12 @@ class ClassNode(ClassInterNode):
self.data += pLabel("SIT_" + str(i), "inter")
self.data += p("dd", "42")
+ # Layout subtype testing column
+ self.data += pLabel("subT_" + self.name, "inter")
+ for i in range(self.subTypeSize):
+ self.data += pLabel("subT_" + str(i), "inter")
+ self.data += p("dd", "0") # 0 for False, 1 for True
+
self.data += ";END OF CLASS MEMORY LAYOUT FOR CLASS " + self.name + "\n"
@@ -429,19 +441,21 @@ class ClassNode(ClassInterNode):
self.code += p("mov", "[eax]", "dword " + imLabel)
self.code += "; End of fill in SIT.\n"
- self.code += p(instruction="ret", arg1="")
- self.code += "; End of function for filling in class memory layout\n"
-
+ # fill in subtype testing column
+ self.code += "\n; Filling in subtype testing\n"
+ self.code += p("mov", "eax", "I_subT_spot_" + self.name)
+ self.code += p("mov", "[eax]", "dword I_subT_" + self.name)
+ for t in getSupers(self): # getSupers includes self
+ dlabel = "I_subT_" + str(t.subTypeOffset // 4)
+ self.code += p("mov", "eax", dlabel, "self is a subType of " + t.canonName)
+ self.code += p("mov", "[eax]", "dword 1")
+ self.code += "; End of fill in subtype testing.\n"
+ self.code += p(instruction="ret", arg1="")
+ self.code += "; End of function for filling in class memory layout\n"
-
- # print(self.name)
- # print(self.fieldOffset)
-
- # print(self.code)
-
###########################################################
# Generating a function that allocates and initializes all static fields
@@ -558,3 +572,12 @@ def safeReplace(cur, new, className):
# quick fix for final method getClass from java.lang.Object
if 'final' in cur.mods and cur.name != 'getClass':
raise Exception("ERROR: In class {0}, {1} '{2}' in class '{3}' replaces final {1} in class/interface {4}".format(className, methodOrField, new.name, new.typeName, cur.typeName))
+
+
+# helper: get list of all super class/interface of a ClassInterNode
+def getSupers(classType):
+ result = {classType}
+ for s in classType.super:
+ result.add(s)
+ result.union(getSupers(s))
+ return result