Python __builtin__ 模块，type() 实例源码

def init(self, update=None, lang=None):
        '''
        Init pool
        Set update to proceed to update
        lang is a list of language code to be updated
        '''
        with self._lock:
            if not self._started:
                self.start()
        with self._locks[self.database_name]:
            # Don't reset pool if already init and not to update
            if not update and self._pool.get(self.database_name):
                return
            logger.info('init pool for "%s"', self.database_name)
            self._pool.setdefault(self.database_name, {})
            # Clean the _pool before loading modules
            for type in self.classes.keys():
                self._pool[self.database_name][type] = {}
            restart = not load_modules(self.database_name, self, update=update,
                    lang=lang)
            if restart:
                self.init()

def get(self, name, type='model'):
        '''
        Get an object from the pool

        :param name: the object name
        :param type: the type
        :return: the instance
        '''
        if type == '*':
            for type in self.classes.keys():
                if name in self._pool[self.database_name][type]:
                    break
        try:
            return self._pool[self.database_name][type][name]
        except KeyError:
            if type == 'report':
                from trytond.report import Report
                # Keyword argument 'type' conflicts with builtin function
                cls = __builtin__.type(str(name), (Report,), {})
                cls.__setup__()
                self.add(cls, type)
                return cls
            raise

def new(self, name, bits, idaname=None, **kwargs):
        '''Add a register to the architecture's cache.'''

        # older
        if idaapi.__version__ < 7.0:
            dtype_by_size = utils.compose(idaapi.get_dtyp_by_size, ord)
        # newer
        else:
            dtype_by_size = idaapi.get_dtyp_by_size

        dtyp = kwargs.get('dtyp', idaapi.dt_bitfild if bits == 1 else dtype_by_size(bits//8))
        namespace = dict(register_t.__dict__)
        namespace.update({'__name__':name, 'parent':None, 'children':{}, 'dtyp':dtyp, 'offset':0, 'size':bits})
        namespace['realname'] = idaname
        namespace['alias'] = kwargs.get('alias', set())
        res = type(name, (register_t,), namespace)()
        self.__register__.__state__[name] = res
        self.__cache__[idaname or name,dtyp] = name
        return res

def child(self, parent, name, offset, bits, idaname=None, **kwargs):
        '''Add a child-register to the architecture's cache.'''

        # older
        if idaapi.__version__ < 7.0:
            dtype_by_size = utils.compose(idaapi.get_dtyp_by_size, ord)
        # newer
        else:
            dtype_by_size = idaapi.get_dtyp_by_size

        dtyp = kwargs.get('dtyp', idaapi.dt_bitfild if bits == 1 else dtype_by_size(bits//8))
        namespace = dict(register_t.__dict__)
        namespace.update({'__name__':name, 'parent':parent, 'children':{}, 'dtyp':dtyp, 'offset':offset, 'size':bits})
        namespace['realname'] = idaname
        namespace['alias'] = kwargs.get('alias', set())
        res = type(name, (register_t,), namespace)()
        self.__register__.__state__[name] = res
        self.__cache__[idaname or name,dtyp] = name
        parent.children[offset] = res
        return res

def __init__(self, maxlen=132, indent=4, method='smart', prefix='&',
                 suffix='&'):
        # Line length should be long enough that contintuation lines can host at
        # east one character apart of indentation and two continuation signs
        minmaxlen = indent + len(prefix) + len(suffix) + 1
        if maxlen < minmaxlen:
            msg = 'Maximal line length less than {0} when using an indentation'\
                  ' of {1}'.format(minmaxlen, indent)
            raise FyppFatalError(msg)
        self._maxlen = maxlen
        self._indent = indent
        self._prefix = ' ' * self._indent + prefix
        self._suffix = suffix
        if method not in ['brute', 'smart', 'simple']:
            raise FyppFatalError('invalid folding type')
        if method == 'brute':
            self._inherit_indent = False
            self._fold_position_finder = self._get_maximal_fold_pos
        elif method == 'simple':
            self._inherit_indent = True
            self._fold_position_finder = self._get_maximal_fold_pos
        elif method == 'smart':
            self._inherit_indent = True
            self._fold_position_finder = self._get_smart_fold_pos

def _get_callable_argspec_py3(func):
    sig = inspect.signature(func)
    args = []
    defaults = {}
    vararg = None
    for param in sig.parameters.values():
        if param.kind == param.POSITIONAL_OR_KEYWORD:
            args.append(param.name)
            if param.default != param.empty:
                defaults[param.name] = param.default
        elif param.kind == param.VAR_POSITIONAL:
            vararg = param.name
        else:
            msg = "argument '{0}' has invalid argument type".format(param.name)
            raise FyppFatalError(msg)
    return args, defaults, vararg


# Signature objects are available from Python 3.3 (and deprecated from 3.5)

def traverse(self, edges, filter=lambda node:True, **kwds):
        """Will walk the elements returned by the generator ``edges -> node -> ptype.type``

        This will iterate in a top-down approach.
        """
        for self in edges(self, **kwds):
            if not isinstance(self, generic):
                continue

            if filter(self):
                yield self

            for y in self.traverse(edges=edges, filter=filter, **kwds):
                yield y
            continue
        return

def alloc(self, **attrs):
        """Will zero the ptype.container instance with the provided ``attrs``.

        This can be overloaded in order to allocate physical space for the new ptype.
        """

        # If there's a custom .blocksize changing the way this instance get's loaded
        #   then restore the original blocksize temporarily so that .alloc will actually
        #   allocate the entire object.
        if getattr(self.blocksize, 'im_func', None) is not container.blocksize.im_func:
            instancemethod = type.new.__class__
            func = container.blocksize.im_func
            method = instancemethod(func, self, self.__class__)
            attrs.setdefault('blocksize', method)

        return super(container, self).alloc(**attrs)

def append(self, object):
        """Add ``object`` to the ptype.container ``self``. Return the element's index.

        When adding ``object`` to ``self``, none of the offsets are updated and
        thus will need to be manually updated before committing to a provider.
        """

        # if we're uninitialized, then create an empty value and try again
        if self.value is None:
            self.value = []
            return self.append(object)

        # if object is not an instance, then try to resolve it to one and try again
        if not isinstance(object, generic):
            res = self.new(object)
            return self.append(res)

        # assume that object is now a ptype instance
        assert isinstance(object, generic), "container.append : {:s} : Tried to append unknown type to container : {:s}".format(self.instance(), object.__class__)
        object.parent,object.source = self,None

        current = len(self.value)
        self.value.append(object if object.initializedQ() else object.a)
        return current

def define(cls, *definition, **attributes):
        """Add a definition to the cache keyed by the .type attribute of the definition. Return the original definition.

        If any ``attributes`` are defined, the definition is duplicated with the specified attributes before being added to the cache.
        """
        def clone(definition):
            res = dict(definition.__dict__)
            res.update(attributes)
            #res = __builtin__.type(res.pop('__name__',definition.__name__), definition.__bases__, res)
            res = __builtin__.type(res.pop('__name__',definition.__name__), (definition,), res)
            cls.add(getattr(res,cls.attribute),res)
            return definition

        if attributes:
            assert len(definition) == 0, 'Unexpected positional arguments'
            return clone
        res, = definition
        cls.add(getattr(res,cls.attribute),res)
        return res

def reference(self, object, **attrs):
        """Reference ``object`` and encode it into self"""
        object = self.__hook(object)

        # take object, and encode it to an encoded type
        enc = self.encode(object, **attrs)

        # take encoded type and cast it to self's wrapped type in order to preserve length
        res = enc.cast(self._value_, **attrs)

        # now that the length is correct, write it to the wrapper_t
        res.commit(offset=0, source=provider.proxy(self))

        # assign some default attributes to object
        object.__name__ = '*'+self.name()
        self._object_ = object.__class__
        return self

def test_container_copy():
        class leaf_sr(ptype.type):
            length = 4
        class leaf_jr(ptype.type):
            length = 2

        class branch(ptype.container): pass

        a = branch(source=prov.empty())
        a.set(leaf_sr, leaf_jr, branch().set(leaf_jr,leaf_jr,leaf_jr))
        b = a.copy()
        if b.v[2].v[1].size() == leaf_jr.length:
            raise Success

    # XXX: test casting between block types and stream types (szstring) as this
    #      might've been broken at some point...

def test_decompression_block():
        from ptypes import dynamic,pint,pstruct,ptype
        class cblock(pstruct.type):
            class _zlibblock(ptype.encoded_t):
                _object_ = ptype.block
                def encode(self, object, **attrs):
                    data = object.serialize().encode('zlib')
                    return super(cblock._zlibblock,self).encode(ptype.block().set(data), length=len(data))
                def decode(self, object, **attrs):
                    data = object.serialize().decode('zlib')
                    return super(cblock._zlibblock,self).decode(ptype.block().set(data), length=len(data))

            def __zlibblock(self):
                return ptype.clone(self._zlibblock, _value_=dynamic.block(self['size'].l.int()))

            _fields_ = [
                (pint.uint32_t, 'size'),
                (__zlibblock, 'data'),
            ]
        message = 'hi there.'
        cmessage = message.encode('zlib')
        data = pint.uint32_t().set(len(cmessage)).serialize()+cmessage
        a = cblock(source=prov.string(data)).l
        if a['data'].d.l.serialize() == message:
            raise Success

def __init__(self, *args, **kwds):
        super(enum, self).__init__(*args, **kwds)

        # invert ._values_ if they're defined backwards
        if len(self._values_):
            name, value = self._values_[0]
            if isinstance(value, basestring):
                Log.warning("pint.enum : {:s} : {:s}._values_ is defined backwards. Inverting it's values.".format(self.classname(), self.typename()))
                self._values_ = [(k,v) for v,k in self._values_]

        # verify the types are correct for ._values_
        if any(not isinstance(k, basestring) or not isinstance(v, six.integer_types) for k,v in self._values_):
            raise TypeError(self, 'enum.__init__', "{:s}._values_ is of an incorrect format. Should be [({:s}, {:s}), ...]".format(self.classname(), basestring, int))

        # FIXME: fix constants within ._values_ by checking to see if they're out of bounds of our type
        return

def test_load(cls, integer, expected):
        if cls.length == 4:
            expected, = struct.unpack('f', struct.pack('f', expected))
            i,_ = bitmap.join(bitmap.new(ord(x),8) for x in reversed(struct.pack('f',expected)))
        elif cls.length == 8:
            expected, = struct.unpack('d', struct.pack('d', expected))
            i,_ = bitmap.join(bitmap.new(ord(x),8) for x in reversed(struct.pack('d',expected)))
        else:
            i = 0

        a = cls()
        super(type,a).set(integer)
        n = a.getf()

        if n == expected:
            raise Success
        raise Failure('getf: 0x%x == %s? %s (%s) %x'%( integer, expected, a.num(), n, i))

    ## tests for floating-point

def __init__(self, *args, **kwargs):

        self.data = {}

        # Initialise from sequence object

        if len(args) == 1 and type(args[0]) == list:
            for item in args[0]:
                self[item[0]] = item[1]

        # Initialise from mapping object

        if len(args) == 1 and type(args[0]) == dict:
            self.update(args[0])

        # Initialise from NocaseDict

        if len(args) == 1 and isinstance(args[0], NocaseDict):
            self.data = args[0].data.copy()

        # Initialise from keyword args

        self.update(kwargs)

    # Basic accessor and settor methods

def __str__(self):

        s = ''

        if self.host is not None:
            s += '//%s/' % self.host

        if self.namespace is not None:
            s += '%s:' % self.namespace

        s += '%s.' % self.classname

        for key, value in self.keybindings.items():

            s +='%s=' % key

            if type(value) == int or type(value) == long:
                s += str(value)
            else:
                s += '"%s"' % value

            s += ','

        return s[:-1]

def __setitem__(self, key, value):

        # Don't let anyone set integer or float values.  You must use
        # a subclass from the cim_type module.

        if type(value) == int or type(value) == float or type(value) == long:
            raise TypeError('Must use a CIM type assigning numeric values.')

        if self.property_list is not None and key.lower() not in \
                self.property_list:
            if self.path is not None and key not in self.path.keybindings:
                return
        # Convert value to appropriate PyWBEM type

        if isinstance(value, CIMProperty):
            v = value
        else:
            v = CIMProperty(key, value)

        self.properties[key] = v
        if self.path is not None and key in self.path.keybindings:
            self.path[key] = v.value

def tocimxml(self):

        props = []

        for key, value in self.properties.items():

            # Value has already been converted into a CIM object
            # property type (e.g for creating null property values).

            if isinstance(value, CIMProperty):
                props.append(value)
                continue

            props.append(CIMProperty(key, value))

        instance_xml = cim_xml.INSTANCE(
            self.classname,
            properties = [p.tocimxml() for p in props],
            qualifiers = [q.tocimxml() for q in self.qualifiers.values()])

        if self.path is None:
            return instance_xml

        return cim_xml.VALUE_NAMEDINSTANCE(self.path.tocimxml(),
                                           instance_xml)

def tomof(self):

        def _prop2mof(_type, value):
            if value is None:
                val = 'NULL'
            elif isinstance(value, list):
                val = '{'
                for i,x in enumerate(value):
                    if i > 0:
                        val += ', '
                    val += _prop2mof(_type, x)
                val += '}'
            elif _type == 'string':
                val = '"' + value + '"'
            else:
                val = str(value)
            return val

        s = 'instance of %s {\n' % self.classname
        for p in self.properties.values():
            s+= '\t%s = %s;\n' % (p.name, _prop2mof(p.type, p.value))
        s+= '};\n'

        return s

def tocimxml(self):

        value = None

        if type(self.value) == list:
            value = VALUE_ARRAY([VALUE(v) for v in self.value])
        elif self.value is not None:
            value = VALUE(self.value)

        return QUALIFIER(self.name,
                         self.type,
                         value,
                         propagated = self.propagated,
                         overridable = self.overridable,
                         tosubclass = self.tosubclass,
                         toinstance = self.toinstance,
                         translatable = self.translatable)

def __cmp__(self, other):

        if self is other:
            return 0
        elif not isinstance(other, CIMQualifierDeclaration):
            return 1

        return (cmpname(self.name, other.name) or
                cmp(self.type, other.type) or
                cmp(self.value, other.value) or
                cmp(self.is_array, other.is_array) or
                cmp(self.array_size, other.array_size) or
                cmp(self.scopes, other.scopes) or
                cmp(self.overridable, other.overridable) or
                cmp(self.tosubclass, other.tosubclass) or
                cmp(self.toinstance, other.toinstance) or
                cmp(self.translatable, other.translatable))

def __new__(cls, name, bases, dct):
        new = type.__new__(cls, name, bases, dct)
        if '__name__' in dct:
            try:
                new.__name__ = dct['__name__']
            except TypeError:
                new.__name__ = dct['__name__'].encode('utf-8')
        return new

def add(self, cls, type='model'):
        '''
        Add a classe to the pool
        '''
        with self._locks[self.database_name]:
            self._pool[self.database_name][type][cls.__name__] = cls

def iterobject(self, type='model'):
        '''
        Return an iterator over object name, object

        :param type: the type
        :return: an iterator
        '''
        return self._pool[self.database_name][type].iteritems()

def type(self):
        '''Returns the IDA dtype of the register.'''
        return self.dtyp

def define(cls, processor, type):
        def decorator(fn):
            res = processor, type
            return cls.cache.setdefault(res, fn)
        return decorator

def lookup(cls, type, processor=None):
        try: return cls.cache[processor or idaapi.ph.id, type]
        except KeyError: return cls.cache[0, type]

def type(cls, op, processor=None):
        res = cls.lookup(op.type, processor=processor)
        return res.__name__

def operand(ea, none):
    '''Return all the op_t's of the instruction at ``ea``.'''
    insn = at(ea)
    res = itertools.takewhile(utils.compose(operator.attrgetter('type'), functools.partial(operator.ne, idaapi.o_void)), insn.Operands)
    if idaapi.__version__ < 7.0:
        return tuple(op.copy() for op in res)
    res = ((idaapi.op_t(), op) for op in res)
    return tuple([n.assign(op), n][1] for n, op in res)

def op_type(n):
    '''Returns the string type of the ``n``th operand for the instruction at the current address.'''
    return op_type(ui.current.address(), n)

def op_type(ea, n):
    """Returns the string type of the ``n``th operand for the instruction at the address ``ea``.
    Some of the types returned are: imm, reg, phrase, or addr
    """
    res = operand(ea, n)
    return __optype__.type(res)

def op_value(ea, n):
    """Returns the value of the ``n``th operand for the instruction at the address ``ea``.

    The formats are based on the operand type as emitted by the ins.op_type function:
    imm -> integer
    reg -> register name
    addr -> address
    phrase -> (offset, base-register name, index-register name, scale)
    """
    res = operand(ea, n)
    return __optype__.decode(res)

def op_refs(n):
    '''Returns the (address, opnum, type) of all the instructions that reference the ``n``th operand of the current instruction.'''
    return op_refs(ui.current.address(), n)

def is_return(ea):
    '''Returns True if the instruction at ``ea`` is a ret-type instruction.'''
    idaapi.decode_insn(ea)
    return database.is_code(ea) and idaapi.is_ret_insn(ea)
#    return feature(ea) & idaapi.CF_STOP == idaapi.CF_STOP

def register(op):
        '''Return the operand as a register_t.'''
        dtype_by_size = utils.compose(idaapi.get_dtyp_by_size, ord) if idaapi.__version__ < 7.0 else idaapi.get_dtyp_by_size
        if op.type in (idaapi.o_reg,):
            res, dt = op.reg, dtype_by_size(database.config.bits()//8)
            return reg.by_indextype(res, op.dtyp)
        optype = "{:s}({:d})".format('idaapi.o_reg', idaapi.o_reg)
        raise TypeError("{:s}.register(...) : {:s} : Invalid operand type. : {:d}".format('.'.join((__name__, 'operand_types')), s_optype, op.type))

def immediate(op):
        '''Return the operand as an integer.'''
        if op.type in (idaapi.o_imm,idaapi.o_phrase):
            bits = idaapi.get_dtyp_size(op.dtyp) * 8
            return op.value & (2**bits-1)
        optype = "{:s}({:d})".format('idaapi.o_imm', idaapi.o_imm)
        raise TypeError("{:s}.immediate(...) : {:s} : Invalid operand type. : {:d}".format('.'.join((__name__, 'operand_types')), optype, op.type))

def memory(op):
        '''Return the operand.addr field from an operand.'''
        if op.type in (idaapi.o_mem,idaapi.o_far,idaapi.o_near,idaapi.o_displ):
            seg,sel = (op.specval & 0xffff0000) >> 16, (op.specval & 0x0000ffff) >> 0
            return op.addr
        optype = map(utils.unbox("{:s}({:d})".format), [('idaapi.o_far', idaapi.o_far), ('idaapi.o_near', idaapi.o_near)])
        raise TypeError("{:s}.address(...) : {:s},{:s} : Invalid operand type. : {:d}".format('.'.join((__name__, 'operand_types')), optype[0], optype[1], op.type))

def __newprc__(id):
    plfm, m = idaapi.ph.id, __import__('sys').modules[__name__]
    if plfm == idaapi.PLFM_386:     # id == 15
        m.reg = Intel()
        m.register = m.reg.r
    elif plfm == idaapi.PLFM_ARM:   # id == 1
        m.reg = AArch32()
        m.register = m.reg.r
    else:
        logging.warn("{:s} : IDP_Hooks.newprc({:d}) : {:d} : Unknown processor type. instruction module might not work properly.".format(__name__, id, plfm))
    return

def __eq__(self, other):
            classname = self.__class__.__name__
            if isinstance(other, basestring):
                if other.endswith(')'):
                    other_name = other.split('(')[0]
                    other_size = other.split('(')[-1].split(')')[0]
                    try: return cmp(classname, other_name) == 0 and self.size == int(other_size)
                    except ValueError: return False
                return cmp(classname, other) == 0
            return isinstance(self, other) if isinstance(other, __builtin__.type) else super(object, self) == other

def isiterator(t):
    """True if type ``t`` is iterable"""
    # FIXME: also insure that it's not a class with these attributes
    return hasattr(t, '__iter__') and hasattr(t, 'next')

def iscallable(t):
    """True if type ``t`` is a code object that can be called"""
    return callable(t) and hasattr(t, '__call__')

def istype(t):
    """True if type ``t`` inherits from ptype.type"""
    return t.__class__ is t.__class__.__class__ and not isresolveable(t) and (isinstance(t, types.ClassType) or hasattr(object, '__bases__')) and issubclass(t, generic)

def iscontainer(t):
    """True if type ``t`` inherits from ptype.container """
    return (istype(t) and issubclass(t, container)) or pbinary.istype(t)

def isresolveable(t):
    """True if type ``t`` can be descended into"""
    return isinstance(t, (types.FunctionType, types.MethodType))    # or isiterator(t)

def force(t, self, chain=None):
    """Resolve type ``t`` into a ptype.type for the provided object ``self``"""
    if chain is None:
        chain = []
    chain.append(t)

    # of type pbinary.type. we insert a partial node into the tree
    if pbinary.istype(t):
        t = clone(pbinary.partial, _object_=t)
        return t

    # of type ptype
    if istype(t) or isinstance(t, base):
        return t

    # functions
    if isinstance(t, types.FunctionType):
        res = t(self)
        return force(res, self, chain)

    # bound methods
    if isinstance(t, types.MethodType):
        return force(t(), self, chain)

    if inspect.isgenerator(t):
        return force(next(t), self, chain)

    if False:
        # and lastly iterators
        if isiterator(t):
            return force(next(t), self, chain)

    path = ','.join(self.backtrace())
    raise error.TypeError(self, 'force<ptype>', message='chain={!r} : Refusing request to resolve {!r} to a type that does not inherit from ptype.type : {{{:s}}}'.format(chain, t, path))

def instance(self):
        """Returns a minimal string describing the type and it's location"""
        name,ofs = self.classname(),self.getoffset()
        try:
            bs = self.blocksize()
            return '{:s}[{:x}:+{:x}]'.format(name, ofs, bs)
        except:
            pass
        return '{:s}[{:x}:+???]'.format(name, ofs)

def hexdump(self, **options):
        """Return a hexdump of the type using utils.hexdump(**options)

        Options can provide formatting specifiers
        terse -- display the hexdump tersely if larger than a specific threshold
        threshold -- maximum number of rows to display
        """
        options.setdefault('width', Config.display.hexdump.width)
        options.setdefault('offset', self.getoffset())
        return utils.hexdump(self.serialize(), **options)

def getparent(self, *args, **kwds):
        """Returns the creator of the current type.

        If nothing is specified, return the parent element.

        If an argument is provided, return the element whose parent is the one
        specified.

        If the ``type`` argument is specified, recursively descend into .parent
        elements until encountering an instance that inherits from the one
        provided.
        """
        if len(args) == 0 and 'type' not in kwds:
            return self.parent

        t = args[0] if len(args) > 0 else kwds['type']

        if self.__class__ is t:
            return self

        #if self.__class__ == t or self is t or (isinstance(t,__builtin__.type) and (isinstance(self,t) or issubclass(self.__class__,t))):
        #    return self

        for x in self.traverse(edges=lambda node:(node.parent for x in range(1) if node.parent is not None)):
            if x.parent is t or (isinstance(t,__builtin__.type) and (isinstance(x,t) or issubclass(x.__class__,t))):
                return x
            continue

        # XXX
        chain = ';'.join(utils.repr_instance(x.classname(),x.name()) for x in self.traverse(edges=lambda node:(node.parent for x in range(1) if node.parent is not None)))
        try: bs = hex(self.blocksize())
        except: bs = '???'
        raise error.NotFoundError(self, 'base.getparent', message="match {:s} not found in chain : {:s}[{:x}:+{:s}] : {:s}".format(type.typename(), self.classname(), self.getoffset(), bs, chain))

def new(self, t, **attrs):
        """Create a new instance of ``ptype`` with the provided ``attrs``

        If any ``attrs`` are provided, this will assign them to the new instance.
        The newly created instance will inherit the current object's .source and
        any .attributes designated by the current instance.
        """

        if 'recurse' in attrs:
            attrs['recurse'].update(self.attributes)
        else:
            attrs['recurse'] = self.attributes

        attrs.setdefault('parent', self)

        # instantiate an instance if we're given a type
        if not(istype(t) or isinstance(t,generic)):
            raise error.TypeError(self, 'base.new', message='{!r} is not a ptype class'.format(t.__class__))

        # if it's a type, then instantiate it
        if istype(t):
            t = t(**attrs)

        # if already instantiated, then update it's attributes
        elif isinstance(t,generic):
            t.__update__(**attrs)

        # give the instance a default name
        if '__name__' in attrs:
            t.__name__ = attrs['__name__']
        return t