def compile(self):
while True:
if not self.active:
break
line = ''
try:
line = self.compiler.nextline()
except EOFError:
if self.acceptsEOF:
self._exit()
break
throwhelper.throw('end of file reached', context=self.__name__)
if self.endtext and line == self.endtext:
self._exit()
break
for context in self.availablecontexts:
if context.checkstart(line):
startstament = line[len(context.starttext
):] if context.starttext else line
c = context(self, startstament)
c.compile()
break
else:
if self.parseline(line) is False:
throwhelper.throw('line could not be parsed',
file=self.compiler.name,
linenumber=self.compiler.linenumber,
context=type(self).__name__)
if self.parent:
self.parent.oncontextend(self.__class__, self.result)
return self.result
def initializefile(name):
filename = findfile(name)
# strip eventual extension
name = os.path.splitext(name)[0]
name = name.replace('/', '_')
if name in filesIncluded:
return filesIncluded[name]
if name in filesCurrentlyIncluding:
throwhelper.throw('including: {} would cause a dependency loop'.format(name))
printverbose('begins importing of {}', name)
filesCurrentlyIncluding.append(name)
c = FileCompiler(name, filename)
compileOrder.append(c)
filesIncluded[name] = c
filesCurrentlyIncluding.remove(name)
printverbose('end importing of {}', name)
return c
def asignsegment(self, segment: MemorySegment):
if self.currentaddress + segment.size >= self.maxsize:
throwhelper.throw('not enough memoey avaliable')
else:
name = segment.getasignmessage()
if not name:
name = 'unknown'
printverbose('asignning {}, size:{} at address {}', name, segment.size, self.currentaddress)
segment.address = self.currentaddress
self.currentaddress += segment.size
def __init__(self, parent, statement):
super().__init__(parent)
self.scope.update({'msb': msb})
name, result = self.docontext(DefContext, statement)
if type(result) is not MemorySegment:
throwhelper.throw('result is not memorysegment')
result.id = name
if compiler.phase == 1:
self.compiler.components[MemorySegment, name] = result
elif compiler.phase == 2:
self.compiler.components[MemorySegment, name].content = result.content
self.end(name, Pointer(self.compiler.components[MemorySegment, name]))
def parseline(self, line: str):
if line.startswith(self.indextext):
i = line.lstrip(self.indextext)
if compiler.phase == 1:
self.function.indices[i] = self.offset
elif compiler.phase == 2 and self.offset is not self.function.indices[
i]:
throwhelper.throw('offset doesnt match second pass',
function=self.function,
offset=self.offset)
else:
mnemonic, args = self.parsestatement(line)
args = self.evaluateargs(args)
s = self.getsyntax(mnemonic, args)
if compiler.phase == 1:
self.function.size += s.size
elif compiler.phase == 2:
self.function.content.extend(s.compile(args))
self.offset += s.size
def getsyntax(self, mnemonic: str, args: list) -> syntax.Syntax:
s = syntax.query(mnemonic, args)
if not s:
throwhelper.throw('syntax {} not found'.format(mnemonic))
return s