Exemplo n.º 1
0
def convert_array(container, carray=None):
    ARRAY = container._TYPE
    if carray is None:
        # if 'container' is an inlined substructure, convert the whole
        # bigger structure at once
        parent, parentindex = lltype.parentlink(container)
        if parent is not None:
            convert_struct(parent)
            return
        # regular case: allocate a new ctypes array of the proper type
        cls = get_ctypes_type(ARRAY)
        carray = cls._malloc(container.getlength())
    add_storage(container, _array_mixin, carray)
    if not isinstance(ARRAY.OF, lltype.ContainerType):
        # fish that we have enough space
        ctypes_array = ctypes.cast(carray.items,
                                   ctypes.POINTER(carray.items._type_))
        for i in range(container.getlength()):
            item_value = container.items[i]  # fish fish
            ctypes_array[i] = lltype2ctypes(item_value)
        remove_regular_array_content(container)
    else:
        assert isinstance(ARRAY.OF, lltype.Struct)
        for i in range(container.getlength()):
            item_ptr = container.items[i]  # fish fish
            convert_struct(item_ptr, carray.items[i])
Exemplo n.º 2
0
    def setup(self):
        for value in self._getvalues():
            self.db.prepare_constant(lltype.typeOf(value), value)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 3
0
 def ref(self, firstitemptr):
     A = lltype.typeOf(firstitemptr).TO
     if A == self.TYPE:
         # for array of containers
         parent, index = lltype.parentlink(firstitemptr._obj)
         assert parent, "%r is not within a container" % (firstitemptr, )
         assert isinstance(
             lltype.typeOf(parent),
             (lltype.Array,
              lltype.FixedSizeArray)), ("%r is not within an array" %
                                        (firstitemptr, ))
         if isinstance(index, str):
             assert index.startswith('item')  # itemN => N
             index = int(index[4:])
         index += self.repeat
         if index == parent.getlength():
             # for references exactly to the end of the array
             try:
                 endmarker = _end_markers[parent]
             except KeyError:
                 endmarker = _endmarker_struct(A,
                                               parent=parent,
                                               parentindex=index)
                 _end_markers[parent] = endmarker
             return endmarker._as_ptr()
         else:
             return parent.getitem(index)._as_ptr()
     elif (isinstance(A, lltype.FixedSizeArray)
           and array_item_type_match(A.OF, self.TYPE)):
         # for array of primitives or pointers
         return lltype.direct_ptradd(firstitemptr, self.repeat)
     else:
         raise TypeError('got %r, expected %r' % (A, self.TYPE))
Exemplo n.º 4
0
 def setup(self):
     if isinstance(self.value, lltype._subarray):
         p, c = lltype.parentlink(self.value)
         if p is not None:
             self.db.prepare_constant(lltype.typeOf(p), p)
     else:
         super(FixedSizeArrayNode, self).setup()
Exemplo n.º 5
0
def convert_struct(container, cstruct=None):
    STRUCT = container._TYPE
    if cstruct is None:
        # if 'container' is an inlined substructure, convert the whole
        # bigger structure at once
        parent, parentindex = lltype.parentlink(container)
        if parent is not None:
            convert_struct(parent)
            return
        # regular case: allocate a new ctypes Structure of the proper type
        cls = get_ctypes_type(STRUCT)
        cstruct = cls._malloc()
    add_storage(container, _struct_mixin, cstruct)
    for field_name in STRUCT._names:
        FIELDTYPE = getattr(STRUCT, field_name)
        field_value = getattr(container, field_name)
        if not isinstance(FIELDTYPE, lltype.ContainerType):
            # regular field
            setattr(cstruct, field_name, lltype2ctypes(field_value))
        else:
            # inlined substructure/subarray
            if isinstance(FIELDTYPE, lltype.Struct):
                csubstruct = getattr(cstruct, field_name)
                convert_struct(field_value, csubstruct)
            else:
                raise NotImplementedError('inlined field', FIELDTYPE)
    remove_regular_struct_content(container)
