Exemplo n.º 1
0
    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)
Exemplo n.º 2
0
 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()))
Exemplo n.º 3
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')
Exemplo n.º 4
0
 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)))
Exemplo n.º 5
0
    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
Exemplo n.º 6
0
    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
Exemplo n.º 7
0
	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
Exemplo n.º 9
0
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
Exemplo n.º 10
0
    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
Exemplo n.º 11
0
    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]
Exemplo n.º 12
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
Exemplo n.º 13
0
    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))
Exemplo n.º 14
0
 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
Exemplo n.º 15
0
	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
Exemplo n.º 16
0
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
Exemplo n.º 17
0
    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")
Exemplo n.º 19
0
    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
Exemplo n.º 21
0
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
Exemplo n.º 22
0
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
Exemplo n.º 23
0
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
Exemplo n.º 24
0
 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)]
Exemplo n.º 25
0
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
Exemplo n.º 26
0
 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)]
Exemplo n.º 27
0
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)
Exemplo n.º 28
0
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
Exemplo n.º 29
0
    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
Exemplo n.º 31
0
 def VisitNumNode(self, node, context):
     return RTResult().success(
         Number(node.token.value).setContext(context).setPosition(
             node.startPos, node.endPos))
Exemplo n.º 32
0
            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)
Exemplo n.º 33
0
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
Exemplo n.º 34
0
    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
Exemplo n.º 35
0
 def convert(self, value, from_decimal):
     value = int(value)
     return Number.convert(self, value, from_decimal)
Exemplo n.º 36
0
 def __init__(self):
     Number.__init__(self, 8)
Exemplo n.º 37
0
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