def fill(self, qty, price): for q in qty: # globalAtomicPrinter.printit(q) self.qty.append(Number(q).value) for p in price: # globalAtomicPrinter.printit(p) self.price.append(Number(p).value)
def derive(self): if isinstance(self.getOperand(), Variable): return BinaryOp(Op.Mult, Number(-1), Sin(self.getOperand())) else: return BinaryOp( Op.Mult, BinaryOp(Op.Mult, Number(-1), self.getOperand().derive()), Cos(self.getOperand()))
def setCC(self, index): PSR_left = self.PSR.bin()[:-3] if self.readRegCom(index) > 0: self.PSR = Number(16, PSR_left + '001') elif self.readRegCom(index) == 0: self.PSR = Number(16, PSR_left + '010') else: self.PSR = Number(16, PSR_left + '100')
def derive(self): if self.getPower() == 0: return Number(0) else: if isinstance(self.__operand, Variable): return BinaryOp(Op.Mult, Number(self.__power), Poly(self.__operand, self.__power - 1)) else: return BinaryOp( Op.Mult, Number(self.__power), BinaryOp(Op.Mult, self.__operand.derive(), Poly(self.__operand, self.__power - 1)))
def __init__(self, terminalHandler=stdout, debug=None): super().__init__(terminalHandler, debug) self.bus = smbus.SMBus(1) self.bus.write_byte(constants.BAT_BUTTONS_I2C_ADDRESS, 0xFF) self.bus.write_byte(constants.BALL_LED_I2C_ADDRESS, 0xFF) self.batButtonState = 0xFF GPIO.setmode(GPIO.BCM) GPIO.setup(constants.BAT_BUTTONS_INTERRUPT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect( constants.BAT_BUTTONS_INTERRUPT_PIN, GPIO.FALLING, callback=self.handleControllerInterrupt) for pin in constants.LED_PINS: GPIO.setup(pin, GPIO.OUT) self.lastLED = None self.scoreLeft = Number(0, 29, 2, "cyan") self.scoreRight = Number(0, 49, 2, "pink") self.leftController = CPLDHandler( self.bus, constants.LEFT_BAT_I2C_ADDRESS ) self.rightController = OnBoardADCHandler(self.bus, constants.RIGHT_BAT_I2C_ADDRESS, constants.RIGHT_BAT_CMD_CODE) self.batLeft = Bat(3, 12, 6, "cyan", self.leftController) self.batRight = Bat(77, 12, -6, "pink", self.rightController) self.edges = [ GameObject(0, -1, constants.PONG_WIDTH, 1, "red"), #deleted the "+1" that followed constants.PONG_HEIGHT GameObject(0, constants.PONG_HEIGHT + 1, constants.PONG_WIDTH, 1, "red"), ] self.ball = Ball( 10, 20, constants.SERVE_SPEED, "green", self.edges + [self.batLeft, self.batRight], 25, 1, 1 ) self.addObjects( [self.scoreLeft, self.scoreRight, self.batLeft, self.batRight, self.ball] + self.edges ) self.ball.serving = 'right' self.serves = 0 self.gameOver = False self.winnerText = None
def term(self): """Match the grammar for a term.""" self.stack.append("Factor") operator_map = {"*": "*", "DIV": "/", "MOD": "%"} cur = self.factor() # 0 or more patterns. while True: if self.current.kind == "*" or self.current.kind == "DIV" or self.current.kind == "MOD": if self.current.kind == "*": operator = self.match("*") elif self.current.kind == "DIV": operator = self.match("DIV") else: operator = self.match("MOD") self.stack.append("Factor") var = self.factor() if isinstance(cur, Number) and isinstance(var, Number): # Constant folding. try: val = int(eval(str(cur.entry.value) + str(operator_map[operator.kind]) + str(var.entry.value))) except ZeroDivisionError: # Divide by 0 error. self.invalid_token(DivideByZero(self.last)) break const = Constant(self.integer_type, val) cur = Number(const) else: if isinstance(cur, VariableAST) and ( isinstance(cur.variable, Array) or isinstance(cur.variable, Record) ): # Trying to perform an operation on non-integers. try: raise InvalidArithmeticOperation(cur, self.last) except InvalidArithmeticOperation as e: self.invalid_token(e) else: cur = Binary(operator.kind, cur, var, self.integer_type) # Remember the token for node in case of run time errors. cur.token = self.last else: # Pattern ended. break return cur
def __init__(self, poll, output, debug, info): self.wordLength = 16 self.addressibility = 16 self.gRegNum = 8 self.gRegs = [ Number(self.wordLength) ] * self.gRegNum self.IR = Number(self.wordLength) self.PC = Number(self.addressibility) self.PSR = Number(self.wordLength) self.debug = debug self.info = info self.ch = -1 self.SSP = Number(self.wordLength, 'b0011000000000000') # Stack Bottom self.USP = Number(self.wordLength, 'b1111111000000000') # Stack Bottom # Program State Register, inluding Pr, PL, CC # When loaded in the user program and running, the Pr will be set; # When a device issues a interrupt, the Pr will change into priliveged mode # Write to Registers will incur changes to CC # address of special memory mapped locations self.MCR = Number(16, 'b1111111111111110') self.mem = Memory(self.interrupt, poll, output) self.writeMem = self.mem.write self.readMem = self.mem.read self.getOperands = { 'ADDr' : ['R4-7', 'R7-10', 'R13-16'], 'ADDimm' : ['R4-7', 'R7-10', 'I11-16'], 'ANDr' : ['R4-7', 'R7-10', 'R13-16'], 'ANDimm' : ['R4-7', 'R7-10', 'I11-16'], 'BR' : ['S4-7', 'O7-16'], 'LD' : ['R4-7', 'O7-16'], 'ST' : ['R4-7', 'O7-16'], 'NOT' : ['R4-7', 'R7-10'], 'JMP' : ['R7-10'], 'JSR' : ['O5-16'], 'JSRR' : ['R7-10'], 'LDI' : ['R4-7', 'O7-16'], 'LDR' : ['R4-7','R7-10', 'O10-16'], 'LEA' : ['R4-7', 'O7-16'], 'STI' : ['R4-7', 'O7-16'], 'STR' : ['R4-7','R7-10', 'O10-16'], 'TRAP' : ['S8-16'], 'RTI' : [] }
def create_randoms(): """ ------------------------------------------------------- Create a 2D list of Number objects with TEST rows and SIZE columns of values between 0 and XRANGE. Use: lists = create_randoms() ------------------------------------------------------- Returns: arrays - TEST lists of SIZE Number objects containing values between 0 and XRANGE (list of list of Number) ------------------------------------------------------- """ arrays = [ ] list_1 = arrays for i in range(TESTS): row = [ ] for j in range((SIZE)): row.append(Number(random.randint(0,XRANGE))) arrays.append(row) arrays = list_1 return arrays
def create_randoms(): """ ------------------------------------------------------- Create a 2D list of Number objects. Use: lists = create_randoms() ------------------------------------------------------- Returns: lists - TEST lists of SIZE Number objects containing values between 0 and XRANGE (list of List of Number) ------------------------------------------------------- """ lists = List() for x in range(TESTS): row = [] for i in range(SIZE): v = randint(0, XRANGE) num = Number(v) row.append(num) lists.append(row) return lists
def updateValue(self, table_img): self.value_container.numbers = [] if not (self.is_available): return numbers_list = [] table_img_portion = table_img.crop( (self.box.left, self.box.top, self.box.left + self.box.width, self.box.top + self.box.height)) if (True): #Attempt to locate stack for i, file in enumerate(range(10)): file = str(i) + '.png' for j, box in enumerate( pyautogui.locateAll( constants.NUMBERS_BUTTON_PATH + file, table_img_portion, confidence=constants.NUMBERS_BUTTON_DET_CONFIDENCE) ): if (box != None): numbers_list.append(Number(value=i, box=box)) else: pass else: pass numbers_list.sort(key=lambda number: number.left) #print([number.value for number in numbers_list]) for number in numbers_list: self.value_container.addNumber(number) self.value_container.computeValue() self.value_container.corresponding_entity = self.id self.value = self.value_container.value print('[Button] ' + str(self.id) + ' holds value: ' + str(self.value)) return
def parse_term(cls, term): """ Parse a string into a Term object """ # # tests the term for syntactical errors # then cleans up the string # if it is a compound term like 3x^2 it first expands that to 3*x^2 # then parses 3 and x^2 separately, then simplifies it to a single term. # if isinstance(term, Term): return term cls.test_term(term) term = cls.clean_up(term) terms = cls.separate(term, "*/()") while "(" in terms: start, end = cls.get_parentheses_location(terms) result = cls.parse_term("".join(terms[start + 1:end])) terms = cls.list_replace(terms, start, end, result) if len(terms) == 1: term = terms[0] if number_pattern.fullmatch(term): # its a number return Term(Number(float(term)), [], []) elif term in delimiters: # it is an operator or parenthesis return term elif "^" in term: # it was not a Number, operator, or parenthesis. # it is something of the form (var)^(exponent) return Term(Number(1), [Symbol(term[0])], [Number(float(term[term.rfind("^") + 1:]))]) else: # it is just a single variable such as "x" or "y" return Term(Number(1), [Symbol(term)], [Number(1)]) else: # it is not possible for recursion depth to exceed 2 here. terms = [cls.parse_term(t) for t in terms] while "*" in terms or "/" in terms: index = cls.list_index(terms, ["*", "/"]) # ^^ this will be the first occurence of an operator. terms = cls.list_substitute(terms, index) return terms[0]
def __truediv__(self, other): f = dict(zip(map(lambda v: v.symbol, self.syms), self.exps)) new_numerator, new_denominator = {}, {} if other.syms: for var, exp in zip(other.syms, other.exps): var = var.symbol if var in f.keys(): f[var] -= exp number = f[var] else: f[var] = -exp number = f[var] null = Number(0) if number < null: new_denominator[var] = -number elif number > null: new_numerator[var] = number else: pass # if the new exponent is 0, don't include it. else: new_numerator = dict( zip(map(lambda s: s.symbol, self.syms), self.exps)) new_coef = self.coef / other.coef numerator_term = Term( Number(new_coef.numerator), list(map(lambda v: Symbol(v), new_numerator.keys())), list(new_numerator.values())) denominator_term = Term( Number(new_coef.denominator), list(map(lambda v: Symbol(v), new_denominator.keys())), list(new_denominator.values())) if not denominator_term.syms: return Term(new_coef, numerator_term.syms, numerator_term.exps) else: # not sure what to do here either. if this block executes it means # that the division could not be simplified to a single term... raise NotImplementedError
def VisitForNode(self, node, context): res = RTResult() elements = [] startVal = res.register(self.visit(node.startVal, context)) if res.shouldReturn(): return res endVal = res.register(self.visit(node.endVal, context)) if res.shouldReturn(): return res if node.stepVal: stepVal = res.register(self.visit(node.stepVal, context)) if res.shouldReturn(): return res else: stepVal = Number(1) i = startVal.value if stepVal.value >= 0: condition = lambda: i < endVal.value else: condition = lambda: i > endVal.value while condition(): context.symbTable.set(node.varToken.value, Number(i)) i += stepVal.value value = res.register(self.visit(node.body, context)) if res.shouldReturn( ) and res.contLoop == False and res.breakLoop == False: return res if res.contLoop: continue if res.breakLoop: break elements.append(value) return res.success( Number.null if node.returnNull else List(elements). setContext(context).setPosition(node.startPos, node.endPos))
def run(n, r, test): if n % 2 == 0: return False a = Number(n, n - 1) while a > 0 and r > 0: if not (gcd(a, n) == 1 and PrimeTests.condition_of_test(test, a, n)): return False a -= 1 r -= 1 return True
def interrupt(self, PL, vector): assert(len(vector) == 8) if int(self.PSR.data[5:8], 2) > int(PL, 2): self.debug("[CPU]: interrupt Rejected") return # Reject the interrupt addr = Number(16, 'b00000001' + vector) SSP = self.gRegs[6] self.writeMem(SSP.MINUS(Number(self.wordLength, 1)), self.PSR) self.writeMem(SSP.MINUS(Number(self.wordLength, 2)), self.PC) self.gRegs[6] = SSP.MINUS(Number(self.wordLength, 2)) self.PC = self.readMem(addr) self.PSR = Number(16, 'b00000' + PL + '00000000') self.debug("[CPU]: interrupt accepted") self.ch = -1
def create_reversed(): """ ------------------------------------------------------- Create a reversed List of Number objects. Use: values = create_reversed() ------------------------------------------------------- Returns: values - a reversed list of SIZE Number objects (List of Number) ------------------------------------------------------- """ values = List() for i in range(SIZE - 1, -1, -1): temp_num = Number(i) values.append(temp_num) return values
def VisitUnaryOperationNode(self, node, context): res = RTResult() number = res.register(self.visit(node.node, context)) if res.shouldReturn(): return res error = None if node.oper.type == MINUS_T: number, error = number.mult(Number(-1)) elif node.oper.sameElem(KEYWORD_T, 'not'): number, error = number.notBool() if error: return res.failure(error) else: return res.success(number.setPosition(node.startPos, node.endPos))
def main(): numbers = [Number(randint(-10, 10)), Number(randint(-10, 10)), Number(randint(-10, 10)), Number(randint(-10, 10)), Number(randint(-10, 10)), Number(randint(-10, 10))] for number in numbers: print("Angka:", number.number) print("Positif Genap:", number.is_even_positive()) print("Negatif Genap:", number.is_even_negative()) print("Positif Ganjil:", number.is_odd_positive()) print("Negatif Ganjil:", number.is_odd_negative(), end="\n\n")
def visit_UnaryOpNode(self, node, context): response = RunTimeResult() number = response.register(self.visit(node.node, context)) if response.error: return response error = None if node.operation_token.token_type == TokenType.MINUS: number, error = number.multed_by(Number(-1)) elif node.operation_token.matches(TokenType.KEYWORD, 'NOT'): number, error = number.notted() if error: return response.failure(error) else: return response.success( number.set_position(node.position_start, node.position_end))
def create_sorted(): """ ------------------------------------------------------- Creates a sorted List of Number objects. Use: values = create_sorted() ------------------------------------------------------- Returns: values - a sorted list of SIZE Number objects (List of Number) ------------------------------------------------------- """ # your code here values = List() for i in range(SIZE): num = Number(i) values.append(num) return values
def create_reversed(): """ ------------------------------------------------------- Create a reversed list of Number objects. Use: values = create_reversed() ------------------------------------------------------- Returns: values - a reversed list of SIZE Number objects (list of Number) ------------------------------------------------------- """ # your code here values = [] for i in range(SIZE - 1, -1, -1): num = Number(i) values.append(num) return values
def create_sorted(): """ ------------------------------------------------------- Creates a sorted list of SIZE Number objects with values from 0 up to SIZE-1. Use: values = create_sorted() ------------------------------------------------------- Returns: values - a sorted list of SIZE Number objects (list of Number) ------------------------------------------------------- """ values = [] for i in range(SIZE): temp_num = Number(i) values.append(temp_num) return values
def create_reversed(): """ ------------------------------------------------------- Create a reversed list of SIZE Number objects with values from SIZE-1 down to 0. Use: values = create_reversed() ------------------------------------------------------- Returns: values - a reversed list of SIZE Number objects (list of Number) ------------------------------------------------------- """ values = [] for i in range(SIZE-1,-1,-1): values.append(Number(i)) return values
def convert_int2str(i: int, parser: Number, d: dict) -> typing.List[int]: parsing = parser.parse( NumberGenerator.add_symbols( NumberGenerator.chain( *NumberGenerator.add_parentheses( NumberGenerator.add_multiples( NumberGenerator.chunk( NumberGenerator.int2list( i ) ) ) ) ) ) ) if parsing[1] is not None: return list(map(lambda x: NumberGenerator.int2str(x, d), NumberGenerator.delete0(parsing[1]))) else: return [NumberGenerator.int2str(int(parsing[0]), d)]
def create_randoms(): """ ------------------------------------------------------- Create a 2D list of Number objects. Use: lists = create_randoms() ------------------------------------------------------- Returns: arrays - TESTS lists of SIZE Number objects containing values between 0 and XRANGE (list of list of Number) ------------------------------------------------------- """ # your code here arrays = [[None for i in range(SIZE)] for j in range(TESTS)] for i in range(TESTS): for j in range(SIZE): rand = random.randint(0, XRANGE) num = Number(rand) arrays[i][j] = num return arrays
def convert_int2str(i: int, parser: Number, d: dict) -> list: parsing = parser.parse( NumberGenerator.add_symbols( NumberGenerator.chain( *NumberGenerator.add_parentheses( NumberGenerator.add_multiples( NumberGenerator.chunk( NumberGenerator.int2list( i ) ) ) ) ) ) ) if parsing[1] is not None: return list(map(lambda x: NumberGenerator.int2str(x, d), NumberGenerator.delete0(parsing[1]))) else: return [NumberGenerator.int2str(int(parsing[0]), d)]
def main1(): import sqlite3 import pickle c = NumberGenerator() base = pickle.load(open('exceptions.pickle', 'rb')).get('français') parser = Number(excpetions=base) reche = "SELECT integer, ortho, phon FROM Lexique WHERE isinteger = 1" with sqlite3.connect('Lexique.db') as conn: cursor = conn.cursor() intp = range(1, 9999) # base2 = {x: (y, z) for x, y, z in cursor.execute(reche).fetchall()} # pour avoir int: (graphie, phonologie) base2 = {x: y for x, y, z in cursor.execute(reche).fetchall()} # pour avoir int: graphie for x in map(lambda x: c.convert_int2str(x, parser, base2), intp): print(x)
def create_randoms(): """ ------------------------------------------------------- Create a 2D list of Number objects. Use: lists = create_randoms() ------------------------------------------------------- Returns: lists - TEST lists of SIZE Number objects containing values between 0 and XRANGE (list of List of Number) ------------------------------------------------------- """ lists = [] for i in range(TESTS): temp = List() for j in range(SIZE): temp.append(Number(randint(0, XRANGE))) lists.append(temp) return lists
def updateStack(self, table_img): self.stack_container.numbers = [] numbers_list = [] table_img_portion = table_img.crop( (self.player_box.left, self.player_box.top, self.player_box.left + self.player_box.width, self.player_box.top + self.player_box.height + 25)) try: #Attempt to locate stack for i, file in enumerate(range(10)): file = str(i) + '.png' for j, box in enumerate( pyautogui.locateAll( constants.NUMBERS_STACK_PATH + file, table_img_portion, confidence=constants.NUMBERS_STACK_DET_CONFIDENCE) ): if (box != None): numbers_list.append(Number(value=i, box=box)) else: pass except: pass numbers_list.sort(key=lambda number: number.left) #print([number.value for number in numbers_list]) for number in numbers_list: self.stack_container.addNumber(number) try: self.stack_container.computeValue() self.stack_container.corresponding_entity = self.id self.stack_value = self.stack_container.value except: pass #print('[Player] Player '+str(self.id)+' has stack of size: '+str(self.stack_value)) return
def create_randoms(): """ ------------------------------------------------------- Create a 2D list of Number objects. Use: lists = create_randoms() ------------------------------------------------------- Returns: lists - TEST lists of SIZE Number objects containing values between 0 and XRANGE (list of List of Number) ------------------------------------------------------- """ # your code here lists = [] for i in range(TESTS): for _ in range(SIZE): inner_list = List() rand = random.randint(0, XRANGE) num = Number(rand) inner_list.append(num) lists.append(inner_list) return lists
def VisitNumNode(self, node, context): return RTResult().success( Number(node.token.value).setContext(context).setPosition( node.startPos, node.endPos))
for i in range(len) ] result = [d[i] == (a[i] == (b[i] == c[i + 1])) for i in range(len)] carry = [ c[i] == Or(And(a[i], b[i]), And(a[i], c[i + 1]), And(b[i], c[i + 1])) for i in range(len) ] edge = [Not(c[0]), Not(c[len])] s = Solver() s.add(result + carry + premiseA + premiseB + premiseD + edge) if s.check() == sat: ans = 0 for i in range(len): ans <<= 1 if is_true(s.model()[b[i]]): ans += 1 print('the answer is %d.' % ans) else: print('no solution!') if __name__ == '__main__': cal = Calculator() print("请输入被减数:") sum = Number() sum.set_value(int(input())) print("请输入减数:") operand = Number() operand.set_value(int(input())) cal.substract(sum, operand)
class CPU(object): def __init__(self, poll, output, debug, info): self.wordLength = 16 self.addressibility = 16 self.gRegNum = 8 self.gRegs = [ Number(self.wordLength) ] * self.gRegNum self.IR = Number(self.wordLength) self.PC = Number(self.addressibility) self.PSR = Number(self.wordLength) self.debug = debug self.info = info self.ch = -1 self.SSP = Number(self.wordLength, 'b0011000000000000') # Stack Bottom self.USP = Number(self.wordLength, 'b1111111000000000') # Stack Bottom # Program State Register, inluding Pr, PL, CC # When loaded in the user program and running, the Pr will be set; # When a device issues a interrupt, the Pr will change into priliveged mode # Write to Registers will incur changes to CC # address of special memory mapped locations self.MCR = Number(16, 'b1111111111111110') self.mem = Memory(self.interrupt, poll, output) self.writeMem = self.mem.write self.readMem = self.mem.read self.getOperands = { 'ADDr' : ['R4-7', 'R7-10', 'R13-16'], 'ADDimm' : ['R4-7', 'R7-10', 'I11-16'], 'ANDr' : ['R4-7', 'R7-10', 'R13-16'], 'ANDimm' : ['R4-7', 'R7-10', 'I11-16'], 'BR' : ['S4-7', 'O7-16'], 'LD' : ['R4-7', 'O7-16'], 'ST' : ['R4-7', 'O7-16'], 'NOT' : ['R4-7', 'R7-10'], 'JMP' : ['R7-10'], 'JSR' : ['O5-16'], 'JSRR' : ['R7-10'], 'LDI' : ['R4-7', 'O7-16'], 'LDR' : ['R4-7','R7-10', 'O10-16'], 'LEA' : ['R4-7', 'O7-16'], 'STI' : ['R4-7', 'O7-16'], 'STR' : ['R4-7','R7-10', 'O10-16'], 'TRAP' : ['S8-16'], 'RTI' : [] } def match(self, pattern, inst): rulesMatch = { 'R' : lambda segment : int(segment, 2), # Register 'O' : lambda segment : Number(9, 'b' + segment).SEX(self.wordLength), # Offset 'I' : lambda segment : Number(len(segment), 'b' + segment).SEX(self.wordLength), # Immediate Value 'S' : lambda segment : segment # return the segment itself } operands = [] for rule in pattern: [start, end] = rule[1:].split('-') operands.append(rulesMatch[rule[0]](inst.data[int(start):int(end)])) return operands def getOpcode(self, instruction): singleModeOpcode = { '0000' : 'BR', '0010' : 'LD', '0011' : 'ST', '1001' : 'NOT', '1100' : 'JMP', '1010' : 'LDI', '0110' : 'LDR', '1110' : 'LEA', '1011' : 'STI', '0111' : 'STR', '1111' : 'TRAP', '1000' : 'RTI' } opcode = instruction.data[0:4] if opcode == '0001': if instruction.data[10:13] == '000': return 'ADDr' elif instruction.data[10] == '1': return 'ADDimm' else: raise StandardError("Error -- Wrong ADD instruction format") if opcode == '0101': if instruction.data[10:13] == '000': return 'ANDr' elif instruction.data[10] == '1': return 'ANDimm' else: raise StandardError("Error -- Wrong AND instruction format") if opcode == '0100': if instruction.data[4] == '1': return 'JSR' elif instruction.data[4:7] == '000': return 'JSRR' else: raise StandardError("Error -- Wrong AND instruction format") else: return singleModeOpcode[opcode] def step(self): self.IR = self.readMem(self.PC) self.PC = self.PC.ADD(Number(self.wordLength, 1)) opcode = self.getOpcode(self.IR) MCR = self.readMem(self.MCR) if MCR.data[0] == '0': # RUN Latch is cleared return 0 elif opcode: operands = self.match(self.getOperands[opcode], self.IR) apply(self.__getattribute__(opcode), operands) return 1 else: self.info("Error: Invalid Opcode") return 0 def setCC(self, index): PSR_left = self.PSR.bin()[:-3] if self.readRegCom(index) > 0: self.PSR = Number(16, PSR_left + '001') elif self.readRegCom(index) == 0: self.PSR = Number(16, PSR_left + '010') else: self.PSR = Number(16, PSR_left + '100') def getCC(self): return self.PSR.bin()[-3:] def readRegCom(self, index): return Tools.intCom(self.gRegs[index].bin()[1:]) # ----------------------- ISA ----------------------- def LD(self, DR, offset): SRCaddr = self.PC.ADD(offset) self.debug('LD R' + str(DR)+ ' <- mem(' + SRCaddr.hex() + ')') self.gRegs[DR] = self.readMem(SRCaddr) self.setCC(DR) def BR(self, nzp, offset): if Tools.match(self.getCC(), nzp): self.PC = self.PC.ADD(offset) self.debug("BR offset(" + str(offset.intCom()) + ")") else: self.debug("BR -- 'not match'") def ST(self, SR, offset): DESTaddr = self.PC.ADD(offset) self.debug('ST R' + str(SR) + ' -> mem(' + DESTaddr.hex() + ')') self.writeMem(DESTaddr, self.gRegs[SR]) def ADDr(self, DR, SR1, SR2): self.debug('ADDr R' + str(DR) + ' <- R' + str(SR1) + ' + R' + str(SR2)) self.gRegs[DR] = self.gRegs[SR1].ADD(self.gRegs[SR2]) self.setCC(DR) def ADDimm(self, DR, SR, Simm): self.debug('ADDimm R' + str(DR) + ' <- R' + str(SR) + ' + Imm(' + str(Tools.intCom(Simm.data)) + ')') self.gRegs[DR] = self.gRegs[SR].ADD(Simm) self.setCC(DR) def ANDr(self, DR, SR1, SR2): self.debug('ANDr R' + str(DR) + ' <- R' + str(SR1) + ' & R' + str(SR2)) self.gRegs[DR] = self.gRegs[SR1].AND(self.gRegs[SR2]) self.setCC(DR) def ANDimm(self, DR, SR, Simm): self.debug('ANDimm R' + str(DR) + ' <- R' + str(SR) + ' & Imm(' + str(Tools.intCom(Simm.data)) + ')') self.gRegs[DR] = self.gRegs[SR].AND(Simm) self.setCC(DR) def NOT(self, DR, SR): self.debug('NOT R' + str(DR) + ' <- ! R' + str(SR)) self.gRegs[DR] = self.gRegs[SR].NOT() self.setCC(DR) def JMP(self, BR): self.debug('JMP PC <- R' + str(BR)) self.PC = self.gRegs[BR] def JSR(self, offset): self.gRegs[7] = self.PC self.PC = self.PC.ADD(offset) self.debug('JSR R7 <- PC, PC <- ' + self.PC.hex()) def JSRR(self, BR): self.gRegs[7] = self.PC self.PC = self.gRegs[BR] self.debug('JSRR R7 <- PC, PC <- R' + str(BR)) def LDI(self, DR, offset): addr = self.PC.ADD(offset) self.gRegs[DR] = self.readMem(self.readMem(addr)) self.debug('LDI R' + str(DR) + ' <- mem(mem(' + addr.hex() + '))') self.setCC(DR) def STI(self, SR, offset): addr = self.PC.ADD(offset) self.writeMem(self.readMem(addr), self.gRegs[SR]) self.debug('STI R' + str(SR) + ' -> mem(mem(' + addr.hex() + '))') def LDR(self, DR, BR, offset): addr = self.gRegs[BR].ADD(offset) self.gRegs[DR] = self.readMem(addr) self.setCC(DR) self.debug('LDR R' + str(DR) + ' <- mem(' + 'R' + str(BR) + ' + ' + str(offset.int()) + ')') def STR(self, SR, BR, offset): addr = self.gRegs[BR].ADD(offset) self.writeMem(addr, self.gRegs[SR]) self.debug('STR R' + str(SR) + ' -> mem(' + 'R' + str(BR) + ' + ' + str(offset.int()) + ')') def LEA(self, DR, offset): self.gRegs[DR] = self.PC.ADD(offset) self.setCC(DR) self.debug('LEA R' + str(DR) + ' <- PC + ' + str(offset.intCom())) def TRAP(self, vector): self.gRegs[7] = self.PC # R7 <- PC self.PC = self.readMem(Number(16, 'b00000000' + vector)) # PC <- mem[ZEX(vector)] self.debug('TRAP V' + vector) def RTI(self): # Return From interrupt privileged = (self.PSR.data[0] == '0') if privileged: SSP = self.gRegs[6] self.PC = self.readMem(SSP) self.PSR = self.readMem(SSP.ADD(Number(self.wordLength, 1))) self.gRegs[6] = SSP.ADD(Number(self.wordLength, 2)) else: raise Exception("Exception: RTI not privileged") def interrupt(self, PL, vector): assert(len(vector) == 8) if int(self.PSR.data[5:8], 2) > int(PL, 2): self.debug("[CPU]: interrupt Rejected") return # Reject the interrupt addr = Number(16, 'b00000001' + vector) SSP = self.gRegs[6] self.writeMem(SSP.MINUS(Number(self.wordLength, 1)), self.PSR) self.writeMem(SSP.MINUS(Number(self.wordLength, 2)), self.PC) self.gRegs[6] = SSP.MINUS(Number(self.wordLength, 2)) self.PC = self.readMem(addr) self.PSR = Number(16, 'b00000' + PL + '00000000') self.debug("[CPU]: interrupt accepted") self.ch = -1
def expression(self): """Match the grammar of an expression.""" operator = None if self.current.kind == "+": operator = self.match("+") elif self.current.kind == "-": operator = self.match("-") self.stack.append("Term") cur = self.term() if operator != None and operator.kind == "-": # Negate the expression if needed. if isinstance(cur, Number): # Constant folding. cur = Number(Constant(self.integer_type, eval(str(operator.kind) + str(cur.entry.value)))) else: if isinstance(cur, VariableAST) and ( isinstance(cur.variable, Array) or isinstance(cur.variable, Record) ): # Trying to perform an operation on non-integers. try: raise InvalidArithmeticOperation(cur, self.last) except InvalidArithmeticOperation as e: self.invalid_token(e) else: cur = Binary(operator.kind, Number(Constant(self.integer_type, 0)), cur, self.integer_type) # Remember the token for node in case of run time errors. cur.token = self.last # 0 or more patterns. while True: if self.current.kind in {"+", "-"}: if self.current.kind == "+": operator = self.match("+") else: operator = self.match("-") self.stack.append("Term") var = self.term() if isinstance(cur, Number) and isinstance(var, Number): # Constant folding. cur = Number( Constant( self.integer_type, eval(str(cur.entry.value) + str(operator.kind) + str(var.entry.value)) ) ) else: if isinstance(cur, VariableAST) and ( isinstance(cur.variable, Array) or isinstance(cur.variable, Record) ): # Trying to perform an operation on non-integers. try: raise InvalidArithmeticOperation(cur, self.last) except InvalidArithmeticOperation as e: self.invalid_token(e) else: cur = Binary(operator.kind, cur, var, self.integer_type) # Remember token for node in case of run time errors. cur.token = self.last else: # Pattern ended. break if cur == None: # Return an invalid variable node in case of parsing errors. cur = VariableAST("INVALID", Variable(Invalid())) return cur
def convert(self, value, from_decimal): value = int(value) return Number.convert(self, value, from_decimal)
def __init__(self): Number.__init__(self, 8)
from Number import Number from TerminalHandler import TerminalHandler from Game import Game number = Number(4, 10, 2, 'red') print(number.render()) game = Game() game.addObject(Number(4, 10, 2, 'red')) game.addObject(Number(1, 20, 2, 'red')) game.addObject(Number(123, 3, 10, 'blue')) game.render(0) while(True): pass