Example #1
0
File: test.py Project: egils/OS
    def test_hex_int(self):

        assert int_to_hex(5) == '5'
        assert int_to_hex(10) == 'a'
        assert int_to_hex(5, 2) == '05'
        assert int_to_hex(32, 2) == '20'

        assert hex_to_int('5') == 5
        assert hex_to_int('a') == 10
        assert hex_to_int('05') == 5
        assert hex_to_int('20') == 32
Example #2
0
File: memory.py Project: egils/OS
    def create_virtual_memory(
            self, code, code_size, data, data_size,
            stdin_handler=None, stdout_handler=None):
        u""" Išskiria virtualią atmintį ir į ją įkelia kodą bei duomenis.
        """

        pager = Pager(
                self, C=code_size, D=data_size,
                stdin_handler=stdin_handler, stdout_handler=stdout_handler)

        # Įkeliamas kodo segmentas.
        vmcode = VirtualMemoryCode(self, pager)
        labels = {}
        clean_code = []
        for i, line in enumerate(code):
            if ':' in line:
                label, command = line.split(':')
                labels[label.strip()] = i
            else:
                command = line
            clean_code.append(command.strip().decode('utf-8'))

        for i, command in enumerate(clean_code):
            if u'«' in command:
                label = command.split(u'«', 1)[1].split(u'»', 1)[0]
                command = command.replace(
                        u'«{0}»'.format(label),
                        int_to_hex(labels[label], 3)).encode('utf-8')
            else:
                command = command.encode('utf-8')
            command += ' ' * (WORD_SIZE - len(command))
            vmcode[i] = command

        # Įkeliamas duomenų segmentas. 
        vmdata = VirtualMemoryData(self, pager)
        clean_data = {}
        address = 0
        for i, line in enumerate(data):
            result = re.search('^\[(?P<address>\w+)\]:', line)
            if result:
                hex_address = result.groupdict()['address']
                line = line[len('[{0}]:'.format(hex_address)):]
                address = hex_to_int(hex_address)
                if not clean_data.has_key(address):
                    clean_data[address] = []
            line = line.replace('\n', '')
            clean_data[address].append(line)

        word_format = '{{0:<{0}}}'.format(WORD_SIZE)
        for address, lines in clean_data.items():
            data = ''.join(lines)
            for i, j in enumerate(range(0, len(data), WORD_SIZE)):
                vmdata[address + i] = word_format.format(
                        data[j:j + WORD_SIZE])
        return vmcode, vmdata
Example #3
0
File: memory.py Project: egils/OS
    def get_code_cell_address(self, virtual_address):
        u""" Apskaičiuoja realų ląstelės adresą pagal kodo segmento
        virtualų adresą.
        """

        virtual_address = self.memory.get_address_int(virtual_address)
        C = self.get_C()

        min_address = 0
        max_address = C * BLOCK_SIZE
        if not (min_address <= virtual_address <= max_address):
            raise BadAddress(
                    u'Virtualus adresas nepriklauso kodo segmentui.')
        virtual_block, cell = self.memory.get_address_tuple(virtual_address)

        block = hex_to_int(
                self.get_byte(4 + 2 * virtual_block) +
                self.get_byte(4 + 2 * virtual_block + 1))
        return block, cell
Example #4
0
File: memory.py Project: egils/OS
    def get_data_cell_address(self, virtual_address):
        u""" Apskaičiuoja realų ląstelės adresą pagal duomenų segmento
        virtualų adresą.
        """

        virtual_address = self.memory.get_address_int(virtual_address)
        C = self.get_C()
        D = self.get_D()

        min_address = 0
        max_address = D * BLOCK_SIZE - 1
        if not (min_address <= virtual_address <= max_address):
            raise BadAddress(
                    u'Virtualus adresas nepriklauso duomenų segmentui.')
        virtual_block, cell = self.memory.get_address_tuple(virtual_address)

        block = hex_to_int(
                self.get_byte(4 + 2 * (C + virtual_block)) +
                self.get_byte(4 + 2 * (C + virtual_block) + 1))
        return block, cell
Example #5
0
        def convert(proc, *args):
            u""" Funkcija, kuri konvertuoja komandų argumentus.
            """

            if len(args) != len(self.signature):
                raise WrongOpCode(
                        u'Netinkamas argumentų kiekis.')
            clean_args = []
            for arg, arg_type in zip(args, self.signature):
                try:
                    if arg_type == 'a':
                        clean_args.append(hex_to_int(arg))
                    elif arg_type == 'i':
                        clean_args.append(int(arg))
                    elif arg_type == '?':
                        clean_args.append(arg)
                    else:
                        raise TypeError(
                                u'Blogas komandos parašas.')
                except ValueError:
                    raise WrongOpCode(
                            u'Netinkami komandos argumentai.')
            return fn(proc, *clean_args)
Example #6
0
File: memory.py Project: egils/OS
 def get_D(self):
     u""" Gražina duomenų segmento dydį blokais.
     """
     return hex_to_int(self.get_byte(2) + self.get_byte(3))
Example #7
0
File: memory.py Project: egils/OS
 def get_C(self):
     u""" Gražina kodo segmento dydį blokais.
     """
     return hex_to_int(self.get_byte(0) + self.get_byte(1))