Das deutsche Python-Forum

Code: Alles auswählen

class Foo(object):
    def status_from_byte1(self, status):
        self.flag_C = [0, 1][0 != status & 1]
        self.flag_V = [0, 1][0 != status & 2]
        self.flag_Z = [0, 1][0 != status & 4]
        self.flag_N = [0, 1][0 != status & 8]
        self.flag_I = [0, 1][0 != status & 16]
        self.flag_H = [0, 1][0 != status & 32]
        self.flag_F = [0, 1][0 != status & 64]
        self.flag_E = [0, 1][0 != status & 128]

    def status_from_byte2(self, status):
        self.flag_C = 0 if status & 1 == 0 else 1
        self.flag_V = 0 if status & 2 == 0 else 1
        self.flag_Z = 0 if status & 4 == 0 else 1
        self.flag_N = 0 if status & 8 == 0 else 1
        self.flag_I = 0 if status & 16 == 0 else 1
        self.flag_H = 0 if status & 32 == 0 else 1
        self.flag_F = 0 if status & 64 == 0 else 1
        self.flag_E = 0 if status & 128 == 0 else 1

    def status_from_byte3(self, status):
        data = tuple([int(x) for x in '{0:08b}'.format(status)])
        self.flag_E, \
        self.flag_F, \
        self.flag_H, \
        self.flag_I, \
        self.flag_N, \
        self.flag_Z, \
        self.flag_V, \
        self.flag_C = data

    def status_from_byte4(self, status):
        data = [0 if status & x == 0 else 1 for x in (128, 64, 32, 16, 8, 4, 2, 1)]
        self.flag_E, \
        self.flag_F, \
        self.flag_H, \
        self.flag_I, \
        self.flag_N, \
        self.flag_Z, \
        self.flag_V, \
        self.flag_C = data

    def status_as_byte(self):
        return self.flag_C | \
            self.flag_V << 1 | \
            self.flag_Z << 2 | \
            self.flag_N << 3 | \
            self.flag_I << 4 | \
            self.flag_H << 5 | \
            self.flag_F << 6 | \
            self.flag_E << 7

f = Foo()

for i in xrange(255):
    f.status_from_byte4(i)
    i2 = f.status_as_byte()
    assert i == i2

Code: Alles auswählen

class Foo(object):
    FLAGS = [(n, 2**i) for i, n in enumerate('CVZNIFE')]
    FLAG_PREFIX = 'flag_'

    def __init__(self):
        for name, _ in self.FLAGS:
            setattr(self, self.FLAG_PREFIX + name, False)

    @property
    def status_byte(self):
        return sum(
            m for n, m in self.FLAGS if getattr(self, self.FLAG_PREFIX + n)
        )

    @status_byte.setter
    def status_byte(self, status):
        for name, mask in self.FLAGS:
            setattr(self, self.FLAG_PREFIX + name, bool(status & mask))

Code: Alles auswählen

C, V, Z, N, I, H, F, E = (bool(status & (1 << i)) for i in xrange(8))

Code: Alles auswählen

status = sum(value << i for (i, value) in enumerate((C, V, Z, N, I, H, F, E)))

Code: Alles auswählen

def _property_bit(digit):
    def setter(self, value):
        if value:
            self.flags |= digit
        else: 
            self.flags &= ~digit 
    return property(lambda self: int(self.flags&digit!=0), setter)

class Foo(object):
    def __init__(self, flags):
        self.flags = flags
    
    flag_C = _property_bit(1)
    flag_V = _property_bit(2)
    flag_Z = _property_bit(4)
    flag_N = _property_bit(8)
    flag_I = _property_bit(16)
    flag_H = _property_bit(32)
    flag_F = _property_bit(64)
    flag_E = _property_bit(128)

Code: Alles auswählen

class Bar(object):
	# sorted flags in byte
	FLAGS = 'CVZNIHFE'
	# prototype for flag reading
	FLAG_PROTO = lambda cls, x: lambda self: (self._status >> x) & 1
	
	def __new__(cls, *arg, **kwarg):
		inst = object.__new__(cls, arg, kwarg)
		for i, c in enumerate(cls.FLAGS):
			setattr(cls, 'flag_' + c, property(inst.FLAG_PROTO(i)))
		return inst
		
	def __init__(self):
		self._status = 0
		
	@property
	def status(self):
		'''return status as byte'''
		return chr(self._status)
		
	@status.setter
	def status(self, value):
		'''set status from byte'''
		self._status = ord(value)

Code: Alles auswählen

class Foo(object):
    FLAGS = 'CVZNIHFE'
    FLAGS_SET = False
    
    @classmethod
    def _get_flag(cls, x):
        return lambda self: (self._status >> x) & 1
        
    @classmethod
    def _set_flag(cls, x):
        def set_flag(self, value):
            if value:
                self._status |= 1 << x
            else:
                self._status &= ~(1 << x)
        return set_flag
    
    def __new__(cls, *args, **kwargs):
        if not cls.FLAGS_SET:
            for i, c in enumerate(cls.FLAGS):
                setattr(cls, 'flag_' + c,
                        property(cls._get_flag(i), cls._set_flag(i)))
            cls.FLAGS_SET = True
        return object.__new__(cls, args, kwargs)
        
    def __init__(self):
        self._status = 0
        
    @property
    def status(self):
        return self._status
        
    @status.setter
    def status(self, value):
        self._status = value & 255

