777 lines
18 KiB
Python
777 lines
18 KiB
Python
'''
|
|
* @author Dr.Nguyen Hua Phung
|
|
* @version 1.0
|
|
* 28/6/2006
|
|
* This class provides facilities for method generation
|
|
*
|
|
'''
|
|
from abc import ABC, abstractmethod # , ABCMeta
|
|
from codegen.CodeGenError import (
|
|
IllegalOperandException
|
|
)
|
|
|
|
|
|
class MachineCode(ABC):
|
|
@abstractmethod
|
|
def emitPUSHNULL(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitICONST(self, i):
|
|
# i: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitBIPUSH(self, i):
|
|
# i: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitSIPUSH(self, i):
|
|
# i: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitLDC(self, in_):
|
|
# in_: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFCONST(self, i):
|
|
# i: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitILOAD(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFLOAD(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitISTORE(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFSTORE(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitALOAD(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitASTORE(self, in_):
|
|
# in_: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIASTORE(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFASTORE(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitBASTORE(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitAASTORE(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIALOAD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFALOAD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitBALOAD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitAALOAD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitGETSTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitPUTSTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitGETFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitPUTFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIADD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFADD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitISUB(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFSUB(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIMUL(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFMUL(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIDIV(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFDIV(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIAND(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIOR(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIREM(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFACMPEQ(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFACMPNE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPEQ(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPNE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPLT(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPLE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPGT(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFICMPGE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFEQ(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFNE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFLT(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFLE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFGT(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIFGE(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitLABEL(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitGOTO(self, label):
|
|
# label: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitINEG(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFNEG(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitDUP(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitDUPX2(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitPOP(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitI2F(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitNEW(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitNEWARRAY(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitANEWARRAY(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitMULTIANEWARRAY(self, typ, dimensions):
|
|
# typ: String
|
|
# dimensions: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitINVOKESTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitINVOKESPECIAL(self, lexeme=None, typ=None):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitINVOKEVIRTUAL(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitI(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitF(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emit(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitLIMITSTACK(self, in_):
|
|
# in_: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFCMPL(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitLIMITLOCAL(self, in_):
|
|
# in_: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitVAR(self, in_, varName, inType, fromLabel, toLabel):
|
|
# in_: Int
|
|
# varName: String
|
|
# inType: String
|
|
# fromLabel: Int
|
|
# toLabel: Int
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitMETHOD(self, lexeme, typ, isStatic):
|
|
# lexeme: String
|
|
# typ: String
|
|
# isStaic: Boolean
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitENDMETHOD(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitSOURCE(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitCLASS(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitSUPER(self, lexeme):
|
|
# lexeme: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitSTATICFIELD(self, lexeme, typ, isFinal):
|
|
# lexeme: String
|
|
# typ: String
|
|
# isFinal: Boolean
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitINSTANCEFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitRETURN(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitIRETURN(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitFRETURN(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def emitARETURN(self):
|
|
pass
|
|
|
|
|
|
class JasminCode(MachineCode):
|
|
END = "\n"
|
|
INDENT = "\t"
|
|
|
|
def emitPUSHNULL(self):
|
|
return JasminCode.INDENT + "aconst_null" + JasminCode.END
|
|
|
|
def emitICONST(self, i):
|
|
# i: Int
|
|
if i == -1:
|
|
return JasminCode.INDENT + "iconst_ml" + JasminCode.END
|
|
elif i >= 0 or i <= 5:
|
|
return JasminCode.INDENT + "iconst_" + str(i) + JasminCode.END
|
|
else:
|
|
raise IllegalOperandException(str(i))
|
|
|
|
def emitBIPUSH(self, i):
|
|
# i: Int
|
|
if (i >= -128 and i < -1) or (i > 5 and i <= 127):
|
|
return JasminCode.INDENT + "bipush " + str(i) + JasminCode.END
|
|
else:
|
|
raise IllegalOperandException(str(i))
|
|
|
|
def emitSIPUSH(self, i):
|
|
# i: Int
|
|
if (i >= -32768 and i < -128) or (i > 127 and i <= 32767):
|
|
return JasminCode.INDENT + "sipush " + str(i) + JasminCode.END
|
|
else:
|
|
raise IllegalOperandException(str(i))
|
|
|
|
def emitLDC(self, in_):
|
|
# in_: String
|
|
return JasminCode.INDENT + "ldc " + in_ + JasminCode.END
|
|
|
|
def emitFCONST(self, i):
|
|
# i: String
|
|
if i == "0.0":
|
|
return JasminCode.INDENT + "fconst_0" + JasminCode.END
|
|
elif i == "1.0":
|
|
return JasminCode.INDENT + "fconst_1" + JasminCode.END
|
|
elif i == "2.0":
|
|
return JasminCode.INDENT + "fconst_2" + JasminCode.END
|
|
else:
|
|
raise IllegalOperandException(i)
|
|
|
|
def emitILOAD(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "iload_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "iload " + str(in_) + JasminCode.END
|
|
|
|
def emitFLOAD(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "fload_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "fload " + str(in_) + JasminCode.END
|
|
|
|
def emitISTORE(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "istore_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "istore " + str(in_) + JasminCode.END
|
|
|
|
def emitFSTORE(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "fstore_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "fstore " + str(in_) + JasminCode.END
|
|
|
|
def emitALOAD(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "aload_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "aload " + str(in_) + JasminCode.END
|
|
|
|
def emitASTORE(self, in_):
|
|
# in_: Int
|
|
if in_ >= 0 and in_ <= 3:
|
|
return JasminCode.INDENT + "astore_" + str(in_) + JasminCode.END
|
|
else:
|
|
return JasminCode.INDENT + "astore " + str(in_) + JasminCode.END
|
|
|
|
def emitIASTORE(self):
|
|
return JasminCode.INDENT + "iastore" + JasminCode.END
|
|
|
|
def emitFASTORE(self):
|
|
return JasminCode.INDENT + "fastore" + JasminCode.END
|
|
|
|
def emitBASTORE(self):
|
|
return JasminCode.INDENT + "bastore" + JasminCode.END
|
|
|
|
def emitAASTORE(self):
|
|
return JasminCode.INDENT + "aastore" + JasminCode.END
|
|
|
|
def emitIALOAD(self):
|
|
return JasminCode.INDENT + "iaload" + JasminCode.END
|
|
|
|
def emitFALOAD(self):
|
|
return JasminCode.INDENT + "faload" + JasminCode.END
|
|
|
|
def emitBALOAD(self):
|
|
return JasminCode.INDENT + "baload" + JasminCode.END
|
|
|
|
def emitAALOAD(self):
|
|
return JasminCode.INDENT + "aaload" + JasminCode.END
|
|
|
|
def emitGETSTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "getstatic " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitPUTSTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "putstatic " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitGETFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "getfield " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitPUTFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "putfield " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitIADD(self):
|
|
return JasminCode.INDENT + "iadd" + JasminCode.END
|
|
|
|
def emitFADD(self):
|
|
return JasminCode.INDENT + "fadd" + JasminCode.END
|
|
|
|
def emitISUB(self):
|
|
return JasminCode.INDENT + "isub" + JasminCode.END
|
|
|
|
def emitFSUB(self):
|
|
return JasminCode.INDENT + "fsub" + JasminCode.END
|
|
|
|
def emitIMUL(self):
|
|
return JasminCode.INDENT + "imul" + JasminCode.END
|
|
|
|
def emitFMUL(self):
|
|
return JasminCode.INDENT + "fmul" + JasminCode.END
|
|
|
|
def emitIDIV(self):
|
|
return JasminCode.INDENT + "idiv" + JasminCode.END
|
|
|
|
def emitFDIV(self):
|
|
return JasminCode.INDENT + "fdiv" + JasminCode.END
|
|
|
|
def emitIAND(self):
|
|
return JasminCode.INDENT + "iand" + JasminCode.END
|
|
|
|
def emitIOR(self):
|
|
return JasminCode.INDENT + "ior" + JasminCode.END
|
|
|
|
def emitIREM(self):
|
|
return JasminCode.INDENT + "irem" + JasminCode.END
|
|
|
|
def emitIFACMPEQ(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_acmpeq Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFACMPNE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_acmpne Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPEQ(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmpeq Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPNE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmpne Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPLT(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmplt Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPLE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmple Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPGT(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmpgt Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFICMPGE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "if_icmpge Label" + \
|
|
str(label) + JasminCode.END
|
|
|
|
def emitIFEQ(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "ifeq Label" + str(label) + JasminCode.END
|
|
|
|
def emitIFNE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "ifne Label" + str(label) + JasminCode.END
|
|
|
|
def emitIFLT(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "iflt Label" + str(label) + JasminCode.END
|
|
|
|
def emitIFLE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "ifle Label" + str(label) + JasminCode.END
|
|
|
|
def emitIFGT(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "ifgt Label" + str(label) + JasminCode.END
|
|
|
|
def emitIFGE(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "ifge Label" + str(label) + JasminCode.END
|
|
|
|
def emitLABEL(self, label):
|
|
# label: Int
|
|
return "Label" + str(label) + ":" + JasminCode.END
|
|
|
|
def emitGOTO(self, label):
|
|
# label: Int
|
|
return JasminCode.INDENT + "goto Label" + str(label) + JasminCode.END
|
|
|
|
def emitINEG(self):
|
|
return JasminCode.INDENT + "ineg" + JasminCode.END
|
|
|
|
def emitFNEG(self):
|
|
return JasminCode.INDENT + "fneg" + JasminCode.END
|
|
|
|
def emitDUP(self):
|
|
return JasminCode.INDENT + "dup" + JasminCode.END
|
|
|
|
def emitDUPX2(self):
|
|
return JasminCode.INDENT + "dup_x2" + JasminCode.END
|
|
|
|
def emitPOP(self):
|
|
return JasminCode.INDENT + "pop" + JasminCode.END
|
|
|
|
def emitI2F(self):
|
|
return JasminCode.INDENT + "i2f" + JasminCode.END
|
|
|
|
def emitNEW(self, lexeme):
|
|
# lexeme: String
|
|
return JasminCode.INDENT + "new " + lexeme + JasminCode.END
|
|
|
|
def emitNEWARRAY(self, lexeme):
|
|
# lexeme: String
|
|
return JasminCode.INDENT + "newarray " + lexeme + JasminCode.END
|
|
|
|
def emitANEWARRAY(self, lexeme):
|
|
# lexeme: String
|
|
return JasminCode.INDENT + "anewarray " + lexeme + JasminCode.END
|
|
|
|
def emitMULTIANEWARRAY(self, typ, dimensions):
|
|
# typ: String
|
|
# dimensions: Int
|
|
return JasminCode.INDENT + "multianewarray " + \
|
|
typ + " " + dimensions + JasminCode.END
|
|
|
|
def emitINVOKESTATIC(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "invokestatic " + lexeme + typ + JasminCode.END
|
|
|
|
def emitINVOKESPECIAL(self, lexeme=None, typ=None):
|
|
# lexeme: String
|
|
# typ: String
|
|
if lexeme is None and typ is None:
|
|
return JasminCode.INDENT + "invokespecial java/lang/Object/<init>()V" + \
|
|
JasminCode.END
|
|
elif lexeme is not None and typ is not None:
|
|
return JasminCode.INDENT + "invokespecial " + lexeme + typ + JasminCode.END
|
|
|
|
def emitINVOKEVIRTUAL(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return JasminCode.INDENT + "invokevirtual " + lexeme + typ + JasminCode.END
|
|
|
|
def emitI(self):
|
|
return JasminCode.INDENT + "i" + JasminCode.END
|
|
|
|
def emitF(self):
|
|
return JasminCode.INDENT + "f" + JasminCode.END
|
|
|
|
def emit(self):
|
|
return JasminCode.INDENT + "" + JasminCode.END
|
|
|
|
def emitLIMITSTACK(self, in_):
|
|
# in_: Int
|
|
return ".limit stack " + str(in_) + JasminCode.END
|
|
|
|
def emitFCMPL(self):
|
|
return JasminCode.INDENT + "fcmpl" + JasminCode.END
|
|
|
|
def emitLIMITLOCAL(self, in_):
|
|
# in_: Int
|
|
return ".limit locals " + str(in_) + JasminCode.END
|
|
|
|
def emitVAR(self, in_, varName, inType, fromLabel, toLabel):
|
|
# in_: Int
|
|
# varName: String
|
|
# inType: String
|
|
# fromLabel: Int
|
|
# toLabel: Int
|
|
return ".var " + str(in_) + " is " + varName + " " + inType + " from Label" + \
|
|
str(fromLabel) + " to Label" + str(toLabel) + JasminCode.END
|
|
|
|
def emitMETHOD(self, lexeme, typ, isStatic):
|
|
# lexeme: String
|
|
# typ: String
|
|
# isStaic: Boolean
|
|
if isStatic:
|
|
return JasminCode.END + ".method public static " + lexeme + typ + JasminCode.END
|
|
else:
|
|
return JasminCode.END + ".method public " + lexeme + typ + JasminCode.END
|
|
|
|
def emitENDMETHOD(self):
|
|
return ".end method" + JasminCode.END
|
|
|
|
def emitSOURCE(self, lexeme):
|
|
# lexeme: String
|
|
return ".source " + lexeme + JasminCode.END
|
|
|
|
def emitCLASS(self, lexeme):
|
|
# lexeme: String
|
|
return ".class " + lexeme + JasminCode.END
|
|
|
|
def emitSUPER(self, lexeme):
|
|
# lexeme: String
|
|
return ".super " + lexeme + JasminCode.END
|
|
|
|
def emitSTATICFIELD(self, lexeme, typ, isFinal):
|
|
# lexeme: String
|
|
# typ: String
|
|
# isFinal: Boolean
|
|
if isFinal:
|
|
return ".field static final " + lexeme + " " + typ + JasminCode.END
|
|
else:
|
|
return ".field static " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitINSTANCEFIELD(self, lexeme, typ):
|
|
# lexeme: String
|
|
# typ: String
|
|
return ".field " + lexeme + " " + typ + JasminCode.END
|
|
|
|
def emitRETURN(self):
|
|
return JasminCode.INDENT + "return" + JasminCode.END
|
|
|
|
def emitIRETURN(self):
|
|
return JasminCode.INDENT + "ireturn" + JasminCode.END
|
|
|
|
def emitFRETURN(self):
|
|
return JasminCode.INDENT + "freturn" + JasminCode.END
|
|
|
|
def emitARETURN(self):
|
|
return JasminCode.INDENT + "areturn" + JasminCode.END
|