def __init__(self):
self.private = "public"
self.address = 0
self.param_key = []
self.params = VarTable()
self.return_type = SparkyType()
self.varTable = VarTable()
self.funMemory = MemoryMap("function")
self.tempMemory = MemoryMap("temporal")
def main():
mem = Memory(32 * 1024 * 1024)
high = Memory(32 * 1024 * 1024)
m = MemoryMap([
(0, mem),
(0xffffffff - len(high) + 1, high),
(40000000, SimpleIO()),
])
with open(sys.argv[1], 'rb') as f:
mem.write_bin(0, f.read())
cpu = CPU(m, debug_trace=False)
while not cpu.ebreak:
cpu.step()
print(cpu.regs)
def __init__(self):
self.BASE = 0 # Starting location for Quadruples //list starts with empty so its -1
self.Quads = []
self.globalMemory = MemoryMap("program")
self.ConsMemory = MemoryMap("Constant")
self.varTable = VarTable()
self.funDir = FunctionDirectory()
self.ClassDir = ClassTable()
self.semanticCube = SemanticCube()
self.pJumps = [] #
self.VP = [] # Polish vector
self.pOper = []
self.pType = []
self.pArray = []
self.pIDs = []
self.pEras = []
self.pendingQuads = []
self.current_quad = ()
self.current_param_num = 0
self.current_class = Class()
self.current_object = Object()
self.current_var = Var()
self.current_function = Function()
self.current_params = VarTable()
self.current_type = SparkyType()
self.local_class_func = FunctionDirectory()
self.local_func = Function()
self.local_class = Class()
self.local_type = SparkyType()
self.current_value = 0
self.current_class_name = ""
self.current_var_name = ""
self.current_function_name = ""
self.called_function = Function()
self.current_scope = "" # Working inside the global program
self.class_stage = False # Working either in a class or a function
self.current_id_is_func = False
def __init__(self):
self.funDir = FunctionDirectory()
self.varTable = VarTable()
self.claMemory = MemoryMap("class")
def __init__(self,
arch,
listfile,
binfile,
options,
logLevel=0,
logfile=None):
self.options = options
self.verbose = options.verbose
self.debug = options.debug
self.logfile = logfile
self.assembler = None
self.arch = arch
self.listfile = listfile
self.binfile = binfile
self.srcfile = None
self.opcodes = OPCODES[self.arch]
self.symtab = SymbolTable(self)
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.memmap = MemoryMap(arch, options.verbose)
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.records = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.passnum = 0
self.complementNext = False # STADR complements the following instruction(s).
self.errorMsg = None
self.warningMsg = None
# Log level:
# 0 - None.
# 1 - Errors.
# 2 - Warnings.
# 3 - Info messages.
# 4 - Bank changes, binary generation.
# 5 - LOC changes, detailed interpretive logging.
# 6 - Symbol information, address conversion.
# 7 - Parser operation.
# 8 - Symbol resolution.
self.logLevel = logLevel
self.loc = 0 # Assembler PC, i.e. current position in erasable or fixed memory.
self.ebank = 0 # Current E-Bank.
self.fbank = 0 # Current F-Bank.
self.super = 0 # Superbank bit (0/1).
self.lastSuper = 0
self.ebankloc = {} # Saved current location for each erasable bank.
self.fbankloc = {} # Saved current location for each fixed bank.
for bank in range(len(self.memmap.banks[MemoryType.ERASABLE])):
self.ebankloc[bank] = 0
for bank in range(len(self.memmap.banks[MemoryType.FIXED])):
self.fbankloc[bank] = 0
self.errors = 0
self.warnings = 0
class Context:
def __init__(self,
arch,
listfile,
binfile,
options,
logLevel=0,
logfile=None):
self.options = options
self.verbose = options.verbose
self.debug = options.debug
self.logfile = logfile
self.assembler = None
self.arch = arch
self.listfile = listfile
self.binfile = binfile
self.srcfile = None
self.opcodes = OPCODES[self.arch]
self.symtab = SymbolTable(self)
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.memmap = MemoryMap(arch, options.verbose)
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.records = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.passnum = 0
self.complementNext = False # STADR complements the following instruction(s).
self.errorMsg = None
self.warningMsg = None
# Log level:
# 0 - None.
# 1 - Errors.
# 2 - Warnings.
# 3 - Info messages.
# 4 - Bank changes, binary generation.
# 5 - LOC changes, detailed interpretive logging.
# 6 - Symbol information, address conversion.
# 7 - Parser operation.
# 8 - Symbol resolution.
self.logLevel = logLevel
self.loc = 0 # Assembler PC, i.e. current position in erasable or fixed memory.
self.ebank = 0 # Current E-Bank.
self.fbank = 0 # Current F-Bank.
self.super = 0 # Superbank bit (0/1).
self.lastSuper = 0
self.ebankloc = {} # Saved current location for each erasable bank.
self.fbankloc = {} # Saved current location for each fixed bank.
for bank in range(len(self.memmap.banks[MemoryType.ERASABLE])):
self.ebankloc[bank] = 0
for bank in range(len(self.memmap.banks[MemoryType.FIXED])):
self.fbankloc[bank] = 0
self.errors = 0
self.warnings = 0
def __str__(self):
text = ""
text += "options: %s\n" % self.options
text += "logfile: %s" % self.logfile
text += "arch=%d\n" % self.arch
text += "listfile: %s\n" % self.listfile
text += "binfile: %s\n" % self.binfile
text += "srcfile: %s\n" % self.srcfile
text += "linenum=%d\n" % self.linenum
text += "global_linenum=%d\n" % self.global_linenum
text += "mode=%d\n" % self.mode
text += "lastEbank=%s\n" % self.lastEbank
text += "previousWasEbankEquals=%s\n" % self.previousWasEbankEquals
text += "previousWasSbankEquals=%s\n" % self.previousWasSbankEquals
text += "previousWasIndex=%s\n" % self.previousWasIndex
text += "code: %s\n" % self.code
text += "srcline: %s\n" % self.srcline
text += "interpMode=%s\n" % self.interpMode
text += "interpInstCount=%d\n" % self.interpInstCount
text += "interpArgs=%d\n" % self.interpArgs
text += "interpArgCount=%d\n" % self.interpArgCount
text += "interpArgTypes: %s\n" % self.interpArgTypes
text += "interpArgCodes: %s\n" % self.interpArgCodes
text += "interpArgIncrement: %s\n" % self.interpArgIncrement
text += "indexed=%s\n" % self.indexed
text += "currentRecord: %s\n" % self.currentRecord
text += "currentRecord.type: %s (%d)\n" % (RecordType.toString(
self.currentRecord.type), self.currentRecord.type)
text += "previousRecord: %s\n" % self.previousRecord
text += "previousRecord.type: %s (%d)\n" % (RecordType.toString(
self.previousRecord.type), self.previousRecord.type)
text += "addSymbol=%s\n" % self.addSymbol
text += "reparse=%s\n" % self.reparse
text += "passnum=%d\n" % self.passnum
text += "complementNext=%s\n" % self.complementNext
text += "logLevel=%d\n" % self.logLevel
text += "loc=%06o\n" % self.loc
text += "ebank=%02o\n" % self.ebank
text += "fbank=%02o\n" % self.fbank
text += "super=%s\n" % self.super
text += "ebankloc: %s\n" % self.ebankloc
text += "fbankloc: %s\n" % self.fbankloc
text += "errors=%d\n" % self.errors
text += "warnings=%d\n" % self.warnings
return text
def reset(self):
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.loc = 0
self.super = 1
self.ebank = 0
self.fbank = 0
self.complementNext = False
def load(self, record, partial=True):
self.linenum = record.linenum
self.global_linenum = record.global_linenum
self.code = record.code
self.srcline = record.srcline
self.loc = record.loc
self.errorMsg = record.errorMsg
self.warningMsg = record.warningMsg
if partial == False:
self.mode = record.mode
self.lastEbank = record.lastEbank
self.previousWasEbankEquals = record.previousWasEbankEquals
self.previousWasSbankEquals = record.previousWasSbankEquals
self.previousWasIndex = record.previousWasIndex
self.complementNext = record.complementNext
self.super = record.super
self.ebank = record.ebank
self.fbank = record.fbank
def save(self, record, partial=True):
record.linenum = self.linenum
record.global_linenum = self.global_linenum
record.code = self.code
record.srcline = self.srcline
record.errorMsg = self.errorMsg
record.warningMsg = self.warningMsg
if partial == False:
record.lastEbank = self.lastEbank
record.previousWasEbankEquals = self.previousWasEbankEquals
record.previousWasSbankEquals = self.previousWasSbankEquals
record.previousWasIndex = self.previousWasIndex
record.complementNext = self.complementNext
record.mode = self.mode
record.loc = self.loc
record.super = self.super
record.ebank = self.ebank
record.fbank = self.fbank
def setLoc(self, loc):
if not self.memmap.isValid(loc):
self.error("trying to set loc to an invalid address (%06o)" % loc)
if not self.reparse:
self.log(5, "changing loc from %06o to %06o" % (self.loc, loc))
self.loc = loc
def incrLoc(self, delta):
if not self.memmap.isValid(self.loc + delta):
self.error("trying to set loc to an invalid address (%06o)" %
(self.loc + delta))
if not self.reparse:
self.log(
5, "incrementing loc from %06o to %06o (delta=%04o)" %
(self.loc, self.loc + delta, delta))
self.loc += delta
def switchEBank(self, bank):
pa = self.ebankloc[bank]
self.printBanks()
self.switchEBankPA(pa)
def saveCurrentBank(self):
(bank, offset) = self.memmap.pseudoToBankOffset(self.loc)
if bank != None and offset != None:
if self.memmap.isErasable(self.loc):
if offset > self.ebankloc[bank]:
self.log(
4, "saving EB %02o: %04o -> %04o" %
(bank, self.ebankloc[bank], offset))
self.ebankloc[bank] = offset
else:
if offset > self.fbankloc[bank]:
self.log(
4, "saving FB %02o: %04o -> %04o" %
(bank, self.fbankloc[bank], offset))
self.fbankloc[bank] = offset
else:
self.error("invalid address %06o" % self.loc)
def switchEBankPA(self, pa):
if not self.reparse:
self.lastEbank = self.ebank
self.saveCurrentBank()
self.ebank = self.memmap.pseudoToBank(pa)
self.log(
4, "switched EB: %02o -> %02o" % (self.lastEbank, self.ebank))
if self.memmap.isErasable(self.loc):
# Only change LOC if it is currently erasable. This allows us to move LOC up through the various
# erasable banks at the start as symbols are defined. Later, in fixed banks, you do not want an
# EBANK= to affect LOC.
self.setLoc(
self.memmap.segmentedToPseudo(MemoryType.ERASABLE,
self.ebank,
self.ebankloc[self.ebank]))
self.previousWasEbankEquals = True
self.printBanks()
def revertEbank(self):
if not self.reparse:
self.printBanks()
if self.previousWasEbankEquals == True:
self.saveCurrentBank()
self.ebank = self.lastEbank
self.log(
4,
"reverted EB: %02o -> %02o" % (self.lastEbank, self.ebank))
if self.memmap.isErasable(self.loc):
self.setLoc(
self.memmap.segmentedToPseudo(
MemoryType.ERASABLE, self.lastEbank,
self.ebankloc[self.lastEbank]))
self.previousWasEbankEquals = False
def revertSuper(self):
if not self.reparse:
self.printBanks()
if self.previousWasSbankEquals == True:
self.saveCurrentBank()
self.super = self.lastSuper
self.log(
4, "reverted SB: %o -> %o" % (self.lastSuper, self.super))
self.previousWasSbankEquals = False
def switchFBank(self, bank=None):
if not self.reparse:
if bank != None:
self.saveCurrentBank()
oldbank = self.fbank
self.fbank = bank
self.log(4,
"switched FB: %02o -> %02o" % (oldbank, self.fbank))
if bank > 037:
self.super = 1
self.log(3, "BANK: setting superbit to 1")
self.setLoc(
self.memmap.segmentedToPseudo(MemoryType.FIXED, self.fbank,
self.fbankloc[self.fbank]))
self.log(
4, "switched FB to %s" %
(self.memmap.pseudoToSegmentedString(self.loc)))
def getBankCount(self, memtype, bank):
if memtype == MemoryType.ERASABLE:
return self.ebankloc[bank]
else:
return self.fbankloc[bank]
def getBankSize(self, memtype, bank):
return self.memmap.banks[memtype][bank].size
def printBanks(self):
text = "LOC=%06o EB=%02o FB=%02o SB=%o " % (self.loc, self.ebank,
self.fbank, self.super)
text += "EBs: "
for eb in self.ebankloc.keys():
if self.ebankloc[eb] > 0:
text += "%02o:%04o " % (eb, self.ebankloc[eb])
text += "FBs: "
for fb in self.fbankloc.keys():
if self.fbankloc[fb] > 0:
text += "%02o:%04o " % (fb, self.fbankloc[fb])
self.log(4, text)
def __init__(self, test_vectors_file=None, debug=False):
self.debug = debug
self.test_vectors_file = test_vectors_file
mkdir_safe(config.gen_path)
mkdir_safe(os.path.join(config.gen_path, config.vhdl_path))
mkdir_safe(os.path.join(config.gen_path, 'c'))
mkdir_safe(os.path.join(config.gen_path, config.ipcore_path))
if self.test_vectors_file:
global_symb = {}
execfile(self.test_vectors_file, global_symb)
self.test_vectors = global_symb['test_vectors']
else:
self.test_vectors = None
self.ast_list = []
if config.design_tool == 'pa':
from poroto.plan_ahead import PlanAhead
self.designer = PlanAhead()
elif config.design_tool == 'ghdl':
from poroto.ghdl import Ghdl
self.designer = Ghdl()
else:
raise Exception("Unknown design tool '%s'" % config.design_tool)
FunctionInstance.designer = self.designer
self.registers_map = RegisterMap(self.debug)
self.mems_map = MemoryMap(self.debug)
self.functions = FunctionsRegistry(self.designer, self.mems_map,
self.debug)
self.streams_map = StreamMap(self.mems_map, self.functions, self.debug)
self.pragma_registry = PragmaRegistry(self.debug)
if config.converter == 'roccc':
self.converter = ROCCC(self.debug)
else:
raise Exception("Unknown converter '%s'" % config.converter)
self.converter.init(self.pragma_registry)
if config.device_vendor == "xilinx":
from poroto.xilinx import XilinxPlatform
self.platform = XilinxPlatform(self.designer, self.debug)
elif config.device_vendor == "sim":
from poroto.sim import SimPlatform
self.platform = SimPlatform(self.designer, self.debug)
else:
raise Exception("Unknown device vendor '%s'" %
config.platform_vendor)
if config.sdk == "alphadata":
from poroto.alphadata import AlphaDataSDK
self.sdk = AlphaDataSDK(self.platform, self.designer,
self.functions.functions,
self.registers_map, self.mems_map,
self.streams_map, self.test_vectors,
self.debug)
elif config.sdk == "none":
from poroto.none import NoneSDK
self.sdk = NoneSDK(self.platform, self.designer,
self.functions.functions, self.registers_map,
self.mems_map, self.streams_map,
self.test_vectors, self.debug)
elif config.sdk == "riffa":
from poroto.riffa import RiffaSDK
self.sdk = RiffaSDK(self.platform, self.designer,
self.functions.functions, self.registers_map,
self.mems_map, self.streams_map,
self.test_vectors, self.debug)
else:
raise Exception("Unknown sdk '%s'" % config.sdk)
self.pragma_registry.add_pragma_type('file',
FilePragmaHandler(self.debug))
self.pragma_registry.add_pragma_type('template',
TemplatePragmaHandler(self.debug))
self.pragma_registry.add_pragma_type(
'memory',
MemoryPragmaHandler(self.functions, self.mems_map, self.sdk,
self.debug))
self.pragma_registry.add_pragma_type(
'stream', StreamPragmaHandler(self.streams_map, self.debug))
self.pragma_registry.add_pragma_type('latency',
LatencyPragmaHandler(self.debug))
self.pragma_registry.add_pragma_type('array',
ArrayPragmaHandler(self.debug))
array.init(self.platform, self.converter, self.functions,
self.mems_map, self.streams_map)
IPInstance.converter = self.converter
FileTemplate.platform = self.platform
def __init__(self, arch, listfile, binfile, options, logLevel=0, logfile=None):
self.options = options
self.verbose = options.verbose
self.debug = options.debug
self.logfile = logfile
self.assembler = None
self.arch = arch
self.listfile = listfile
self.binfile = binfile
self.srcfile = None
self.opcodes = OPCODES[self.arch]
self.symtab = SymbolTable(self)
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.memmap = MemoryMap(arch, options.verbose)
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.records = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.passnum = 0
self.complementNext = False # STADR complements the following instruction(s).
self.errorMsg = None
self.warningMsg = None
# Log level:
# 0 - None.
# 1 - Errors.
# 2 - Warnings.
# 3 - Info messages.
# 4 - Bank changes, binary generation.
# 5 - LOC changes, detailed interpretive logging.
# 6 - Symbol information, address conversion.
# 7 - Parser operation.
# 8 - Symbol resolution.
self.logLevel = logLevel
self.loc = 0 # Assembler PC, i.e. current position in erasable or fixed memory.
self.ebank = 0 # Current E-Bank.
self.fbank = 0 # Current F-Bank.
self.super = 0 # Superbank bit (0/1).
self.lastSuper = 0
self.ebankloc = {} # Saved current location for each erasable bank.
self.fbankloc = {} # Saved current location for each fixed bank.
for bank in range(len(self.memmap.banks[MemoryType.ERASABLE])):
self.ebankloc[bank] = 0
for bank in range(len(self.memmap.banks[MemoryType.FIXED])):
self.fbankloc[bank] = 0
self.errors = 0
self.warnings = 0
class Context:
def __init__(self, arch, listfile, binfile, options, logLevel=0, logfile=None):
self.options = options
self.verbose = options.verbose
self.debug = options.debug
self.logfile = logfile
self.assembler = None
self.arch = arch
self.listfile = listfile
self.binfile = binfile
self.srcfile = None
self.opcodes = OPCODES[self.arch]
self.symtab = SymbolTable(self)
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.memmap = MemoryMap(arch, options.verbose)
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.records = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.passnum = 0
self.complementNext = False # STADR complements the following instruction(s).
self.errorMsg = None
self.warningMsg = None
# Log level:
# 0 - None.
# 1 - Errors.
# 2 - Warnings.
# 3 - Info messages.
# 4 - Bank changes, binary generation.
# 5 - LOC changes, detailed interpretive logging.
# 6 - Symbol information, address conversion.
# 7 - Parser operation.
# 8 - Symbol resolution.
self.logLevel = logLevel
self.loc = 0 # Assembler PC, i.e. current position in erasable or fixed memory.
self.ebank = 0 # Current E-Bank.
self.fbank = 0 # Current F-Bank.
self.super = 0 # Superbank bit (0/1).
self.lastSuper = 0
self.ebankloc = {} # Saved current location for each erasable bank.
self.fbankloc = {} # Saved current location for each fixed bank.
for bank in range(len(self.memmap.banks[MemoryType.ERASABLE])):
self.ebankloc[bank] = 0
for bank in range(len(self.memmap.banks[MemoryType.FIXED])):
self.fbankloc[bank] = 0
self.errors = 0
self.warnings = 0
def __str__(self):
text = ""
text += "options: %s\n" % self.options
text += "logfile: %s" % self.logfile
text += "arch=%d\n" % self.arch
text += "listfile: %s\n" % self.listfile
text += "binfile: %s\n" % self.binfile
text += "srcfile: %s\n" % self.srcfile
text += "linenum=%d\n" % self.linenum
text += "global_linenum=%d\n" % self.global_linenum
text += "mode=%d\n" % self.mode
text += "lastEbank=%s\n" % self.lastEbank
text += "previousWasEbankEquals=%s\n" % self.previousWasEbankEquals
text += "previousWasSbankEquals=%s\n" % self.previousWasSbankEquals
text += "previousWasIndex=%s\n" % self.previousWasIndex
text += "code: %s\n" % self.code
text += "srcline: %s\n" % self.srcline
text += "interpMode=%s\n" % self.interpMode
text += "interpInstCount=%d\n" % self.interpInstCount
text += "interpArgs=%d\n" % self.interpArgs
text += "interpArgCount=%d\n" % self.interpArgCount
text += "interpArgTypes: %s\n" % self.interpArgTypes
text += "interpArgCodes: %s\n" % self.interpArgCodes
text += "interpArgIncrement: %s\n" % self.interpArgIncrement
text += "indexed=%s\n" % self.indexed
text += "currentRecord: %s\n" % self.currentRecord
text += "currentRecord.type: %s (%d)\n" % (
RecordType.toString(self.currentRecord.type),
self.currentRecord.type,
)
text += "previousRecord: %s\n" % self.previousRecord
text += "previousRecord.type: %s (%d)\n" % (
RecordType.toString(self.previousRecord.type),
self.previousRecord.type,
)
text += "addSymbol=%s\n" % self.addSymbol
text += "reparse=%s\n" % self.reparse
text += "passnum=%d\n" % self.passnum
text += "complementNext=%s\n" % self.complementNext
text += "logLevel=%d\n" % self.logLevel
text += "loc=%06o\n" % self.loc
text += "ebank=%02o\n" % self.ebank
text += "fbank=%02o\n" % self.fbank
text += "super=%s\n" % self.super
text += "ebankloc: %s\n" % self.ebankloc
text += "fbankloc: %s\n" % self.fbankloc
text += "errors=%d\n" % self.errors
text += "warnings=%d\n" % self.warnings
return text
def reset(self):
self.linenum = 0
self.global_linenum = 0
self.mode = OpcodeType.BASIC
self.lastEbank = 0
self.previousWasEbankEquals = False
self.previousWasSbankEquals = False
self.previousWasIndex = False
self.code = []
self.srcline = None
self.interpMode = False
self.interpInstCount = 0
self.interpArgs = 0
self.interpArgCount = 0
self.interpArgTypes = [None, None, None, None]
self.interpArgCodes = [0, 0, 0, 0]
self.interpArgIncrement = [False, False, False, False]
self.indexed = False
self.currentRecord = None
self.previousRecord = None
self.addSymbol = True
self.reparse = False
self.loc = 0
self.super = 1
self.ebank = 0
self.fbank = 0
self.complementNext = False
def load(self, record, partial=True):
self.linenum = record.linenum
self.global_linenum = record.global_linenum
self.code = record.code
self.srcline = record.srcline
self.loc = record.loc
self.errorMsg = record.errorMsg
self.warningMsg = record.warningMsg
if partial == False:
self.mode = record.mode
self.lastEbank = record.lastEbank
self.previousWasEbankEquals = record.previousWasEbankEquals
self.previousWasSbankEquals = record.previousWasSbankEquals
self.previousWasIndex = record.previousWasIndex
self.complementNext = record.complementNext
self.super = record.super
self.ebank = record.ebank
self.fbank = record.fbank
def save(self, record, partial=True):
record.linenum = self.linenum
record.global_linenum = self.global_linenum
record.code = self.code
record.srcline = self.srcline
record.errorMsg = self.errorMsg
record.warningMsg = self.warningMsg
if partial == False:
record.lastEbank = self.lastEbank
record.previousWasEbankEquals = self.previousWasEbankEquals
record.previousWasSbankEquals = self.previousWasSbankEquals
record.previousWasIndex = self.previousWasIndex
record.complementNext = self.complementNext
record.mode = self.mode
record.loc = self.loc
record.super = self.super
record.ebank = self.ebank
record.fbank = self.fbank
def setLoc(self, loc):
if not self.memmap.isValid(loc):
self.error("trying to set loc to an invalid address (%06o)" % loc)
if not self.reparse:
self.log(5, "changing loc from %06o to %06o" % (self.loc, loc))
self.loc = loc
def incrLoc(self, delta):
if not self.memmap.isValid(self.loc + delta):
self.error("trying to set loc to an invalid address (%06o)" % (self.loc + delta))
if not self.reparse:
self.log(5, "incrementing loc from %06o to %06o (delta=%04o)" % (self.loc, self.loc + delta, delta))
self.loc += delta
def switchEBank(self, bank):
pa = self.ebankloc[bank]
self.printBanks()
self.switchEBankPA(pa)
def saveCurrentBank(self):
(bank, offset) = self.memmap.pseudoToBankOffset(self.loc)
if bank != None and offset != None:
if self.memmap.isErasable(self.loc):
if offset > self.ebankloc[bank]:
self.log(4, "saving EB %02o: %04o -> %04o" % (bank, self.ebankloc[bank], offset))
self.ebankloc[bank] = offset
else:
if offset > self.fbankloc[bank]:
self.log(4, "saving FB %02o: %04o -> %04o" % (bank, self.fbankloc[bank], offset))
self.fbankloc[bank] = offset
else:
self.error("invalid address %06o" % self.loc)
def switchEBankPA(self, pa):
if not self.reparse:
self.lastEbank = self.ebank
self.saveCurrentBank()
self.ebank = self.memmap.pseudoToBank(pa)
self.log(4, "switched EB: %02o -> %02o" % (self.lastEbank, self.ebank))
if self.memmap.isErasable(self.loc):
# Only change LOC if it is currently erasable. This allows us to move LOC up through the various
# erasable banks at the start as symbols are defined. Later, in fixed banks, you do not want an
# EBANK= to affect LOC.
self.setLoc(self.memmap.segmentedToPseudo(MemoryType.ERASABLE, self.ebank, self.ebankloc[self.ebank]))
self.previousWasEbankEquals = True
self.printBanks()
def revertEbank(self):
if not self.reparse:
self.printBanks()
if self.previousWasEbankEquals == True:
self.saveCurrentBank()
self.ebank = self.lastEbank
self.log(4, "reverted EB: %02o -> %02o" % (self.lastEbank, self.ebank))
if self.memmap.isErasable(self.loc):
self.setLoc(
self.memmap.segmentedToPseudo(
MemoryType.ERASABLE, self.lastEbank, self.ebankloc[self.lastEbank]
)
)
self.previousWasEbankEquals = False
def revertSuper(self):
if not self.reparse:
self.printBanks()
if self.previousWasSbankEquals == True:
self.saveCurrentBank()
self.super = self.lastSuper
self.log(4, "reverted SB: %o -> %o" % (self.lastSuper, self.super))
self.previousWasSbankEquals = False
def switchFBank(self, bank=None):
if not self.reparse:
if bank != None:
self.saveCurrentBank()
oldbank = self.fbank
self.fbank = bank
self.log(4, "switched FB: %02o -> %02o" % (oldbank, self.fbank))
if bank > 037:
self.super = 1
self.log(3, "BANK: setting superbit to 1")
self.setLoc(self.memmap.segmentedToPseudo(MemoryType.FIXED, self.fbank, self.fbankloc[self.fbank]))
self.log(4, "switched FB to %s" % (self.memmap.pseudoToSegmentedString(self.loc)))
def getBankCount(self, memtype, bank):
if memtype == MemoryType.ERASABLE:
return self.ebankloc[bank]
else:
return self.fbankloc[bank]
def getBankSize(self, memtype, bank):
return self.memmap.banks[memtype][bank].size
def printBanks(self):
text = "LOC=%06o EB=%02o FB=%02o SB=%o " % (self.loc, self.ebank, self.fbank, self.super)
text += "EBs: "
for eb in self.ebankloc.keys():
if self.ebankloc[eb] > 0:
text += "%02o:%04o " % (eb, self.ebankloc[eb])
text += "FBs: "
for fb in self.fbankloc.keys():
if self.fbankloc[fb] > 0:
text += "%02o:%04o " % (fb, self.fbankloc[fb])
self.log(4, text)