if __name__ == '__main__':		
        f = Foo()
        print bin(f.status)[2:].zfill(8), f.flag_C, f.flag_E
        f.flag_C = 1
        print bin(f.status)[2:].zfill(8), f.flag_C, f.flag_E
        f.flag_E = True
        f.flag_C = False
        print bin(f.status)[2:].zfill(8), f.flag_C, f.flag_E

Code: Alles auswählen

        if foo == bar:
            register_value = self.stack_pointer
            reg_attr_name = "stack_pointer"
...
        if bar==foo:
            ea = register_value
            setattr(self, reg_attr_name, register_value + 1)

Code: Alles auswählen

#define SET_Z(r)          ( REG_CC |= ((r) ? 0 : CC_Z) )
#define SET_N8(r)         ( REG_CC |= (r&0x80)>>4 )
#define SET_N16(r)        ( REG_CC |= (r&0x8000)>>12 )
#define SET_H(a,b,r)      ( REG_CC |= ((a^b^r)&0x10)<<1 )
#define SET_C8(r)         ( REG_CC |= (r&0x100)>>8 )
#define SET_C16(r)        ( REG_CC |= (r&0x10000)>>16 )
#define SET_V8(a,b,r)     ( REG_CC |= ((a^b^r^(r>>1))&0x80)>>6 )
#define SET_V16(a,b,r)    ( REG_CC |= ((a^b^r^(r>>1))&0x8000)>>14 )

Code: Alles auswählen

    def set_H(self, a, b, r):
        r2 = (a ^ b ^ r) & 0x10
        self.H = 0 if r2 == 0 else 1
        log.debug("\tset_H(): set half-carry flag to %i: ($%x ^ $%x ^ $%x) & 0x10 = $%x",
            self.H, a, b, r, r2
        )

    def set_Z8(self, r):
        r2 = r & 0xff
        self.Z = 1 if r2 == 0 else 0
        log.debug("\tset_Z8(): set zero flag to %i: $%02x & 0xff = $%02x",
            self.Z, r, r2
        )

    def set_Z16(self, r):
        r2 = r & 0xffff
        self.Z = 1 if r2 == 0 else 0
        log.debug("\tset_Z16(): set zero flag to %i: $%04x & 0xffff = $%04x",
            self.Z, r, r2
        )

    def set_N8(self, r):
        r2 = r & 0x80
        self.N = 0 if r2 == 0 else 1
        log.debug("\tset_N8(): set negative flag to %i: ($%02x & 0x80) = $%02x",
            self.N, r, r2
        )

    def set_N16(self, r):
        r2 = r & 0x8000
        self.N = 0 if r2 == 0 else 1
        log.debug("\tset_N16(): set negative flag to %i: ($%04x & 0x8000) = $%04x",
            self.N, r, r2
        )

    def set_C8(self, r):
        r2 = r & 0x100
        self.C = 0 if r2 == 0 else 1
        log.debug("\tset_C8(): carry flag to %i: ($%02x & 0x100) = $%02x",
            self.C, r, r2
        )

    def set_C16(self, r):
        r2 = r & 0x10000
        self.C = 0 if r2 == 0 else 1
        log.debug("\tset_C16(): carry flag to %i: ($%04x & 0x10000) = $%04x",
            self.C, r, r2
        )

    def set_V8(self, a, b, r):
        r2 = (a ^ b ^ r ^ (r >> 1)) & 0x80
        self.V = 0 if r2 == 0 else 1
        log.debug("\tset_V8(): overflow flag to %i: (($%02x ^ $%02x ^ $%02x ^ ($%02x >> 1)) & 0x80) = $%02x",
            self.V, a, b, r, r, r2
        )

    def set_V16(self, a, b, r):
        r2 = (a ^ b ^ r ^ (r >> 1)) & 0x8000
        self.V = 0 if r2 == 0 else 1
        log.debug("\tset_V16(): overflow flag to %i: (($%04x ^ $%04x ^ $%04x ^ ($%04x >> 1)) & 0x8000) = $%04x",
            self.V, a, b, r, r, r2
        )

Code: Alles auswählen

self.H = 0 if r2 == 0 else 1
self.H = bool(r2)

self.Z = 1 if r2 == 0 else 0
self.Z = not r2

Code: Alles auswählen

#define SET_N8(r)         ( REG_CC |= (r&0x80)>>4 )

Code: Alles auswählen

  REG_CC(zuvor)  |  rechts   -->  REG_CC(danach)
1     0               0                 0
2     0               1                 1
3     1               0                 1
4     1               1                 1

Code: Alles auswählen

self.N = 0 if r2 == 0 else 1

Code: Alles auswählen

if r & 0x80:
    self.N = 1
# else uninteressant, da N auf vorherigen Wert bleibt

Code: Alles auswählen

def set_N8(self, r):
    if r & 0x80:
        self.N = 1