def compile_pascal(source, dest, is_debug = False, is_interpret = False, out_stream = sys.stdout, output_tokens = False, output_bytecodes = False, lib = ['.'], in_stream = sys.stdin):
'''
DID YOU KNOW that compile() is a built in function?
'''
set_debug(is_debug)
debug("Compiling %s into %s" % (source, dest))
scanner = Scanner(source)
tokens = scanner.scan()
if output_tokens:
write(tokens, source + "_tokenized")
debug('scanning complete')
parser = Parser(tokens, source, lib = lib)
bytecodes, success = parser.parse()
if output_bytecodes:
if is_debug:
write(prettify(bytecodes), source + "_unassembled")
else:
write(bytecodes, source + "_unassembled")
if not success:
print 'Parsing error'
return
debug('parsing complete')
assembler = Assembler(bytecodes)
assembled = assembler.assemble()
if is_debug:
write(prettify(assembled), dest + '_debug')
write(assembled, dest)
debug('assembly complete.' )
if is_interpret:
interp = Interpreter(out_stream, in_stream, code = assembled)
interp.interpret()
else:
debug('run program now with `python interpreter.py %s`' % dest)
def test_add():
asm = ADD_Operation().resolve()
print(asm)
expected = ASM('''
// MACRO=LOAD_SP
@SP
A=M
// MACRO_END
// pop y into D
A=A-1
D=M
// pop x into M
A=A-1
// do the operation
M=M+D
// MACRO=DEC_SP
@SP
M=M-1
// MACRO_END
''')
assert str(asm) == str(expected)
# make sure it output valid assembly
assembler = Assembler()
assembler.assemble(str(asm))
def deobfuscate(codestring):
# Instructions are stored as a string, we need
# to convert it to an array of the raw bytes
insBytes = bytearray(codestring)
oep = find_oep(insBytes)
logger.info('Original code entrypoint at {}'.format(oep))
logger.info('Starting control flow analysis...')
disasm = Disassembler(insBytes, oep)
disasm.find_leaders()
disasm.construct_basic_blocks()
disasm.build_bb_edges()
logger.info('Control flow analysis completed.')
logger.info('Starting simplication of basic blocks...')
render_graph(disasm.bb_graph, 'before.svg')
simplifier = Simplifier(disasm.bb_graph)
simplifier.eliminate_forwarders()
render_graph(simplifier.bb_graph, 'after_forwarder.svg')
simplifier.merge_basic_blocks()
logger.info('Simplification of basic blocks completed.')
simplified_graph = simplifier.bb_graph
render_graph(simplified_graph, 'after.svg')
logger.info('Beginning verification of simplified basic block graph...')
if not verify_graph(simplified_graph):
logger.error('Verification failed.')
raise SystemExit
logger.info('Verification succeeded.')
logger.info('Assembling basic blocks...')
asm = Assembler(simplified_graph)
codestring = asm.assemble()
logger.info('Successfully assembled. ')
return codestring
def main():
if len(sys.argv) < 6:
print >>sys.stderr, "Usage: %s <instmem.mif> <instmem_size in byte> <datamem.mif> <datamem_size in byte> <xxx.S> [xxx.S] ..." % (sys.argv[0])
sys.exit(1)
if sys.argv[1] != '-':
instmif = MifFile(sys.argv[1])
instmif.init(int(sys.argv[2]), 1)
else:
instmif = None
if sys.argv[3] != '-':
datamif = MifFile(sys.argv[3])
datamif.init(int(sys.argv[4]), 4)
else:
datamif = None
assembler = Assembler()
for filename in sys.argv[5:]:
assembler.compile(filename)
assembler.relocate()
if instmif != None:
if assembler.instmem.get_size() > instmif.memory.size:
print "Inst mem too small, need %dB" % (assembler.instmem.get_size())
sys.exit(1)
assembler.instmem.fill(instmif.memory)
instmif.write_back()
if datamif != None:
if assembler.datamem.get_size() > datamif.memory.size:
print "Data mem too small, need %dB" % (assembler.datamem.get_size())
sys.exit(1)
assembler.datamem.fill(datamif.memory)
datamif.write_back()
def test_determine_order(self):
from assembler import Assembler
assbl = Assembler(sequences, identifiers)
c = map_top_bottom
d = map_bottom_top
o = assbl._determine_order(c, d)
self.assertEqual(o, order)
def test_assemble(self):
from assembler import Assembler
assbl = Assembler(sequences, identifiers)
assbl._find_matching_pairs = MagicMock(return_value=(map_top_bottom,
map_bottom_top))
assbl._determine_order = MagicMock(return_value=order)
self.assertEqual(assbl.assemble(), assembled_seq)
def test_assemble_ipform(self):
# =====================================================================
# Test 7: Assemble Kernel
# =====================================================================
mesh = Mesh1D(resolution=(10, ))
Q1 = QuadFE(1, 'DQ1')
dofhandler = DofHandler(mesh, Q1)
dofhandler.distribute_dofs()
phi = Basis(dofhandler, 'u')
k = Explicit(lambda x, y: x * y, n_variables=2, dim=1)
kernel = Kernel(k)
form = IPForm(kernel, test=phi, trial=phi)
assembler = Assembler(form, mesh)
assembler.assemble()
#af = assembler.af[0]['bilinear']
M = assembler.get_matrix().toarray()
u = Nodal(lambda x: x, basis=phi)
v = Nodal(lambda x: 1 - x, basis=phi)
u_vec = u.data()
v_vec = v.data()
I = v_vec.T.dot(M.dot(u_vec))
self.assertAlmostEqual(I[0, 0], 1 / 18)
def evaluate(self, st):
try:
input_value = int(input("Input: "))
Assembler.write_line("MOV EBX, {}".format(input_value))
return (input_value, "INT")
except:
raise ValueError("AST Error (Input): Only INT is a valid input type")
def start(self):
print("Starting MRI_FID_Widget")
# send 1 as signal to start MRI_FID_Widget
gsocket.write(struct.pack('<I', 1))
# enable/disable GUI elements
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.applyFreqButton.setEnabled(True)
self.gradOffset_x.setEnabled(True)
self.gradOffset_y.setEnabled(True)
self.gradOffset_z.setEnabled(True)
self.gradOffset_z2.setEnabled(True)
self.acquireButton.setEnabled(True)
self.saveShimButton.setEnabled(True)
self.loadShimButton.setEnabled(True)
self.zeroShimButton.setEnabled(True)
self.openFlipangletoolBtn.setEnabled(True)
# setup global socket for receive data
gsocket.setReadBufferSize(8 * self.size)
gsocket.readyRead.connect(self.read_data)
# send the sequence to the backend
ass = Assembler()
seq_byte_array = ass.assemble(self.seq_filename)
print(len(seq_byte_array))
gsocket.write(struct.pack('<I', len(seq_byte_array)))
gsocket.write(seq_byte_array)
self.load_shim()
self.idle = False
def start(self):
print("Starting MRI_SE_Widget")
# send 2 as signal to start MRI_SE_Widget
gsocket.write(struct.pack('<I', 2))
# enable/disable GUI elements
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.gradOffset_x.setEnabled(True)
self.gradOffset_y.setEnabled(True)
self.gradOffset_z.setEnabled(True)
self.gradOffset_z2.setEnabled(True)
self.acquireButton.setEnabled(True)
self.saveShimButton.setEnabled(True)
self.loadShimButton.setEnabled(True)
self.zeroShimButton.setEnabled(True)
self.zoomCheckBox.setEnabled(True)
self.peakWindowCheckBox.setEnabled(True)
self.cycAcqBtn.setEnabled(False)
self.cyclesValue.setEnabled(False)
# setup global socket for receive data
gsocket.readyRead.connect(self.read_data)
# send the sequence to the backend
ass = Assembler()
seq_byte_array = ass.assemble(self.seq_filename)
print(len(seq_byte_array))
gsocket.write(struct.pack('<I', len(seq_byte_array)))
gsocket.write(seq_byte_array)
self.load_shim()
self.idle = False
def experiment01():
"""
Compute the quantity of interest, it's expectation and variance
"""
#
# FE Discretization
#
# Computational mesh
mesh = Mesh1D(resolution=(64, ))
# Element
element = QuadFE(mesh.dim(), 'DQ0')
dofhandler = DofHandler(mesh, element)
dofhandler.distribute_dofs()
# Linear Functional
mesh.mark_region('integrate',
lambda x: x > 0.75,
entity_type='cell',
strict_containment=False)
phi = Basis(dofhandler)
assembler = Assembler(Form(1, test=phi, flag='integrate'))
assembler.assemble()
L = assembler.get_vector()
def test_assemble_iiform(self):
mesh = Mesh1D(resolution=(1, ))
Q1 = QuadFE(1, 'DQ1')
dofhandler = DofHandler(mesh, Q1)
dofhandler.distribute_dofs()
phi = Basis(dofhandler, 'u')
k = Explicit(lambda x, y: x * y, n_variables=2, dim=1)
kernel = Kernel(k)
form = IIForm(kernel, test=phi, trial=phi)
assembler = Assembler(form, mesh)
assembler.assemble()
Ku = Nodal(lambda x: 1 / 3 * x, basis=phi)
#af = assembler.af[0]['bilinear']
M = assembler.get_matrix().toarray()
u = Nodal(lambda x: x, basis=phi)
u_vec = u.data()
self.assertTrue(np.allclose(M.dot(u_vec), Ku.data()))
def set_IR(
self,
TI=15
): #, REC=1000): # Function to modify SE -- call whenever acquiring a SE
params.ti = TI
self.change_IR(params.ti, self.seq_ir) #, REC)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_ir)
# Implement new concept:
# com.set_sequence(byte_array)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
self.ir_flag = True
self.se_flag = False
self.fid_flag = False
print("\nIR sequence uploaded with TI = ", TI,
" ms.") #" and REC = ", REC, " ms.")
def reset(self):
###
#self.generate_routefile_two_intersections()
self.generate_routefile()
traci.load([
"-c", "one_lane/one_lane4.sumocfg", "--collision.check-junctions",
"1", "--start", '--no-step-log', 'true'
])
###
#traci.load(["-c", "one_intersection_w_priority/one_intersection_w_priority.sumocfg", "--collision.check-junctions", "1", "--start"])
run = Assembler(self.carID)
terminate = False
while terminate == False:
num_vec = traci.vehicle.getIDList()
for i in range(len(num_vec)):
if num_vec[i] != 'ego':
traci.vehicle.setLaneChangeMode(num_vec[i], 512)
self.output = run.getTensor()
if self.output is not None:
terminate = True
traci.simulationStep()
return self.getObservation()
def lade_datei(self, datei):
if (self.rechner!=None):
asm = Assembler(self.rechner)
asm.parse_datei(datei)
self.rechner.lade_programm(asm.programm)
return asm.tipps
else:
raise RuntimeError("Rechner muss erzeugt werden bevor Programm geladen wird")
def test_assembler_translate(self):
assembler = Assembler(asm_path=self.ADD_ASM_FILE)
assembler._translate()
result_file = open(assembler.hack_path, 'r')
for result, expect in zip(result_file, HACK_CONTENT):
with self.subTest(result=result, expect=expect):
self.assertEqual(result.strip(), expect)
def touch(f):
click.echo(click.format_filename(f))
fasta_parser = FASTAparser(f)
parsed_sequences = fasta_parser.parse()
assembler = Assembler(parsed_sequences)
result = assembler.assemble()
with open("result_assembled_sequence.txt", "w") as text_file:
text_file.write(result)
def test_find_matching_pairs(self):
from assembler import Assembler
assbl = Assembler(sequences)
a, b, c, d = assbl._find_matching_pairs()
self.assertEqual(c, top_ranges_dict)
self.assertEqual(d, bottom_ranges_dict)
self.assertEqual(a, top_seq_dict)
self.assertEqual(b, bottom_seq_dict)
def test_determine_order(self):
from assembler import Assembler
assbl = Assembler(sequences)
c = top_ranges_dict
d = bottom_ranges_dict
a = top_seq_dict
b = bottom_seq_dict
o = assbl._determine_order(a,b,c,d)
self.assertEqual(o, order)
def test_pop_static():
translator = VM2ASM(annotate=True, no_init=True)
asm = translator.translate('pop static 1').dumps()
Assembler().assemble(asm)
print('pop static 1\n', asm)
translator = VM2ASM(annotate=True, no_init=True)
asm = translator.translate('pop static 0').dumps()
Assembler().assemble(asm)
print('pop static 0\n', asm)
def send_pulse(self, inp_file):
''' Sends the pulse sequence to the server '''
# write a 3 to signal that the button has been pushed
gsocket.write(struct.pack('<I', 3 << 28))
ass = Assembler()
btye_array = ass.assemble(inp_file)
print("Byte array = {}".format(btye_array))
print("Length of byte array = {}".format(len(btye_array)))
gsocket.write(btye_array)
print("Sent byte array")
def touch(fasta_file, output_file, show):
click.echo(click.format_filename(fasta_file))
fasta_parser = FastaParser(fasta_file)
fragments, fragment_ids = fasta_parser.parse()
assembler = Assembler(fragments,
fragment_ids,
print_fragment_id_order=show)
assembled = assembler.assemble()
with open(output_file, "w") as text_file:
text_file.write(assembled)
def sample_qoi(q, dofhandler):
"""
Sample total energy of output for a given sample of q's
"""
#
# Set up weak form
#
# Basis
phi = Basis(dofhandler, 'v')
phi_x = Basis(dofhandler, 'vx')
# Elliptic problem
problems = [[Form(q, test=phi_x, trial=phi_x), Form(1, test=phi)],
[Form(1, test=phi, trial=phi)]]
# Assemble
assembler = Assembler(problems, mesh)
assembler.assemble()
# System matrices
A = assembler.af[0]['bilinear'].get_matrix()
b = assembler.af[0]['linear'].get_matrix()
M = assembler.af[1]['bilinear'].get_matrix()
# Define linear system
system = LS(phi)
system.add_dirichlet_constraint('left',1)
system.add_dirichlet_constraint('right',0)
n_samples = q.n_samples()
y_smpl = []
QoI_smpl = []
for i in range(n_samples):
# Sample system
if n_samples > 1:
Ai = A[i]
else:
Ai = A
system.set_matrix(Ai)
system.set_rhs(b.copy())
# Solve system
system.solve_system()
# Record solution and qoi
y = system.get_solution(as_function=False)
y_smpl.append(y)
QoI_smpl.append(y.T.dot(M.dot(y)))
# Convert to numpy array
y_smpl = np.concatenate(y_smpl,axis=1)
QoI = np.concatenate(QoI_smpl, axis=1).ravel()
return y_smpl, QoI
def ensamblar(self):
if not self.fileOpener(): return
ens = Assembler(self.filename)
ens.leerArchivo()
try:
ens.first_pass()
ens.Second_pass()
ens.print_tabla()
except Exception as ex:
self.newWindow = tk.Toplevel(self.master)
self.pop = PopUP(self.newWindow)
self.pop.addMessage("Error", str(ex))
return
fileOut = open(self.directory + "out.obj", "w+")
for line in ens.CO:
fileOut.write(line + "\n")
fileOut.close()
self.newWindow = tk.Toplevel(self.master)
self.pop = PopUP(self.newWindow)
self.pop.addMessage("Información",
"Archivo .obj creado en: \n" + self.directory)
def content():
data = request.form['data']
ass = Assembler(data)
ass.gen_bin_instructions()
c = Computer()
program_start, end = ass.load(c.ram)
c.run(program_start)
return jsonify({
'assembler': ass.show_ins_table(),
'run': c.ram.show_relevant(program_start, end),
'storage': show_bin_rep(data)
})
def execute(self, action):
#traci.vehicle.setSpeedMode('ego', 0)
#print(action)
run = Assembler(self.carID)
# self.output = tensor.executeTensor()
self.output = run.getTensor()
# print(self.output)
if self.output is None:
term = True
return self.getObservation(), term, 0
# rew = Reward('ego', self.output)
rew = Reward('ego')
coll, term = rew.collision()
if term is True:
cost = coll
return self.getObservation(), term, cost
traci.vehicle.setSpeedMode('ego', 0)
num_vec = traci.vehicle.getIDList()
for i in range(len(num_vec)):
if num_vec[i] != 'ego':
traci.vehicle.setLaneChangeMode(num_vec[i], 512)
# print(action)
carID = 'ego'
act = Action(carID)
if action == 0:
pass
#act.decelerate()
#print('dec')
elif action == 1:
pass
#act.accelerate()
#print('acc')
else:
pass
#act.remain()
#print('rem')
traci.simulationStep()
#net = sumolib.net.readNet('huge_crossing/huge_crossing.net.xml')
#tensor = Tensor('ego', net, self.conflictory_list[0], self.connection_list[0])
#self.output = tensor.executeTensor()
#rew = Reward('ego', self.output)
win = rew.target()
cost = rew.optimum_speed_deviation() + win
# + brake
traci.simulationStep()
return self.getObservation(), term, cost
class InputBuilder(object):
def __init__(self, biodb_selector, fam_path, index_col= "Name", calculation_type="sum"):
self.biodb_selector= biodb_selector
self.abundance_frame= read_csv(fam_path, sep= '\t', index_col=index_col)
self.abundance= self.abundance_frame.T.mean()
self.assembler= Assembler(biodb_selector, self.abundance, calculation_type)
self.assembler.assemble_ideograms()
self.io_worker= IOWorker(self.assembler)
def build_circos_inputs_and_run(self, plots=None, links=None, highlights=None):
"""
pathway names will be added
"""
self.io_worker.build_links(links)
self.io_worker.build_highlights(highlights)
self.io_worker.edit_plots_config(plots)
self.io_worker.build_karyotype()
self.io_worker.build_text()
self.io_worker.build_pathway_names()
self.io_worker.build_data()
self.save_settings(plots, links, highlights)
self.run_circos()
def save_settings(self, plots, links, highlights):
plots.dump()
links.dump()
highlights.dump()
def run_circos(self):
circos_file= file_provider['output']['circos_png']
config= file_provider['circos_config']['conf']
out_dir = os.path.dirname(circos_file)
out_file= os.path.basename(circos_file)
circos_bin= file_provider['circos']['bin']
cmd_args= ['perl', circos_bin,'--conf', config,' --outputdir', out_dir, '--outputfile', out_file]
cmd= ' '.join(cmd_args)
print "Running circos...", cmd
p= subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr= subprocess.PIPE)
#p= subprocess.Popen(cmd_args)
output, err= p.communicate()
print output
print "#####"
print err
return output
def build_optionals(self):
pass
def test_compat():
ASM.set_compat(True)
asm = EQ_Operation(compat=True).resolve()
Assembler(compat=True).assemble(str(asm))
try:
ASM.set_compat(False)
asm = EQ_Operation().resolve()
Assembler(compat=True).assemble(str(asm))
except:
pass
else:
assert False, 'Should have failed'
def _reset(self, mpu_type, getc_addr=0xF004, putc_addr=0xF001):
self._mpu = mpu_type(memory=self.memory)
self.addrWidth = self._mpu.ADDR_WIDTH
self.byteWidth = self._mpu.BYTE_WIDTH
self.addrFmt = self._mpu.ADDR_FORMAT
self.byteFmt = self._mpu.BYTE_FORMAT
self.addrMask = self._mpu.addrMask
self.byteMask = self._mpu.byteMask
if getc_addr and putc_addr:
self._install_mpu_observers(getc_addr, putc_addr)
self._address_parser = AddressParser()
self._disassembler = Disassembler(self._mpu, self._address_parser)
self._assembler = Assembler(self._mpu, self._address_parser)
def main():
try:
filename = sys.argv[1] #"test_file.vbs"
except IndexError:
print("This program needs an input .vbs file to continue. Exiting...")
sys.exit(1)
with open(filename, 'r') as file:
code = file.read()
Parser.run(code)
Assembler.write_file()
os.system("nasm -f elf32 -F dwarf -g program.asm ")
os.system("ld -m elf_i386 -o program program.o")
os.system("./program")
def set_2dSE(
self
): # Function to init and set FID -- only acquire call is necessary afterwards
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_2dSE)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
socket.setReadBufferSize(8 * self.size)
print("\n2D SE sequence uploaded.")
def set_SIR(self, TI=15):
params.ti = TI
#self.change_SIR(params.ti, self.seq_sir)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_sir)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
print("\nSIR sequence uploaded with TI = ", TI,
" ms.") #" and REC = ", REC, " ms.")
def execute(self, action):
run = Assembler(self.carID)
self.output = run.getTensor()
#print(run.getTensor())
if self.output is None:
term = True
return self.getObservation(), term, 0
rew = Reward('ego', run.getTraffic(), self.output)
coll, term = rew.collision()
if term is True:
cost = coll
return self.getObservation(), term, cost
traci.vehicle.setSpeedMode('ego', 0)
num_vec = traci.vehicle.getIDList()
for i in range(len(num_vec)):
if num_vec[i] != 'ego':
traci.vehicle.setLaneChangeMode(num_vec[i], 512)
###
#if i % 2 == 0:
#traci.vehicle.setSpeedMode(num_vec[i], 23)
carID = 'ego'
act = Action(carID)
if action == 0:
act.decelerate()
# print('dec')
elif action == 1:
act.accelerate()
# print('acc')
else:
act.remain()
# print('rem')
gap, term = rew.emergency_gap()
wary = rew.wary_before_intersection()
#win = rew.target()
brake = rew.emergency_brake()
cost = rew.optimum_speed_deviation() + brake + gap + wary
traci.simulationStep()
#print(self.output)
return self.getObservation(), term, cost
def upload_seq(self):
''' Takes an input text file, compiles it to machine code '''
dialog = QFileDialog() # open a Dialog box to take the file
fname = dialog.getOpenFileName(None, "Import Pulse Sequence", "",
"Text files (*.txt)")
# returns a tuple, fname[0] is filename(including path), fname[1] is file type
inp_file = fname[0]
print("Uploading sequence to server")
try:
ass = Assembler()
self.upload_seq_byte_array = ass.assemble(inp_file)
self.uploadSeq.setText(inp_file)
except IOError as e:
print("Error: required txt file doesn't exist")
return
print("Uploaded successfully to server")
def __init__(self, biodb_selector, fam_path, index_col= "Name", calculation_type="sum"):
self.biodb_selector= biodb_selector
self.abundance_frame= read_csv(fam_path, sep= '\t', index_col=index_col)
self.abundance= self.abundance_frame.T.mean()
self.assembler= Assembler(biodb_selector, self.abundance, calculation_type)
self.assembler.assemble_ideograms()
self.io_worker= IOWorker(self.assembler)
def set_uploaded_seq(self, seq):
print("Set uploaded Sequence.")
self.assembler = Assembler()
byte_array = self.assembler.assemble(seq)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten():
break
# Multiple function calls
socket.setReadBufferSize(8 * self.size)
print(byte_array)
print("Sequence uploaded to server.")
self.uploaded.emit(True)
def runTest(self):
self.assembler = Assembler()
self.test_reg_to_binary()
self.test_int_to_binary()
self.test_twos_complement()
self.test_binary_to_hex()
self.test_command()
self.test_command2()
def main(args):
if len(args) != 2:
print "USAGE:", args[0], "program.asm"
print "\tprogram.asm is the source asm file"
print "\tA hack file will be created from the source file."
print "\tThe output file will use the same prefix as the source, but"
print "\tthe extension will be .hack"
sys.exit(1)
# the source filename
source_filename = args[1]
# create the assembler and assemble the code
try:
assembler = Assembler(source_filename)
assembler.assemble()
except IOError:
print "ERROR: Could not open source file or error writing to destination"
class Streamer:
#Global variables
fo = open('authentication.txt')
lines = [str(line.rstrip('\n')) for line in fo]
consumer_key = lines[0]
consumer_secret = lines[1]
access_token = lines[2]
access_token_secret = lines[3]
fo.close()
# OAuth process, using the keys and tokens
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
# Creation of the actual interface, using authentication
api = tweepy.API(auth)
def __init__(self):
self.assembler = Assembler()
self.wrapper = Wrapper()
def priceupdate(self, base, mid, quote):
timestamp = datetime.fromtimestamp(time.time())
rates = self.assembler.assemble(base, mid, quote)
base_per_mid, mid_per_quote = rates[0], rates[1]
last_update = self.wrapper.c.execute("SELECT * FROM Prices ORDER BY year DESC, month DESC, day DESC, hour DESC, minute DESC").fetchone()
new_price = base_per_mid*mid_per_quote
last_price = last_update[5]*last_update[6]
delta = new_price/last_price - 1
self.wrapper.update_price_db(timestamp, base_per_mid, mid_per_quote)
if delta >= 0:
return '[%s CST]: The average #dogecoin price is now $%.6f, +%.1f%% growth wow (%.2f bits)' \
% (timestamp.strftime('%m-%d %H:%M'), new_price, delta*100, base_per_mid*(1000000))
else:
return '[%s CST]: The average #dogecoin price is now $%.6f, %.1f%% decline (%.2f bits)' \
% (timestamp.strftime('%m-%d %H:%M'), new_price, delta*100, base_per_mid*(1000000))
#return '[%s CST]: The average #dogecoin price is now $%.6f (%.2f bits)' \
#% (timestamp.strftime('%m-%d %H:%M'), new_price, base_per_mid*(1000000))
#return '[%s CST]: The average dogecoin price is now %.2f bits ($%.6f).\n$1 = Ð%.2f\n1BTC = Ð%d' % (datetime.fromtimestamp(time.time()).strftime('%m-%d %H:%M:%S'), dogebtcprice, dogeusdprice, 1/dogeusdprice, dogebtcprice*100000)
#Continuous price stream
def stream(self):
print 'Initiating Dogecoin Price Stream --------------------------'
while True:
try:
tweet = self.priceupdate('DOGE', 'BTC', 'USD')
self.api.update_status(tweet)
print tweet
print 'Tweeted successfully'
except Exception, e:
print str(e)
time.sleep(3570)
class AssemblerTest(unittest.TestCase):
def runTest(self):
self.assembler = Assembler()
self.test_reg_to_binary()
self.test_int_to_binary()
self.test_twos_complement()
self.test_binary_to_hex()
self.test_command()
self.test_command2()
# Tests the register to binary method
def test_reg_to_binary(self):
input = "r3"
expected = "0011"
result = self.assembler.reg_to_binary(input, 4)
self.assertEqual(expected, result)
# Tests the integer to binary method
def test_int_to_binary(self):
input = 15
expected = "1111"
result = self.assembler.int_to_binary(input, 4)
self.assertEqual(expected, result)
# Tests the two's complement method
def test_twos_complement(self):
input = "0000010001110001"
expected = "1111101110001111"
result = self.assembler.twos_complement(input, 16)
self.assertEqual(expected, result)
# Tests the binary to hexadecimal method
def test_binary_to_hex(self):
input = "000101100001111100111110"
expected = "161f3e"
result = self.assembler.binary_to_hex(input)
self.assertEqual(expected, result)
# Tests a compare command
def test_command(self):
input = Command(["cmp", "r2", "r3"], 10, "0010")
expected = "\t10\t\t\t:\t32012e;"
result = self.assembler.r_type(input)
self.assertEqual(expected, result)
# Tests a load immediate command
def test_command2(self):
input = Command(["li", "r3", "31"], 10, "0000")
expected = "\t10\t\t\t:\t3001f2;"
result = self.assembler.j_type(input)
self.assertEqual(expected, result)
def on_start_button_clicked(self, widget):
finalfile = self.x[0].split('.')[0] + '.8085'
info = self.shell_ui.get_object("start_info_label")
# str1 = ''
# str1 += 'Interpreting...........\nRunning Assembler \n'
# info.set_text(str1)
self.assembler_instance = Assembler(self.shell_ui)
self.assembler_instance.test(self.x)
# str1 = str1 + 'Assembler Completed \n' + 'Running Linker \n'
# info.set_text(str1)
self.linker_instance = Linker(self.shell_ui, self.assembler_instance.symTable,
self.assembler_instance.globTable,
self.assembler_instance.filelen)
self.linker_instance.linker(self.x)
# str1 = str1 + 'Linker Completed \n' + 'Set offset and run loader\n'
# info.set_text(str1)
self.loader_instance = Loader(self.shell_ui)
self.loader_instance.loader(self.x)
from assembler import Assembler
# Runs the assembler. First it prompts the user for
# input and output file names. The input file should
# be .s or .asm. The output files should be .mif.
# Then it runs the assembler. If an exception is
# raised, it is caught and the error message is
# printed.
program = Assembler()
filename = input("\nEnter the input file name: ")
file_out = input("Enter the output file name: ")
ascii = [
"Assembling...\n\n"
" .-\"\"-.",
" /[] _ _\\",
" _|_o_LII|_",
" / | ==== | \\ BEEP BOOP",
" |_| ==== |_| BLOP BLEEP",
" || || || BOOP!",
" ||LI o ||",
" ||'----'||",
" /__| |__\\"
]
try:
file = open(filename)
code = file.readlines()
output = program.compile(code)
#!/usr/bin/python2.6
from assembler import Assembler
from sys import argv
#only care about the first argument.
if(None == argv[1]):
print("No input file specified.")
exit(255)
file = argv[1]
assembler = Assembler(file)
#assembler.symbol_less_assembly()
assembler.two_pass_assembly()
class Converter:
#Global variables
fo = open('authentication.txt')
lines = [str(line.rstrip('\n')) for line in fo]
consumer_key = lines[0]
consumer_secret = lines[1]
access_token = lines[2]
access_token_secret = lines[3]
fo.close()
# OAuth process, using the keys and tokens
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
# Creation of the actual interface, using authentication
api = tweepy.API(auth)
#All 168 foreign currencies able to be converted via bitcoinaverage
#Bypasses openexchangerates.org
currency_codes = ['AED' , 'AFN' , 'ALL' , 'AMD' , 'ANG' , 'AOA' , 'ARS' , 'AUD' , 'AWG' ,\
'AZN' , 'BAM' , 'BBD' , 'BDT' , 'BGN' , 'BHD' , 'BIF' , 'BMD' , 'BND' ,\
'BOB' , 'BRL' , 'BSD' , 'BTC' , 'BTN' , 'BWP' , 'BYR' , 'BZD' , 'CAD' ,\
'CDF' , 'CHF' , 'CLF' , 'CLP' , 'CNY' , 'COP' , 'CRC' , 'CUP' , 'CVE' ,\
'CZK' , 'DJF' , 'DKK' , 'DOP' , 'DZD' , 'EEK' , 'EGP' , 'ERN' , 'ETB' ,\
'EUR' , 'FJD' , 'FKP' , 'GBP' , 'GEL' , 'GGP' , 'GHS' , 'GIP' , 'GMD' ,\
'GNF' , 'GTQ' , 'GYD' , 'HKD' , 'HNL' , 'HRK' , 'HTG' , 'HUF' , 'IDR' ,\
'ILS' , 'IMP' , 'INR' , 'IQD' , 'IRR' , 'ISK' , 'JEP' , 'JMD' , 'JOD' ,\
'JPY' , 'KES' , 'KGS' , 'KHR' , 'KMF' , 'KPW' , 'KRW' , 'KWD' , 'KYD' ,\
'KZT' , 'LAK' , 'LBP' , 'LKR' , 'LRD' , 'LSL' , 'LTL' , 'LVL' , 'LYD' ,\
'MAD' , 'MDL' , 'MGA' , 'MKD' , 'MMK' , 'MNT' , 'MOP' , 'MRO' , 'MTL' ,\
'MUR' , 'MVR' , 'MWK' , 'MXN' , 'MYR' , 'MZN' , 'NAD' , 'NGN' , 'NIO' ,\
'NOK' , 'NPR' , 'NZD' , 'OMR' , 'PAB' , 'PEN' , 'PGK' , 'PHP' , 'PKR' ,\
'PLN' , 'PYG' , 'QAR' , 'RON' , 'RSD' , 'RUB' , 'RWF' , 'SAR' , 'SBD' ,\
'SCR' , 'SDG' , 'SEK' , 'SGD' , 'SHP' , 'SLL' , 'SOS' , 'SRD' , 'STD' ,\
'SVC' , 'SYP' , 'SZL' , 'THB' , 'TJS' , 'TMT' , 'TND' , 'TOP' , 'TRY' ,\
'TTD' , 'TWD' , 'TZS' , 'UAH' , 'UGX' , 'USD' , 'UYU' , 'UZS' , 'VEF' ,\
'VND' , 'VUV' , 'WST' , 'XAF' , 'XAG' , 'XAU' , 'XCD' , 'XDR' , 'XOF' ,\
'XPF' , 'YER' , 'ZAR' , 'ZMK' , 'ZMW' , 'ZWL']
#Expanding to other cryptocurrencies in v1.7
cryptocurrency_codes = []
def __init__(self):
self.assembler = Assembler()
self.wrapper = Wrapper()
def populate_db(self):
for mention in self.api.mentions_timeline():
self.wrapper.update_mentions_db(mention.user.screen_name, mention.id, mention.text)
#Return True if mention is a duplicate, False otherwise
def no_duplicates(self, mention):
command = "SELECT * FROM Mentions WHERE id = %d" % (mention.id)
duplicates = self.wrapper.c.execute(command).fetchall()
if len(duplicates) == 0:
return True
return False
def insert_into_db(self, mention):
self.wrapper.update_mentions_db(mention.user.screen_name, mention.id, mention.text)
def convert(self, mention):
if self.no_duplicates(mention):
user = mention.user.screen_name
#Textual trigger
if '@dogepricebot convert' in mention.text.lower():
print "Found conversion request"
print user+" : "+mention.text
words = mention.text.lower().split(" ")
command_start = words.index('@dogepricebot')
amount, base, quote = float(words[command_start+2]), words[command_start+3], words[command_start+5]
if base.lower() == "dogecoin" or base.lower() == "doge":
rates = self.assembler.assemble(quote.upper())
rate = rates[0]*rates[1]
tweet = '@%s wow such convert: %.1f #dogecoin = %.2f %s' % (user, amount, amount*rate, quote.upper())
print tweet
self.api.update_status(tweet)
else:
rates = self.assembler.assemble(base.upper())
rate = rates[0]*rates[1]
tweet = '@%s wow such convert: %.1f %s = %.2f #dogecoin' % (user, amount, base.upper(), amount/rate)
print tweet
self.api.update_status(tweet)
self.insert_into_db(mention)
else:
print "duplicate"
#Continuous price stream
def listen(self):
print 'Listening for @dogepricebot convert requests --------------------------'
while True:
for mention in self.api.mentions_timeline(count=10):
try:
self.convert(mention)
except Exception, e:
print "In exception"
print str(e)
time.sleep(300)
def main(fname):
a = Assembler()
p = a.parse(fname)
with open(fname.split('.')[0], 'wb') as f:
f.write(bytearray(p))
def __init__(self): self.assembler = Assembler() self.wrapper = Wrapper()
class AssemblerTest(unittest.TestCase):
def setUp(self):
self.assembler = Assembler()
def test_instance(self):
thing = object()
self.assembler.instance('thing', thing)
result = self.assembler.assemble('thing')
self.assertEqual(thing, result)
def test_factory(self):
def thing_maker():
return object()
self.assembler.factory('thing', thing_maker)
result1 = self.assembler.assemble('thing')
self.assertTrue(isinstance(result1, object))
result2 = self.assembler.assemble('thing')
self.assertTrue(isinstance(result2, object))
self.assertNotEqual(result1, result2)
def test_assemble_with_args(self):
def thing_maker(one, two):
return [one, two]
self.assembler.factory('thing', thing_maker)
result = self.assembler.assemble('thing', 'one', 'two')
self.assertEqual(['one', 'two'], result)
def test_assemble_with_kwargs(self):
def thing_maker(one, two):
return [one, two]
self.assembler.factory('thing', thing_maker)
result = self.assembler.assemble('thing', two='one', one='two')
self.assertEqual(['two', 'one'], result)
def test_assemble_with_args_and_kwargs(self):
def thing_maker(one, two, a=None, b=None):
return [one, two, (a, b)]
self.assembler.factory('thing', thing_maker)
result = self.assembler.assemble('thing', 'one', 'two', b='b', a='a')
self.assertEqual(['one', 'two', ('a', 'b')], result)
def test_assemble_with_defaults(self):
def thing_maker(one='one', two='two', a='a', b='b'):
return [one, two, (a, b)]
self.assembler.factory('thing', thing_maker)
result = self.assembler.assemble('thing')
self.assertEqual(['one', 'two', ('a', 'b')], result)
def test_recursive_assemble(self):
def thing1_maker(thing2):
return thing2
def thing2_maker():
return 'instance of thing2'
self.assembler.factory('thing1', thing1_maker)
self.assembler.factory('thing2', thing2_maker)
result = self.assembler.assemble('thing1')
self.assertEqual('instance of thing2', result)
def test_class_constructors(self):
class A(object):
def __init__(self, b, c):
self.b = b
self.c = c
class B(object):
def __init__(self):
pass
class C(object):
def __init__(self, d):
self.d = d
class D(object):
def __init__(self):
pass
self.assembler.factory('a', A)
self.assembler.factory('b', B)
self.assembler.factory('c', C)
self.assembler.factory('d', D)
a = self.assembler.assemble('a')
self.assertTrue(isinstance(a, A))
self.assertTrue(hasattr(a, 'b'))
self.assertNotEqual(None, a.b)
self.assertTrue(isinstance(a.b, B))
self.assertTrue(hasattr(a, 'c'))
self.assertNotEqual(None, a.c)
self.assertTrue(isinstance(a.c, C))
self.assertTrue(hasattr(a.c, 'd'))
self.assertNotEqual(None, a.c.d)
self.assertTrue(isinstance(a.c.d, D))
def setUp(self):
self.assembler = Assembler()
def main(argv):
if parse_args(argv):
asm = Assembler(options)
asm.run()
#!/usr/bin/env python
import os
from assembler import Assembler
from optionresolver import OptionResolver
from patchers import PatchManager, PatchPatcher
# Get the user supplied options
options = OptionResolver()
# Assemble the source code
assembler = Assembler(options.manifest()["projects"], options.destination(), options.extra_parameters())
assembler.assemble()
# Apply any patches
patchmanager = PatchManager(options.manifest()["patches"], options.destination())
patch_base = os.path.dirname(options.manifest_location())
patchmanager.add_patcher("patch_file", PatchPatcher(patch_base))
patchmanager.patch()
self.pc = 2
while self.pc < end and program[self.pc] != opset.HALT:
instruction = program[self.pc]
self.pc += 1
if opset.nullary(instruction):
self.debug("%02d %s", self.pc, opset.byte2name[instruction])
self.nullary[instruction]()
elif opset.unary(instruction):
argument = program[self.pc]
self.pc += 1
self.debug("%02d %s %s", self.pc, opset.byte2name[instruction], argument)
self.unary[instruction - opset.LIT](argument)
if __name__ == "__main__":
from sys import argv
from assembler import Assembler
from argparser import parseArgs
# Grab command line arguments
args = parseArgs()
try:
asm = Assembler(args.debug)
vm = VirtualMachine(args.debug)
vm.run(asm.assemble(open(args.filename)))
except Exception as e:
print(e)
# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
class AllApp(Gtk.Application):
# constructor of the Gtk Application
def __init__(self):
Gtk.Application.__init__(self)
self.shell_ui = Gtk.Builder()
self.shell_ui.add_from_file("shell.glade")
self.handler_dict = {
"on_start_file_chooser_button_clicked": self.on_start_file_chooser_button_clicked,
"on_start_button_clicked": self.on_start_button_clicked,
"on_simulator_open_file_button_clicked": self.on_simulator_open_file_button_clicked,
"on_simulate_pass_button_clicked": self.on_simulate_pass_button_clicked,
"on_run_button_clicked": self.on_run_button_clicked,
"on_quit_image_menu_item_activate": self.on_quit_activate,
"on_offset_button_clicked": self.on_offset_button_clicked
}
self.shell_ui.connect_signals(self.handler_dict)
self.x = []
self.z = []
self.assembler_instance = None
self.loader_instance = None
self.linker_instance = None
self.simulator_instance = None
# self.simulator=Simulator()
def on_offset_button_clicked(self, widget):
self.loader_instance.loader2(self.x)
def do_activate(self):
window = self.shell_ui.get_object("all_window")
self.add_window(window)
window.show_all()
def on_start_file_chooser_button_clicked(self, widget):
window = self.shell_ui.get_object("all_window")
dialog = Gtk.FileChooserDialog(title="Please choose a file", parent=window, action=Gtk.FileChooserAction.OPEN,
buttons=(
Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
response = dialog.run()
if response == Gtk.ResponseType.OK:
selected_file_path = dialog.get_filename()
relative_path = os.path.basename(selected_file_path)
inputfile = open(relative_path, "r")
code = inputfile.read()
lines = code.split('\n')
finalfile = lines[0].split('.')[0] + '.8085'
print(lines[0].split('.')[0])
print(finalfile)
entries_box = self.shell_ui.get_object("start_entries_box")
wids = entries_box.get_children()
for widget in wids:
widget.destroy()
i = 0
print (lines)
for line in lines:
if line != '':
self.z.append(line)
label = Gtk.Label("Code" + str(i))
tv = Gtk.TextView()
tb = tv.get_buffer()
entries_box.add(label)
entries_box.add(tv)
i += 1
with open(line, "r") as file:
s = file.read()
tb.set_text(s)
print(s)
self.shell_ui.get_object("start_entry_number_entry").set_text(str(i))
entries_box.show_all()
self.x = preprocess(self.z)
processed_box = self.shell_ui.get_object("processed_box")
i = 0
for file_name in self.x:
if file_name != '':
label = Gtk.Label("Code" + str(i))
tv = Gtk.TextView()
tb = tv.get_buffer()
processed_box.add(label)
processed_box.add(tv)
i += 1
with open(file_name, "r") as file:
s = file.read()
tb.set_text(s)
print(s)
processed_box.show_all()
elif response == Gtk.ResponseType.CANCEL:
print("Cancel clicked")
dialog.destroy()
def on_start_button_clicked(self, widget):
finalfile = self.x[0].split('.')[0] + '.8085'
info = self.shell_ui.get_object("start_info_label")
# str1 = ''
# str1 += 'Interpreting...........\nRunning Assembler \n'
# info.set_text(str1)
self.assembler_instance = Assembler(self.shell_ui)
self.assembler_instance.test(self.x)
# str1 = str1 + 'Assembler Completed \n' + 'Running Linker \n'
# info.set_text(str1)
self.linker_instance = Linker(self.shell_ui, self.assembler_instance.symTable,
self.assembler_instance.globTable,
self.assembler_instance.filelen)
self.linker_instance.linker(self.x)
# str1 = str1 + 'Linker Completed \n' + 'Set offset and run loader\n'
# info.set_text(str1)
self.loader_instance = Loader(self.shell_ui)
self.loader_instance.loader(self.x)
# str1 = str1 + 'Loading Complete \n' + '\t\tFile ready to simulate.\n' + '\t\tFile name is : ' + finalfile + '\n'
# info.set_text(str1)
def on_simulator_open_file_button_clicked(self, widget):
pass
def on_simulate_pass_button_clicked(self, widget):
finalfile = self.x[0].split('.')[0] + '.8085'
self.simulator_instance = Simulator(self.shell_ui, self.shell_ui.get_object("all_window"))
self.simulator_instance.load(finalfile)
def on_run_button_clicked(self, widget):
self.simulator_instance.callbackf()
def do_startup(self):
Gtk.Application.do_startup(self)
def on_quit_activate(self, menu_item):
sys.exit()
def main():
totalTime = 0.0
startTime = time.time()
parser = OptionParser("usage: %prog [options] src_file [src_file...]")
parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="Verbose output.")
parser.add_option("-l", "--log", dest="logLevel", default=0, help="Print detailed log information.")
parser.add_option("-t", "--test", action="store_true", dest="test", default=False, help="Run assembler test code.")
parser.add_option("-d", "--debug", action="store_true", dest="debug", default=False, help="Turn on assembler debugging code.")
parser.add_option("-s", "--syntax-only", action="store_true", dest="syntaxOnly", default=False, help="Exit after checking syntax.")
(options, args) = parser.parse_args()
if len(args) < 1:
parser.error("At least one source file must be supplied!")
sys.exit(1)
sources = []
for arg in args:
sources.append(arg)
if not os.path.isfile(arg):
parser.error("File \"%s\" does not exist" % arg)
sys.exit(1)
buildname = os.path.basename(os.getcwd())
firstfile = args[0]
firstfilename = args[0].split('.')[0]
listfile = open(firstfile + ".lst", 'w')
symtabfile = open(firstfile + ".symtab", 'w')
binfile = open(firstfile + ".bin", 'wb')
logfile = None
if options.logLevel > 0:
logfile = open(firstfilename + ".log", 'w')
context = Context(Architecture.AGC4_B2, listfile, binfile, options, int(options.logLevel), logfile)
assembler = Assembler(context)
context.assembler = assembler
if options.debug:
print "Build:", buildname
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Initialisation: %3.2f seconds" % delta
assembler.info("Simple AGC Assembler, v0.1", source=False)
assembler.info("", source=False)
startTime = time.time()
for arg in args:
try:
assembler.assemble(arg)
except:
print >>sys.stderr
print >>sys.stderr, "EXCEPTION:"
traceback.print_exc(file=sys.stderr)
print >>sys.stderr, "Context:"
print >>sys.stderr, context
raise
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Pass 1: %3.2f seconds" % delta
context.saveCurrentBank()
if options.syntaxOnly == False and context.errors == 0:
assembler.info("Resolving symbols...", source=False)
startTime = time.time()
try:
assembler.resolve()
except:
assembler.log(1, "EXCEPTION:\n%s" % context)
raise
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
for record in assembler.context.records:
record.printMessages()
assembler.info("Writing listing...", source=False)
startTime = time.time()
print >>listfile
print >>listfile, "Listing"
print >>listfile, "-------"
for record in assembler.context.records:
print >>listfile, record
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Write listing: %3.2f seconds" % delta
if not options.syntaxOnly:
assembler.info("Writing symbol table listing...", source=False)
startTime = time.time()
print >>listfile
print >>listfile, "Symbol Table"
print >>listfile, "------------"
assembler.context.symtab.printTable(listfile)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Write symbol table listing: %3.2f seconds" % delta
if not options.syntaxOnly and context.errors == 0:
assembler.info("Writing symbol table...", source=False)
startTime = time.time()
assembler.context.symtab.write(symtabfile)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Write symbol table: %3.2f seconds" % delta
if context.errors == 1:
msg = "1 error, "
else:
msg = "%d errors, " % (context.errors)
if context.warnings == 1:
msg += "1 warning, "
else:
msg += "%d warnings, " % (context.warnings)
assembler.info(msg, source=False)
print msg
if not options.syntaxOnly:
if options.test:
startTime = time.time()
# FIXME: Temporary hack
# Check generated symbols against the symtab generated by yaYUL.
assembler.info("Checking symbol table against yaYUL version...", source=False)
from artemis072_symbols import ARTEMIS_SYMBOLS
from memory import MemoryType
nsyms = assembler.context.symtab.getNumSymbols()
check_nsyms = len(ARTEMIS_SYMBOLS.keys())
assembler.info("Number of symbols: yaYUL=%d pyagc=%d" % (check_nsyms, nsyms), source=False)
my_syms = []
other_syms = []
common_syms = []
for sym in assembler.context.symtab.keys():
if sym in ARTEMIS_SYMBOLS.keys():
common_syms.append(sym)
else:
if sym != "FIXED":
my_syms.append(sym)
for sym in ARTEMIS_SYMBOLS.keys():
if sym not in assembler.context.symtab.keys():
if not sym.startswith('$') and sym != "'":
other_syms.append(sym)
if len(my_syms) != 0 or len(other_syms) != 0:
assembler.error("incorrect number of symbols, expected %d, got %d" % (check_nsyms, nsyms), source=False)
if len(my_syms) > 0:
assembler.error("symbols defined that should not be defined: %s" % my_syms, source=False)
if len(other_syms) > 0:
assembler.error("symbols not defined that should be defined: %s" % other_syms, source=False)
errcount = 0
bad_syms = {}
for sym in common_syms:
entry = assembler.context.symtab.lookup(sym)
if entry == None:
assembler.error("symbol %-8s not defined" % entry, source=False)
pa = entry.value
aval = ARTEMIS_SYMBOLS[sym]
if ',' in aval:
bank = aval.split(',')[0]
type = MemoryType.FIXED
if bank.startswith('E'):
bank = bank[1:]
type = MemoryType.ERASABLE
bank = int(bank, 8)
offset = int(aval.split(',')[1], 8)
check_pa = context.memmap.segmentedToPseudo(type, bank, offset, absolute=True)
else:
check_pa = int(aval, 8)
if pa != check_pa:
errcount += 1
bad_syms[pa] = (sym, check_pa)
if errcount > 0:
bad_addrs = bad_syms.keys()
bad_addrs.sort()
for pa in bad_addrs:
sym = bad_syms[pa][0]
check_pa = bad_syms[pa][1]
assembler.error("symbol %-8s defined as %06o %s, expected %06o %s" % (sym, pa, context.memmap.pseudoToSegmentedString(pa), check_pa, context.memmap.pseudoToSegmentedString(check_pa)), source=False)
assembler.error("%d/%d symbols incorrectly defined" % (errcount, len(common_syms)), source=False)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Symbol checking: %3.2f seconds" % delta
# FIXME: End of temporary hack
if not options.syntaxOnly and context.errors == 0:
assembler.info("Writing binary output...", source=False)
startTime = time.time()
ocode = ObjectCode(context)
ocode.generateBuggers()
ocode.write(binfile)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Binary generation: %3.2f seconds" % delta
assembler.info("Writing rope usage...", source=False)
startTime = time.time()
print >>listfile
print >>listfile
print >>listfile, "Bank Usage"
print >>listfile, "----------"
print >>listfile
ocode.writeUsage(listfile)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Rope usage: %3.2f seconds" % delta
assembler.info("Writing rope image listing...", source=False)
startTime = time.time()
print >>listfile
print >>listfile
print >>listfile, "Rope Image Listing"
print >>listfile, "------------------"
print >>listfile
ocode.writeListing(listfile)
if options.debug:
endTime = time.time()
delta = endTime - startTime
totalTime += delta
print "Rope image listing: %3.2f seconds" % delta
assembler.info("Done.", source=False)
listfile.close()
symtabfile.close()
binfile.close()
if logfile:
logfile.close()
if options.debug:
print "Total time: %3.2f seconds" % totalTime
print "Done."