219 lines
8.8 KiB
Python
219 lines
8.8 KiB
Python
#!/usr/bin/env python3
|
|
# The reference assembler for NRJ OISC (tested for NRJ16)
|
|
# By Luxferre, 2022, public domain
|
|
|
|
import sys
|
|
import array
|
|
from os.path import realpath
|
|
|
|
# some constants to redefine more easily in case of major breaking changes
|
|
|
|
NRJDEF_BITS = 16 # default word/addr size if the .bit directive is omitted
|
|
|
|
# service characters
|
|
NRJCHAR_COMMENT = ';' # all comments are after ;
|
|
NRJCHAR_VARDEREF = '@' # variable dereferencing is with @
|
|
NRJCHAR_CHARDEREF = "'" # character dereferencing is with '
|
|
NRJCHAR_SUBST = '%' # var-in-macro substitution is with %
|
|
|
|
# macro variables
|
|
NRJVAR1 = NRJCHAR_SUBST + 'A' # %A
|
|
NRJVAR2 = NRJCHAR_SUBST + 'B' # %B
|
|
NRJVAR3 = NRJCHAR_SUBST + 'C' # %C
|
|
|
|
# and preprocessor directives
|
|
NRJDIR_INC = '.inc'
|
|
NRJDIR_BITS = '.bit'
|
|
NRJDIR_ORG = '.org'
|
|
NRJDIR_DEF = '.def'
|
|
NRJDIR_END = '.end'
|
|
NRJDIR_VAR = '.var'
|
|
NRJDIR_SET = '.set'
|
|
NRJDIR_FREE = 'FREE'
|
|
NRJDIR_NXT = 'NXT'
|
|
NRJDIR_HLT = 'HLT'
|
|
|
|
included_files = [] # stash to check the already included files
|
|
|
|
def readsrc(fname): # read source file contents, stripping comments, empty lines and trailing/leading whitespace
|
|
f = open(fname, 'r')
|
|
rawlines = f.readlines()
|
|
f.close()
|
|
lines = []
|
|
global included_files
|
|
included_files.append(realpath(fname))
|
|
for line in rawlines:
|
|
line = line.split(NRJCHAR_COMMENT)[0].strip()
|
|
if len(line) > 0:
|
|
tokens = line.split() # split on any whitespace, which is what we need
|
|
if tokens[0] == NRJDIR_INC: # process include directive immediately
|
|
incfname = realpath(' '.join(tokens[1:])) # because the name may include spaces
|
|
if incfname not in included_files: # cyclic inclusion protection
|
|
incfile = readsrc(incfname) # call itself recursively, trying to include a file
|
|
included_files.append(incfname) # update the list of included files
|
|
lines.extend(incfile) # update the source with the included contents in place
|
|
else:
|
|
print('Attempt to include an already included file %s, ignoring!' % incfname)
|
|
else: # otherwise just append the tokenized source line
|
|
lines.append(tokens)
|
|
return lines
|
|
|
|
def start_assembly(srcfname, dstfname): # main assembly method
|
|
wordsize = NRJDEF_BITS # define machine word/address size
|
|
|
|
# we're starting with tokenized Stage 1 source: all includes processed, comments and whitespace stripped
|
|
stage1src = readsrc(srcfname)
|
|
|
|
# Stage 2: scan the source for the first word size set directive
|
|
for line in stage1src:
|
|
if line[0] == NRJDIR_BITS:
|
|
wordsize = int(line[1])
|
|
break
|
|
print('Building for NRJ%u' % wordsize)
|
|
|
|
# Stage 3: expand all macros
|
|
stage3src = []
|
|
macrobuffers = {}
|
|
macrostart = False
|
|
macroname = None
|
|
for line in stage1src:
|
|
if macrostart: # we already are buffering a macro
|
|
if line[0] == NRJDIR_END: # macro ended and saved in the buffers
|
|
macrostart = False
|
|
macroname = None
|
|
else: # continue buffering
|
|
macrobuffers[macroname].append(line)
|
|
else: # usual code
|
|
if line[0] == NRJDIR_DEF: # starting a macro
|
|
macroname = line[1]
|
|
macrobuffers[macroname] = [] # prepare the place to buffer the macro into
|
|
macrostart = True
|
|
elif line[0] != NRJDIR_BITS: # ignoring word size directive as we already processed it
|
|
if line[0] in macrobuffers: # detected an already compiled macro, substituting the code and parameters
|
|
p1 = NRJDIR_HLT # placeholders for missing parameters
|
|
p2 = NRJDIR_HLT
|
|
p3 = NRJDIR_NXT # assume we're referring to the next address in p3
|
|
if len(line) > 1: # fill the first parameter if present
|
|
p1 = line[1]
|
|
if len(line) > 2: # fill the second parameter if present
|
|
p2 = line[2]
|
|
if len(line) > 3: # fill the third parameter if present
|
|
p3 = line[3]
|
|
for macroline in macrobuffers[line[0]]: # now, perform the macrosubstitution with parameter replacement
|
|
stage3src.append(' '.join(macroline).replace(NRJVAR1, p1).replace(NRJVAR2, p2).replace(NRJVAR3, p3).split())
|
|
else: # append a normal line
|
|
stage3src.append(line)
|
|
|
|
# Stage 4: now, process .var directive, FREE directive, @ and ' dereferencing operators
|
|
vartable = {} # don't store numeric locations here yet, only string representations (hex or FREE)
|
|
stage4src = []
|
|
for line in stage3src:
|
|
if line[0] == NRJDIR_VAR: # .var directive: no @ or ' operators allowed here
|
|
if line[2] == NRJDIR_FREE:
|
|
vartable[line[1]] = 0
|
|
else:
|
|
vartable[line[1]] = int(line[2], 16)
|
|
# now, fill in the FREE bits
|
|
maxvar = 0
|
|
for vname in vartable:
|
|
if vartable[vname] > maxvar:
|
|
maxvar = vartable[vname]
|
|
for vname in vartable:
|
|
if vartable[vname] == 0:
|
|
maxvar += 1
|
|
vartable[vname] = maxvar
|
|
for line in stage3src:
|
|
if line[0] != NRJDIR_VAR: # finally, perform variable substitution
|
|
# but first, attempt to perform character substitution
|
|
for i, el in enumerate(line):
|
|
if el.startswith(NRJCHAR_CHARDEREF):
|
|
line[i] = hex(ord(el[1]))[2:].upper()
|
|
sline = ' '.join(line)
|
|
for vname in vartable:
|
|
sline = sline.replace(NRJCHAR_VARDEREF+vname, hex(vartable[vname])[2:].upper())
|
|
stage4src.append(sline.split())
|
|
|
|
# now, our Stage 4 code is fully flat and we can start allocating memory for it
|
|
# directives left to process at this point: .org, .set, NXT, HLT
|
|
# (we cannot process .set before because it can also take value of NXT or HLT)
|
|
|
|
memsize = 1 << wordsize
|
|
haltaddr = memsize - 1 # halting address to be filled in the lookup table
|
|
print('Allocating %u %u-bit words of memory...' % (memsize, wordsize))
|
|
memmod = 'H'
|
|
if wordsize >= 32:
|
|
memmod = 'L'
|
|
elif wordsize >= 64:
|
|
memmod = 'Q'
|
|
elif wordsize <= 8:
|
|
memmod = 'B'
|
|
targetmem = array.array(memmod, [0]*memsize)
|
|
|
|
# here is the trickiest part of the whole assembly process - building a lookup table
|
|
# as NRJ can't directly jump to the next instruction by itself, we need to tell it to
|
|
# the NXT macro will be replaced with a cell in the lookup table that points to the next instruction
|
|
# and the lookup table will also take some memory in the machine
|
|
|
|
ltoffset = memsize >> 1 # in the worst case scenario, the code will take half of all memory and lookup table will take the other half
|
|
targetmem[ltoffset] = haltaddr # the first lookup table entry is always the halting address
|
|
codepos = 0
|
|
ltpos = 1
|
|
# let's iterate over the code
|
|
# pass 1
|
|
for line in stage4src:
|
|
if line[0] == NRJDIR_ORG: # handle .org
|
|
codepos = int(line[1], 16)
|
|
elif line[0] == NRJDIR_SET: # handle .set
|
|
addr = int(line[1], 16)
|
|
val = line[2]
|
|
if val == 'HLT':
|
|
targetmem[addr] = ltoffset
|
|
elif val != 'NXT':
|
|
targetmem[addr] = int(val, 16)
|
|
else: # 3-value vector where HLT or NXT can be encountered
|
|
# save current instruction in the lookup table
|
|
targetmem[ltoffset + ltpos] = codepos
|
|
ltpos += 1
|
|
for v in line:
|
|
if v == 'HLT':
|
|
targetmem[codepos] = ltoffset
|
|
elif v == 'NXT':
|
|
targetmem[codepos] = ltoffset + ltpos
|
|
else:
|
|
targetmem[codepos] = int(v, 16)
|
|
codepos += 1
|
|
# pass 2 - fill in NXT
|
|
codepos = 0
|
|
ltpos = 1
|
|
for line in stage4src:
|
|
if line[0] == NRJDIR_ORG: # handle .org
|
|
codepos = int(line[1], 16)
|
|
elif line[0] == NRJDIR_SET: # handle .set
|
|
addr = int(line[1], 16)
|
|
val = line[2]
|
|
if val == 'NXT':
|
|
val = targetmem[ltoffset + ltpos]
|
|
targetmem[addr] = val
|
|
else: # 3-value vector where HLT or NXT can be encountered
|
|
ltpos += 1
|
|
for v in line:
|
|
codepos += 1
|
|
|
|
# now, we have assembled our target memory snapshot, let's write the output file
|
|
|
|
outf = open(dstfname, "wb")
|
|
targetmem.tofile(outf)
|
|
outf.close()
|
|
print('Assembled %s' % dstfname)
|
|
|
|
|
|
if __name__ == '__main__': # nrjasm entry point
|
|
version = '0.0.1'
|
|
print('nrjasm v%s by Luxferre, 2022' % version)
|
|
if len(sys.argv) > 2:
|
|
print('Assembling %s into %s...' % (sys.argv[1], sys.argv[2]))
|
|
start_assembly(sys.argv[1], sys.argv[2])
|
|
else:
|
|
print('Usage: nrjasm.py [source] [binary]')
|
|
|