예제 #1
0
파일: core.py 프로젝트: ProgVal/vMars
 def write(self, ptr, instruction=None, **kwargs):
     data = cvar(dict)
     old_instruction = cvar(object)
     if STRICT and not isinstance(ptr, int):
         raise ValueError('Pointer must be an integer, not %r' % ptr)
     ptr %= self.size
     if instruction is not None:
         if not isinstance(instruction, Instruction):
             raise TypeError('The instruction parameter must be an '
                     'Instruction instance')
         if STRICT and kwargs != {}:
             raise ValueError('Cannot supply extra attribute if '
                     'instruction is given')
         with self._lock:
             old_instruction = self._memory[ptr]
             self._memory[ptr] = instruction
         for callback in self._callbacks:
             callback(ptr, old_instruction, instruction)
     else:
         for key in kwargs:
             if key not in SYNTAX.data_blocks:
                 raise ValueError('%r is not a valid data block.')
         data = self.read(ptr).as_dict
         data.update(kwargs)
         self.write(ptr, Instruction(**data))
예제 #2
0
파일: core.py 프로젝트: ProgVal/vMars
    def _read(self, memory, ptr):
        """Return input data of the instruction, based on modifiers.

        Data with None should _never_ be read."""
        m = cvar(str)
        A = cvar(object)
        B = cvar(object)

        m = self.modifier
        A = memory.read(memory.get_absolute_ptr(ptr, self.A))
        B = memory.read(memory.get_absolute_ptr(ptr, self.B))
        if m == 'A':
            return ((None, None, A.A, None), (None, None, B.A, None))
        elif m == 'B':
            return ((None, None, A.B, None), (None, None, B.B, None))
        elif m == 'AB':
            return ((None, None, A.A, None), (None, None, B.B, None))
        elif m == 'BA':
            return ((None, None, A.B, None), (None, None, B.A, None))
        elif m == 'F':
            return ((None, None, A.A, A.B ), (None, None, B.A, B.B ))
        elif m == 'X':
            return ((None, None, A.A, A.B ), (None, None, B.B, B.A ))
        elif m == 'I':
            return (A.as_tuple, B.as_tuple)
        else:
            assert False
예제 #3
0
파일: core.py 프로젝트: ProgVal/vMars
    def _math(self, A, B, function):
        "Shortcut for running math operations."
        res1 = cvar(str)
        res2 = cvar(str)

        assert None not in (A[2], B[2])
        res1 = B[2][0]+str(function(get_int(A[2]), get_int(B[2])))
        res2 = None
        if A[3] is not None:
            assert B[3] is not None
            res2 = B[3][0]+str(function(get_int(A[3]), get_int(B[3])))
        return (B[0], B[1], res1, res2)
예제 #4
0
파일: core.py 프로젝트: ProgVal/vMars
    def _write(self, memory, dest, inst):
        """Writes data to the memory"""
        m = cvar(str)

        m = self.modifier
        if isinstance(inst, tuple):
            if m != 'I':
                # Add an opcode if needed, so it passes sanity checks
                inst = (inst[0] or 'DAT', inst[1], inst[2], inst[3])
            inst = Instruction.from_tuple(inst)
        elif STRICT and not isinstance(inst, Instruction):
            raise ValueError('You can only write tuples and instructions, '
                    'not %r' % inst)
        if STRICT and not isinstance(dest, int):
            raise ValueError('Destination must be an int, not %r.' % dest)

        if m == 'A':
            memory.write(dest, A=inst.A)
        elif m == 'B':
            memory.write(dest, B=inst.A)
        elif m == 'AB':
            memory.write(dest, B=inst.A)
        elif m == 'BA':
            memory.write(dest, A=inst.A)
        elif m == 'F':
            memory.write(dest, A=inst.A, B=inst.B)
        elif m == 'X':
            memory.write(dest, B=inst.B, A=inst.A)
        elif m == 'I':
            memory.write(dest, instruction=inst)
        else:
            assert False