Exemplo n.º 6
0
 def ref(self, firstitemptr):
     A = lltype.typeOf(firstitemptr).TO
     if A == self.TYPE:
         # for array of containers
         parent, index = lltype.parentlink(firstitemptr._obj)
         assert parent, "%r is not within a container" % (firstitemptr,)
         assert isinstance(lltype.typeOf(parent),
                           (lltype.Array, lltype.FixedSizeArray)), (
             "%r is not within an array" % (firstitemptr,))
         if isinstance(index, str):
             assert index.startswith('item')    # itemN => N
             index = int(index[4:])
         index += self.repeat
         if index == parent.getlength():
             # for references exactly to the end of the array
             try:
                 endmarker = _end_markers[parent]
             except KeyError:
                 endmarker = _endmarker_struct(A, parent=parent,
                                               parentindex=index)
                 _end_markers[parent] = endmarker
             return endmarker._as_ptr()
         else:
             return parent.getitem(index)._as_ptr()
     elif (isinstance(A, lltype.FixedSizeArray) and
           array_item_type_match(A.OF, self.TYPE)):
         # for array of primitives or pointers
         return lltype.direct_ptradd(firstitemptr, self.repeat)
     else:
         raise TypeError('got %r, expected %r' % (A, self.TYPE))
Exemplo n.º 7
0
def convert_struct(container, cstruct=None):
    STRUCT = container._TYPE
    if cstruct is None:
        # if 'container' is an inlined substructure, convert the whole
        # bigger structure at once
        parent, parentindex = lltype.parentlink(container)
        if parent is not None:
            convert_struct(parent)
            return
        # regular case: allocate a new ctypes Structure of the proper type
        cls = get_ctypes_type(STRUCT)
        if STRUCT._arrayfld is not None:
            n = getattr(container, STRUCT._arrayfld).getlength()
        else:
            n = None
        cstruct = cls._malloc(n)
    add_storage(container, _struct_mixin, ctypes.pointer(cstruct))
    for field_name in STRUCT._names:
        FIELDTYPE = getattr(STRUCT, field_name)
        field_value = getattr(container, field_name)
        if not isinstance(FIELDTYPE, lltype.ContainerType):
            # regular field
            if FIELDTYPE != lltype.Void:
                setattr(cstruct, field_name, lltype2ctypes(field_value))
        else:
            # inlined substructure/subarray
            if isinstance(FIELDTYPE, lltype.Struct):
                csubstruct = getattr(cstruct, field_name)
                convert_struct(field_value, csubstruct)
            elif field_name == STRUCT._arrayfld:    # inlined var-sized part
                csubarray = getattr(cstruct, field_name)
                convert_array(field_value, csubarray)
            else:
                raise NotImplementedError('inlined field', FIELDTYPE)
    remove_regular_struct_content(container)
Exemplo n.º 8
0
def convert_array(container, carray=None):
    ARRAY = container._TYPE
    if carray is None:
        # if 'container' is an inlined substructure, convert the whole
        # bigger structure at once
        parent, parentindex = lltype.parentlink(container)
        if parent is not None:
            convert_struct(parent)
            return
        # regular case: allocate a new ctypes array of the proper type
        cls = get_ctypes_type(ARRAY)
        carray = cls._malloc(container.getlength())
    add_storage(container, _array_mixin, ctypes.pointer(carray))
    if not isinstance(ARRAY.OF, lltype.ContainerType):
        # fish that we have enough space
        ctypes_array = ctypes.cast(carray.items,
                                   ctypes.POINTER(carray.items._type_))
        for i in range(container.getlength()):
            item_value = container.items[i]    # fish fish
            ctypes_array[i] = lltype2ctypes(item_value)
        remove_regular_array_content(container)
    else:
        assert isinstance(ARRAY.OF, lltype.Struct)
        for i in range(container.getlength()):
            item_ptr = container.items[i]    # fish fish
            convert_struct(item_ptr, carray.items[i])
Exemplo n.º 9
0
    def to_getelementptr(self, value):
        # so we build the thing up instead
        p = value
        children = []
        while True:
            p, c = lltype.parentlink(p)
            if p is None:
                break
            children.append((p, c))

        children.reverse()
        
        TYPE = lltype.typeOf(children[0][0])
        parentnode = self.obj2node[children[0][0]]

        indices = [("i32", 0)]

        for _, ii in children:
            typedefnode = self.obj2node[TYPE]
            if isinstance(ii, str):
                TYPE = typedefnode.fieldname_to_getelementptr(indices, ii)
            else:
                TYPE = typedefnode.indexref_to_getelementptr(indices, ii)

        indices_str = ', '.join ([('%s %s' % (x,y)) for x, y in indices])
        ref = "getelementptr(%s* %s, %s)" % (
            parentnode.get_typerepr(),
            parentnode.ref,
            indices_str)

        return ref
