def __init__(self, virt_r, descriptor, page_size, n):
self.virt_r = virt_r
self.descriptor = descriptor
self.attributes = Register(
descriptor.value,
software=(58, 55),
XN=(54, 54),
PXN=(53, 53),
contiguous_hint=(52, 52),
nG=(11, 11),
AF=(10, 10),
sh_10=(9, 8),
ap_21=(7, 6),
ns=(5, 5),
attr_index_20=(4, 2),
)
self.page_size = page_size
self.leaf = True
p = Register(output_address=(39, n), page_offset=(n - 1, 0))
p.output_address = self.descriptor.output_address
self.virt_r.add_field('rest', (n - 1, 0))
p.page_offset |= self.virt_r.rest
self.phys = p.value
def __init__(self, name, id, position=None, signal=device.SIGUSR2):
"""
Constructor.
@see Device.__init__()
@param position device position can be set from the User
"""
""" Create LCD registers"""
Reg0 = Register(name + "_REG0")
Reg1 = Register(name + "_REG1")
Reg2 = Register(name + "_REG2")
Reg3 = Register(name + "_REG3")
Reg4 = Register(name + "_REG4")
Reg5 = Register(name + "_REG5")
Reg6 = Register(name + "_REG6")
Reg7 = Register(name + "_REG7")
Reg8 = Register(name + "_REG8")
Reg9 = Register(name + "_REG9")
self.__reg0 = Reg0.name
self.__reg1 = Reg1.name
self.__reg2 = Reg2.name
self.__reg3 = Reg3.name
self.__reg4 = Reg4.name
self.__reg5 = Reg5.name
self.__reg6 = Reg6.name
self.__reg7 = Reg7.name
self.__reg8 = Reg8.name
self.__reg9 = Reg9.name
self._width = lcd_width
self._height = lcd_height
self._position = position
device.Device.__init__(
self, name, id, signal,
[Reg0, Reg1, Reg2, Reg3, Reg4, Reg5, Reg6, Reg7, Reg8, Reg9])
def __init__(self, parent=None):
super(Application, self).__init__(parent)
self.title = 'Zadanie projektowe nr 2'
screen_width = w32.GetSystemMetrics(0)
screen_height = w32.GetSystemMetrics(1)
self.width = 1024
self.height = 768
self.left = (screen_width - self.width) / 2
self.top = -30 + (screen_height - self.height) / 2
self.form_widget = None
self.regA = Register("AX")
self.regB = Register("BX")
self.regC = Register("CX")
self.regD = Register("DX")
self.program_code = QPlainTextEdit(self)
self.mode = -1
self.help_bios = None
self.step = False
self.pattern1 = re.compile(r"\d{1,3}\s\D{3}\s\S{2},\S{2}")
self.pattern2 = re.compile(r"\d{1,3}\s\D{3}\s\S{2},#\d{1,3}")
self.pattern3 = re.compile(r"\d{1,3}\sINT\S{2}")
self.pattern4 = re.compile(r"\d{1,3}\s\D{3,4}\s\S{2}")
self.stack = []
self.max_stack = 15
self.stack_pointer = 0
self.initWindow()
def __init__(self,
program,
position,
name=None,
first=None,
second=None,
third=None,
imm=None,
label=None):
name = name.lower()
if name not in r_type.keys() and \
name not in i_type.keys() and \
name not in j_type.keys():
raise Exception("'%s' is not a MIPS opcode" % (name.lower()))
self.program = program
self.position = position
self.name = name
self.rs = UnusedRegister()
self.rt = UnusedRegister()
self.rd = UnusedRegister()
# Verify that the right registers are present
registers = (r_type[name][-1] if name in r_type else \
i_type[name][-1] if name in i_type else \
j_type[name][-1])
rlist = [x for x in [first, second, third] if x is not None]
if len(registers) == 3 and (first is None or second is None \
or third is None):
raise Exception("'%s' requires three registers" % (name))
if len(registers) == 2 and (first is None or second is None \
or third is not None):
raise Exception("'%s' requires two registers" % (name))
if len(registers) == 1 and (first is None or second is not None \
or third is not None):
raise Exception("'%s' requires one register" % (name))
if len(registers) == 0 and (first is not None or second is not None \
or third is not None):
raise Exception("'%s' requires no registers" % (name))
for pos, reg in zip(registers, rlist):
if pos == "rs": self.rs = Register(reg)
if pos == "rd": self.rd = Register(reg)
if pos == "rt": self.rt = Register(reg)
if isinstance(imm, int):
self.imm = imm
else:
self.imm = eval(imm) if imm is not None else 0
self.label = label
if imm is not None and self.label is not None:
raise Exception("A label and an immediate. Confused.")
def setUp(self):
self.name = "Tom"
self.mail = "*****@*****.**"
self.wrongmail = "*****@*****.**"
self.phone = "110110110"
self.password = "******"
self.register = Register(self.name, self.mail, self.phone,
self.password)
self.wrongregister = Register(self.name, self.wrongmail, self.phone,
self.password)
def init_registers(self):
# 32 registers
for i in range(32):
self.registers.append(Register(i))
# 14 conditional registers
count = 0
for val in CONDITIONS.values():
self.condition_registers.update({val: Register(count, is_conditional=True)})
reg = self.condition_registers[val]
reg.data = Conditional(val)
count += 1
def __init__(self):
""" Initialize with the base_type """
self.PC = Register_With_History()
self.DS = Register()
self.CS = Register()
self.ES = Register()
self.PTOS = Register()
self.RTOS = Register()
self.PSP = Register()
self.PSP.write(0xFF00)
self.RSP = Register()
self.RSP.write(0xFE00)
self.INT_CTL_LOW = Register()
# self.INT_CTL_LOW.write = self.special_write
self._interrupt_pin = 0
self._address_history = 10000 * [0x0000]
self._break_point_list = dict()
self._prev_break_point_address = 0x00000
# set_opcodes()
print "CPU has been initialized..."
def _adjust_registers(self):
# Register $zero
self._set_regs("zero", 0)
# at $at
self._set_regs("at", 1)
# $v
self._set_regs('v0', 2)
self._set_regs('v1', 3)
# $a
self._set_regs('a0', 4)
self._set_regs('a1', 5)
self._set_regs('a2', 6)
self._set_regs('a3', 7)
# $t
self._set_regs('t0', 8)
self._set_regs('t1', 9)
self._set_regs('t2', 10)
self._set_regs('t3', 11)
self._set_regs('t4', 12)
self._set_regs('t5', 13)
self._set_regs('t6', 14)
self._set_regs('t7', 15)
# $s
self._set_regs('s0', 16)
self._set_regs('s1', 17)
self._set_regs('s2', 18)
self._set_regs('s3', 19)
self._set_regs('s4', 20)
self._set_regs('s5', 21)
self._set_regs('s6', 22)
self._set_regs('s7', 23)
# $t
self._set_regs('t8', 24)
self._set_regs('t9', 25)
# $k
self._set_regs('k0', 26)
self._set_regs('k1', 27)
#$gp
self.registers["gp"] = Register("gp")
self.registers["gp"].binVal = self.registers["gp"].toBin(28)
#$sp
self.registers["sp"] = Register("sp")
self.registers["sp"].binVal = self.registers["sp"].toBin(29)
#$fp
self.registers["fp"] = Register("fp")
self.registers["fp"].binVal = self.registers["fp"].toBin(30)
#$fp
self.registers["ra"] = Register("ra")
self.registers["ra"].binVal = self.registers["ra"].toBin(31)
def __init__(self,
program,
pos,
name=None,
first=None,
second=None,
third=None,
imm=None,
label=None):
name = name.lower()
if name not in rType.keys() and \
name not in iType.keys() and \
name not in jType.keys():
raise "'%s' is not a MIPS assembly command." % (name.lower())
self.program = program
self.pos = pos
self.name = name
self.rs = EmptyRegister()
self.rt = EmptyRegister()
self.rd = EmptyRegister()
registers = (
rType[name][-1] if name in rType else \
iType[name][-1] if name in iType else \
jType[name][-1]
)
rList = [x for x in [first, second, third] if x is not None]
if len(registers) != len(rList):
raise "'%s' requires %d registers." % (name, len(registers))
for _, reg in zip(registers, rList):
if _ == "rs":
self.rs = Register(reg)
if _ == "rd":
self.rd = Register(reg)
if _ == "rt":
self.rt = Register(reg)
if isinstance(imm, int):
self.imm = imm
else:
self.imm = eval(imm) if imm is not None else 0
self.label = label
if imm is not None and self.label is not None:
raise "Label and imm can't both exist."
def test_ban():
reg = Register('Metropoliten1')
time = TimeDuration.OneMonth
c2 = reg.create_card(CardType.TimeLimit, time)
reg.ban_card(c2.id)
assert c2.id in reg.banned.keys()
def three_operation_code(p, cl):
p[0] = NoneTerminal(p)
reg = Register('real')
p[0].place = reg.place
temp1 = ''
if p[2].place != '':
temp1 = p[2].place
else:
temp1 = p[2].value
# p[0].code = p[1].code + p[3].code + p[0].place + " = " + p[1].value + " " + p[2] + " " + p[3].value() + ";\n"
p[0].code = p[0].place + " = " + p[1] + temp1 + ";"
# if p[2].value!='':
# if p[1] == '~':
# p[0].value = str(~ int(p[2].value))
# elif p[1] == '-':
# p[0].value = str(- int(p[2].value))
# elif p[1] == '!':
# p2 = int(p[2].value)
# if p2 != 0:
# p[0].value = str(0)
# else:
# p[0].value = str(random.randint(1,30))
# print('++++')
# # print(p[0].value)
cl.append(p[0].code)
def __init__(self, size):
self.registerList = []
self.IntegisterList = []
self.size = size
register = Register("", 0)
for i in range(size):
self.registerList.append(register)
def index():
mail = Mail(app)
if request.method == "POST":
Register(request, con, mail)
return render_template('index.html')
if request.method == "GET":
return render_template('index.html')
def directive_start(self,name,length,inicial):
r = Register("H")
self.list_registers_h = []
register_h = r.make_H(name.upper(),length,inicial)
self.list_registers_h.append(register_h)
self.h_name = r.adjust_name(name.upper())
del r
def make_register_r(self,list_symb):
r = Register("X")
reg = "R"
for l in list_symb:
name = r.adjust_name(l)
reg+=name
self.list_registers_r.append(reg)
def add_user():
if request.method == "GET":
# user request form
return render_template("add_user.html")
elif request.method == "POST":
form = request.form
u = form["username"]
e = form["email"]
p = form["password"]
exist_user = Register.objects(username=u).first()
exist_mail = Register.objects(email=e).first()
if exist_user != None:
return "User already exist!"
if exist_mail != None:
return "Email already exist!"
else:
r = Register(username=u, email=e, password=p)
r.save()
message = Message("Chuc mung ban da dang ky thanh cong vao NGANH",
to=e)
gmail.send(message)
return "Chuc mung!! Ban da dang ky thanh cong"
def __init__(self):
self.operations = {
'ADD':'18','ADDF':'58','ADDR':'90','AND':'40','CLEAR':'B4','COMP':'28',
'COMPF':'88','DIV':'24','COMPR':'A0','DIVF':'64','DIVR':'9C','FIX':'C4',
'FLOAT':'C0','HIO':'F4','J':'3C','JEQ':'30','JGT':'34','JLT':'38',
'JSUB':'48','LDA':'00','LDB':'68','LDCH':'50','LDF':'70','LDL':'08','LDS':'6C',
'LDT':'74','LDX':'04','LPS':'D0','MUL':'20','MULF':'60','MULR':'98','NORM':'C8',
'OR':'44','RD':'D8','RMO':'AC','RSUB':'4C','SHIFTL':'A4','SHIFTR':'A8','SIO':'F0',
'SSK':'EC','STA':'0C','STB':'78','STCH':'54','STF':'80','STI':'D4',
'STL':'14','STS':'7C','STSW':'E8','STT':'84','STX':'10',
'SUB':'1C','SUBF':'5C','SUBR':'94','SVC':'B0','TD':'E0','TIO':'F8','TIX':'2C',
'TIXR':'B8','WD':'DC'
}
self.d = Displacement()
self.list_registers_h = []
self.list_registers = []
self.list_registers_m = []
self.list_registers_r = []
self.list_registers_e = []
self.current_register = Register("T")
self.registers = {"A":"0","X":"1","L":"2","CP":"8","SW":"9","B":"3","S":"4","T":"5","F":"6"}
self.base = "1038H"
self.m_register = []
self.m_modif_register = []
self.h_name = ""
self.list_registers_d = []
self.list_word_m = []
self.list_op_m = []
def parse_operands(operands: List[Operand], *args: OperandType):
parsed_operands = []
if len(operands) == 1:
if not operands[0].type == OperandType.INTEGER:
raise Exception(
f"Operand should be a {OperandType.INTEGER} but was a {operands[0].type}."
)
parsed_operands.append(Immediate(operands[0].value))
elif len(operands) == 2:
if not operands[1].type == OperandType.INTEGER:
raise Exception(
f"Operand should be a {OperandType.INTEGER} but was a {operands[1].type}."
)
parsed_operands.append(Immediate(operands[1].value))
if not operands[0].type == OperandType.REGISTER:
raise Exception(
f"Operand should be a {OperandType.REGISTER} but was a {operands[0].type}."
)
parsed_operands.append(Register(operands[0].value))
else:
raise Exception(
f"Should have either 1 or 2 operands but has {len(operands)}.")
return parsed_operands
def test_operations(intA, intB):
from util import bits2int, int2bits
from register import Register
from bus import Bus
A = Bus("A", 32)
B = Bus("B", 32)
C = Bus("C", 32)
mir = Register("MIR", 36, None, None, None)
alu = ALU(A, B, C, mir)
wordSize = max(intA.bit_length(), intB.bit_length())
A.val = int2bits(intA, wordSize)
B.val = int2bits(intB, wordSize)
print("A = binary({0}) -> {1}".format(intA, list(reversed(A.val))))
print("B = binary({0}) -> {1}".format(intB, list(reversed(B.val))))
print()
for _, op in operations.items():
mir.val = [0 for _ in range(16)
] + op.bit_string + [0 for _ in range(16 + 6, 36)]
alu.tick()
sol = C.val
print("f(A,B) = {0}".format(op.name))
print("binary({0}) -> {1}".format(bits2int(sol),
list(reversed(sol))))
print()
def startPrint(self):
self.register = Register(self.DS, self.SHCP, self.STCP)
# setting disable shutdown and sacan limit
self.register.shift(0, '101100000111')
self.register.shift(0, '110000000001')
self.printLoop()
def __init__(self):
self.index = 0
self.list_n = []
self.conv = Convert()
self.reg = Register("X")
self.hexa = Hexadecimal()
self.last_code = 0
def get_msgcode(self):
'''获取验证码'''
self.host = self.env.get().strip()
print(self.host)
try:
register = Register(self.host)
self.text.config(state=NORMAL)
results = register.get_msg_code()
sendtime = str(results[2])[:4] + '.' + str(
results[2])[4:6] + '.' + str(results[2])[6:8] + ' ' + str(
results[2])[8:10] + ':' + str(
results[2])[10:12] + ':' + str(results[2])[12:]
self.text.insert(END, '\n\n手机号：%s\n' % results[3])
self.text.insert(END, '发送时间：%s\n' % sendtime)
self.text.insert(END, '验证码：%s\n' % results[0])
self.text.insert(END, '短信密码：%s\n\n' % results[1])
self.text.see(END)
self.text.config(state=DISABLED)
except:
self.text.insert(END, '\n查看验证码失败!\n\n')
self.text.see(END)
index = float(self.text.index(INSERT))
self.text.tag_add('code1', index - 2, index + 1)
self.text.tag_config('code1', foreground='red')
self.text.config(state=DISABLED)
def __init__(self, mem, entry_point, stack_bottom):
self.register = []
self.mm_register = []
self.xmm_register = []
self.mem_stream = Stream(mem, entry_point)
self.stopped = False
self.flags = FlagsRegister()
self.stack = Stack(mem, stack_bottom)
self.fs = 0
self.gs = 0
for i in range(16):
reg = Register()
reg.write(0, [i, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
reg.name = "reg #%d %s" % (i, Cpu.reg_names[i])
self.register.append(reg)
for i in range(32):
reg = MMRegister()
reg.name = "mm #%d" % i
self.mm_register.append(reg)
for i in range(32):
reg = XMMRegister()
reg.name = "xmm #%d" % i
self.xmm_register.append(reg)
def __init__(self, parent=None, mainwindow=None):
super(Sign, self).__init__(parent)
self.setupUi(self)
self.main = mainwindow
self.register = Register(self)
self.passwd = Password(self)
self.set_connect()
def setUp(self):
'''
Set up method to run before each test cases.
'''
self.new_Register = Register("James", "Muriuki", "Jemo-Mruks",
"0712345678", "*****@*****.**",
"jMur463463",
"Instagram") # create register object
def build(self):
manager = ScreenManager()
manager.add_widget(Login(name='login'))
manager.add_widget(Connected(name='connected'))
manager.add_widget(Register(name='register'))
return manager
def _startPrint(self, step, width, delay):
self.register = Register(self.DS, self.SHCP, self.STCP)
while self.now_layer < self.max_layer:
i = self.now_layer * 2
graph_slice = self.graph[i:i + width]
# print to 8x8
self.show8x8(graph_slice, sec=delay)
def create_register(first_name, last_name, username, number, email, password,
account_type):
'''
Function to create a new account
'''
new_register = Register(first_name, last_name, username, number, email,
password, account_type)
return new_register
def do_level_lookup(self, table_base_address, table_index,
input_addr_split):
"""Does a base + index descriptor lookup. Returns a tuple with the
Register object representing the found descriptor and a
Register object representing the the computed descriptor
address.
"""
n = input_addr_split
# these Registers are overkill but nice documentation :).
table_base = Register(table_base_address, base=(39, n))
descriptor_addr = Register(base=(39, n), offset=(n - 1, 3))
descriptor_addr.base = table_base.base
descriptor_addr.offset = table_index
descriptor_val = self.read_phys_dword(descriptor_addr.value)
descriptor = Register(descriptor_val, dtype=(1, 0))
return descriptor, descriptor_addr
def __init__(self):
self.output = []
self.shift_register1 = Lfsr(input("seed for the first RFSR:"),[8,12,20,25])
self.shift_register2 = Lfsr(input("seed for the second RFSR:"),[21,16,24,31])
self.shift_register3 = Lfsr(input("seed for the third RFSR:"),[4,24,28,33])
self.shift_register4 = Lfsr(input("seed for the fourth RFSR:"),[4,28,36,39])
self.r1 = Register(input("seed for the register R1:"))
self.r2 = Register(self.r1.output)
self.t1 = InternalState()
self.t2 = InternalState()
self.adder1 = Adder()
self.adder2 = Adder()
self.iz = Iz()
self.xor_iz_t2 = Xor([self.t2.output,self.iz.output])
self.xor_t1_xor = Xor([self.t1.output,self.xor_iz_t2.output])
self.xor_zt = Xor([self.shift_register1.output,self.shift_register2.output,
self.shift_register3.output,self.shift_register4.output,self.r1.least_significant()])
