def __init__(self, database):
self.database = database
self.types = {
lltype.Char: "i8",
lltype.Bool: "i1",
lltype.SingleFloat: "float",
lltype.Float: "double",
lltype.UniChar: "i32",
lltype.Void: "void",
lltype.UnsignedLongLong: "i64",
lltype.SignedLongLong: "i64",
llmemory.Address: "i8*",
}
# 32 bit platform
if sys.maxint == 2**31-1:
self.types.update({
lltype.Signed: "i32",
lltype.Unsigned: "i32" })
# 64 bit platform
elif sys.maxint == 2**63-1:
self.types.update({
lltype.Signed: "i64",
lltype.Unsigned: "i64" })
else:
raise Exception("Unsupported platform - unknown word size")
self.reprs = {
lltype.SignedLongLong : self.repr_signed,
lltype.Signed : self.repr_signed,
lltype.UnsignedLongLong : self.repr_default,
lltype.Unsigned : self.repr_default,
lltype.SingleFloat: self.repr_singlefloat,
lltype.Float : self.repr_float,
lltype.Char : self.repr_char,
lltype.UniChar : self.repr_unichar,
lltype.Bool : self.repr_bool,
lltype.Void : self.repr_void,
llmemory.Address : self.repr_address,
}
try:
import ctypes
except ImportError:
pass
else:
def update(from_, type):
if from_ not in self.types:
self.types[from_] = type
if from_ not in self.reprs:
self.reprs[from_] = self.repr_default
for tp in [rffi.SIGNEDCHAR, rffi.UCHAR, rffi.SHORT,
rffi.USHORT, rffi.INT, rffi.UINT, rffi.LONG, rffi.ULONG,
rffi.LONGLONG, rffi.ULONGLONG]:
bits = rffi.size_and_sign(tp)[0] * 8
update(tp, 'i%s' % bits)
def build_result(self, info, config_result):
if self.ifdef is not None:
if not info['defined']:
return None
layout = [None] * info['size']
for fieldname, fieldtype in self.interesting_fields:
if isinstance(fieldtype, Struct):
offset = info['fldofs ' + fieldname]
size = info['fldsize ' + fieldname]
c_fieldtype = config_result.get_entry_result(fieldtype)
layout_addfield(layout, offset, c_fieldtype, fieldname)
else:
offset = info['fldofs ' + fieldname]
size = info['fldsize ' + fieldname]
sign = info.get('fldunsigned ' + fieldname, False)
if (size, sign) != rffi.size_and_sign(fieldtype):
fieldtype = fixup_ctype(fieldtype, fieldname, (size, sign))
layout_addfield(layout, offset, fieldtype, fieldname)
n = 0
padfields = []
for i, cell in enumerate(layout):
if cell is not None:
continue
name = '_pad%d' % (n, )
layout_addfield(layout, i, rffi.UCHAR, name)
padfields.append('c_' + name)
n += 1
# build the lltype Structure
seen = {}
fields = []
fieldoffsets = []
for offset, cell in enumerate(layout):
if cell in seen:
continue
fields.append((cell.name, cell.ctype))
fieldoffsets.append(offset)
seen[cell] = True
allfields = tuple(['c_' + name for name, _ in fields])
padfields = tuple(padfields)
name = self.name
padding_drop = PaddingDrop(name, allfields, padfields,
config_result.CConfig._compilation_info_)
hints = {
'align': info['align'],
'size': info['size'],
'fieldoffsets': tuple(fieldoffsets),
'padding': padfields,
'get_padding_drop': padding_drop
}
if name.startswith('struct '):
name = name[7:]
else:
hints['typedef'] = True
kwds = {'hints': hints}
return rffi.CStruct(name, *fields, **kwds)
def build_result(self, info, config_result):
if self.ifdef is not None and not info['defined']:
return None
size = info['size']
sign = info.get('unsigned', False)
ctype = self.ctype_hint
if (size, sign) != rffi.size_and_sign(ctype):
ctype = fixup_ctype(ctype, self.name, (size, sign))
return ctype
def build_result(self, info, config_result):
if self.ifdef is not None:
if not info["defined"]:
return None
layout = [None] * info["size"]
for fieldname, fieldtype in self.interesting_fields:
if isinstance(fieldtype, Struct):
offset = info["fldofs " + fieldname]
size = info["fldsize " + fieldname]
c_fieldtype = config_result.get_entry_result(fieldtype)
layout_addfield(layout, offset, c_fieldtype, fieldname)
else:
offset = info["fldofs " + fieldname]
size = info["fldsize " + fieldname]
sign = info.get("fldunsigned " + fieldname, False)
if (size, sign) != rffi.size_and_sign(fieldtype):
fieldtype = fixup_ctype(fieldtype, fieldname, (size, sign))
layout_addfield(layout, offset, fieldtype, fieldname)
n = 0
padfields = []
for i, cell in enumerate(layout):
if cell is not None:
continue
name = "_pad%d" % (n,)
layout_addfield(layout, i, rffi.UCHAR, name)
padfields.append("c_" + name)
n += 1
# build the lltype Structure
seen = {}
fields = []
fieldoffsets = []
for offset, cell in enumerate(layout):
if cell in seen:
continue
fields.append((cell.name, cell.ctype))
fieldoffsets.append(offset)
seen[cell] = True
allfields = tuple(["c_" + name for name, _ in fields])
padfields = tuple(padfields)
name = self.name
padding_drop = PaddingDrop(name, allfields, padfields, config_result.CConfig._compilation_info_)
hints = {
"align": info["align"],
"size": info["size"],
"fieldoffsets": tuple(fieldoffsets),
"padding": padfields,
"get_padding_drop": padding_drop,
}
if name.startswith("struct "):
name = name[7:]
else:
hints["typedef"] = True
kwds = {"hints": hints}
return rffi.CStruct(name, *fields, **kwds)
def build_result(self, info, config_result):
if self.ifdef is not None and not info['defined']:
return None
size = info['size']
sign = info.get('unsigned', False)
ctype = self.ctype_hint
if (size, sign) != rffi.size_and_sign(ctype):
ctype = fixup_ctype(ctype, self.name, (size, sign))
return ctype
def build_result(self, info, config_result):
if self.ifdef is not None:
if not info['defined']:
return None
layout = [None] * info['size']
for fieldname, fieldtype in self.interesting_fields:
if isinstance(fieldtype, Struct):
offset = info['fldofs ' + fieldname]
size = info['fldsize ' + fieldname]
c_fieldtype = config_result.get_entry_result(fieldtype)
layout_addfield(layout, offset, c_fieldtype, fieldname)
else:
offset = info['fldofs ' + fieldname]
size = info['fldsize ' + fieldname]
sign = info.get('fldunsigned ' + fieldname, False)
if (size, sign) != rffi.size_and_sign(fieldtype):
fieldtype = fixup_ctype(fieldtype, fieldname, (size, sign))
layout_addfield(layout, offset, fieldtype, fieldname)
n = 0
padfields = []
for i, cell in enumerate(layout):
if cell is not None:
continue
name = '_pad%d' % (n,)
layout_addfield(layout, i, rffi.UCHAR, name)
padfields.append('c_' + name)
n += 1
# build the lltype Structure
seen = {}
fields = []
fieldoffsets = []
for offset, cell in enumerate(layout):
if cell in seen:
continue
fields.append((cell.name, cell.ctype))
fieldoffsets.append(offset)
seen[cell] = True
allfields = tuple(['c_' + name for name, _ in fields])
padfields = tuple(padfields)
name = self.name
padding_drop = PaddingDrop(name, allfields, padfields,
config_result.CConfig._compilation_info_)
hints = {'align': info['align'],
'size': info['size'],
'fieldoffsets': tuple(fieldoffsets),
'padding': padfields,
'get_padding_drop': padding_drop}
if name.startswith('struct '):
name = name[7:]
else:
hints['typedef'] = True
kwds = {'hints': hints}
return rffi.CStruct(name, *fields, **kwds)
def fixup_ctype(fieldtype, fieldname, expected_size_and_sign):
for typeclass in [integer_class, float_class]:
if fieldtype in typeclass:
for ctype in typeclass:
if rffi.size_and_sign(ctype) == expected_size_and_sign:
return ctype
if isinstance(fieldtype, lltype.FixedSizeArray):
size, _ = expected_size_and_sign
return lltype.FixedSizeArray(fieldtype.OF, size / _sizeof(fieldtype.OF))
raise TypeError("conflicting field type %r for %r" % (fieldtype, fieldname))
def fixup_ctype(fieldtype, fieldname, expected_size_and_sign):
for typeclass in [integer_class, float_class]:
if fieldtype in typeclass:
for ctype in typeclass:
if rffi.size_and_sign(ctype) == expected_size_and_sign:
return ctype
if isinstance(fieldtype, lltype.FixedSizeArray):
size, _ = expected_size_and_sign
return lltype.FixedSizeArray(fieldtype.OF, size/_sizeof(fieldtype.OF))
raise TypeError("conflict between translating python and compiler field"
" type %r for %r" % (fieldtype, fieldname))
def get_attrs_for_type(self, type):
# because we want to bind to external functions that depend
# on sign/zero extensions, we need to use these attributes in function sigs
# note that this is not needed for internal functions because they use
# casts if necessary
type_attrs = ""
if not isinstance(type, lltype.Number):
return type_attrs
size, sign = rffi.size_and_sign(type)
if size < 4:
if not sign:
type_attrs += "signext"
else:
type_attrs += "zeroext"
return type_attrs
def issigned(ct):
# XXX why does size_and_sign() think lltype.Char, lltype.UniChar are signed??
if ct in [lltype.Bool, lltype.Char, lltype.UniChar]:
return False
from pypy.rpython.lltypesystem.rffi import size_and_sign
return not size_and_sign(ct)[1]