Exemplo n.º 10
0
 def setup(self):
     if isinstance(self.value, lltype._subarray):
         p, c = lltype.parentlink(self.value)
         if p is not None:
             self.db.prepare_constant(lltype.typeOf(p), p)
     else:
         super(FixedSizeArrayNode, self).setup()
Exemplo n.º 11
0
    def setup(self):
        for value in self._getvalues():
            self.db.prepare_constant(lltype.typeOf(value), value)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 12
0
    def setup(self):
        for item in self.value.items:
            self.db.prepare_constant(self.arraytype, item)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 13
0
    def get_pbcref(self, toptr):
        ref = self.ref
        p, c = lltype.parentlink(self.value)
        assert p is None, "child PBC arrays are NOT needed by rtyper"

        fromptr = "%s*" % self.get_typerepr()
        ref = "cast(%s %s to %s)" % (fromptr, ref, toptr)
        return ref
Exemplo n.º 14
0
    def setup(self):
        for name, T in self._get_types:
            assert T is not lltype.Void
            value = getattr(self.value, name)
            self.db.prepare_constant(T, value)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 15
0
    def setup(self):
        for value in self.db.gcpolicy.gcheader_initdata(self.value):
            self.db.prepare_constant(lltype.typeOf(value), value)
        for item in self.value.items:
            self.db.prepare_constant(self.arraytype, item)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 16
0
    def setup(self):
        for value in self.db.gcpolicy.gcheader_initdata(self.value):
            self.db.prepare_constant(lltype.typeOf(value), value)
        for item in self.value.items:
            self.db.prepare_constant(self.arraytype, item)

        p, c = lltype.parentlink(self.value)
        if p is not None:
            self.db.prepare_constant(lltype.typeOf(p), p)
Exemplo n.º 17
0
 def get_pbcref(self, toptr):
     """ Returns a reference as used per pbc. """        
     ref = self.ref
     p, c = lltype.parentlink(self.value)
     assert p is None, "child varsize struct are NOT needed by rtyper"
     fromptr = "%s*" % self.get_typerepr()
     refptr = "getelementptr(%s %s, int 0)" % (fromptr, ref)
     ref = "cast(%s %s to %s)" % (fromptr, refptr, toptr)
     return ref
Exemplo n.º 18
0
 def pyobj_initexpr(self):
     parent, parentindex = parentlink(self.obj)
     typenode = self.db.getcontainernode(self.obj.ob_type._obj)
     typenode.where_to_copy_me.append('(PyObject **) & %s.ob_type' % (
         self.name,))
     if typeOf(parent)._hints.get('inline_head'):
         return 'PyObject_HEAD_INIT(NULL)'
     else:
         return '{ PyObject_HEAD_INIT(NULL) },'
Exemplo n.º 19
0
 def get_ref(self):
     """ Returns a reference as used for operations in blocks. """        
     if self._get_ref_cache:
         return self._get_ref_cache
     p, c = lltype.parentlink(self.value)
     if p is None:
         ref = self.ref
     else:
         ref = self.db.get_childref(p, c)
     self._get_ref_cache = ref
     return ref
Exemplo n.º 20
0
 def get_ref(self):
     p, c = lltype.parentlink(self.value)
     if p is None:
         ref = self.ref
     else:
         ref = self.db.get_childref(p, c)
         if isinstance(self.value, lltype._subarray):
             # ptr -> array of len 1
             ref = "cast(%s* %s to %s*)" % (self.db.repr_type(self.arraytype),
                                            ref,
                                            self.db.repr_type(lltype.typeOf(self.value)))
     return ref
Exemplo n.º 21
0
    def get_ref(self):
        typeval = self.db.repr_type(lltype.typeOf(self.value))
        p, c = lltype.parentlink(self.value)
        if p is None:
            ref = self.ref
        else:
            ref = self.db.get_childref(p, c)

        ref = "cast(%s* %s to %s*)" % (self.get_typerepr(),
                                       ref,
                                       typeval)
        return ref