예제 #5
0
파일: core.py 프로젝트: ProgVal/vMars
    def _increment(self, memory, ptr, field):
        "Shortcut for incrementing fields."
        inst = cvar(object)

        inst = memory.read(ptr + get_int(field))
        if field.startswith('}'):
            inst.A = inst.A[0] + str(int(inst.A[1:])+1)
        elif field.startswith('>'):
            inst.B = inst.B[0] + str(int(inst.B[1:])+1)
예제 #6
0
파일: core.py 프로젝트: ProgVal/vMars
    def run(self, memory, ptr):
        oc = cvar(str)
        dest = cvar(int)
        A = cvar(object)
        B = cvar(object)
        threads = cvar(list)

        assert memory.read(ptr) == self

        # Predecrement
        for field in (self.A, self.B):
            inst = memory.read(ptr + get_int(field))
            if field.startswith('{'):
                inst.A = inst.A[0] + str(int(inst.A[1:])-1)
            elif field.startswith('<'):
                inst.B = inst.B[0] + str(int(inst.B[1:])-1)

        oc = self.opcode

        # Postincrement
        # The order matters: http://www.koth.org/info/icws94.html#5.3.5
        self._increment(memory, ptr, self.A)
        dest = memory.get_absolute_ptr(ptr, self.B)
        self._increment(memory, ptr, self.B)
        A, B = self._read(memory, ptr)

        if oc == 'DAT':
            threads = []
        elif oc == 'NOP':
            threads = [ptr+1]
        elif oc == 'MOV':
            self._write(memory, dest, A)
            threads = [ptr+1]
        elif oc == 'ADD':
            self._write(memory, dest, self._math(A, B, lambda a,b:a+b))
            threads = [ptr+1]
        elif oc == 'SUB':
            self._write(memory, dest, self._math(A, B, lambda a,b:b-a))
            threads = [ptr+1]
        elif oc == 'MUL':
            self._write(memory, dest, self._math(A, B, lambda a,b:a*b))
            threads = [ptr+1]
        elif oc == 'DIV':
            try:
                self._write(memory, dest, self._math(A, B, lambda a,b:int(b/a)))
                threads = [ptr+1]
            except ZeroDivisionError:
                threads = []
        elif oc == 'MOD':
            try:
                self._write(memory, dest, self._math(A, B, lambda a,b:b%a))
                threads = [ptr+1]
            except ZeroDivisionError:
                threads = []
        elif oc == 'JMP':
            # Note that the modifier is ignored
            threads = [memory.get_absolute_ptr(ptr, self.A)]
        elif oc == 'JMZ':
            if get_int(B[2]) == 0 and \
                    (B[3] is None or get_int(B[3]) == 0):
                threads = [memory.get_absolute_ptr(ptr, self.A)]
            else:
                threads = [ptr+1]
        elif oc == 'JMN':
            if get_int(B[2]) == 0 and \
                    (B[3] is None or get_int(B[3]) == 0):
                threads = [ptr+1]
            else:
                threads = [memory.get_absolute_ptr(ptr, self.A)]
        elif oc == 'DJN':
            self.B = self.B[0] + str(get_int(self.B)-1)
            ptrB = memory.get_absolute_ptr(ptr, self.B)
            B = self._read(memory, ptrB)[1] # Load the new pointed data

            # Jump
            if get_int(B[2]) == 0 and \
                    (B[3] is None or get_int(B[3]) == 0):
                threads = [ptr+1]
            else:
                threads = [memory.get_absolute_ptr(ptr, self.A)]
        elif oc == 'CMP' or oc == 'SEQ':
            if A == B:
                threads = [ptr+2]
            else:
                threads = [ptr+1]
        elif oc == 'SLT':
            if get_int(A[2]) < get_int(B[2]) and \
                    (A[3] is None or A[3] < B[3]):
                threads = [ptr+2]
            else:
                threads = [ptr+1]
        elif oc == 'SPL':
            threads = [ptr+1, ptr+get_int(self.A)]
        else:
            raise NotImplementedError()

        return threads