def click_run(self):
self.console.setText("")
if self.select == 'c':
try:
self.code['c'] = self.editor.get_text()
self.code['asm'] = Compiler().parse(self.code['c'])
self.code['coe'] = Assembler().parse(self.code['asm'])
self.code['debug'] = self.get_debug_code()
if str(self.console.toPlainText()) == "":
print 'successful complie c code!'
else:
print 'failed complie c code!!!'
except:
print traceback.format_exc()
print 'failed complie c code!!!'
elif self.select == 'asm':
try:
self.code['asm'] = self.editor.get_text()
self.code['coe'] = Assembler().parse(self.code['asm'])
self.code['debug'] = self.get_debug_code()
if str(self.console.toPlainText()) == "":
print 'successful complie asm code!'
else:
print 'failed complie asm code!!!'
except:
print traceback.format_exc()
print 'failed complie asm code!!!'
def load_button(self, w):
tb = self.textEditor.get_buffer()
string = tb.get_text(tb.get_start_iter(), tb.get_end_iter(), False)
asm = Assembler()
try:
asm.Lex(string)
try:
addr = int(self.loadaddr.get_text(), 16)
except:
addr = 0
asm.Parse(addr)
for byte_list in asm.bytes_list:
ad = byte_list["address"]
i = 0
for byte in byte_list["bytes"]:
ram.Write(ad + i, byte)
i += 1
strlbl = ""
for lbl in asm.labels:
strlbl += "\n" + lbl + " : " + hex(asm.labels[lbl])
self.lblLabel.set_text(strlbl)
self.Clear()
print("Assembled and loaded succesfully")
return True
except Exception as ex:
self.lblLabel.set_text("")
self.Clear()
print("Assembling Error: ")
print("=======")
print(ex)
print("at line: \n\t" + asm.line + "\nline no.: " +
str(asm.line_no))
return False
def setupAssembleMenu(self):
assembleMenu = QMenu('汇编(&A)', self)
self.menuBar().addMenu(assembleMenu)
self.assembler = Assembler() # 创建汇编器对象
assembleMenu.addAction('汇编(&A)', self.assemble, 'F10') # 对当前代码实行汇编操作
assembleMenu.addAction('反汇编(&D)', self.disassemble,
'F11') # 对当前代码实行反汇编操作
def main():
m = argparse.ArgumentParser()
m.add_argument("--input", "-i", type=str)
m.add_argument("--output", "-o", type=str)
options = m.parse_args()
asm = AsmEncoder()
tree = asm.parse(options.input)
coded = Assembler(tree)
with open(options.output, "wb") as f:
f.write(coded.state)
def __init__(self, code, debug=False):
"""Takes a program, runs it through the assembler, and converts that
code to bytecode.
"""
self.variables = {}
assembly = str(Assembler(code, debug))
self.bytecode = self.comp(assembly)
# If debugging is enabled, set it up.
if debug:
self.out = open(os.path.join(os.getcwd(), "compiler_output.txt"), "w")
self.out.write(self.bytecode)
self.out.close()
def Export(self, filename, withAsm=False):
fp = open(filename, 'w')
tb = self.textEditor.get_buffer()
string = tb.get_text(tb.get_start_iter(), tb.get_end_iter(), False)
asm = Assembler()
try:
asm.Lex(string)
try:
addr = int(self.loadaddr.get_text(), 16)
except:
addr = 0
asm.Parse(addr)
for byte_list in asm.bytes_list:
ad = byte_list["address"]
i = 0
if withAsm:
fp.write(byte_list["asm"] + "\t;")
else:
fp.write('{:04x}'.format(ad) + ": ")
for byte in byte_list["bytes"]:
fp.write('{:02x}'.format(byte) + " ")
i += 1
if not withAsm:
fp.write("\t\t;" + byte_list["asm"])
fp.write("\n")
strlbl = ""
for lbl in asm.labels:
strlbl += "\n" + lbl + " : " + hex(asm.labels[lbl])
self.lblLabel.set_text(strlbl)
self.Clear()
print("Assembled and exported succesfully")
except Exception as ex:
self.lblLabel.set_text("")
self.Clear()
print("Assembling Error: ")
print("=======")
print(ex)
print("at line: \n\t" + asm.line + "\nline no.: " +
str(asm.line_no))
fp.close()
def main():
teste = './teste.txt'
compMemoria = Memoria()
motor = MotorDeEventos()
assembler = Assembler()
programCounter = motor.programCounter
assembler.primeiroPasso(teste)
instruCodMaq = assembler.segundoPasso(teste)
compMemoria.loader(instruCodMaq)
motor.acumulador = 5
compMemoria.memoria[200] = '0x0002'
compMemoria.memoria[210] = '0x0003'
compMemoria.memoria[220] = '0x0005'
compMemoria.memoria[100] = 7
#compMemoria.memoria[130] = 2
motor.fluxoEventos(compMemoria)
print()
print("Acumulador:")
print(motor.acumulador)
print()
print("Posição 0x100 da memória:")
print(compMemoria.memoria[100])
print()
print("Memoria:")
print(compMemoria.memoria)
import sys
from pathlib import Path
from Assembler import Assembler
from c_instruction_map import comp, dest, jump, symbols
try:
relative_path = Path(sys.argv[1])
except IndexError:
relative_path = Path(
input("type file path from projects. eg \"06/add/Add.asm\" :"))
PROJECT_PATH = Path("D:/nand2tetris/projects")
PROGRAM_PATH = PROJECT_PATH / relative_path
HACK_PATH = PROGRAM_PATH.parent / (PROGRAM_PATH.stem + ".hack")
if __name__ == "__main__":
with open(PROGRAM_PATH) as asm_file:
assembler_instance = Assembler(comp, dest, jump, symbols, asm_file)
assembly = assembler_instance.extract_assembly_from_file()
assembler_instance.load_reference_to_symbols_table(assembly)
assembly_without_references = assembler_instance.remove_references(
assembly)
hack_binary = assembler_instance.assemble(assembly_without_references)
with open(HACK_PATH, "w") as hack_file:
hack_file.writelines(hack_binary)
def main():
args = parseArgs()
assembler = Assembler(args)
assembler.process()
from Assembler import Assembler
def print_usage():
'''
Prints the usage for this script.
'''
print ('Usage: python sbasm.py <input file name> <output file name, default a.mif>')
if __name__ == "__main__":
argc = len(sys.argv)
if argc >= 4:
print ('ERROR: Too many arguments.')
print_usage()
elif argc <= 1:
print ('ERROR: Too few arguments.')
print_usage()
else:
# Parse the in and out file names from the arguments.
# Default the output filename to a.mif.
in_filename = sys.argv[1]
out_filename = 'a.mif'
if argc > 2:
out_filename = sys.argv[2]
# Create the assembler and assemble.
a = Assembler(in_filename, out_filename)
a.assemble()
from CPU import CPU
from Assembler import Assembler
Assembler('example/example.asm', 'example/example.bin')
CPU('example/example.bin')
def Solve(self):
'''
This method builds System Matrix and gets Solution
'''
if self.SimulationContext.Id != self.NetworkMesh.Id:
raise self.SimulationContext.XMLIdError()
try:
self.TimeStep = self.SimulationContext.Context['timestep']
self.SquareTimeStep = self.TimeStep * self.TimeStep
except KeyError:
print "Error, Please set timestep in Simulation Context XML File"
raise
try:
self.Period = self.SimulationContext.Context['period']
self.TimeStepFreq = int(self.Period / self.TimeStep)
except KeyError:
print "Error, Please set period in Simulation Context XML File"
raise
try:
self.Cycles = self.SimulationContext.Context['cycles']
self.NumberOfIncrements = (self.Cycles * self.TimeStepFreq)
except KeyError:
print "Error, Please set cycles number in Simulation Context XML File"
raise
history = []
assembler = Assembler()
assembler.SetNetworkMesh(self.NetworkMesh)
assembler.SetBoundaryConditions(self.BoundaryConditions)
info = {
'dofmap': assembler.DofMap,
'solution': None,
'incrementNumber': self.IncrementNumber,
'history': history
}
self.Evaluator.SetInfo(info)
self.PrescribedPressures = assembler.AssembleBoundaryConditions(
self.SimulationContext)
self.LinearZeroOrderGlobalMatrix, self.LinearFirstOrderGlobalMatrix, self.LinearSecondOrderGlobalMatrix = \
assembler.AssembleInit(self.SimulationContext, self.Evaluator)
self.ZeroOrderGlobalMatrix = assembler.ZeroOrderGlobalMatrix
self.FirstOrderGlobalMatrix = assembler.FirstOrderGlobalMatrix
self.SecondOrderGlobalMatrix = assembler.SecondOrderGlobalMatrix
NumberOfGlobalDofs = assembler.GetNumberOfGlobalDofs(
) # number of dofs
self.UnknownPressures = arange(0, NumberOfGlobalDofs).reshape(
NumberOfGlobalDofs, 1) # unknown pressures
self.UnknownPressures = delete(self.UnknownPressures,
s_[self.PrescribedPressures[:, 0]],
axis=0)
PressuresMatrix = zeros((NumberOfGlobalDofs, self.NumberOfIncrements))
self.p = zeros((NumberOfGlobalDofs, 1))
self.pt = zeros((NumberOfGlobalDofs, 1))
self.ptt = zeros((NumberOfGlobalDofs, 1))
self.dp = zeros((NumberOfGlobalDofs, 1))
self.ddp = zeros((NumberOfGlobalDofs, 1))
self.dpt = zeros((NumberOfGlobalDofs, 1))
self.ddpt = zeros((NumberOfGlobalDofs, 1))
self.fe = zeros((NumberOfGlobalDofs, 1))
self.fet = zeros((NumberOfGlobalDofs, 1))
self.dfe = zeros((NumberOfGlobalDofs, 1))
self.dfet = zeros((NumberOfGlobalDofs, 1))
self.fi = zeros((NumberOfGlobalDofs, 1))
self.fit = zeros((NumberOfGlobalDofs, 1))
self.sumv = zeros((NumberOfGlobalDofs, 1))
sumvbk = zeros((NumberOfGlobalDofs, 1))
nonLinear = False
for el in self.NetworkMesh.Elements:
if el.IsNonLinear() == True:
nonLinear = True
break
while self.IncrementNumber <= self.NumberOfIncrements:
icc = (self.IncrementNumber % self.TimeStepFreq)
if icc == 0:
icc = self.TimeStepFreq
#for flow in self.BoundaryConditions.elementFlow:
for el in self.BoundaryConditions.elementFlow:
if self.steady == True:
self.Flow = assembler.BoundaryConditions.GetSteadyFlow(
el, self.TimeStep, icc * self.TimeStep)
else:
self.Flow = assembler.BoundaryConditions.GetTimeFlow(
el, icc * self.TimeStep)
self.fe[assembler.FlowDof[el.Id]] = self.Flow
CoeffRelax = 0.9
nltol = self.nltol
self.pi = None
pI = None
sumvbk[:, :] = self.sumv[:, :]
counter = 0
while True:
#Build the algebric equation system for the increment
SystemMatrix = (
2.0 / self.TimeStep
) * self.SecondOrderGlobalMatrix + self.FirstOrderGlobalMatrix + (
self.TimeStep /
2.0) * self.ZeroOrderGlobalMatrix #system matrix
RightVector = self.fe + (2.0 / self.TimeStep) * dot(
self.SecondOrderGlobalMatrix, (self.pt)) + dot(
self.SecondOrderGlobalMatrix, (self.dpt)) - dot(
self.ZeroOrderGlobalMatrix,
(self.sumv)) - (self.TimeStep / 2.0) * dot(
self.ZeroOrderGlobalMatrix,
(self.pt)) # right hand side vector
#The reduced (partioned) system of equations is generated.
RightVector[:, :] = RightVector[:, :] - dot(
SystemMatrix[:, self.PrescribedPressures[:, 0]],
self.PrescribedPressures[:, 1:])
SystemMatrix = SystemMatrix[:, s_[self.UnknownPressures[:, 0]]]
if SystemMatrix.shape[0] > 0.0:
SystemMatrix = SystemMatrix[
s_[self.UnknownPressures[:, 0]], :]
RightVector = RightVector[s_[self.UnknownPressures[:, 0]], :]
#Unknown nodal point values are solved from this system.
# Prescribed nodal values are inserted in the solution vector.
Solution = solve(SystemMatrix,
RightVector) # solutions, unknown pressures
self.p[self.UnknownPressures, 0] = Solution[:, :]
self.p[self.PrescribedPressures[:, 0],
0] = self.PrescribedPressures[:, 1]
#Calculating derivatives.
#Calculating internal nodal flow values.
self.dp = dot((2.0 / self.TimeStep),
(self.p - self.pt)) - self.dpt
self.ddp = dot((4.0 / self.SquareTimeStep),
(self.p - self.pt)) - dot(
(4.0 / self.TimeStep), self.dpt) - self.ddpt
self.sumv = sumvbk + dot((self.TimeStep / 2.0),
(self.pt + self.p))
self.fi = dot(self.SecondOrderGlobalMatrix, (self.dp)) + dot(
self.FirstOrderGlobalMatrix,
(self.p)) + dot(self.ZeroOrderGlobalMatrix, (self.sumv))
if not nonLinear:
break
if self.pi == None:
self.pi = zeros((NumberOfGlobalDofs, 1))
self.pi[:, :] = self.pt[:, :]
pI = CoeffRelax * self.p + self.pi * (1.0 - CoeffRelax)
self.p[:, :] = pI[:, :]
den = norm(self.pi, Inf)
if den < 1e-12:
den = 1.0
nlerr = norm(self.p - self.pi, Inf) / den
info = {
'dofmap': assembler.DofMap,
'solution': [self.p, self.pt, self.ptt],
'incrementNumber': self.IncrementNumber,
'history': history
}
self.Evaluator.SetInfo(info)
assembler.Assemble(self.SimulationContext, self.Evaluator,
self.LinearZeroOrderGlobalMatrix,
self.LinearFirstOrderGlobalMatrix,
self.LinearSecondOrderGlobalMatrix)
self.ZeroOrderGlobalMatrix = assembler.ZeroOrderGlobalMatrix
self.FirstOrderGlobalMatrix = assembler.FirstOrderGlobalMatrix
self.SecondOrderGlobalMatrix = assembler.SecondOrderGlobalMatrix
#Dynamic nonlinear relaxing coefficient
if counter == 100:
print "relaxing..."
print nlerr, nltol, CoeffRelax
counter = 0
self.pi[:, :] = None
self.sumv[:, :] = sumvbk[:, :]
CoeffRelax *= 0.6
nltol *= 0.95
if nlerr < nltol:
nltol = self.nltol
counter = 0
break
counter += 1
self.pi[:, :] = self.p[:, :]
self.ptt[:, :] = self.pt[:, :]
self.pt[:, :] = self.p[:, :]
self.dpt[:, :] = self.dp[:, :]
self.ddpt[:, :] = self.ddp[:, :]
self.fet[:, :] = self.fe[:, :]
self.fit[:, :] = self.fi[:, :]
PressuresMatrix[:, (self.IncrementNumber - 1)] = self.p[:, 0]
history.insert(0, self.IncrementNumber)
history = history[:3]
if self.steady == True:
self.MinimumIncrementNumber = 0.01 * self.NumberOfIncrements
if norm(
self.fi - self.fe, Inf
) < self.convergence and self.IncrementNumber > self.MinimumIncrementNumber:
self.IncrementNumber = self.NumberOfIncrements
else:
pass
if self.IncrementNumber == ceil(0.05 * self.NumberOfIncrements):
print "->5%"
if self.IncrementNumber == ceil(0.25 * self.NumberOfIncrements):
print "->25%"
if self.IncrementNumber == ceil(0.5 * self.NumberOfIncrements):
print "->50%"
if self.IncrementNumber == ceil(0.70 * self.NumberOfIncrements):
print "->70%"
if self.IncrementNumber == ceil(0.90 * self.NumberOfIncrements):
print "->90%"
if self.IncrementNumber == ceil(0.99 * self.NumberOfIncrements):
print "->99%"
self.IncrementNumber = self.IncrementNumber + 1
self.EndIncrementTime = self.EndIncrementTime + self.TimeStep # increment
info = {
'dofmap': assembler.DofMap,
'solution': [self.p, self.pt, self.ptt],
'incrementNumber': self.IncrementNumber,
'history': history,
'allSolution': PressuresMatrix
}
self.Evaluator.SetInfo(info)
self.Solutions = PressuresMatrix
return PressuresMatrix
def assembler():
global file_name
global content
assem = Assembler(content)
assem.traverse(assem.tree.root)
assem.ass_file_handler.generate_ass_file(file_name)
Default_Path_For_mem = "F:/3rd-CSE/PythonScripts/Automated_Test"
# The path of the assembly code to be passed to the assembler
Path_For_Assembly = 'F:/3rd-CSE/mips_processor2019/Test_cases/assembly_source'
# The path for the correct test cases to be compared with the generated ones
Path_For_Test = 'F:/3rd-CSE/Test_cases/output_of_modelsim'
# Counter for the current iteration in the test files
test_number = 1
folder = os.fsencode(Path_For_Assembly)
filenames = []
test_result = []
# index = 0
for file in os.listdir(folder):
# print(index)
filename = os.fsdecode(file)
x = Path_For_Assembly + '/' + filename
newline = Assembler(x)
# The file where the binary is generated
newfile_name = "test.txt"
newfile_name = open(newfile_name, "w+")
for line in newline:
newfile_name.write(line)
newfile_name.close()
# index = index + 1
os.chdir(
'F:/3rd-CSE/1stTerm/COIIProjects/Modeltech_pe_edu_10.4a/win32pe_edu')
os.system(
'vsim -c -do "run -all" F:/3rd-CSE/1stTerm/COIIProjects/Modeltech_pe_edu_10.4a/examples/work.MIPS_cpu'
)
os.chdir('F:/3rd-CSE/PythonScripts/Automated_Test')
#this previous part runs the modelsim giving it the binary file
local_mem_file = Default_Path_For_mem + '/' + "mem.txt"
from Assembler import Assembler;
file = str(input("Informe o nome do arquivo que deseja converter: ")).strip();
obj = Assembler(file);
obj.StepOne();
obj.Print();
obj.StepTwo();
exit(-1)
if VERBOSE:
print 'Parsed Text Section' + inreportStreamName + ':'
import json
print json.dumps(parsed['instructions'], indent=4)
print 'Parsed Data Section' + inreportStreamName + ':'
print json.dumps(parsed['data'], indent=4)
#pack for assembling
streams[streamName] = parsed
#################################
# assemble all parsed streams
#
assembler = Assembler(opts.archFile)
for streamName, result in assembler(streams).items():
#set names depending on stream name
reportStreamName = ' stream "%s"' % (
streamName) if streamName != '' else ''
inreportStreamName = ' in stream "%s"' % (
streamName) if streamName != '' else ''
#Error handling and message printing of the assembling
success, asm = result #assembler(parsed['instructions'], parsed['data'])
if success == False:
if VERBOSE:
print >> sys.stderr, 'Error while assembling' + reportStreamName
print >> sys.stderr, asm
exit(-1)
# elif cmd == "stbb":
# ppi.StrobeB()
# elif cmd == "show":
# print("")
# alu.Show()
# #print("\n")
# #ram.Show()
# print("\n")
# ppi.Show()
ram.ShowRange(parser.labels["TABLE"], parser.labels["TABLE"]+0x63)
alu.Show()
from Assembler import Assembler
parser = Assembler()
try:
#main()
filep = open("samples/testlbl.asm", "r")
asm = filep.read()
filep.close()
parser.Lex(asm)
parser.Parse()
#filep = open("random.bin", "w")
for bytes in parser.bytes_list:
print(hex(bytes["address"]))
for byte in bytes["bytes"]:
print(hex(byte))
# filep.write('{0:02x}'.format(byte) + "\n")
#filep.close()
def main():
input_file = 'Add.asm'
# initiate parser
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("-d",
"--data",
help="print sample data",
action="store_true")
arg_parser.add_argument("-c",
"--clean",
help="clear sample data",
action="store_true")
arg_parser.add_argument("-n",
"--normal",
help="normalize sample data",
action="store_true")
arg_parser.add_argument("-a",
"--assemble",
help="assemble sample data",
action="store_true")
arg_parser.add_argument("-f",
"--file",
help="assemble from file",
type=str,
required=False)
arg_parser.add_argument("-b",
"--write_bat_file",
help="write drag and drop .bat",
action="store_true")
# read arguments from the command line
args = arg_parser.parse_args()
# check for --data or -d
if args.data:
asm_parser = Parser(input_file)
asm_parser.print_data("d")
# check for --clean or -c
if args.clean:
asm_parser = Parser(input_file)
asm_parser.print_data("c")
# check for --normal or -n
if args.normal:
asm_parser = Parser(input_file)
asm_parser.print_data("n")
# check for --assemble or -a
if args.assemble:
asm_parser = Parser(input_file)
assembler = Assembler()
assembler.print_assembler_data("a", asm_parser.normalize_data())
# check for --file or -f
if args.file:
asm_parser = Parser(args.file)
assembler = Assembler()
assembler.write_to_file(args.file, asm_parser.normalize_data())
return
# check for --write_bat_file or -k
if args.write_bat_file:
if Path("Assembler.bat").is_file():
print("File already exists")
input()
else:
file_object = open("Assembler.bat", "w")
file_object.write("python \"%~dp0/Main.py\" -f %1\n\nrem cmd /k")
from Assembler import Assembler from SystemBuilder import ProcessorSystem sysbuilder = ProcessorSystem() assembler = Assembler(sysbuilder) assembler.readcommands() sysbuilder.run()