Exemplo n.º 22
0
 def get_ref(self):
     """ Returns a reference as used for operations in blocks. """        
     # XXX cache here is **dangerous** considering it can return different values :-(
     # XXX should write a test to prove this
     #if self._get_ref_cache:
     #    return self._get_ref_cache
     p, c = lltype.parentlink(self.value)
     if p is None:
         ref = self.ref
     else:
         ref = self.db.get_childref(p, c)
     #XXXself._get_ref_cache = ref
     return ref
Exemplo n.º 23
0
def reccollect(constants, llvalue):
    if isinstance(llvalue, lltype._abstract_ptr) and llvalue._obj is not None and llvalue._obj not in constants:
        TYPE = llvalue._T
        constants[llvalue._obj] = True
        if isinstance(TYPE, lltype.Struct):
            for name in TYPE._names:
                reccollect(constants, getattr(llvalue, name))
        elif isinstance(TYPE, lltype.Array):
            for llitem in llvalue:
                reccollect(constants, llitem)
        parent, parentindex = lltype.parentlink(llvalue._obj)
        if parent is not None:
            reccollect(constants, parent._as_ptr())
Exemplo n.º 24
0
def _find_parent(llobj):
    parent, parentindex = lltype.parentlink(llobj)
    if parent is None:
        return llobj, 0
    next_p, next_i = _find_parent(parent)
    if isinstance(parentindex, int):
        c_tp = get_ctypes_type(lltype.typeOf(parent))
        sizeof = ctypes.sizeof(get_ctypes_type(lltype.typeOf(parent).OF))
        ofs = c_tp.items.offset + parentindex * sizeof
        return next_p, next_i + ofs
    else:
        c_tp = get_ctypes_type(lltype.typeOf(parent))
        ofs = getattr(c_tp, parentindex).offset
        return next_p, next_i + ofs
Exemplo n.º 25
0
def reccollect(constants, llvalue):
    if (isinstance(llvalue, lltype._abstract_ptr) and llvalue._obj is not None
            and llvalue._obj not in constants):
        TYPE = llvalue._T
        constants[llvalue._obj] = True
        if isinstance(TYPE, lltype.Struct):
            for name in TYPE._names:
                reccollect(constants, getattr(llvalue, name))
        elif isinstance(TYPE, lltype.Array):
            for llitem in llvalue:
                reccollect(constants, llitem)
        parent, parentindex = lltype.parentlink(llvalue._obj)
        if parent is not None:
            reccollect(constants, parent._as_ptr())
Exemplo n.º 26
0
def _find_parent(llobj):
    parent, parentindex = lltype.parentlink(llobj)
    if parent is None:
        return llobj, 0
    next_p, next_i = _find_parent(parent)
    if isinstance(parentindex, int):
        c_tp = get_ctypes_type(lltype.typeOf(parent))
        sizeof = ctypes.sizeof(get_ctypes_type(lltype.typeOf(parent).OF))
        ofs = c_tp.items.offset + parentindex * sizeof
        return next_p, next_i + ofs
    else:
        c_tp = get_ctypes_type(lltype.typeOf(parent))
        ofs = getattr(c_tp, parentindex).offset
        return next_p, next_i + ofs
Exemplo n.º 27
0
def parentchain(container):
    current = container
    links = []
    while True:
        link = lltype.parentlink(current)
        if link[0] is None:
            try:
                addr = ctypes.addressof(container._storage)
                actual = _parent_cache[addr]
                if len(links) < len(actual):
                    return actual
            except KeyError:
                pass
            return links
        links.append(link)
        current = link[0]
Exemplo n.º 28
0
def parentchain(container):
    current = container
    links = []
    while True:
        link = lltype.parentlink(current)
        if link[0] is None:
            try:
                addr = ctypes.addressof(container._storage)
                actual = _parent_cache[addr]
                if len(links) < len(actual):
                    return actual
            except KeyError:
                pass
            return links
        links.append(link)
        current = link[0]
Exemplo n.º 29
0
    def dump_pbcs(self):
        r = ""
        for k, v in self.obj2node.iteritems():
            
            if isinstance(k, lltype.LowLevelType):
                continue

            assert isinstance(lltype.typeOf(k), lltype.ContainerType)
            # Only dump top levels
            p, _ = lltype.parentlink(k)
            if p is None:
                ref = v.get_ref()
                pbc_ref = v.get_ref()
                
                r += "\ndump_pbcs %s (%s)\n" \
                     "getref -> %s \n" \
                     "pbcref -> %s \n" % (v, k, ref, pbc_ref)
        return r
