def RunProgram(self, debugging = False):
'''Run the program contained in the store.'''
self.__accumulator = Register.Register(0)
running = True
instructionCount = 0
self.__ci = Register.Register(0)
self.Print()
print '\nExecuting program:'
while running:
#
# First, increment CI (the program counter).
#
self.IncrementCI()
#
# Extract the store line given by CI from memory and put it in PI.
#
storeLineNumber = self.ReverseBits(self.LineNumber(self.__ci.Value), 5)
self.__pi = self.__storeLines.GetLine(storeLineNumber)
#
# Decode the instruction.
#
instructionCount += 1
mnemonic, lineNumber = self.DecodeInstruction(self.__pi)
if ((mnemonic == 'STOP') or (mnemonic == 'CMP')):
instruction = mnemonic
else:
instruction = '{} {}'.format(mnemonic, lineNumber)
print '{:-5} - {:02}: {}'.format(instructionCount, storeLineNumber, instruction)
#
# Execute the instruction.
#
if (mnemonic == 'JMP'):
self.__ci = Register.Register(self.__storeLines.GetLine(lineNumber).Value)
elif (mnemonic == 'JRP'):
self.__ci = self.Add(self.__ci, self.__storeLines.GetLine(lineNumber))
elif (mnemonic == 'LDN'):
line = self.__storeLines.GetLine(lineNumber)
negatedValue = self.ReverseBits(line.Value, 32) * -1
self.__accumulator.Value = self.ReverseBits(negatedValue, 32)
elif (mnemonic == 'STO'):
self.__storeLines.SetLine(lineNumber, Register.Register(self.__accumulator.Value))
elif ((mnemonic == 'SUB') or (mnemonic == '---')):
self.__accumulator = self.Sub(self.__accumulator, self.__storeLines.GetLine(lineNumber))
elif (mnemonic == 'CMP'):
if (self.__accumulator.Value & 0x1):
self.IncrementCI()
elif (mnemonic == 'STOP'):
running = False
else:
raise ValueError
if (running and debugging):
self.Print()
command = raw_input()
if (command == 'stop'): return
self.Print()
print 'Executed {} instruction(s)'.format(instructionCount)
def __init__(self, size=32):
'''Construct a new StoreLines object with the specified number of lines
in the store. The default number of lines is 32, the same as the SSEM.'''
if ((size > 0) and (size < MAX_STORE_SIZE)):
self.__storeLines = [Register.Register() for x in range(size)]
else:
raise ValueError
class TestBot:
#symbols = Symbol.Symbol("ES\H20.CM", "symbol")
symbols = Symbol.Symbol("Earnings_2020-02-04.csv", "file")
Register.Register(
"TOS",
"5555",
)
def __init__(self, master, file_name, input_info, output_info,
duration_estimate):
self.master = master
border_width = 15
self.canvas_width = master.winfo_width()
self.canvas_height = master.winfo_height()
self.output_info = output_info
arrow_width = self.canvas_height / 200
border = 0
#processor must be initialized first
OutTop.OutTop(master, self.canvas_width, self.canvas_height, border,
border_width)
OutBottom.OutBottom(master, self.canvas_width, self.canvas_height,
border, border_width)
OutLeft.OutLeft(master, self.canvas_width, self.canvas_height, border,
border_width)
OutRight.OutRight(master, self.canvas_width, self.canvas_height,
border, border_width)
self.processor = Processor.Processor(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.wheel = Wheel.Wheel(master, self.canvas_width, self.canvas_height,
border, arrow_width)
self.register = Register.Register(master, self.canvas_width,
self.canvas_height, border,
self.processor.exit_height,
arrow_width)
self.memory = Memory.Memory(master, self.canvas_width,
self.canvas_height, border)
self.memory_op = MemoryOp.MemoryOp(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.cable = Cable.Cable(master, self.canvas_width, self.canvas_height,
arrow_width, border,
self.processor.entry_width,
self.memory_op.entry_width,
self.wheel.exit_height, self)
self.controls = Controls.Controls(master, self.canvas_width,
self.canvas_height, self, input_info,
duration_estimate)
## TODO : MEANINGFUL EXCEPTIONS
# file_name = sys.argv[1]
self.command_sequence = []
memory_preset = []
input_file = open(file_name, 'r')
for line in input_file:
line = line.strip()
if line.strip().startswith('#') or line == '':
continue
elif line.strip().startswith('['):
memory_preset = line[1:-1].split(',')
else:
self.command_sequence.append(line.strip().upper())
self.memory.init(memory_preset, self.command_sequence)
self.wheel.init(self.command_sequence)
input_file.close()
def __register_to_redis(self):
try:
rgtr = Register(self.myIP)
task = Tasks(self.myIP)
except Exception as e:
self.__error_handle(
{
"error":{
"title": "__register_to_redis",
"message": e
}
}
)
self.__stop(internal=True)
else:
startTime = datetime.today().strftime("%Y-%m-%d %H-%M-%S")
resp = rgtr.register(self.myIP, startTime)
if "error" in resp:
self.__error_handle(resp)
self.__stop(internal=True)
else:
self.logger.info("Redis registered")
resp = task.set_change()
if "error" in resp:
self.__error_handle(resp)
def create_app_register(aName,
aSize,
aIndex,
aType,
aClass,
aBoot,
aAltPhysReg=None):
new_reg = Register(
**{
'name': aName,
'length': aSize,
'index': aIndex,
'type': aType,
'class': aClass,
'boot': aBoot
})
new_field = RegisterField(aName)
if aAltPhysReg is not None:
new_field.mPhysicalRegister = aAltPhysReg # Alternative physical register specified.
else:
new_field.mPhysicalRegister = aName
new_bit_field = BitField(aSize, 0)
new_field.mBitFields.append(new_bit_field)
new_reg.addRegisterFieldInOrder(new_field)
return new_reg
def Assembler(fileName, storeLines):
'''Open the specified file and convert the assembler instructions into
binary and save into the storeLines.'''
with open(fileName, "r") as source:
lineNumber = 0
for line in source:
lineNumber += 1
words = line.rstrip('\n').split()
if (words[0] != '--'):
sl = int(words[0].strip(':'))
m = words[1].upper()
if (m == 'NUM'):
store = ReverseBits(int(words[2]))
else:
i = next((i for i, x in enumerate(instructions)
if (x['mnemonic'] == m)), None)
if (i == None):
print('Cannot process line {}: {}'.format(
lineNumber, line))
exit()
else:
opcode = instructions[i]['opcode']
if (m in ['STOP', 'HLT', 'CMP', 'SKN']):
ln = 0
else:
ln = int(words[2])
store = ReverseBits(ln | (opcode << 13))
storeLines.SetLine(sl, Register.Register(store))
def create_app_register(aName,
aSize,
aIndex,
aType,
aClass,
aBoot,
aAltPhysReg=None):
new_reg = Register(
**{
"name": aName,
"length": aSize,
"index": aIndex,
"type": aType,
"class": aClass,
"boot": aBoot,
})
new_field = RegisterField(aName)
if aAltPhysReg is not None:
new_field.mPhysicalRegister = aAltPhysReg
else:
new_field.mPhysicalRegister = aName
new_bit_field = BitField(aSize, 0)
new_field.mBitFields.append(new_bit_field)
new_reg.addRegisterFieldInOrder(new_field)
return new_reg
def __init__(self, *args, **kwargs):
global reg, enum, bdd
tk.Frame.__init__(self, *args, **kwargs)
# Setup 4 frames for the 4 pages of the application
reg = Register(self)
enum = List(self)
stat = Stats(self)
admin = Admin(self)
call.id_call.enum = enum
bdd = Page.get_bdd(enum)
call.id_call.bdd = bdd
button_frame = tk.Frame(self)
container = tk.Frame(self)
button_frame.pack(side="top", fill='x', expand=False)
container.pack(side="top", fill="both", expand=True)
# Place all the 4 frames on the main windows, they are superimposed
reg.place(in_=container, x=0, y=0, relwidth=1, relheight=1)
enum.place(in_=container, x=0, y=0, relwidth=1, relheight=1)
stat.place(in_=container, x=0, y=0, relwidth=1, relheight=1)
admin.place(in_=container, x=0, y=0, relwidth=1, relheight=1)
# Setup all the 4 buttons to switch between the 4 pages
reg_b = tk.Button(button_frame,
text="Inscription",
width=19,
height=1,
command=reg.lift,
font=BIG_FONT)
enum_b = tk.Button(button_frame,
text="Liste",
width=19,
height=1,
command=enum.lift_list,
font=BIG_FONT)
stat_b = tk.Button(button_frame,
text="Statistiques",
width=20,
height=1,
command=stat.lift_stats,
font=BIG_FONT)
admin_b = tk.Button(button_frame,
text="Administration",
width=20,
height=1,
command=admin.ask_password,
font=BIG_FONT)
# Place all the buttons on the main windows
reg_b.grid(row=0, column=0)
enum_b.grid(row=0, column=1)
stat_b.grid(row=0, column=2)
admin_b.grid(row=0, column=3)
reg.show()
def passRequest():
reg = Register()
dataFromMessenger = request.get_json(
) # ge/home/test"t json data from naver talk talk
SR = dataFromMessenger['textContent']['text']
rq = reg.fetchRequest(SR)
if rq == False:
return "NO"
return rq
def bootUpMobile():
# make manager
reg = Register()
dataFromMessenger = request.get_json(
) # get json data from naver talk talk
SR = dataFromMessenger['textContent']['text']
reg.openDB()
UK = reg.getUserFromSerial(SR)
reg.closeDB()
return UK
def sign_up(temp_user_key):
if request.method == 'GET':
return render_template('regist.html')
else :
serial = request.form['serial']
print(serial, temp_user_key)
reg = Register()
reg.insertUserData(temp_user_key, serial)
return render_template("regist_success.html"), 200
def create_quad_precision_app_register(aIndex, aRegSize):
q_reg = Register(**{'name':"Q%d" % aIndex, 'length':128, 'index':aIndex, 'type':"FPR", 'class':"LargeRegister", 'boot':0})
numberOfReg = 128 // aRegSize
for i in range(0, numberOfReg):
q_field = RegisterField("Q%d_%d" % (aIndex, i))
q_field.mPhysicalRegister = "f%d_%d" % (aIndex, i)
q_bfield = BitField(aRegSize, 0)
q_field.mBitFields.append(q_bfield)
q_reg.addRegisterFieldInOrder(q_field)
return q_reg
def create_vector_app_register(aIndex, aRegSize):
v_reg = Register(**{'name':"v%d" % aIndex, 'length':512, 'index':aIndex, 'type':"VECREG", 'class':"LargeRegister", 'boot':0x3000})
numberOfReg = 512 // aRegSize
for i in range(0, numberOfReg):
v_field = RegisterField("v%d_%d" % (aIndex, i))
v_field.mPhysicalRegister = "v%d_%d" % (aIndex, i)
v_bfield = BitField(aRegSize, 0)
v_field.mBitFields.append(v_bfield)
v_reg.addRegisterFieldInOrder(v_field)
return v_reg
def __init__(self):
self.operator_list = ['+', '-', '*', '/']
self.operand_list = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c',
'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
self.sequence = input("Enter the Sequance : ")
self.r = Register()
def __init__(self, m, g1, g2, g3):
self.m = 2
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.g1pol = self.octal2poly(g1)
self.g2pol = self.octal2poly(g2)
self.g3pol = self.octal2poly(g3)
self.register = Register.Register(m)
def my_handler(event, context):
myReg = Register()
try:
name = event['name']
message = 'Hello {} from lambda!'.format(name)
vmSpec = myReg.profileVM()
vmSpec['message'] = message
vmSpec['name'] = name
return vmSpec
except:
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
logger.error('THE INPUT JSON DOESN\'T HAVE SPECIFIED FIELD.')
return {'error': 'please check log and input JSON'}
def create_double_precision_app_register(aIndex, aRegSize):
d_reg = Register(**{'name':"D%d" % aIndex, 'length':64, 'index':aIndex, 'type':"FPR", 'class':None, 'boot':0x3000})
numberOfReg = 64 // aRegSize
for i in range(0, numberOfReg):
if numberOfReg > 1:
d_field = RegisterField("D%d_%d" % (aIndex, i))
else:
d_field = RegisterField("D%d" % aIndex)
d_field.mPhysicalRegister = "f%d_%d" % (aIndex, i)
d_bfield = BitField(aRegSize, 0)
d_field.mBitFields.append(d_bfield)
d_reg.addRegisterFieldInOrder(d_field)
return d_reg
def signup():
if request.method=="GET":
return render_template("signup.html")
else:
if request.form['pass'] != request.form['confirmpass']:
return render_template("signup.html", NOTLOGGEDIN = "Error: 'Password' and 'Confirm Password' do not match.")
elif len(request.form['user']) < 4 or len(request.form['pass']) < 8:
return render_template("signup.html", NOTLOGGEDIN = "Error: 'Username' must be at least 4 characters and 'Password' must be at least 8 characters.")
else:
uname = request.form['user']
passw = request.form['pass']
button = request.form['button']
if Register.Register(uname, passw):
return redirect(url_for("login"))
else:
return render_template("signup.html", NOTLOGGEDIN = "Error: Username already exists")
def main():
userInput = 0
# Variable holds the user menu selection
registerItem = Register.Register()
# Create a Register object via call to Register from an external module
while userInput != 6: # Loop while user does not choose to exit
print("1. Add new item to cart")
print("2. View all items in cart")
print("3. Remove item from cart")
print("4. View total")
print("5. Checkout and pay")
print("6. Exit Program")
userInput = int(input())
# Get user input and convert it to an integer to be used for the if/else statements
if userInput == 1: # OPTION 1: Add new item to cart
addCart(registerItem)
# Pass the Register object as a parameter
elif userInput == 2: # OPTION 2: View all items in cart
print("\nItems in cart\n")
registerItem.show_items()
# Call the Register object's show item method
print()
elif userInput == 3: # OPTION 3: Remove item from cart
removeItem(registerItem)
# Call the remove item method and pass the Register object as a parameter
elif userInput == 4: # OPTION 4: View the total cost of the cart
print("\nTotal: $", end="")
registerItem.get_total()
# Call the Register object's method to calculate the total
print()
elif userInput == 5: # OPTION 5: Checkout and pay
print("\nTransaction successful")
print("Thank you for shopping with us\n")
registerItem.clear()
# Clear the Register object's cart and total list
else: # User chooses to exit
print("\nGood-bye!\n")
registerItem.clear()
def create_vector_app_register(aIndex):
v_reg = Register(
**{
'name': "V%d" % aIndex,
'length': 128,
'index': aIndex,
'type': "VECREG",
'class': "LargeRegister",
'boot': 0x3000
})
for i in range(0, 2):
v_field = RegisterField("V%d_%d" % (aIndex, i))
v_field.mPhysicalRegister = "v%d_%d" % (aIndex, i)
v_bfield = BitField(64, 0)
v_field.mBitFields.append(v_bfield)
v_reg.addRegisterFieldInOrder(v_field)
return v_reg
def sign_up(temp_user_key):
if request.method == 'GET':
return render_template('regist.html')
else:
#get data from form
serial = request.form['serial']
email = request.form['email']
location = request.form['location']
reg = Register()
#get user key from temp id
userKey = reg.getUserKeyByTempID(temp_user_key)
#regist user
reg.insertUserData(userKey, serial, email, location)
#delete temp information
reg.deleteTempID(temp_user_key)
# push mobile to notify update user
reg.insertUserRequest(userKey, "UPDATE")
return render_template("regist_success.html"), 200
def create_quad_precision_app_register(aIndex, aRegSize):
q_reg = Register(
**{
"name": "Q%d" % aIndex,
"length": 128,
"index": aIndex,
"type": "FPR",
"class": "LargeRegister",
"boot": 0,
})
numberOfReg = 128 // aRegSize
for i in range(0, numberOfReg):
q_field = RegisterField("Q%d_%d" % (aIndex, i))
q_field.mPhysicalRegister = "f%d_%d" % (aIndex, i)
q_bfield = BitField(aRegSize, 0)
q_field.mBitFields.append(q_bfield)
q_reg.addRegisterFieldInOrder(q_field)
return q_reg
def create_vector_app_register(aIndex, aRegSize):
v_reg = Register(
**{
"name": "v%d" % aIndex,
"length": 512,
"index": aIndex,
"type": "VECREG",
"class": "LargeRegister",
"boot": 0x3000,
})
numberOfReg = 512 // aRegSize
for i in range(0, numberOfReg):
v_field = RegisterField("v%d_%d" % (aIndex, i))
v_field.mPhysicalRegister = "v%d_%d" % (aIndex, i)
v_bfield = BitField(aRegSize, 0)
v_field.mBitFields.append(v_bfield)
v_reg.addRegisterFieldInOrder(v_field)
return v_reg
def __treading(self):
try:
task = Tasks(self.myIP)
mem = Members(self.myIP)
algor = Algorithm()
rgtr = Register(self.myIP)
rsync = RSYNC(self.myIP)
except Exception as e:
self.__error_handle(
{
"error":{
"title": "__threading",
"message": e
}
}
)
else:
self.__members_handler(mem, rgtr, task)
self.__task_allocation(task, algor)
self.__task_announcement(task)
def get_dict_dst_src(self):
res = {}
if self.__name == 'gets':
res[Memory(self.__args[0], UNLIMITED_LENGTH)] = USER_INPUT
## implement for fun =))
# elif self.__name == 'printf':
# res[STD_OUTPUT] = Memory(self.__args[0], DEFAULT_STRLEN)
elif self.__name == 'read':
if self.__args[0].get_value() == 0:
#fd = 0 -> stdin
res[Memory(self.__args[1], self.__args[2].get_value())] = USER_INPUT
elif self.__name == 'atoi':
if 'eax' not in globals():
globals()['eax'] = Register('eax')
res[eax] = Memory(self.__args[0], DEFAULT_STRLEN)
return res
def click(self):
if len(self.lineEdit.text()) == 0 or len(
self.lineEdit_2.text()) == 0 or len(
self.lineEdit_3.text()) == 0:
msgBox = QtGui.QMessageBox()
msgBox.setText("Some fields have not been filled out!")
msgBox.exec_()
elif (str(self.lineEdit_3.text()).isdigit()):
msgBox = QtGui.QMessageBox()
msgBox.setText("Numbers not allowed in passphrase!")
msgBox.exec_()
else:
register = Register(str(self.lineEdit.text()),
str(self.lineEdit_2.text()),
str(self.lineEdit_3.text()),
self.comboBox_2.currentText(),
self.comboBox.currentText())
register.folderCheck()
register.capImg()
msgBox = QtGui.QMessageBox()
msgBox.setText("Successfully registered user.")
msgBox.exec_()
def create_double_precision_app_register(aIndex, aRegSize):
d_reg = Register(
**{
"name": "D%d" % aIndex,
"length": 64,
"index": aIndex,
"type": "FPR",
"class": None,
"boot": 0x3000,
})
numberOfReg = 64 // aRegSize
for i in range(0, numberOfReg):
if numberOfReg > 1:
d_field = RegisterField("D%d_%d" % (aIndex, i))
else:
d_field = RegisterField("D%d" % aIndex)
d_field.mPhysicalRegister = "f%d_%d" % (aIndex, i)
d_bfield = BitField(aRegSize, 0)
d_field.mBitFields.append(d_bfield)
d_reg.addRegisterFieldInOrder(d_field)
return d_reg
def __deregister_to_redis(self):
try:
rgtr = Register(self.myIP)
task = Tasks(self.myIP)
except Exception as e:
self.__error_handle(
{
"error":{
"title": "__deregister_to_redis",
"message": e
}
}
)
else:
resp = rgtr.deregister(self.myIP)
if "error" in resp:
self.__error_handle(resp)
else:
self.logger.info("Redis deregistered")
resp = task.set_change()
if "error" in resp:
self.__error_handle(resp)
self.__clear_crontab()
def __init__(self):
self.register = Register.Register()
self.reg_pc = Register.Register(amount=1, content=0)
self.memory = Memory.Memory()
self.start()
