def runtest():
"""check cross-generated images files from disassembled data blobs"""
# disassembled image files
for n in [
'IMGRAND00', 'IMGRAND01', 'IMGRAND02', 'IMGRAND03', 'IMGRAND04',
'IMGRAND05', 'IMGRAND06', 'IMGRAND07', 'IMGRAND08', 'IMGRAND09',
'IMGRAND10', 'IMGRAND11', 'IMGRAND12', 'IMGRAND13', 'IMGRAND14',
'IMGRAND15', 'IMGRAND16', 'IMGRAND17', 'IMGRAND18', 'IMGRAND19',
'IMGRAND20', 'IMGRAND21', 'IMG000000', 'IMG000AA9', 'IMG001552',
'IMG001FFB', 'IMG002AA4', 'IMG00354D', 'IMG003FF6', 'IMG004A9F',
'IMG005548', 'IMG005FF1', 'IMG006A9A', 'IMG007543', 'IMG007FEC',
'IMG008A95', 'IMG00953E', 'IMG009FE7', 'IMG00AA90', 'IMG00B539',
'IMG00BFE2', 'IMG00CA8B', 'IMG00D534', 'IMG00DFDD', 'IMG00EA86',
'IMG00F52F', 'IMG00FFD8'
]:
archive = os.path.join(Dirs.sources, 'dis', n + '.dis.gz')
with gzip.open(archive, 'rt') as fin, open(Files.input, 'w') as fout:
src_code = process_source(fin.readlines())
fout.write(src_code)
xas(Files.input, '-i', '-R', '-q', '-o', Files.output)
check_image_files_eq(n, os.path.join(Dirs.sources, 'dis', n + '.img'),
Files.outputff)
# cleanup
os.remove(Files.input)
os.remove(Files.output)
for fn in Files.outputff:
try:
os.remove(fn)
except OSError:
pass
def runtest():
"""check cross-generated images files from disassembled data blobs"""
# disassembled image files
for n in [
"IMGRAND00", "IMGRAND01", "IMGRAND02", "IMGRAND03", "IMGRAND04",
"IMGRAND05", "IMGRAND06", "IMGRAND07", "IMGRAND08", "IMGRAND09",
"IMGRAND10", "IMGRAND11", "IMGRAND12", "IMGRAND13", "IMGRAND14",
"IMGRAND15", "IMGRAND16", "IMGRAND17", "IMGRAND18", "IMGRAND19",
"IMGRAND20", "IMGRAND21", "IMG000000", "IMG000AA9", "IMG001552",
"IMG001FFB", "IMG002AA4", "IMG00354D", "IMG003FF6", "IMG004A9F",
"IMG005548", "IMG005FF1", "IMG006A9A", "IMG007543", "IMG007FEC",
"IMG008A95", "IMG00953E", "IMG009FE7", "IMG00AA90", "IMG00B539",
"IMG00BFE2", "IMG00CA8B", "IMG00D534", "IMG00DFDD", "IMG00EA86",
"IMG00F52F", "IMG00FFD8"
]:
archive = os.path.join(Dirs.sources, "dis", n + ".dis.gz")
with gzip.open(archive, "rb") as fin, open(Files.input, "w") as fout:
srccode = processSource(fin.readlines())
fout.write(srccode)
xas(Files.input, "-i", "-R", "-o", Files.output)
checkImageFilesEq(n, os.path.join(Dirs.sources, "dis", n + ".img"),
Files.outputff)
# cleanup
os.remove(Files.input)
os.remove(Files.output)
for fn in Files.outputff:
try:
os.remove(fn)
except:
pass
def runtest():
"""check cross-generated images files from disassembled data blobs"""
# disassembled image files
for n in [
"IMGRAND00", "IMGRAND01", "IMGRAND02", "IMGRAND03",
"IMGRAND04", "IMGRAND05", "IMGRAND06", "IMGRAND07",
"IMGRAND08", "IMGRAND09", "IMGRAND10", "IMGRAND11",
"IMGRAND12", "IMGRAND13", "IMGRAND14", "IMGRAND15",
"IMGRAND16", "IMGRAND17", "IMGRAND18", "IMGRAND19",
"IMGRAND20", "IMGRAND21",
"IMG000000", "IMG000AA9", "IMG001552", "IMG001FFB",
"IMG002AA4", "IMG00354D", "IMG003FF6", "IMG004A9F",
"IMG005548", "IMG005FF1", "IMG006A9A", "IMG007543",
"IMG007FEC", "IMG008A95", "IMG00953E", "IMG009FE7",
"IMG00AA90", "IMG00B539", "IMG00BFE2", "IMG00CA8B",
"IMG00D534", "IMG00DFDD", "IMG00EA86", "IMG00F52F",
"IMG00FFD8"
]:
archive = os.path.join(Dirs.sources, "dis", n + ".dis.gz")
with gzip.open(archive, "rb") as fin, open(Files.input, "w") as fout:
srccode = processSource(fin.readlines())
fout.write(srccode)
xas(Files.input, "-i", "-R", "-o", Files.output)
checkImageFilesEq(n, os.path.join(Dirs.sources, "dis", n + ".img"),
Files.outputff)
# cleanup
os.remove(Files.input)
os.remove(Files.output)
for fn in Files.outputff:
try:
os.remove(fn)
except:
pass
def runtest():
"""check cross-generated output against native reference files"""
for infile, opts, reffile in [("ashello.asm", ["-R"], "ASHELLO-L"),
("asdirs.asm", [], "ASDIRS-L"),
("asorgs.asm", [], "ASORGS-L"),
("asopcs.asm", [], "ASOPCS-L"),
("asexprs.asm", [], "ASEXPRS-L"),
("asbss.asm", [], "ASBSS-L"),
("asregs.asm", ["-R"], "ASREGS-L"),
("assize1.asm", [], "ASSIZE1-L"),
("assize2.asm", [], "ASSIZE2-L"),
("assize3.asm", [], "ASSIZE3-L"),
("assize4.asm", [], "ASSIZE4-L"),
("astisym.asm", [], "ASTISYM-L"),
("asimg1.asm", [], "ASIMG1-L"),
("asimg2.asm", [], "ASIMG2-L"),
("asimg3.asm", [], "ASIMG3-L"),
("ascart.asm", ["-R", "-s"], "ASCART-L")]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
check_list_files_eq(Files.output, Files.reference)
for infile, opts, reffile in [("ascopy.asm", [], "ASCOPY-L")
#("ascopyn.asm", [], "ASCOPYN-L")
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
check_list_files_eq(Files.output, Files.reference, ignore_lino=True)
# symbols
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "-R", "-L", Files.output, "-S", "-o", Files.input)
reffile = os.path.join(Dirs.refs, "ashello.sym")
check_end_equal(Files.output, reffile)
# EQUs
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "-R", "-E", Files.output, "-o", Files.input)
reffile = os.path.join(Dirs.refs, "ashello.sym")
check_sym_equ_equiv(Files.output, reffile)
# auto-generated constants
source = os.path.join(Dirs.sources, "asautogen.asm")
xas(source, "-R", "-o", Files.error, "-S", "-L", Files.input)
with open(Files.input, "r") as fin, open(Files.output, "w") as fout:
lines = fin.readlines()[-20:]
fout.writelines(lines)
reffile = os.path.join(Dirs.refs, "asautogen.lst")
check_text_files_eq("autogen", Files.output, reffile)
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check cross-generated output against native reference files"""
for infile, opts, reffile in [
("ashello.asm", ["-R"], "ASHELLO-L"),
("asdirs.asm", [], "ASDIRS-L"),
("asorgs.asm", [], "ASORGS-L"),
("asopcs.asm", [], "ASOPCS-L"),
("asexprs.asm", [], "ASEXPRS-L"),
("asbss.asm", [], "ASBSS-L"),
("asregs.asm", ["-R"], "ASREGS-L"),
("assize1.asm", [], "ASSIZE1-L"),
("assize2.asm", [], "ASSIZE2-L"),
("assize3.asm", [], "ASSIZE3-L"),
("assize4.asm", [], "ASSIZE4-L"),
("astisym.asm", [], "ASTISYM-L"),
("asimg1.asm", [], "ASIMG1-L"),
("asimg2.asm", [], "ASIMG2-L"),
("asimg3.asm", [], "ASIMG3-L"),
("ascart.asm", ["-R"], "ASCART-L")
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkListFilesEq(Files.output, Files.reference)
for infile, opts, reffile in [
("ascopy.asm", [], "ASCOPY-L")
#("ascopyn.asm", [], "ASCOPYN-L")
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkListFilesEq(Files.output, Files.reference, ignoreLino=True)
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
def runtest():
"""check command line interface"""
# input and output files
source = os.path.join(Dirs.sources, 'ashellon.asm')
with open(Files.output, 'wb') as f:
xas(source, '-R', '-o', '-', stdout=f)
xdm(Disks.asmsrcs, '-e', 'ASHELLO-O', '-q', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-R', '-o', Dirs.tmp) # -o <dir>
if not os.path.isfile(os.path.join(Dirs.tmp, 'ashellon.obj')):
error('output', '-o <dir> failed')
with open(Files.output, 'wb') as f:
xas(source,
'-R',
'-i',
'-D',
'VSBW=>210C',
'VMBW=>2110',
'VWTR=>211C',
'KSCAN=>2108',
'-o',
'-',
stdout=f)
xdm(Disks.asmsrcs, '-e', 'ASHELLO-I', '-o', Files.reference)
check_image_files_eq(Files.output, Files.reference)
with open(Files.output, 'w') as f:
xas(source, '-R', '-q', '-o', Files.output, '-L', '-', stdout=f)
xdm(Disks.asmsrcs, '-e', 'ASHELLO-L', '-o', Files.reference)
check_list_files_eq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, 'nonexisting')
with open(Files.error, 'w') as ferr:
xas(source, '-i', '-R', '-o', Files.output, stderr=ferr, rc=1)
with open(Files.error, 'r') as ferr:
errs = ferr.readlines()
if len(errs) != 1 or 'File not found' not in errs[
0] or 'nonexisting' not in errs[0]:
error('File error', 'Incorrect file error message')
# include path
source = os.path.join(Dirs.sources, 'ascopyi.asm')
incls = os.path.join(Dirs.sources, 'test') + ',' + os.path.join(
Dirs.sources, 'test', 'test')
xas(source, '-i', '-I', incls, '-o', Files.output)
with open(Files.output, 'rb') as f:
data = f.read()
if len(data) != 6 + 20:
error('Include paths', 'Incorrect image length')
# command-line definitions
source = os.path.join(Dirs.sources, 'asdef.asm')
xas(source, '-b', '-D', 's1=1', 's3=3', 's2=4', '-o', Files.output)
if content(Files.output) != b'\x01\x03':
error('-D', 'Content mismatch')
xas(source, '-b', '-D', 's1=2,s2=2,s3=3', '-o', Files.output)
if content(Files.output) != b'\x02\x03':
error('-D', 'Content mismatch')
# rebase -a
source = os.path.join(Dirs.sources, 'asrebase.asm')
xas(source, '-b', '-a', '>2000', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'asrebasen.asm')
xas(ref, '-b', '-o', Files.reference)
check_binary_files_eq('rebase', Files.output, Files.reference)
# various parameter combinations
source = os.path.join(Dirs.sources, 'asxbank1.asm')
remove([Files.reference])
xas(source, '-b', '-q', '-o', Files.output, '-L', Files.reference)
check_exists([Files.reference])
# text data output
source = os.path.join(Dirs.sources, 'ascart.asm')
xas(source, '-b', '-R', '-o', Files.reference)
xas(source, '-t', 'a2', '-R', '-o', Files.output)
check_bin_text_equal_bytes(Files.output, Files.reference)
source = os.path.join(Dirs.sources, 'asmtext.asm')
xas(source, '-t', 'a2', '-R', '-o', Files.output)
dat = content(Files.output, mode='r')
if (not 'aorg >1000' in dat or 'aorg >1010' in dat or 'data' in dat
or not 'byte' in dat or '0x' in dat or not '>' in dat):
error('dat', 'Invalid .dat file contents')
# symbols
source = os.path.join(Dirs.sources, 'assyms.asm')
xas(source, '-b', '-R', '-o', Files.reference, '-E', Files.output)
check_symbols(
Files.output,
(
('VDPWA', 'SCAN'), # referencecs
(('START', '>0000'), ('S1', '>0001'), ('S2', '>0018')))) # symbols
# disable warnings
source = os.path.join(Dirs.sources, 'aswarn.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-q', '-o', Files.output, stderr=ferr, rc=0)
if content_len(Files.error) > 0:
error('warn', 'warnings, even though disabled')
# linker
source1 = os.path.join(Dirs.sources, 'aslink0a.asm')
source2 = os.path.join(Dirs.sources, 'aslink0b.asm')
xas(source1, '-q', '-o', Files.input)
xas(source2, '-q', '-o', Files.output)
with open(Files.error, "w") as ferr:
xas('-l',
Files.input,
'-ll',
Files.output,
'-o',
Files.reference,
rc=2,
stderr=ferr) # mutually exclusive
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check xdt99 extensions"""
# xdt99 extensions
source = os.path.join(Dirs.sources, "asxext.asm")
xas(source, "-R", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2=2,sym3=2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# some CLI options
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "--embed", "-R", "-o", Files.output)
# misc new features
for infile, reffile in [("asxnew.asm", "ASXNEW-O"),
("asmacs.asm", "ASMACS-O")]:
source = os.path.join(Dirs.sources, infile)
xas(source, "-o", Files.output)
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# SAVE directive
source = os.path.join(Dirs.sources, "asxsave.asm")
xas(source, "-b", "--base", "0xb000", "-o", Files.output)
save1s = [Files.output + "_" + ext for ext in ["b000", "b020", "b030"]]
checkConcatEq(save1s, os.path.join(Dirs.refs, "save1"))
checkNoFiles([Files.output + "_b080"])
# bank switching
source = os.path.join(Dirs.sources, "asxbank1.asm")
xas(source, "-b", "-o", Files.output)
save2s = [
Files.output + "_" + ext for ext in
["0000", "6000_b0", "6000_b1", "6100_b0", "6200_b1", "6200_b2"]
]
checkConcatEq(save2s, os.path.join(Dirs.refs, "save2"))
checkNoFiles([
Files.output + "_" + ext
for ext in ["0000_b0", "6000", "6100_b1", "6200_b0"]
])
source = os.path.join(Dirs.sources, "asxbank2.asm")
xas(source, "-b", "-o", Files.output)
save3s = [
Files.output + "_" + ext
for ext in ["c000", "c000_b0", "c000_b1", "d000_b0", "e000_b1"]
]
checkConcatEq(save3s, os.path.join(Dirs.refs, "save3"))
checkNoFiles([
Files.output + "_" + ext
for ext in ["d000", "d000_b1", "e000", "e000_b0"]
])
source = os.path.join(Dirs.sources, "asxsegm.asm")
xas(source, "-b", "-o", Files.output)
checkFileSizes([
(Files.output + "_" + ext, size)
for ext, size in [("0000", 20), ("b000_b1", 14), ("b010_b1",
2), ("b012_b2", 6)]
])
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
for fn in save1s + save2s + save3s:
os.remove(fn)
def runtest():
"""check cross-generated output against native reference files"""
# disassembler: run
for srcfile, aopts, addr, start in [
#("asopcs.asm", ["-R"], "0000", "0000"]), only for -d
#("asexprs.asm", [], "0000", "0154"), too many segments
("ashello.asm", ["-R", "--base", "0xa000"], "a000", "a016"),
("asregs.asm", ["-R"], "0000", "0000"),
("ascart.asm", ["-R"], "0000", "000c"),
("darun.asm", ["-R"], "0000", "0002")
]:
source = os.path.join(Dirs.sources, srcfile)
xas(*[source, "-b"] + aopts + ["-w", "-o", Files.reference])
xda(Files.reference, "-a", addr, "-r", start, "-p", "-o", Files.input)
xas(*[Files.input, "-b", "-R", "-o", Files.output])
check_files_eq(srcfile, Files.output, Files.reference, "PROGRAM")
# disassembler: top-down
for srcfile, aopts, addr, start in [("asopcs.asm", ["-R"], "0000", "0000"),
("asexprs.asm", [], "0000", "0154"),
("asregs.asm", ["-R"], "0000", "0000"),
("ascart.asm", ["-R"], "0000", "000c"),
("darun.asm", ["-R"], "0000", "0002")]:
source = os.path.join(Dirs.sources, srcfile)
xas(*[source, "-b"] + aopts + ["-w", "-o", Files.reference])
xda(Files.reference, "-a", addr, "-f", start, "-p", "-o", Files.input)
xas(*[Files.input, "-b", "-R", "-w", "-o", Files.output])
check_files_eq(srcfile, Files.output, Files.reference, "PROGRAM")
# running disassembler
source = os.path.join(Dirs.sources, "darun.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "0", "-r", "2", "-p", "-o", Files.output)
check_eq(check_data(Files.output), check_data(source), "run")
source = os.path.join(Dirs.sources, "daexec.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "1000", "-r", "103c", "1008", "-p", "-o",
Files.output)
check_eq(check_data(Files.output), check_data(source), "run")
# disassemble cart BINs
for binfile, start in (("blobm.bin", "6012"), ("blobh.bin", "start")):
binary = os.path.join(Dirs.refs, binfile)
xda(binary, "-a", "6000", "-r", start, "-p", "-o", Files.input)
xas(Files.input, "-b", "-R", "-w", "-o", Files.output)
check_files_eq(binary, Files.output, binary, "PROGRAM")
xda(binary, "-a", "6000", "-f", start, "-p", "-o", Files.input)
xas(Files.input, "-b", "-R", "-w", "-o", Files.output)
check_files_eq(binary, Files.output, binary, "PROGRAM")
# disassemble random
for r in xrange(16):
random.seed(r)
binary = "".join([chr(random.randrange(256)) for i in xrange(2048)])
with open(Files.reference, "wb") as fref:
fref.write(binary)
xda(Files.reference, "-a", "1000", "-f", "1000", "-p", "-o",
Files.input)
xas(Files.input, "-b", "-R", "-w", "-o", Files.output)
check_files_eq("random" + str(r), Files.reference, Files.output,
"PROGRAM")
# Cleanup
os.remove(Files.input)
for f in glob.glob(Files.output + "*"):
os.remove(f)
for f in glob.glob(Files.reference + "*"):
os.remove(f)
def runtest():
"""check cross-generated output against native reference files"""
# object code
for inp_file, opts, ref_file, compr_file in [
("asdirs.asm", [], "ASDIRS-O", "ASDIRS-C"),
("asorgs.asm", [], "ASORGS-O", "ASORGS-C"),
("asopcs.asm", [], "ASOPCS-O", "ASOPCS-C"),
("asexprs.asm", [], "ASEXPRS-O", "ASEXPRS-C"),
("asbss.asm", [], "ASBSS-O", "ASBSS-C"),
("asregs.asm", ["-R"], "ASREGS-O", "ASREGS-C"),
("ashello.asm", ["-R"], "ASHELLO-O", "ASHELLO-C"),
("ascopy.asm", [], "ASCOPY-O", None),
("ascopyn.asm", [], "ASCOPYN-O", None),
("assize1.asm", [], "ASSIZE1-O", "ASSIZE1-C"),
("assize2.asm", [], "ASSIZE2-O", None),
("assize3.asm", [], "ASSIZE3-O", None),
("assize4.asm", [], "ASSIZE4-O", None),
("astisym.asm", [], "ASTISYM-O", "ASTISYM-C"),
("asimg1.asm", [], "ASIMG1-O", "ASIMG1-C"),
("asimg2.asm", [], "ASIMG2-O", None),
("asimg3.asm", [], "ASIMG3-OX", None),
#("asreloc.asm", [], "ASRELOC-O", None),
("asxorg.asm", [], "ASXORG-O", None),
("ascart.asm", ["-R"], "ASCART-O", "ASCART-C")
]:
source = os.path.join(Dirs.sources, inp_file)
xdm(Disks.asmsrcs, "-e", ref_file, "-o", Files.reference)
xas(*[source] + opts + ["-o", Files.output])
check_obj_code_eq(Files.output, Files.reference)
xas(*[source] + opts + ["--strict", "-o", Files.output])
check_obj_code_eq(Files.output, Files.reference)
if compr_file:
# compressed object code
xas(*[source] + opts + ["-C", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", compr_file, "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# image files
for inp_file, opts, ref_file in [("ashello.asm", ["-R"], "ASHELLO-I"),
("astisym.asm", [], "ASTISYM-I"),
("asimg1.asm", [], "ASIMG1-I"),
("asimg2.asm", [], "ASIMG2-I")
#("asimg3.asm", [], "ASIMG3-I")
]:
source = os.path.join(Dirs.sources, inp_file)
xas(*[source] + opts + ["-i", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", ref_file, "-o", Files.reference)
check_image_files_eq(Files.output, Files.reference)
for inp_file, reffiles in [
("aslimg.asm", ["ASLIMG-I", "ASLIMG-J", "ASLIMG-K"]),
("assimg.asm", ["ASSIMG-I", "ASSIMG-J", "ASSIMG-K", "ASSIMG-L"]),
("asreloc.asm", ["ASRELOC-I"])
]:
source = os.path.join(Dirs.sources, inp_file)
xas(source, "-R", "-i", "-w", "-o", Files.output)
for i, ref_file in enumerate(reffiles):
xdm(Disks.asmimgs, "-e", ref_file, "-o", Files.reference)
check_files_eq("Image file",
Files.outputff[i],
Files.reference,
fmt="P")
# JMP instruction
source = os.path.join(Dirs.sources, "asjmp.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
xaserrors = read_stderr(Files.error)
referrors = get_source_markers(source, r";ERROR(:....)?")
check_errors(referrors, xaserrors)
# cleanup
for i in xrange(4):
os.remove(Files.outputff[i])
os.remove(Files.reference)
def runtest():
"""check cross-generated output against native reference files"""
# object code
for infile, opts, reffile, cprfile in [
("asdirs.asm", [], "ASDIRS-O", "ASDIRS-C"),
("asorgs.asm", [], "ASORGS-O", "ASORGS-C"),
("asopcs.asm", [], "ASOPCS-O", "ASOPCS-C"),
("asexprs.asm", [], "ASEXPRS-O", "ASEXPRS-C"),
("asbss.asm", [], "ASBSS-O", "ASBSS-C"),
("asregs.asm", ["-R"], "ASREGS-O", "ASREGS-C"),
("ashello.asm", ["-R"], "ASHELLO-O", "ASHELLO-C"),
("ascopy.asm", [], "ASCOPY-O", None),
("ascopyn.asm", [], "ASCOPYN-O", None),
("assize1.asm", [], "ASSIZE1-O", "ASSIZE1-C"),
("assize2.asm", [], "ASSIZE2-O", None),
("assize3.asm", [], "ASSIZE3-O", None),
("assize4.asm", [], "ASSIZE4-O", None),
("astisym.asm", [], "ASTISYM-O", "ASTISYM-C"),
("asimg1.asm", [], "ASIMG1-O", "ASIMG1-C"),
("asimg2.asm", [], "ASIMG2-O", None),
("asimg3.asm", [], "ASIMG3-OX", None),
#("asreloc.asm", [], "ASRELOC-O", None),
("asxorg.asm", [], "ASXORG-O", None),
("ascart.asm", ["-R"], "ASCART-O", "ASCART-C")
]:
source = os.path.join(Dirs.sources, infile)
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
xas(*[source] + opts + ["-o", Files.output])
checkObjCodeEq(Files.output, Files.reference)
xas(*[source] + opts + ["--strict", "-o", Files.output])
checkObjCodeEq(Files.output, Files.reference)
if cprfile:
# compressed object code
xas(*[source] + opts + ["-C", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", cprfile, "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# image files
for infile, opts, reffile in [("ashello.asm", ["-R"], "ASHELLO-I"),
("astisym.asm", [], "ASTISYM-I"),
("asimg1.asm", [], "ASIMG1-I"),
("asimg2.asm", [], "ASIMG2-I")
#("asimg3.asm", [], "ASIMG3-I")
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-i", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkImageFilesEq(Files.output, Files.reference)
for infile, reffiles in [
("aslimg.asm", ["ASLIMG-I", "ASLIMG-J", "ASLIMG-K"]),
("assimg.asm", ["ASSIMG-I", "ASSIMG-J", "ASSIMG-K", "ASSIMG-L"]),
("asreloc.asm", ["ASRELOC-I"])
]:
source = os.path.join(Dirs.sources, infile)
xas(source, "-R", "-i", "-o", Files.output)
for i, reffile in enumerate(reffiles):
xdm(Disks.asmimgs, "-e", reffile, "-o", Files.reference)
checkFilesEq("Image file",
Files.outputff[i],
Files.reference,
fmt="P")
# cleanup
for i in xrange(4):
os.remove(Files.outputff[i])
os.remove(Files.reference)
def runtest():
"""check cross-generated output against native reference files"""
# object code
for infile, opts, reffile, cprfile in [
("asdirs.asm", [], "ASDIRS-O", "ASDIRS-C"),
("asorgs.asm", [], "ASORGS-O", "ASORGS-C"),
("asopcs.asm", [], "ASOPCS-O", "ASOPCS-C"),
("asexprs.asm", [], "ASEXPRS-O", "ASEXPRS-C"),
("asbss.asm", [], "ASBSS-O", "ASBSS-C"),
("asregs.asm", ["-R"], "ASREGS-O", "ASREGS-C"),
("ashello.asm", ["-R"], "ASHELLO-O", "ASHELLO-C"),
("ascopy.asm", [], "ASCOPY-O", None),
("ascopyn.asm", [], "ASCOPYN-O", None),
("assize1.asm", [], "ASSIZE1-O", "ASSIZE1-C"),
("assize2.asm", [], "ASSIZE2-O", None),
("assize3.asm", [], "ASSIZE3-O", None),
("assize4.asm", [], "ASSIZE4-O", None),
("astisym.asm", [], "ASTISYM-O", "ASTISYM-C"),
("asimg1.asm", [], "ASIMG1-O", "ASIMG1-C"),
("asimg2.asm", [], "ASIMG2-O", None),
("asimg3.asm", [], "ASIMG3-OX", None),
#("asreloc.asm", [], "ASRELOC-O", None),
("asxorg.asm", [], "ASXORG-O", None),
("ascart.asm", ["-R"], "ASCART-O", "ASCART-C")
]:
source = os.path.join(Dirs.sources, infile)
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
xas(*[source] + opts + ["-o", Files.output])
checkObjCodeEq(Files.output, Files.reference)
xas(*[source] + opts + ["--strict", "-o", Files.output])
checkObjCodeEq(Files.output, Files.reference)
if cprfile:
# compressed object code
xas(*[source] + opts + ["-C", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", cprfile, "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# image files
for infile, opts, reffile in [
("ashello.asm", ["-R"], "ASHELLO-I"),
("astisym.asm", [], "ASTISYM-I"),
("asimg1.asm", [], "ASIMG1-I"),
("asimg2.asm", [], "ASIMG2-I")
#("asimg3.asm", [], "ASIMG3-I")
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ["-i", "-o", Files.output])
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkImageFilesEq(Files.output, Files.reference)
for infile, reffiles in [
("aslimg.asm", ["ASLIMG-I", "ASLIMG-J", "ASLIMG-K"]),
("assimg.asm", ["ASSIMG-I", "ASSIMG-J", "ASSIMG-K", "ASSIMG-L"]),
("asreloc.asm", ["ASRELOC-I"])
]:
source = os.path.join(Dirs.sources, infile)
xas(source, "-R", "-i", "-o", Files.output)
for i, reffile in enumerate(reffiles):
xdm(Disks.asmimgs, "-e", reffile, "-o", Files.reference)
checkFilesEq("Image file",
Files.outputff[i], Files.reference, fmt="P")
# cleanup
for i in xrange(4):
os.remove(Files.outputff[i])
os.remove(Files.reference)
def runtest():
"""check cross-generated output against native reference files"""
source = os.path.join(Dirs.sources, 'dasource.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference, '-E', Files.input)
# bad command line arguments
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-a',
'foo',
'-f',
'6666',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badarg', 'Bad argument not caught')
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-a',
'fff',
'-f',
'600x',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badarg', 'Bad argument not caught')
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-a',
'1000',
'-f',
'1000',
'-e',
'1100',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badarg', 'Bad argument not caught')
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-a',
'1000',
'-f',
'1000',
'-e',
'1100-1-1',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badarg', 'Bad argument not caught')
# skip all bytes
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-k',
'>ffffffff',
'-a',
'1234',
'-f',
'1000',
'-o',
Files.output,
stderr=ferr,
rc=0)
if content(Files.output).strip() != b'aorg >1234':
error('skipall', 'still unskipped content left')
# missing files
with open(Files.error, 'w') as ferr:
xda('asm/nosuchfile',
'-a',
'6000',
'-f',
'6666',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badfile', 'Bad input file not caught')
with open(Files.error, 'w') as ferr:
xda(Files.reference,
'-a',
'6000',
'-f',
'6016',
'-S',
'nosuchfile',
'-o',
Files.output,
stderr=ferr,
rc=1)
if 'Traceback' in content(Files.error, mode='r'):
error('badfile', 'Bad input file not caught')
# Cleanup
os.remove(Files.input)
os.remove(Files.error)
os.remove(Files.reference)
try:
os.remove(Files.output)
except FileNotFoundError:
pass
def runtest():
"""check command line interface"""
# input and output files
source = os.path.join(Dirs.sources, "ashello.asm")
with open(Files.output, "wb") as f:
xas(source, "-R", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
with open(Files.output, "wb") as f:
xas(source, "-R", "-i", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference)
checkImageFilesEq(Files.output, Files.reference)
with open(Files.output, "w") as f:
xas(source, "-R", "-o", Files.output, "-L", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-L", "-o", Files.reference)
checkListFilesEq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, "nonexisting")
with open(Files.error, "w") as ferr:
xas(source, "-i", "-R", "-o", Files.output, stderr=ferr, rc=1)
with open(Files.error, "r") as ferr:
errs = ferr.readlines()
if len(errs) != 1 or errs[0][:10] != "File error":
error("File errors", "Incorrect file error message")
# include path
source = os.path.join(Dirs.sources, "ascopyi.asm")
incls = os.path.join(Dirs.sources, "test") + "," + \
os.path.join(Dirs.sources, "test", "test")
xas(source, "-i", "-I", incls, "-o", Files.output)
with open(Files.output, "rb") as f:
data = f.read()
if len(data[6:]) != 20:
error("Include paths", "Incorrect image length")
# jumpstart disk
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "-R", "--jumpstart", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference)
with open(Files.output, "rb") as fout, open(Files.reference, "rb") as fref:
disk = fout.read()
prog = fref.read()
if len(disk) != 360 * 256:
error("Jumpstart", "Incorrect disk size: %d" % len(disk))
if disk[0:10] != "xas99-JS\xc2\xb9" or disk[56:256] != "\xff" * 200:
error("Jumpstart", "Invalid sector 0 data")
plen = ordw(prog[2:4]) - 6
if disk[512:512 + plen] != prog[6:6 + plen]:
error("Jumpstart", "Invalid program data")
# various parameter combinations
source = os.path.join(Dirs.sources, "asxbank1.asm")
remove([Files.reference])
xas(source, "-b", "-o", Files.output, "-L", Files.reference)
checkExists([Files.reference])
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check xdt99 extensions"""
# xdt99 extensions
source = os.path.join(Dirs.sources, "asxext.asm")
xas(source, "-R", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2=2,sym3=2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# some CLI options
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "--embed", "-R", "-o", Files.output)
# misc new features
for infile, reffile in [("asxnew.asm", "ASXNEW-O"),
("asmacs.asm", "ASMACS-O")]:
source = os.path.join(Dirs.sources, infile)
xas(source, "-o", Files.output)
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# SAVE directive
source = os.path.join(Dirs.sources, "asxsave.asm")
xas(source, "-b", "--base", "0xb000", "-o", Files.output)
save1s = [Files.output + "_" + ext for ext in ["b000", "b020", "b030"]]
check_concat_eq(save1s, os.path.join(Dirs.refs, "save1"))
check_no_files([Files.output + "_b080"])
# bank switching: obsolete AORG addr, bank
source = os.path.join(Dirs.sources, "asxbank1.asm")
xas(source, "-b", "-w", "-o", Files.output)
save2s = [
Files.output + "_" + ext for ext in
["0000", "6000_b0", "6000_b1", "6100_b0", "6200_b1", "6200_b2"]
]
check_concat_eq(save2s, os.path.join(Dirs.refs, "save2"))
check_no_files([Files.output + "_0000_b0", Files.output + "_6100_b1"])
source = os.path.join(Dirs.sources, "asxbank2.asm")
xas(source, "-b", "-w", "-o", Files.output)
save3s = [
Files.output + "_" + ext
for ext in ["c000_b0", "c000_b1", "d000_b0", "e000_b1"]
]
check_concat_eq(save3s, os.path.join(Dirs.refs, "save3"))
check_no_files([
Files.output + "_" + ext
for ext in ["c000", "d000", "d000_b1", "e000", "e000_b0"]
])
source = os.path.join(Dirs.sources, "asxsegm.asm")
xas(source, "-b", "-w", "-o", Files.output)
check_file_sizes([
(Files.output + "_" + ext, size)
for ext, size in [("0000", 20), ("b000_b1", 14), ("b010_b1",
2), ("b012_b2", 6)]
])
# BANK directive
source = os.path.join(Dirs.sources, "asdbank.asm")
xas(source, "-b", "-R", "-o", Files.output)
save4s = [Files.output + ext for ext in ["_6000_b0", "_6000_b1"]]
check_concat_eq(save4s, os.path.join(Dirs.refs, "asdbank"))
# cross-bank access
source = os.path.join(Dirs.sources, "asxbank.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr,
rc=0) # no error
source = os.path.join(Dirs.sources, "asnxbank.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr,
rc=1) # with errors
# sections shared across banks
source = os.path.join(Dirs.sources, "asshbank.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr,
rc=1) # with errors
act_errors = read_stderr(Files.error)
exp_errors = get_source_markers(source, r";ERROR(:....)?")
check_errors(exp_errors, act_errors)
source = os.path.join(Dirs.sources, "asshbankx.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr,
rc=0) # no error
# data output (-t)
source = os.path.join(Dirs.sources, "ashexdat.asm")
xas(source, "-t", "a2", "-R", "-o", Files.output)
xas(source, "-b", "-R", "-o", Files.reference)
check_numeric_eq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, "asxtext.asm")
xas(source, "-t", "a2", "-o", Files.output + "1")
xas(source, "-t", "c4", "-o", Files.output + "2")
xas(source, "-t", "b", "-o", Files.output + "3")
xas(source, "-t", "a4", "-o", Files.output + "4")
xas(source, "-t", "c", "-o", Files.output + "5")
save5s = [Files.output + ext for ext in ["1", "2", "3", "4", "5"]]
check_concat_eq(save5s, os.path.join(Dirs.refs, "asxtext"))
# auto-generated constants (b#, w#)
source = os.path.join(Dirs.sources, "asautogen.asm")
xas(source, "-b", "-R", "-o", Files.output)
source = os.path.join(Dirs.sources, "asautoman.asm")
xas(source, "-b", "-R", "-o", Files.reference)
check_binary_files_eq("autogen", Files.output, Files.reference)
source = os.path.join(Dirs.sources, "asautorel.asm")
xas(source, "-b", "-R", "-o",
Files.output) # address is now >00xx instead of >a0xx
with open(Files.reference, "rb+") as f:
data = f.read()
data = data.replace("\xa0", "\x00")
f.seek(0)
f.write(data)
check_binary_files_eq("autogen", Files.output, Files.reference)
# register LSB access (l#)
source = os.path.join(Dirs.sources, "asxrlb.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0)
ref = os.path.join(Dirs.sources, "asxrlbn.asm")
xas(ref, "-b", "-R", "-o", Files.reference)
check_binary_files_eq("rlb", Files.output, Files.reference)
act_errors = read_stderr(Files.error, include_warnings=True)
exp_errors = get_source_markers(source, tag=r";WARN")
check_errors(exp_errors, act_errors)
# size modifier (s#)
source = os.path.join(Dirs.sources, "assmod.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0)
ref = os.path.join(Dirs.sources, "assmodn.asm")
xas(ref, "-b", "-R", "-o", Files.reference)
check_binary_files_eq("s#", Files.output, Files.reference)
with open(Files.error, "r") as ferr:
if "TEXT4" not in ferr.read():
error("s#", "Missing warning about TEXT4")
source = os.path.join(Dirs.sources, "assmode.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=1)
act_errors = read_stderr(Files.error)
exp_errors = get_source_markers(source, tag=r";ERROR")
check_errors(exp_errors, act_errors)
# floating-point numbers
source = os.path.join(Dirs.sources, "asfloat.asm")
xas(source, "-b", "-o", Files.output)
ref = os.path.join(Dirs.refs, "asfloat.ref")
check_binary_files_eq("float", Files.output, ref)
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
for fn in set(save1s + save2s + save3s + save4s + save5s):
os.remove(fn)
def runtest():
"""check error messages against native assembler listing"""
# cross-assembler error messages
source = os.path.join(Dirs.sources, "aserrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-s", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
# TI assembler error messages
tierrors = {}
xdm(Disks.asmsrcs, "-e", "ASERRS-L", "-o", Files.reference)
with open(Files.reference, "r") as f:
for line in f:
err = re.match(r"\*{5}\s+([A-Z ]*) - (\d+)", line)
if err:
lino, errmsg = err.group(2), err.group(1)
tierrors[lino] = errmsg
# compare
compare(tierrors, xaserrors)
# xdt99-specific errors
source = os.path.join(Dirs.sources, "asxerrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
referrors = {}
with open(source, "r") as f:
for i, line in enumerate(f):
m = re.search(r";ERROR(:....)?", line)
if m:
if m.group(1):
referrors[m.group(1)[1:]] = line
else:
referrors["%04d" % (i + 1)] = line
compare(referrors, xaserrors)
# xdt99-specific errors (image generation)
source = os.path.join(Dirs.sources, "asxerrsb.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-b", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
referrors = {}
with open(source, "r") as f:
for i, line in enumerate(f):
m = re.search(r";ERROR(:....)?", line)
if m:
if m.group(1):
referrors[m.group(1)[1:]] = line
else:
referrors["%04d" % (i + 1)] = line
compare(referrors, xaserrors)
# files not found
source = os.path.join(Dirs.sources, "ascopyi.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
# cleanup
os.remove(Files.error)
os.remove(Files.reference)
def runtest():
"""check cross-generated output against native reference files"""
# disassembler: run
for srcfile, aopts, addr, start in [
#('asopcs.asm', ['-R'], '0000', '0000']), only for -d
#('asexprs.asm', [], '0000', '0154'), too many segments
('ashello.asm', ['-R', '--base', '0xa000'], 'a000', 'a016'),
('asregs.asm', ['-R'], '0000', '0000'),
('ascart.asm', ['-R'], '0000', '000c'),
('darun.asm', ['-R'], '0000', '0002')
]:
source = os.path.join(Dirs.sources, srcfile)
xas(*[source, '-b'] + aopts + ['-q', '-o', Files.reference])
xda(Files.reference, '-a', addr, '-r', start, '-p', '-o', Files.input)
xas(*[Files.input, '-b', '-R', '-o', Files.output])
check_binary_files_eq(srcfile, Files.output, Files.reference)
# disassembler: top-down
for srcfile, aopts, addr, start in [('asopcs.asm', ['-R'], '0000', '0000'),
('asexprs.asm', [], '0000', '0154'),
('asregs.asm', ['-R'], '0000', '0000'),
('ascart.asm', ['-R'], '0000', '000c'),
('darun.asm', ['-R'], '0000', '0002')]:
source = os.path.join(Dirs.sources, srcfile)
xas(*[source, '-b'] + aopts + ['-q', '-o', Files.reference])
xda(Files.reference, '-a', addr, '-f', start, '-p', '-o', Files.input)
xas(*[Files.input, '-b', '-R', '-q', '-o', Files.output])
check_binary_files_eq(srcfile, Files.output, Files.reference)
# running disassembler
source = os.path.join(Dirs.sources, 'darun.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '0', '-r', '2', '-p', '-o', Files.output)
check_eq(check_data(Files.output), check_data(source), 'run')
source = os.path.join(Dirs.sources, 'daexec.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '1000', '-r', '103c', '1008', '-p', '-o',
Files.output)
check_eq(check_data(Files.output), check_data(source), 'run')
# disassemble cart BINs
for binfile, start in (('blobm.bin', '6012'), ('blobh.bin', 'start')):
binary = os.path.join(Dirs.refs, binfile)
xda(binary, '-a', '6000', '-r', start, '-p', '-o', Files.input)
xas(Files.input, '-b', '-R', '-q', '-o', Files.output)
check_binary_files_eq(binary, Files.output, binary)
xda(binary, '-a', '6000', '-f', start, '-p', '-o', Files.input)
xas(Files.input, '-b', '-R', '-q', '-o', Files.output)
check_binary_files_eq(binary, Files.output, binary)
# disassemble random
for r in range(16):
random.seed(r)
binary = bytes([random.randrange(256) for i in range(2048)])
with open(Files.reference, 'wb') as fref:
fref.write(binary)
xda(Files.reference, '-a', '1000', '-f', '1000', '-p', '-o',
Files.input)
xas(Files.input, '-b', '-R', '-q', '-o', Files.output)
check_binary_files_eq('random' + str(r), Files.reference, Files.output)
xda(Files.reference, '-a', '1000', '-f', '1000', '-p', '-5', '-18',
'-o', Files.input)
xas(Files.input, '-b', '-R', '-5', '-18', '-q', '-o', Files.output)
check_binary_files_eq('random' + str(r) + '518', Files.reference,
Files.output)
# Cleanup
os.remove(Files.input)
for f in glob.glob(Files.output + '*'):
os.remove(f)
for f in glob.glob(Files.reference + '*'):
os.remove(f)
def runtest():
"""check command line interface"""
# input and output files
source = os.path.join(Dirs.sources, "ashello.asm")
with open(Files.output, "wb") as f:
xas(source, "-R", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-O", "-o", Files.reference)
check_obj_code_eq(Files.output, Files.reference)
with open(Files.output, "wb") as f:
xas(source, "-R", "-i", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference)
check_image_files_eq(Files.output, Files.reference)
with open(Files.output, "w") as f:
xas(source, "-R", "-o", Files.output, "-L", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-L", "-o", Files.reference)
check_list_files_eq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, "nonexisting")
with open(Files.error, "w") as ferr:
xas(source, "-i", "-R", "-o", Files.output, stderr=ferr, rc=1)
with open(Files.error, "r") as ferr:
errs = ferr.readlines()
if len(errs) != 1 or errs[0][:10] != "File error":
error("File error", "Incorrect file error message")
# include path
source = os.path.join(Dirs.sources, "ascopyi.asm")
incls = os.path.join(Dirs.sources, "test") + "," + \
os.path.join(Dirs.sources, "test", "test")
xas(source, "-i", "-I", incls, "-o", Files.output)
with open(Files.output, "rb") as f:
data = f.read()
if len(data[6:]) != 20:
error("Include paths", "Incorrect image length")
# command-line definitions
source = os.path.join(Dirs.sources, "asdef.asm")
xas(source, "-b", "-D", "s1=1", "s3=3", "s2=4", "-o", Files.output)
assert content(Files.output) == "\x01\x03"
xas(source, "-b", "-D", "s1=2,s2=2,s3=3", "-o", Files.output)
assert content(Files.output) == "\x02\x03"
# various parameter combinations
source = os.path.join(Dirs.sources, "asxbank1.asm")
remove([Files.reference])
xas(source, "-b", "-o", Files.output, "-L", Files.reference)
check_exists([Files.reference])
# text data output
source = os.path.join(Dirs.sources, "ascart.asm")
xas(source, "-b", "-R", "-o", Files.reference)
xas(source, "-t", "a2", "-R", "-o", Files.output)
check_bin_text_equal(Files.output, Files.reference)
source = os.path.join(Dirs.sources, "asmtext.asm")
xas(source, "-t", "a2", "-R", "-o", Files.output)
check_instructions(Files.output,
[";aorg>1000", "byte", ";aorg>2000", "byte"])
# symbols
source = os.path.join(Dirs.sources, "assyms.asm")
xas(source, "-b", "-R", "-o", Files.reference, "-E", Files.output)
check_symbols(Files.output, (("START", ">0000"), ("S1", ">0001"),
("S2", ">0018"), ("VDPWA", ">8C02")))
# disable warnings
source = os.path.join(Dirs.sources, "aswarn.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-w", "-o", Files.output, stderr=ferr, rc=0)
if content_len(Files.error) > 0:
error("warn", "warnings, even though disabled")
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check command line interface"""
# input and output files
source = os.path.join(Dirs.sources, "ashello.asm")
with open(Files.output, "wb") as f:
xas(source, "-R", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
with open(Files.output, "wb") as f:
xas(source, "-R", "-i", "-o", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference)
checkImageFilesEq(Files.output, Files.reference)
with open(Files.output, "w") as f:
xas(source, "-R", "-o", Files.output, "-L", "-", stdout=f)
xdm(Disks.asmsrcs, "-e", "ASHELLO-L", "-o", Files.reference)
checkListFilesEq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, "nonexisting")
with open(Files.error, "w") as ferr:
xas(source, "-i", "-R", "-o", Files.output, stderr=ferr, rc=1)
with open(Files.error, "r") as ferr:
errs = ferr.readlines()
if len(errs) != 1 or errs[0][:10] != "File error":
error("File errors", "Incorrect file error message")
# include path
source = os.path.join(Dirs.sources, "ascopyi.asm")
incls = os.path.join(Dirs.sources, "test") + "," + \
os.path.join(Dirs.sources, "test", "test")
xas(source, "-i", "-I", incls, "-o", Files.output)
with open(Files.output, "rb") as f:
data = f.read()
if len(data[6:]) != 20:
error("Include paths", "Incorrect image length")
# jumpstart disk
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "-R", "--jumpstart", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference)
with open(Files.output, "rb") as fout, open(Files.reference, "rb") as fref:
disk = fout.read()
prog = fref.read()
if len(disk) != 360 * 256:
error("Jumpstart", "Incorrect disk size: %d" % len(disk))
if disk[0:10] != "xas99-JS\xc2\xb9" or disk[56:256] != "\xff" * 200:
error("Jumpstart", "Invalid sector 0 data")
plen = ordw(prog[2:4]) - 6
if disk[512:512 + plen] != prog[6:6 + plen]:
error("Jumpstart", "Invalid program data")
# various parameter combinations
source = os.path.join(Dirs.sources, "asxbank1.asm")
remove([Files.reference])
xas(source, "-b", "-o", Files.output, "-L", Files.reference)
checkExists([Files.reference])
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check cross-generated output against native reference files"""
# check if listings match E/A
for infile, opts, reffile in [('ashellon.asm', ['-R'], 'ASHELLO-L'),
('asdirs.asm', [], 'ASDIRS-L'),
('asorgs.asm', [], 'ASORGS-L'),
('asopcs.asm', [], 'ASOPCS-L'),
('asexprs.asm', [], 'ASEXPRS-L'),
('asbss.asm', [], 'ASBSS-L'),
('asregs.asm', ['-R'], 'ASREGS-L'),
('assize1.asm', [], 'ASSIZE1-L'),
('assize2.asm', [], 'ASSIZE2-L'),
('assize3.asm', [], 'ASSIZE3-L'),
('assize4.asm', [], 'ASSIZE4-L'),
('asextsym.asm', [], 'ASEXTSYM-L'),
('asimg1.asm', [], 'ASIMG1-L'),
('asimg2.asm', [], 'ASIMG2-L'),
('asimg3.asm', [], 'ASIMG3-L'),
('ascart.asm', ['-R', '-s'], 'ASCART-L')]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts + ['-q', '-L', Files.output, '-o', Files.input])
xdm(Disks.asmsrcs, '-e', reffile, '-o', Files.reference)
check_list_files_eq(Files.output, Files.reference)
# check if listing words match actual words
for infile, opts in [
('asdirs.asm', []), # cannot use programs with many ?ORGs
('asopcs.asm', []),
('asbss.asm', []),
('asregs.asm', ['-R']),
('ascart.asm', ['-R', '-s']),
('aslist.asm', [])
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts +
['-b', '-q', '-L', Files.output, '-o', Files.reference])
check_list_against_binary(Files.output, Files.reference)
# changing sources
for infile, opts, reffile in [
('ascopy.asm', [], 'ASCOPY-L')
#('ascopyn.asm', [], 'ASCOPYN-L') # TI version is not souce-equal to xas99 version
]:
source = os.path.join(Dirs.sources, infile)
xas(*[source] + opts +
['-q', '-L', Files.output, '-o', Files.reference])
xdm(Disks.asmsrcs, '-e', reffile, '-o', Files.reference)
check_list_files_eq(Files.output, Files.reference, ignore_lino=True)
# bytes and padding
source = os.path.join(Dirs.sources, 'aslist.asm')
xas(source, '-o', Files.input, '-L', Files.output)
ref = os.path.join(Dirs.refs, 'aslist.lst')
check_text_files_eq('listbytes', Files.output, ref)
# symbols
source = os.path.join(Dirs.sources, 'ashello.asm')
xas(source, '-R', '-L', Files.output, '-S', '-q', '-o', Files.input)
reffile = os.path.join(Dirs.refs, 'ashello.sym')
check_end_equal(Files.output, reffile)
# EQUs
source = os.path.join(Dirs.sources, 'ashello.asm')
xas(source, '-R', '-E', Files.output, '-q', '-o', Files.input)
reffile = os.path.join(Dirs.refs, 'ashello.sym')
check_sym_equ_equiv(Files.output, reffile)
# auto-generated constants
source = os.path.join(Dirs.sources, 'asauto.asm')
reffile = os.path.join(Dirs.refs, 'asauto.lst')
with open(reffile, 'r') as fref:
reflines = [line.rstrip() for line in fref.readlines()]
xas(source, '-R', '-o', Files.error, '-S', '-L', Files.output)
with open(Files.output, 'r') as fout:
lines = [line.rstrip() for line in fout.readlines()][-len(reflines):]
if lines != reflines:
error('auto', 'auto-const listing mismatch')
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
os.remove(Files.error)
def runtest():
"""check error messages against native assembler listing"""
# cross-assembler error messages
source = os.path.join(Dirs.sources, "aserrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-s", "-o", Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
# TI assembler error messages
ti_errors = {}
xdm(Disks.asmsrcs, "-e", "ASERRS-L", "-o", Files.reference)
with open(Files.reference, "r") as f:
for line in f:
err = re.match(r"\*{5}\s+([A-Z ]*) - (\d+)", line)
if err:
lino, err_msg = err.group(2), err.group(1)
ti_errors[lino] = err_msg
# compare
check_errors(ti_errors, xas_errors)
# xdt99-specific errors
source = os.path.join(Dirs.sources, "asxerrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-o", Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
ref_errors = get_source_markers(source, r";ERROR(:....)?")
check_errors(ref_errors, xas_errors)
# xdt99-specific errors (image generation)
source = os.path.join(Dirs.sources, "asxerrsb.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-b", "-o", Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
ref_errors = get_source_markers(source, tag=r";ERROR(:....)?")
check_errors(ref_errors, xas_errors)
# open .if-.endif or .defm-.endm
source = os.path.join(Dirs.sources, "asopenif.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
with open(Files.error, "r") as fin:
msgs = " ".join(fin.readlines())
if "Missing .endif" not in msgs:
error("open", "Missing error for open .if/.endif")
source = os.path.join(Dirs.sources, "asopenmac.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
with open(Files.error, "r") as fin:
msgs = " ".join(fin.readlines())
if "Missing .endm" not in msgs:
error("open", "Missing error for open .defm/.endm")
# files not found
source = os.path.join(Dirs.sources, "ascopyi.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
# warnings
source = os.path.join(Dirs.sources, "aswarn.asm")
with open(Files.error, "w") as ferr:
xas(source, "-b", "-R", "-o", Files.output, stderr=ferr,
rc=0) # no error
act_errors = read_stderr(Files.error, include_warnings=True)
exp_errors = get_source_markers(source, tag=r";WARN")
check_errors(exp_errors, act_errors)
source = os.path.join(Dirs.sources, "asuusym.asm") # undefined symbols
with open(Files.error, "w") as ferr:
xas(source, "-R", "-o", Files.output, stderr=ferr, rc=0) # no error
with open(Files.error, "r") as fin:
output = fin.read()
if output.strip()[-14:] != "U1 U2 U3 U4 U5":
error("stdout", "Bad list of unreferenced symbols")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-w", "-o", Files.output, stderr=ferr,
rc=0) # no error
with open(Files.error, "r") as fin:
output = fin.read()
if output.strip():
error("stdout", "Unwanted list of unreferenced symbols")
# STDOUT
source = os.path.join(Dirs.sources, "asstdout.asm")
with open(Files.error, "w") as fout:
xas(source, "-b", "-R", "-o", Files.output, stdout=fout,
rc=0) # no error
with open(Files.error, "r") as fin:
output = fin.read()
if output.strip() != "hello 42 world!":
error("stdout", "Invalid STDOUT output: " + output)
# cleanup
os.remove(Files.error)
os.remove(Files.reference)
def runtest():
"""check xdt99 extensions"""
# xdt99 extensions
source = os.path.join(Dirs.sources, "asxext.asm")
xas(source, "-R", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output)
xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# some CLI options
source = os.path.join(Dirs.sources, "ashello.asm")
xas(source, "--embed", "-R", "-o", Files.output)
# misc new features
for infile, reffile in [
("asxnew.asm", "ASXNEW-O"),
("asmacs.asm", "ASMACS-O")
]:
source = os.path.join(Dirs.sources, infile)
xas(source, "-o", Files.output)
xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference)
checkObjCodeEq(Files.output, Files.reference)
# SAVE directive
source = os.path.join(Dirs.sources, "asxsave.asm")
xas(source, "-b", "--base", "0xb000", "-o", Files.output)
save1s = [Files.output + "_" + ext
for ext in ["b000", "b020", "b030"]]
checkConcatEq(save1s, os.path.join(Dirs.refs, "save1"))
checkNoFiles([Files.output + "_b080"])
# bank switching
source = os.path.join(Dirs.sources, "asxbank1.asm")
xas(source, "-b", "-o", Files.output)
save2s = [Files.output + "_" + ext
for ext in ["0000", "6000_b0", "6000_b1", "6100_b0",
"6200_b1", "6200_b2"]]
checkConcatEq(save2s, os.path.join(Dirs.refs, "save2"))
checkNoFiles([Files.output + "_" + ext
for ext in ["0000_b0", "6000", "6100_b1", "6200_b0"]])
source = os.path.join(Dirs.sources, "asxbank2.asm")
xas(source, "-b", "-o", Files.output)
save3s = [Files.output + "_" + ext
for ext in ["c000", "c000_b0", "c000_b1", "d000_b0", "e000_b1"]]
checkConcatEq(save3s, os.path.join(Dirs.refs, "save3"))
checkNoFiles([Files.output + "_" + ext
for ext in ["d000", "d000_b1", "e000", "e000_b0"]])
source = os.path.join(Dirs.sources, "asxsegm.asm")
xas(source, "-b", "-o", Files.output)
checkFileSizes([(Files.output + "_" + ext, size)
for ext, size in [("0000", 20), ("b000_b1", 14),
("b010_b1", 2), ("b012_b2", 6)]])
# cleanup
os.remove(Files.output)
os.remove(Files.reference)
for fn in save1s + save2s + save3s:
os.remove(fn)
def runtest():
"""check cross-generated output against native reference files"""
# source and symbol EQU file
source = os.path.join(Dirs.sources, 'dasource.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference, '-E', Files.input)
xda(Files.reference, '-a', '6000', '-f', '6016', '-p', '-s', '-S',
Files.input, '-o', Files.output)
check_source(Files.output, source)
# symbols w/o EQUs
source = os.path.join(Dirs.sources, 'dasym.asm')
syms = os.path.join(Dirs.sources, 'dasym.txt')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '2000', '-f', '2000', '-p', '-s', '-S', syms,
'-o', Files.output)
check_source(Files.output, source)
# from/to
source = os.path.join(Dirs.sources, 'dastart.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '6000', '-f', '601c', '-o', Files.output)
check_range(Files.output, 14, 999)
xda(Files.reference, '-a', '6000', '-r', '6006', '-o', Files.output)
check_range(Files.output, 3, 999)
xda(Files.reference, '-a', '6000', '-f', '600c', '-t', '6010', '-o',
Files.output)
check_range(Files.output, 6, 8)
xda(Files.reference, '-a', '6000', '-r', '6004', '-t', '6014', '-o',
Files.output)
check_range(Files.output, 2, 10)
# exclude
source = os.path.join(Dirs.sources, 'daexclude.asm')
xas(source, '-b', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '0', '-r', '0x0', '-e', '0-2', '8-12', '-p',
'-o', Files.output)
datas = count_datas(Files.output)
if datas != 6:
error('exclude', 'DATA count mismatch: %d/6' % datas)
# 'start'
source = os.path.join(Dirs.sources, 'dastart.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '6000', '-f', 'start', '-o', Files.output)
m1 = sum(count_mnemonics(Files.output, offset=9).values())
if m1 != 4:
error('start', 'mnemonic count mismatch: %d/4' % m1)
xda(Files.reference, '-a', '6000', '-r', 'start', '-o', Files.output)
m2 = sum(count_mnemonics(Files.output, offset=9).values())
if m2 != 4:
error('start', 'mnemonic count mismatch: %d/4' % m2)
# origins
source = os.path.join(Dirs.sources, 'dajumps.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '0', '-r', '0', '-o', Files.output)
check_origins(Files.output, {
0xa: [0x2a],
0x20: [0x12],
0x2e: [0xe, 0x24, 0x30]
})
# strings (won't really work with '-f', unless the order is changed
source = os.path.join(Dirs.sources, 'datext.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '7000', '-r', '7000', '-p', '-n', '-o',
Files.output)
check_strings(Files.output, source)
# force
source = os.path.join(Dirs.sources, 'daforce.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', 'a000', '-r', 'a000', '-o', Files.output)
movs = count_mnemonics(Files.output, offset=9, wanted='mov')
if movs != 2:
error('force', 'MOV mnemonics count mismatch: %d/2' % movs)
xda(Files.reference, '-a', 'a000', '-r', 'a000', '-F', '-o', Files.output)
movs = count_mnemonics(Files.output, offset=9, wanted='mov')
if movs != 0:
error('force', 'MOV mnemonics count mismatch: %d/0' % movs)
# layout
source = os.path.join(Dirs.sources, 'dastart.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '6000', '-f', 'start', '-o', Files.output)
check_indent(Files.output, 2)
xda(Files.reference, '-a', '6000', '-f', 'start', '-p', '-o', Files.output)
check_indent(Files.output, 1)
# skip -k
source = os.path.join(Dirs.sources, 'dasource.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference, '-E', Files.symbols)
with open(Files.output, 'wb') as fout, open(Files.reference, 'rb') as fin:
fout.write(b'\xff' * 0x555)
data = fin.read()
fout.write(data)
xda(Files.output, '-k', '555', '-a', '6000', '-f', '6016', '-p', '-S',
Files.symbols, '-o', Files.input)
xas(Files.input, '-b', '-R', '-q', '-o', Files.output)
check_binary_files_eq('skip', Files.output, Files.reference)
# strict -s and no R for registers -R
source = os.path.join(Dirs.sources, 'dasource.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference, '-E', Files.symbols)
xda(Files.reference, '-a', '6000', '-f', '6016', '-p', '-S', Files.symbols,
'-o', Files.output)
with open(Files.output, 'r') as fin:
for line in fin.readlines():
if line != line.lower():
error('strict',
'Source file not entirely lower case: %s' % line)
xas(source, '-b', '-R', '-q', '-o', Files.reference, '-E', Files.symbols)
xda(Files.reference, '-a', '6000', '-f', '6016', '-p', '-s', '-S',
Files.symbols, '-o', Files.output)
with open(Files.output, 'r') as fin:
for line in fin.readlines():
if line != line.upper():
error('strict',
'Source file not entirely upper case: %s' % line)
xda(Files.reference, '-a', '6000', '-f', '6016', '-p', '-R', '-S',
Files.symbols, '-o', Files.output)
with open(Files.output, 'r') as fin:
lines = fin.readlines()
if any([re.search(r'R\d', line, re.IGNORECASE) for line in lines]):
error('no-R', 'Found erroneous register in source file')
# concise -c
source = os.path.join(Dirs.sources, 'daconcis.asm')
xas(source, '-b', '-R', '-q', '-o', Files.reference)
xda(Files.reference, '-a', '2000', '-r', '2000', '-s', '-c', '-o',
Files.output)
check_ellipsis(Files.output, skip=2)
# no condensed output when disassembling as program (-p)
# Cleanup
os.remove(Files.input)
os.remove(Files.symbols)
for f in glob.glob(Files.output + '*'):
os.remove(f)
for f in glob.glob(Files.reference + '*'):
os.remove(f)
def runtest():
"""check error messages against native assembler listing"""
# cross-assembler error messages
source = os.path.join(Dirs.sources, 'aserrs.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-s', '-o', Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
# TI assembler error messages
ti_errors = []
xdm(Disks.asmsrcs, '-e', 'ASERRS-L', '-o', Files.reference)
with open(Files.reference, 'r') as f:
for line in f:
err = re.match(r'\*{5}\s+([A-Z ]*) - (\d+)', line)
if err:
lino = err.group(2)
ti_errors.append(lino)
# compare
check_errors(ti_errors, xas_errors)
# xdt99-specific errors
source = os.path.join(Dirs.sources, 'asxerrs.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-R', '-o', Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
ref_errors = get_source_markers(source, r';ERROR(:....)?')
check_errors(ref_errors, xas_errors)
# xdt99-specific errors (image generation)
source = os.path.join(Dirs.sources, 'asxerrsb.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-R', '-b', '-o', Files.output, stderr=ferr, rc=1)
xas_errors = read_stderr(Files.error)
ref_errors = get_source_markers(source, tag=r';ERROR(:....)?')
check_errors(ref_errors, xas_errors)
# open .if-.endif or .defm-.endm
source = os.path.join(Dirs.sources, 'asopenif.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-o', Files.output, stderr=ferr, rc=1)
with open(Files.error, 'r') as fin:
msgs = ' '.join(fin.readlines())
if 'Missing .endif' not in msgs:
error('open', 'Missing error for open .if/.endif')
source = os.path.join(Dirs.sources, 'asopenmac.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-o', Files.output, stderr=ferr, rc=1)
with open(Files.error, 'r') as fin:
msgs = ' '.join(fin.readlines())
if 'Missing .endm' not in msgs:
error('open', 'Missing error for open .defm/.endm')
# files not found
source = os.path.join(Dirs.sources, 'ascopyi.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-o', Files.output, stderr=ferr, rc=1)
# warnings
source = os.path.join(Dirs.sources, 'aswarn.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr,
rc=0) # no error
act_errors = read_stderr(Files.error, include_warnings=True)
exp_errors = get_source_markers(source, tag=r';WARN')
check_errors(exp_errors, act_errors)
source = os.path.join(Dirs.sources, 'asuusym.asm') # undefined symbols
with open(Files.error, 'w') as ferr:
xas(source, '-R', '-o', Files.output, stderr=ferr, rc=0) # no error
with open(Files.error, 'r') as fin:
output = fin.read()
if output.strip()[-18:] != 'U1, U2, U3, U4, U5':
error('stdout', 'Bad listing of unreferenced symbols')
with open(Files.error, 'w') as ferr:
xas(source, '-R', '-q', '-o', Files.output, stderr=ferr,
rc=0) # no error
with open(Files.error, 'r') as fin:
output = fin.read()
if output.strip():
error('stdout', 'Unwanted listing of unreferenced symbols')
# STDOUT
source = os.path.join(Dirs.sources, 'asstdout.asm')
with open(Files.error, 'w') as fout:
xas(source, '-b', '-R', '-o', Files.output, stdout=fout,
rc=0) # no error
with open(Files.error, 'r') as fin:
output = fin.read()
if output.strip() != 'hello 42 world!':
error('stdout', 'Invalid STDOUT output: ' + output)
# cleanup
os.remove(Files.error)
os.remove(Files.reference)
def runtest():
"""check error messages against native assembler listing"""
# cross-assembler error messages
source = os.path.join(Dirs.sources, "aserrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-s", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
# TI assembler error messages
tierrors = {}
xdm(Disks.asmsrcs, "-e", "ASERRS-L", "-o", Files.reference)
with open(Files.reference, "r") as f:
for line in f:
err = re.match(r"\*{5}\s+([A-Z ]*) - (\d+)", line)
if err:
lino, errmsg = err.group(2), err.group(1)
tierrors[lino] = errmsg
# compare
compare(tierrors, xaserrors)
# xdt99-specific errors
source = os.path.join(Dirs.sources, "asxerrs.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
referrors = {}
with open(source, "r") as f:
for i, line in enumerate(f):
m = re.search(r";ERROR(:....)?", line)
if m:
if m.group(1):
referrors[m.group(1)[1:]] = line
else:
referrors["%04d" % (i + 1)] = line
compare(referrors, xaserrors)
# xdt99-specific errors (image generation)
source = os.path.join(Dirs.sources, "asxerrsb.asm")
with open(Files.error, "w") as ferr:
xas(source, "-R", "-b", "-o", Files.output, stderr=ferr, rc=1)
xaserrors = readstderr(Files.error)
referrors = {}
with open(source, "r") as f:
for i, line in enumerate(f):
m = re.search(r";ERROR(:....)?", line)
if m:
if m.group(1):
referrors[m.group(1)[1:]] = line
else:
referrors["%04d" % (i + 1)] = line
compare(referrors, xaserrors)
# files not found
source = os.path.join(Dirs.sources, "ascopyi.asm")
with open(Files.error, "w") as ferr:
xas(source, "-o", Files.output, stderr=ferr, rc=1)
# cleanup
os.remove(Files.error)
os.remove(Files.reference)
def runtest():
"""check linked files object code against non-linked equivalent file object code
NOTE: Programs commented out contain multiple xORGs, so the relocation of segments
will lead to different object codes.
"""
for inp_file, opts, ref_file, compr_file, relaxed_check in [
('asdirs.asm', [], 'ASDIRS-O', 'ASDIRS-C', False),
('asorg2.asm', [], 'ASORG2-O', None, False),
('asorg3.asm', [], 'ASORG3-O', None, False),
('asopcs.asm', [], 'ASOPCS-O', 'ASOPCS-C', False),
('asbss.asm', [], 'ASBSS-O', 'ASBSS-C', False),
('asbss2.asm', [], 'ASBSS2-O', None, False),
('asbss3.asm', [], 'ASBSS3-O', None, False),
('asbss4.asm', [], 'ASBSS4-O', None, False),
('ashellon.asm', ['-R'], 'ASHELLO-O', 'ASHELLO-C', False),
('ascopy.asm', [], 'ASCOPY-O', None, False),
('assize1.asm', [], 'ASSIZE1-O', 'ASSIZE1-C', False),
('asextsym.asm', [], 'ASEXTSYM-O', 'ASEXTSYM-C', False),
#('asimg1.asm', [], 'ASIMG1-O', 'ASIMG1-C', False),
('asimg2.asm', [], 'ASIMG2-O', None, False),
#('asimg3.asm', [], 'ASIMG3-OX', None, False),
('asreloc.asm', [], 'ASRELOC-O', None, False),
('asxorg.asm', [], 'ASXORG-O', None,
True), # TODO: slightly different structure for linked code
('ascart.asm', ['-R'], 'ASCART-O', 'ASCART-C', False),
]:
source = os.path.join(Dirs.sources, inp_file)
xas(*[source] + opts + ['-q', '-o', Files.input])
xas('-l', Files.input, '-o', Files.output)
xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference)
tagfilter = b'BC' if relaxed_check else None # compare only B and C tags
check_obj_code_eq(Files.output, Files.reference,
tagfilter=tagfilter) # default
xas('-ll', Files.input, '-o', Files.output)
check_obj_code_eq(Files.output, Files.reference,
tagfilter=tagfilter) # resolve conflicts
if compr_file:
# compressed object code
xas(*[source] + opts + ['-C', '-q', '-o', Files.input])
xas('-l', Files.input, '-C', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', compr_file, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference, compressed=True)
# parsing of object code
source = os.path.join(Dirs.sources, 'asbssorg.asm')
xas(source, '-o', Files.reference)
xas('-l', Files.reference, '-o', Files.output)
check_obj_code_eq(Files.output, Files.reference)
# link multiple files
library = os.path.join(Dirs.sources, 'aslink0b.asm')
xas(library, '-q', '-o', Files.input)
source = os.path.join(Dirs.sources, 'aslink0a.asm')
xas(source, '-l', Files.input, '-q', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslink0.asm')
xas(ref, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-ll', Files.input, '-q', '-o', Files.output)
check_obj_code_eq(Files.output, Files.reference)
xas(source, library) # name should be source.obj
objname = 'aslink0a.obj'
if not os.path.isfile(objname):
error('multi-files', 'Bad output file for multiple inputs')
library = os.path.join(Dirs.sources, 'aslink1b.asm')
xas(library, '-R', '-D', 'x=1', '-q', '-o', Files.input)
source = os.path.join(Dirs.sources, 'aslink1a.asm')
xas(source, '-l', Files.input, '-R', '-D', 'x=1', '-q', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslink1.asm')
xas(ref, '-R', '-D', 'x=1', '-q', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# link 3 files
for x in ('a', 'b', 'c'):
xas(os.path.join(Dirs.sources, 'aslink2' + x + '.asm'), '-q', '-o',
Files.input + x)
xas('-l', Files.input + 'a', Files.input + 'b', Files.input + 'c', '-q',
'-b', '-o', Files.output)
xas(os.path.join(Dirs.sources, 'aslink2.asm'), '-q', '-b', '-o',
Files.reference)
check_binary_files_eq('link', Files.output, Files.reference)
xas('-ll', Files.input + 'a', Files.input + 'b', Files.input + 'c', '-q',
'-b', '-o', Files.output)
xas(os.path.join(Dirs.sources, 'aslink2.asm'), '-q', '-b', '-o',
Files.reference)
check_binary_files_eq('link', Files.output, Files.reference)
# ditto with multiple source files
sources = [
os.path.join(Dirs.sources, f'aslink1{x}.asm') for x in ('a', 'b')
]
xas(*sources, '-R', '-D', 'x=1', '-q', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslink1.asm')
xas(ref, '-R', '-D', 'x=1', '-q', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
sources = [
os.path.join(Dirs.sources, f'aslink2{x}.asm') for x in ('a', 'b', 'c')
]
xas(*sources, '-b', '-q', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslink2.asm')
xas(ref, '-b', '-q', '-o', Files.reference)
check_binary_files_eq('multi-source', Files.output, Files.reference)
# link and multi-files with conflict
source1 = os.path.join(Dirs.sources, 'aslink3a.asm')
source2 = os.path.join(Dirs.sources, 'aslink3b.asm')
xas(source1, source2, '-b', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslink3.asm')
xas(ref, '-b', '-o', Files.reference)
check_binary_files_eq('link', Files.output, Files.reference)
xas(source2, '-o', Files.input)
xas(source1, '-l', Files.input, '-b', '-o', Files.output)
check_binary_files_eq('multi-source', Files.output, Files.reference)
# link file with auto-generated constants
source = os.path.join(Dirs.sources, 'asauto.asm')
xas(source, '-R', '-o', Files.input)
xas('-R', '-l', Files.input, '-b', '-o', Files.output)
xas(source, '-R', '-b', '-o', Files.reference)
check_binary_files_eq('link', Files.output, Files.reference)
# link w/o name
xas('-l', Files.input, '-R')
if not os.path.isfile('a.obj'):
error('link', 'Objcode code file with default name not found')
# link and rebase
source = os.path.join(Dirs.sources, 'aslinkr.asm')
xas(source, '-q', '-o', Files.input)
xas('-l', Files.input, '-a', '>2000', '-b', '-q', '-o', Files.output)
xas(source, '-b', '-a', '>2000', '-o', Files.reference)
check_binary_files_eq('link/base', Files.output, Files.reference)
xas('-ll', Files.input, '-a', '>2000', '-b', '-q', '-o', Files.output)
check_binary_files_eq('link/base', Files.output, Files.reference)
# link and rorg/aorg
lib = os.path.join(Dirs.sources, 'aslinkob.asm')
xas(lib, '-o', Files.input)
source = os.path.join(Dirs.sources, 'aslinkoa.asm')
xas(source, '-a', '>4000', '-l', Files.input, '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslinko.asm')
xas(ref, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, lib, '-a', '>4000', '-o', Files.output)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-a', '>4000', '-ll', Files.input, '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslinkor.asm')
xas(ref, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# link and xorg
lib = os.path.join(Dirs.sources, 'aslinkxb.asm')
xas(lib, '-q', '-o', Files.input)
source = os.path.join(Dirs.sources, 'aslinkxa.asm')
xas(source, '-l', Files.input, '-q', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'aslinkx.asm')
xas(ref, '-q', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-ll', Files.input, '-q', '-o', Files.output)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-l', Files.input, '-a', '>e000', '-b', '-q', '-o',
Files.output)
ref = os.path.join(Dirs.sources, 'aslinkxe.asm')
xas(ref, '-b', '-q', '-o', Files.reference)
check_binary_files_eq('link/xorg', Files.output, Files.reference)
xas(source, '-ll', Files.input, '-a', '>e000', '-b', '-q', '-o',
Files.output)
ref = os.path.join(Dirs.sources, 'aslinkxer.asm')
xas(ref, '-b', '-q', '-o', Files.reference)
check_binary_files_eq('link/xorg', Files.output, Files.reference)
# link and -D
lib = os.path.join(Dirs.sources, 'aslink4b.asm')
xas(lib, '-q', '-o', Files.input)
source = os.path.join(Dirs.sources, 'aslink4a.asm')
xas(source, '-l', Files.input, '-D', 'x=69', '-o',
Files.output) # no need for -ll case
ref = os.path.join(Dirs.sources, 'aslink4.asm')
xas(ref, '-D', 'x=69', '-q', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# in-unit conflict resolution
# NOTE: For one program unit, internal conflicts may still be resolved
# against the absolute segments, yielding a non-zero offset for that
# single unit. Inter-reloc conflicts cannot be resolved.
source = os.path.join(Dirs.sources, 'asorgx.asm')
xas(source, '-o', Files.input)
xas('-ll', Files.input, '-b', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'asorgxn.asm')
xas(ref, '-b', '-o', Files.reference)
check_binary_files_eq('in-file conflict', Files.output, Files.reference)
# symbol conflicts
source1 = os.path.join(Dirs.sources, 'aslinks1a.asm')
source2 = os.path.join(Dirs.sources, 'aslinks1b.asm')
with open(Files.error, 'w') as ferr:
xas(source1, source2, '-o', Files.output, rc=1, stderr=ferr)
xas(source2, '-o', Files.input)
with open(Files.error, 'w') as ferr:
xas(source1, '-l', Files.input, '-o', Files.output, rc=1, stderr=ferr)
source1 = os.path.join(Dirs.sources, 'aslinks2a.asm')
xas(source1, source2, '-o', Files.output, rc=0)
source2 = os.path.join(Dirs.sources, 'aslinks2b.asm')
xas(source1, source2, '-o', Files.output, rc=0)
xas(source2, '-o', Files.input)
xas(source1, '-l', Files.input, '-o', Files.output, rc=0)
# entry conflict
source1 = os.path.join(Dirs.sources, 'aslinkea.asm')
source2 = os.path.join(Dirs.sources, 'aslinkeb.asm')
with open(Files.error, 'w') as ferr:
xas(source1, source2, '-o', Files.output, rc=1, stderr=ferr)
xas(source2, '-o', Files.input)
with open(Files.error, 'w') as ferr:
xas(source1, '-l', Files.input, '-o', Files.output, rc=1, stderr=ferr)
# practical example
source = os.path.join(Dirs.sources, 'asstdlib.asm')
libs = ['vmbw.a99', 'vsbr.a99', 'vwbt.a99']
with open(Files.error, 'w') as ferr:
xas(source, *libs, '-R', '-o', Files.output, rc=0, stderr=ferr)
check_file_empty(Files.error)
# cleanup
os.remove(Files.input)
os.remove(Files.input + 'a')
os.remove(Files.input + 'b')
os.remove(Files.input + 'c')
os.remove(Files.output)
os.remove(Files.reference)
os.remove(objname)
os.remove('a.obj')
def runtest():
"""check cross-generated output against native reference files"""
# object code
for inp_file, opts, ref_file, compr_file in [
('asdirs.asm', [], 'ASDIRS-O', 'ASDIRS-C'),
('asorgs.asm', [], 'ASORGS-O', 'ASORGS-C'),
('asopcs.asm', [], 'ASOPCS-O', 'ASOPCS-C'),
('asexprs.asm', [], 'ASEXPRS-O', None),
('asbss.asm', [], 'ASBSS-O', 'ASBSS-C'),
('asregs.asm', ['-R'], 'ASREGS-O', 'ASREGS-C'),
('ashellon.asm', ['-R'], 'ASHELLO-O', 'ASHELLO-C'),
('ascopy.asm', [], 'ASCOPY-O', None),
('ascopyn.asm', [], 'ASCOPYN-O', None),
('assize1.asm', [], 'ASSIZE1-O', 'ASSIZE1-C'),
('assize2.asm', [], 'ASSIZE2-O', None),
('assize3.asm', [], 'ASSIZE3-O', None),
('assize4.asm', [], 'ASSIZE4-O', None),
('asextsym.asm', [], 'ASEXTSYM-O', None),
('asdorg.asm', [], 'ASDORG-O', None),
('asrorg.asm', [], 'ASRORG-O', None),
('asimg1.asm', [], 'ASIMG1-O', 'ASIMG1-C'),
('asimg2.asm', [], 'ASIMG2-O', None),
('asimg3.asm', [], 'ASIMG3-OX', None),
('asreloc.asm', [], 'ASRELOC-O', None),
('asxorg.asm', [], 'ASXORG-O', None),
('ascart.asm', ['-R'], 'ASCART-O', 'ASCART-C')
]:
source = os.path.join(Dirs.sources, inp_file)
xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference)
xas(*[source] + opts + ['-q', '-o', Files.output])
check_obj_code_eq(Files.output, Files.reference)
xas(*[source] + opts + ['--strict', '-q', '-o', Files.output])
check_obj_code_eq(Files.output, Files.reference)
if compr_file:
# compressed object code
xas(*[source] + opts + ['-C', '-q', '-o', Files.output])
xdm(Disks.asmsrcs, '-e', compr_file, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference, compressed=True)
# image files
for inp_file, ref_file in [('asimg1.asm', 'ASIMG1-I'),
('asimg2.asm', 'ASIMG2-I'),
('asimg3.asm', 'ASIMG3-I')]:
source = os.path.join(Dirs.sources, inp_file)
xas(source, '-i', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference)
check_image_files_eq(Files.output, Files.reference)
for inp_file, reffiles in [
('aslimg.asm', ['ASLIMG-I', 'ASLIMG-J', 'ASLIMG-K']),
('assimg.asm', ['ASSIMG-I', 'ASSIMG-J', 'ASSIMG-K', 'ASSIMG-L']),
('asreloc.asm', ['ASRELOC-I'])
]:
source = os.path.join(Dirs.sources, inp_file)
xas(source, '-R', '-i', '-q', '-o', Files.output)
gendata = []
refdata = []
for i, ref_file in enumerate(reffiles):
xdm(Disks.asmimgs, '-e', ref_file, '-o', Files.reference)
with open(Files.outputff[i],
'rb') as fgen, open(Files.reference, 'rb') as fref:
gendata.append(fgen.read())
refdata.append(fref.read())
check_image_set_eq(gendata, refdata)
# JMP instruction
source = os.path.join(Dirs.sources, 'asjmp.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-o', Files.output, stderr=ferr, rc=1)
xaserrors = read_stderr(Files.error)
referrors = get_source_markers(source, r';ERROR(:....)?')
check_errors(referrors, xaserrors)
# xas99-defined symbols
source = os.path.join(Dirs.sources, 'asxassym.asm')
xas(source, '-b', '-o', Files.output)
with open(Files.output, 'rb') as f:
data = f.read()
for i in range(0, len(data), 2):
if data[i:i + 2] == b'\x00\x00':
error('symbols', 'Undefined xas99 symbol')
# DORG special cases
source = os.path.join(Dirs.sources, 'asdorg.asm')
xas(source, '-a', '>2000', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'asdorg-ti.asm')
xas(ref, '-a', '>2000', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# cleanup
for i in range(4):
os.remove(Files.outputff[i])
os.remove(Files.reference)
def runtest():
"""check cross-generated output against native reference files"""
# source and symbol EQU file
source = os.path.join(Dirs.sources, "dasource.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference, "-E", Files.input)
xda(Files.reference, "-a", "6000", "-f", "6016", "-p", "-s", "-S", Files.input, "-o", Files.output)
check_source(Files.output, source)
# symbols w/o EQUs
source = os.path.join(Dirs.sources, "dasym.asm")
syms = os.path.join(Dirs.sources, "dasym.txt")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "2000", "-f", "2000", "-p", "-s", "-S", syms, "-o", Files.output)
check_source(Files.output, source)
# from/to
source = os.path.join(Dirs.sources, "dastart.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "6000", "-f", "601c",
"-o", Files.output)
check_range(Files.output, 14, 999)
xda(Files.reference, "-a", "6000", "-r", "6006", "-o", Files.output)
check_range(Files.output, 3, 999)
xda(Files.reference, "-a", "6000", "-f", "600c", "-t", "6010", "-o", Files.output)
check_range(Files.output, 6, 8)
xda(Files.reference, "-a", "6000", "-r", "6004", "-t", "6014", "-o", Files.output)
check_range(Files.output, 2, 10)
# exclude
source = os.path.join(Dirs.sources, "daexclude.asm")
xas(source, "-b", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "0", "-r", "0x0", "-e", "0-2", "8-12", "-p", "-o", Files.output)
datas = count_datas(Files.output)
if datas != 6:
error("exclude", "DATA count mismatch: %d/6" % datas)
# "start"
source = os.path.join(Dirs.sources, "dastart.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "6000", "-f", "start", "-o", Files.output)
m1 = sum(count_mnemonics(Files.output, offset=9).values())
if m1 != 4:
error("start", "mnemonic count mismatch: %d/4" % m1)
xda(Files.reference, "-a", "6000", "-r", "start", "-o", Files.output)
m2 = sum(count_mnemonics(Files.output, offset=9).values())
if m2 != 4:
error("start", "mnemonic count mismatch: %d/4" % m2)
# origins
source = os.path.join(Dirs.sources, "dajumps.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "0", "-r", "0", "-o", Files.output)
check_origins(Files.output, {
0xa: [0x2a],
0x20: [0x12],
0x2e: [0xe, 0x24, 0x30]})
# strings (won't really work with "-f", unless the order is changed
source = os.path.join(Dirs.sources, "datext.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "7000", "-r", "7000", "-p", "-n",
"-o", Files.output)
check_strings(Files.output, source)
# force
source = os.path.join(Dirs.sources, "daforce.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "a000", "-r", "a000", "-o", Files.output)
movs = count_mnemonics(Files.output, offset=9, wanted="mov")
if movs != 2:
error("force", "MOV mnemonics count mismatch: %d/2" % movs)
xda(Files.reference, "-a", "a000", "-r", "a000", "-F", "-o", Files.output)
movs = count_mnemonics(Files.output, offset=9, wanted="mov")
if movs != 0:
error("force", "MOV mnemonics count mismatch: %d/0" % movs)
# layout
source = os.path.join(Dirs.sources, "dastart.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "6000", "-f", "start", "-o", Files.output)
check_indent(Files.output, 2)
xda(Files.reference, "-a", "6000", "-f", "start", "-p", "-o", Files.output)
check_indent(Files.output, 1)
# skip -k
source = os.path.join(Dirs.sources, "dasource.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference, "-E", Files.symbols)
with open(Files.output, "wb") as fout, open(Files.reference, "rb") as fin:
fout.write("\xff" * 0x555)
data = fin.read()
fout.write(data)
xda(Files.output, "-k", "555", "-a", "6000", "-f", "6016", "-p", "-S", Files.symbols, "-o", Files.input)
xas(Files.input, "-b", "-R", "-w", "-o", Files.output)
check_binary_files_eq("skip", Files.output, Files.reference)
# strict -s and no R for registers -R
source = os.path.join(Dirs.sources, "dasource.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference, "-E", Files.symbols)
xda(Files.reference, "-a", "6000", "-f", "6016", "-p", "-S", Files.symbols, "-o", Files.output)
with open(Files.output, "r") as fin:
for line in fin.readlines():
if line != line.lower():
error("strict", "Source file not entirely lower case: %s" % line)
xas(source, "-b", "-R", "-w", "-o", Files.reference, "-E", Files.symbols)
xda(Files.reference, "-a", "6000", "-f", "6016", "-p", "-s", "-S", Files.symbols, "-o", Files.output)
with open(Files.output, "r") as fin:
for line in fin.readlines():
if line != line.upper():
error("strict", "Source file not entirely upper case: %s" % line)
xda(Files.reference, "-a", "6000", "-f", "6016", "-p", "-R", "-S", Files.symbols, "-o", Files.output)
with open(Files.output, "r") as fin:
lines = fin.readlines()
if any([re.search(r"R\d", line, re.IGNORECASE) for line in lines]):
error("no-R", "Found erroneous register in source file")
# concise -c
source = os.path.join(Dirs.sources, "daconcis.asm")
xas(source, "-b", "-R", "-w", "-o", Files.reference)
xda(Files.reference, "-a", "2000", "-r", "2000", "-s", "-c", "-o", Files.output)
check_ellipsis(Files.output, skip=2)
# no condensed output when disassembling as program (-p)
# Cleanup
os.remove(Files.input)
os.remove(Files.symbols)
for f in glob.glob(Files.output + "*"):
os.remove(f)
for f in glob.glob(Files.reference + "*"):
os.remove(f)
def runtest():
"""check xdt99 extensions"""
# xdt99 extensions
source = os.path.join(Dirs.sources, 'asxext.asm')
xas(source, '-R', '-q', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', 'ASXEXT0-O', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-R', '-D', 'sym2', '-q', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', 'ASXEXT1-O', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-R', '-D', 'sym2=2', 'sym3=2', '-q', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', 'ASXEXT2-O', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-R', '-D', 'sym2=2,sym3=2', '-q', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', 'ASXEXT2-O', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# some CLI options
source = os.path.join(Dirs.sources, 'ascart.asm')
xas(source, '--embed', '-R', '-o', Files.output)
# misc new features
for infile, opts, reffile in [('asxnew.asm', ['-18'], 'ASXNEW-O'),
('asmacs.asm', [], 'ASMACS-O')]:
source = os.path.join(Dirs.sources, infile)
xas(source, *opts, '-q', '-o', Files.output)
xdm(Disks.asmsrcs, '-e', reffile, '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
# macro with text argument in listing
source = os.path.join(Dirs.sources, 'asmactxt.asm')
xas(source, 'vmbw.a99', '-R', '-b', '-o', Files.input, '-L', Files.output)
if "'0'" in content_lines(Files.output):
error('macro/listing', 'Macro arguments not escaped in listing')
# SAVE directive
source = os.path.join(Dirs.sources, 'asxsave.asm')
xas(source, '-b', '--base', '0xb000', '-q', '-o', Files.output)
for i, a in enumerate(['_b000', '_b020', '_b030', '_b080']):
ref = os.path.join(Dirs.refs, f'asxsave_{i}.bin')
check_binary_files_eq('SAVE', Files.output + a, ref)
xas(source, '-t', 'a2', '-a', '0xb000', '-q', '-o', Files.output)
for i, a in enumerate(['_b000', '_b020', '_b030', '_b080']):
ref = os.path.join(Dirs.refs, f'asxsave_{i}.bin')
check_dat_file_eq(Files.output + a, ref)
source = os.path.join(Dirs.sources, 'asxsavee.asm')
xas(source, '-b', '-a', '0x6000', '-q', '-o', Files.output)
if content(Files.output) != b'\x22\x22\x22\x22':
error('SAVE', 'Bad file contents')
source = os.path.join(Dirs.sources, 'asxsaveo.asm')
xas(source, '-b', '-o', Files.output)
ref2 = os.path.join(Dirs.sources, 'asxsaveo2.asm')
ref6 = os.path.join(Dirs.sources, 'asxsaveo6.asm')
xas(ref2, '-b', '-o', Files.reference)
check_binary_files_eq('SAVE', Files.output + '_2000', Files.reference)
xas(ref6, '-b', '-o', Files.reference)
check_binary_files_eq('SAVE', Files.output + '_6000', Files.reference)
# remove front/back padding from saved binary
source = os.path.join(Dirs.sources, 'asxsavem.asm')
# this padding could be avoided if saves would *enable* splitting of segments
xas(source, '-b', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'asxsavem0.asm')
xas(ref, '-b', '-o', Files.reference)
check_binary_files_eq('SAVE', Files.output, Files.reference)
# bank switching: obsolete AORG addr, bank
source = os.path.join(Dirs.sources, 'asxbank1.asm')
xas(source, '-b', '-a', '>6030', '-q', '-o', Files.output)
save2s = [Files.output + '_b' + str(ext) for ext in range(3)]
check_concat_eq(save2s, os.path.join(Dirs.refs, 'save2'))
source = os.path.join(Dirs.sources, 'asxbank2.asm')
xas(source, '-b', '-q', '-o', Files.output)
for i, a in enumerate([
'_c000_b0', '_d000_b0', '_e000_b0', '_c000_b1', '_d000_b1',
'_e000_b1'
]):
xas(os.path.join(Dirs.sources, 'asxbank2' + a + '.asm'), '-b', '-q',
'-o', Files.reference)
check_binary_files_eq('BANK+SAVE', Files.output + a, Files.reference)
source = os.path.join(Dirs.sources, 'asxsegm.asm')
xas(source, '-i', '-q', '-o', Files.output)
check_file_sizes([(Files.outputff[i], size)
for i, size in enumerate([26, 20, 14])])
for i, val in enumerate([0x10, 0x20, 0x30]):
check_image_values(Files.outputff[i], val)
# BANK directive
source = os.path.join(Dirs.sources, 'asdbank.asm')
xas(source, '-b', '-R', '-o', Files.output)
ref1 = os.path.join(Dirs.sources, 'asdbank_b0.asm')
ref2 = os.path.join(Dirs.sources, 'asdbank_b1.asm')
xas(ref1, '-b', '-R', '-o', Files.reference)
check_binary_files_eq('BANK', Files.output + '_b0', Files.reference)
xas(ref2, '-b', '-R', '-o', Files.reference)
check_binary_files_eq('BANK', Files.output + '_b1', Files.reference)
# cross-bank access
source = os.path.join(Dirs.sources, 'asxbank.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr,
rc=0) # no error
source = os.path.join(Dirs.sources, 'asnxbank.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr,
rc=1) # with errors
# sections shared across banks
source = os.path.join(Dirs.sources, 'asshbank.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr,
rc=1) # with errors
act_errors = read_stderr(Files.error)
exp_errors = get_source_markers(source, r';ERROR(:....)?')
check_errors(exp_errors, act_errors)
source = os.path.join(Dirs.sources, 'asshbankx.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr,
rc=0) # no error
# data output (-t)
source = os.path.join(Dirs.sources, 'ashexdat.asm')
xas(source, '-t', 'a2', '-R', '-o', Files.output)
xas(source, '-b', '-R', '-o', Files.reference)
check_numeric_eq(Files.output, Files.reference)
source = os.path.join(Dirs.sources, 'asxtext.asm')
xas(source, '-t', 'a2', '-o', Files.output + '1')
xas(source, '-t', 'c4', '-o', Files.output + '2')
xas(source, '-t', 'b', '-o', Files.output + '3')
xas(source, '-t', 'a4', '-o', Files.output + '4')
xas(source, '-t', 'c', '-o', Files.output + '5')
save5s = [Files.output + ext for ext in ['1', '2', '3', '4', '5']]
check_lines_eq(save5s, os.path.join(Dirs.refs, 'asxtext'))
# auto-generated constants (b#, w#)
source = os.path.join(Dirs.sources, 'asauto.asm')
xas(source, '-R', '-o', Files.output)
ref = os.path.join(Dirs.sources, 'asauton.asm')
xas(ref, '-R', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference)
xas(source, '-R', '-a', '>2000', '-o', Files.output)
xas(ref, '-R', '-a', '>2000', '-o', Files.reference)
check_obj_code_eq(Files.output, Files.reference) # relocated
xas(source, '-b', '-R', '-o', Files.output)
xas(ref, '-b', '-R', '-o', Files.reference)
check_binary_files_eq('auto-const', Files.output,
Files.reference) # as binary
# size modifier (s#)
source = os.path.join(Dirs.sources, 'assmod.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr, rc=0)
ref = os.path.join(Dirs.sources, 'assmodn.asm')
xas(ref, '-b', '-R', '-q', '-o', Files.reference)
check_binary_files_eq('s#', Files.output, Files.reference)
source = os.path.join(Dirs.sources, 'assmode.asm')
with open(Files.error, 'w') as ferr:
xas(source, '-b', '-R', '-o', Files.output, stderr=ferr, rc=1)
act_errors = read_stderr(Files.error)
exp_errors = get_source_markers(source, tag=r';ERROR')
check_errors(exp_errors, act_errors)
# floating-point numbers
source = os.path.join(Dirs.sources, 'asfloat.asm')
xas(source, '-b', '-o', Files.output)
ref = os.path.join(Dirs.refs, 'asfloat.ref')
check_binary_files_eq('float', Files.output, ref)
# 9995 and F18A
source1 = os.path.join(Dirs.sources, 'as9995.asm')
xas(source1, '-R', '-b', '-5', '-o', Files.output)
ref = os.path.join(Dirs.refs, 'as9995.ref')
check_binary_files_eq('9995', Files.output, ref)
source2 = os.path.join(Dirs.sources, 'asf18a.asm')
xas(source2, '-R', '-b', '--f18a', '-o', Files.output)
ref = os.path.join(Dirs.refs, 'asf18a.ref')
check_binary_files_eq('f18a', Files.output, ref)
with open(source1, 'r') as f1, open(source2, 'r') as f2:
lines1 = f1.readlines()
lines2 = f2.readlines()
with open(Files.input, 'w') as fout:
fout.writelines(lines1 + lines2)
xas(Files.input, '-R', '-5', '-18', '-o', Files.output, rc=0)
# cleanup
for fn in glob.glob("tmp/outpu*"):
os.remove(fn)
os.remove(Files.input)
os.remove(Files.reference)