Exemplo n.º 30
0
 def ref(self, firstitemptr):
     A = lltype.typeOf(firstitemptr).TO
     if A == self.TYPE:
         # for array of containers
         parent, index = lltype.parentlink(firstitemptr._obj)
         assert parent, "%r is not within a container" % (firstitemptr,)
         assert isinstance(lltype.typeOf(parent),
                           (lltype.Array, lltype.FixedSizeArray)), (
             "%r is not within an array" % (firstitemptr,))
         if isinstance(index, str):
             assert index.startswith('item')    # itemN => N
             index = int(index[4:])
         return parent.getitem(index + self.repeat)._as_ptr()
     elif isinstance(A, lltype.FixedSizeArray) and A.OF == self.TYPE:
         # for array of primitives or pointers
         return lltype.direct_ptradd(firstitemptr, self.repeat)
     else:
         raise TypeError('got %r, expected %r' % (A, self.TYPE))
Exemplo n.º 31
0
    def dump_pbcs(self):
        r = ""
        for k, v in self.obj2node.iteritems():

            if isinstance(v, FuncImplNode):
                continue
            
            if isinstance(k, lltype.LowLevelType):
                continue

            assert isinstance(lltype.typeOf(k), lltype.ContainerType)
            
            # Only dump top levels
            p, _ = lltype.parentlink(k)
            type_ = self.repr_type(lltype.Ptr(lltype.typeOf(k)))
            r += "\ndump_pbcs %s (%s)\n" \
                 "parent %s\n" \
                 "type %s\n" \
                 "ref -> %s \n" % (v, k, p, type_, v.ref)
        return r
Exemplo n.º 32
0
 def __init__(self, db, T, obj):
     self.db = db
     self.T = T
     self.obj = obj
     # self.dependencies = {}
     self.typename = db.gettype(T)  # , who_asks=self)
     self.implementationtypename = db.gettype(T, varlength=self.getlength())
     parent, parentindex = parentlink(obj)
     if parent is None:
         self.name = db.namespace.uniquename("g_" + self.basename())
         self.globalcontainer = True
     else:
         self.globalcontainer = False
         parentnode = db.getcontainernode(parent)
         defnode = db.gettypedefnode(parentnode.T)
         self.name = defnode.access_expr(parentnode.name, parentindex)
     self.ptrname = "(&%s)" % self.name
     if self.typename != self.implementationtypename:
         ptrtypename = db.gettype(Ptr(T))
         self.ptrname = "((%s)(void*)%s)" % (cdecl(ptrtypename, ""), self.ptrname)
Exemplo n.º 33
0
 def __init__(self, db, T, obj):
     self.db = db
     self.T = T
     self.obj = obj
     #self.dependencies = {}
     self.typename = db.gettype(T)  #, who_asks=self)
     self.implementationtypename = db.gettype(T, varlength=self.getlength())
     parent, parentindex = parentlink(obj)
     if parent is None:
         self.name = db.namespace.uniquename('g_' + self.basename())
         self.globalcontainer = True
     else:
         self.globalcontainer = False
         parentnode = db.getcontainernode(parent)
         defnode = db.gettypedefnode(parentnode.T)
         self.name = defnode.access_expr(parentnode.name, parentindex)
     self.ptrname = '(&%s)' % self.name
     if self.typename != self.implementationtypename:
         ptrtypename = db.gettype(Ptr(T))
         self.ptrname = '((%s)(void*)%s)' % (cdecl(ptrtypename,
                                                   ''), self.ptrname)
Exemplo n.º 34
0
Arquivo: node.py Projeto: ieure/pypy
 def __init__(self, db, T, obj):
     self.db = db
     self.obj = obj
     #self.dependencies = {}
     self.typename = db.gettype(T)  #, who_asks=self)
     self.implementationtypename = db.gettype(T, varlength=self.getlength())
     parent, parentindex = parentlink(obj)
     if obj in exports.EXPORTS_obj2name:
         self.name = exports.EXPORTS_obj2name[obj]
         self.globalcontainer = True
     elif parent is None:
         self.name = db.namespace.uniquename('g_' + self.basename())
         self.globalcontainer = True
     else:
         self.globalcontainer = False
         parentnode = db.getcontainernode(parent)
         defnode = db.gettypedefnode(parentnode.getTYPE())
         self.name = defnode.access_expr(parentnode.name, parentindex)
     if self.typename != self.implementationtypename:
         if db.gettypedefnode(T).extra_union_for_varlength:
             self.name += '.b'
Exemplo n.º 35
0
Arquivo: node.py Projeto: njues/Sypy
 def __init__(self, db, T, obj):
     self.db = db
     self.obj = obj
     #self.dependencies = {}
     self.typename = db.gettype(T)  #, who_asks=self)
     self.implementationtypename = db.gettype(T, varlength=self.getlength())
     parent, parentindex = parentlink(obj)
     if obj in exports.EXPORTS_obj2name:
         self.name = exports.EXPORTS_obj2name[obj]
         self.globalcontainer = True
     elif parent is None:
         self.name = db.namespace.uniquename('g_' + self.basename())
         self.globalcontainer = True
     else:
         self.globalcontainer = False
         parentnode = db.getcontainernode(parent)
         defnode = db.gettypedefnode(parentnode.getTYPE())
         self.name = defnode.access_expr(parentnode.name, parentindex)
     if self.typename != self.implementationtypename:
         if db.gettypedefnode(T).extra_union_for_varlength:
             self.name += '.b'
     self._funccodegen_owner = None
Exemplo n.º 36
0
    def prepare_arg_value(self, const_or_var):
        """if const_or_var is not already in a dictionary self.obj2node,
        the appropriate node gets constructed and gets added to
        self._pendingsetup and to self.obj2node"""
        if isinstance(const_or_var, Constant):
            ct = const_or_var.concretetype
            if isinstance(ct, lltype.Primitive):
                # special cases for address
                if ct is llmemory.Address:
                    fakedaddress = const_or_var.value
                    if fakedaddress:
                        ptrvalue = fakedaddress.ptr
                        ct = lltype.typeOf(ptrvalue)
                    else:
                        return                        
                elif ct is llmemory.WeakGcAddress:
                    return # XXX sometime soon
                else:
                    return
            else:
                assert isinstance(ct, lltype.Ptr), "Preparation of non primitive and non pointer" 
                ptrvalue = const_or_var.value
                
            value = ptrvalue._obj

            if isinstance(value, int):
                return

            # Only prepare root values at this point 
            if isinstance(ct, lltype.Array) or isinstance(ct, lltype.Struct):
                p, c = lltype.parentlink(value)
                if p is None:
                    #log.prepareargvalue("skipping preparing non root", value)
                    return

            if value is not None and value not in self.obj2node:
                self.addpending(value, self.create_constant_node(ct.TO, value))
        else:
            assert isinstance(const_or_var, Variable)
Exemplo n.º 37
0
def convert_struct(container, cstruct=None):
    STRUCT = container._TYPE
    if cstruct is None:
        # if 'container' is an inlined substructure, convert the whole
        # bigger structure at once
        parent, parentindex = lltype.parentlink(container)
        if parent is not None:
            convert_struct(parent)
            return
        # regular case: allocate a new ctypes Structure of the proper type
        cls = get_ctypes_type(STRUCT)
        if STRUCT._arrayfld is not None:
            n = getattr(container, STRUCT._arrayfld).getlength()
        else:
            n = None
        cstruct = cls._malloc(n)
    add_storage(container, _struct_mixin, cstruct)
    for field_name in STRUCT._names:
        FIELDTYPE = getattr(STRUCT, field_name)
        field_value = getattr(container, field_name)
        if not isinstance(FIELDTYPE, lltype.ContainerType):
            # regular field
            if FIELDTYPE != lltype.Void:
                setattr(cstruct, field_name, lltype2ctypes(field_value))
        else:
            # inlined substructure/subarray
            if isinstance(FIELDTYPE, lltype.Struct):
                csubstruct = getattr(cstruct, field_name)
                convert_struct(field_value, csubstruct)
                subcontainer = getattr(container, field_name)
                substorage = subcontainer._storage
                update_parent_cache(substorage, subcontainer)
            elif field_name == STRUCT._arrayfld:  # inlined var-sized part
                csubarray = getattr(cstruct, field_name)
                convert_array(field_value, csubarray)
            else:
                raise NotImplementedError('inlined field', FIELDTYPE)
    remove_regular_struct_content(container)
Exemplo n.º 38
0
    def get_ref(self, value):
        node = self.obj2node[value]
        T = lltype.typeOf(value)
        p, c = lltype.parentlink(value)
        if p is None:
            ref = node.ref
            VT = var_size_type(T)
            if VT and VT is not lltype.Void:
                ref = "bitcast(%s* %s to %s*)" % (node.get_typerepr(),
                                                  ref,
                                                  self.repr_type(T))
        else:
            ref = self.to_getelementptr(value)
            
            if isinstance(node, FixedSizeArrayNode):
                assert isinstance(value, lltype._subarray)

                # XXX UGLY (but needs fixing outside of genllvm)
                #  ptr -> array of len 1 (for now, since operations expect this)
                ref = "bitcast(%s* %s to %s*)" % (self.repr_type(T.OF),
                                                  ref,
                                                  self.repr_type(T))

        return ref
Exemplo n.º 39
0
            # container has regular lltype storage, convert it to ctypes
            if isinstance(T.TO, lltype.Struct):
                convert_struct(container)
            elif isinstance(T.TO, lltype.Array):
                convert_array(container)
            elif isinstance(T.TO, lltype.OpaqueType):
                if T.TO != lltype.RuntimeTypeInfo:
                    cbuf = ctypes.create_string_buffer(T.TO.hints['getsize']())
                else:
                    cbuf = ctypes.create_string_buffer("\x00")
                add_storage(container, _parentable_mixin, cbuf)
            else:
                raise NotImplementedError(T)
            container._ctypes_storage_was_allocated()
        storage = container._storage
        if lltype.parentlink(container)[0] is not None:
            update_parent_cache(storage, container)
        p = ctypes.pointer(storage)
        if index:
            p = ctypes.cast(p, ctypes.c_void_p)
            p = ctypes.c_void_p(p.value + index)
            c_tp = get_ctypes_type(T.TO)
            storage._normalized_ctype = c_tp
        if normalize and hasattr(storage, '_normalized_ctype'):
            p = ctypes.cast(p, ctypes.POINTER(storage._normalized_ctype))
        if lltype.typeOf(llobj) == llmemory.GCREF:
            p = ctypes.cast(p, ctypes.c_void_p)
        return p

    if isinstance(llobj, Symbolic):
        if isinstance(llobj, llmemory.ItemOffset):
Exemplo n.º 40
0
 def writeglobalconstants(self, codewriter):
     p, c = lltype.parentlink(self.value)
     if p is None:
         codewriter.globalinstance(self.ref, self.constantvalue())
Exemplo n.º 41
0
            # container has regular lltype storage, convert it to ctypes
            if isinstance(T.TO, lltype.Struct):
                convert_struct(container)
            elif isinstance(T.TO, lltype.Array):
                convert_array(container)
            elif isinstance(T.TO, lltype.OpaqueType):
                if T.TO != lltype.RuntimeTypeInfo:
                    cbuf = ctypes.create_string_buffer(T.TO.hints['getsize']())
                else:
                    cbuf = ctypes.create_string_buffer("\x00")
                add_storage(container, _parentable_mixin, cbuf)
            else:
                raise NotImplementedError(T)
            container._ctypes_storage_was_allocated()
        storage = container._storage
        if lltype.parentlink(container)[0] is not None:
            update_parent_cache(storage, container)
        p = ctypes.pointer(storage)
        if index:
            p = ctypes.cast(p, ctypes.c_void_p)
            p = ctypes.c_void_p(p.value + index)
            c_tp = get_ctypes_type(T.TO)
            storage._normalized_ctype = c_tp
        if normalize and hasattr(storage, '_normalized_ctype'):
            p = ctypes.cast(p, ctypes.POINTER(storage._normalized_ctype))
        if lltype.typeOf(llobj) == llmemory.GCREF:
            p = ctypes.cast(p, ctypes.c_void_p)
        return p

    if isinstance(llobj, Symbolic):
        if isinstance(llobj, llmemory.ItemOffset):
Exemplo n.º 42
0
 def writeglobalconstants(self, codewriter):
     p, c = lltype.parentlink(self.value)
     if p is None:
         codewriter.globalinstance(self.ref, self.constantvalue())
         codewriter.newline()
         codewriter.newline()