def __init__(self, tp: cindex.Type):
assert isinstance(tp, cindex.Type)
self.tp = tp
self._qualifiers = []
if tp.is_const_qualified():
self._qualifiers.append('const')
if tp.is_volatile_qualified():
self._qualifiers.append('volatile')
if tp.is_restrict_qualified():
self._qualifiers.append('restrict')
def __init__(self, cursor):
super(Type, self).__init__(cursor)
if self.cursor.displayname in ['%sint%d_t' % (s, i) for i in [8,16,32,64] for s in ['','u']]:
self.type = self.cursor.displayname.replace('_t', '')
elif self.cursor.kind.is_attribute():
if len(self.cursor.displayname) > 0:
self.type = '__attr_%s' % self.cursor.displayname
else:
self.type = '__attr_%s' % Sources.getchunk(self.extent).strip('_')
else:
self.type = Type.nameof(self.cursor.type)
self.typename = Type.typenameof(self.cursor.type)
self.name = self.cursor.displayname
def convert_clang_to_gdb_type(t: cindex.Type) -> gdb.Type:
if t.kind == TypeKind.POINTER:
return convert_clang_to_gdb_type(t.get_pointee()).pointer()
if t.kind == TypeKind.CHAR_S:
return gdb.lookup_type("char")
else:
raise ParserError("Unhandled pointer type!", t.kind, t.spelling)
def typedef_elaborated_type(self, underlying: cindex.Type,
c: cindex.Cursor) -> Optional[TypeRef]:
'''
Typedefとともに型定義(struct, enum....)
'''
if underlying.kind != cindex.TypeKind.ELABORATED:
return None
children = [child for child in c.get_children()]
for child in children:
if child.kind in [
cindex.CursorKind.STRUCT_DECL,
cindex.CursorKind.UNION_DECL,
]:
struct = self.get(child)
if struct:
# decl = self.parser.typedef(c.spelling, struct)
# decl.file = pathlib.Path(c.location.file.name)
# decl.line = c.location.line
# self.add(child, decl)
return TypeRef(struct, underlying.is_const_qualified())
raise Exception()
if child.kind == cindex.CursorKind.ENUM_DECL:
enum = self.get(child)
if enum:
# decl = self.parser.typedef(c.spelling, enum)
# decl.file = pathlib.Path(c.location.file.name)
# decl.line = c.location.line
# self.add(child, decl)
return TypeRef(enum, underlying.is_const_qualified())
raise Exception()
if child.kind == cindex.CursorKind.TYPE_REF:
ref = self.get(child.referenced)
if ref:
# decl = self.parser.typedef(c.spelling, ref)
# decl.file = pathlib.Path(c.location.file.name)
# decl.line = c.location.line
# self.add(child, decl)
return TypeRef(ref, underlying.is_const_qualified())
raise Exception()
raise Exception()
raise Exception()
def typenameof(ctype):
utype = ctype.get_canonical()
ukind = utype.kind
qualifiers = []
if ctype.is_const_qualified():
qualifiers += ['const']
if ctype.is_volatile_qualified():
qualifiers += ['volatile']
if ctype.is_restrict_qualified():
qualifiers += ['restrict']
if len(qualifiers) > 0:
qualifier = ' ' + ' '.join(qualifiers)
else:
qualifier = ''
if ukind == TypeKind.COMPLEX:
return '__complex_%s' % Type.typenameof(utype.element_type) + qualifier
elif ukind == TypeKind.POINTER:
return '%s*' % Type.typenameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.LVALUEREFERENCE:
return '%s&' % Type.typenameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.RVALUEREFERENCE:
return '%s&&' % Type.typenameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.CONSTANTARRAY:
return Type.typenameof(utype.element_type) + '[%s]' % utype.element_count + qualifier
elif ukind == TypeKind.VECTOR:
return '__vector_%s' % Type.typenameof(utype.element_type) + '[%s]' % utype.element_count + qualifier
else:
return ctype.get_declaration().displayname + qualifier
def get_type_from_hash(self, t: cindex.Type, c: cindex.Cursor) -> TypeRef:
'''
登録済みの型をhashから取得する
'''
if t.kind in (cindex.TypeKind.ELABORATED, cindex.TypeKind.RECORD,
cindex.TypeKind.TYPEDEF, cindex.TypeKind.ENUM):
# structなど
children = [child for child in c.get_children()]
for child in children:
if child.kind in (cindex.CursorKind.STRUCT_DECL,
cindex.CursorKind.UNION_DECL):
decl = self.get(child)
if decl:
return TypeRef(decl, t.is_const_qualified())
raise Exception()
elif child.kind == cindex.CursorKind.TYPE_REF:
if not self.has(child.referenced):
self.parse_cursor(child.referenced)
decl = self.get(child.referenced)
if decl:
return TypeRef(decl, t.is_const_qualified())
raise Exception()
elif child.kind in (cindex.CursorKind.UNEXPOSED_ATTR,
cindex.CursorKind.DLLIMPORT_ATTR):
pass
else:
raise Exception()
raise Exception()
if t.kind == cindex.TypeKind.FUNCTIONPROTO:
return TypeRef(cpptypeinfo.Void(), t.is_const_qualified())
children = [child for child in c.get_children()]
raise Exception()
def get_primitive_type(t: cindex.Type) -> Optional[TypeRef]:
'''
TypeKind.VOID = TypeKind(2)
TypeKind.BOOL = TypeKind(3)
TypeKind.CHAR_U = TypeKind(4)
TypeKind.UCHAR = TypeKind(5)
TypeKind.CHAR16 = TypeKind(6)
TypeKind.CHAR32 = TypeKind(7)
TypeKind.USHORT = TypeKind(8)
TypeKind.UINT = TypeKind(9)
TypeKind.ULONG = TypeKind(10)
TypeKind.ULONGLONG = TypeKind(11)
TypeKind.UINT128 = TypeKind(12)
TypeKind.CHAR_S = TypeKind(13)
TypeKind.SCHAR = TypeKind(14)
TypeKind.WCHAR = TypeKind(15)
TypeKind.SHORT = TypeKind(16)
TypeKind.INT = TypeKind(17)
TypeKind.LONG = TypeKind(18)
TypeKind.LONGLONG = TypeKind(19)
TypeKind.INT128 = TypeKind(20)
TypeKind.FLOAT = TypeKind(21)
TypeKind.DOUBLE = TypeKind(22)
TypeKind.LONGDOUBLE = TypeKind(23)
TypeKind.NULLPTR = TypeKind(24)
'''
# void
if t.kind == cindex.TypeKind.VOID: # void
return TypeRef(cpptypeinfo.Void(), t.is_const_qualified())
# bool
elif t.kind == cindex.TypeKind.BOOL: # void
assert (t.get_size() == 1)
return TypeRef(cpptypeinfo.Bool(), t.is_const_qualified())
# int
elif t.kind == cindex.TypeKind.CHAR_S: # char
assert (t.get_size() == 1)
return TypeRef(cpptypeinfo.Int8(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.SCHAR: # signed char
assert (t.get_size() == 1)
return TypeRef(cpptypeinfo.Int8(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.SHORT: # short
assert (t.get_size() == 2)
return TypeRef(cpptypeinfo.Int16(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.INT: # int
assert (t.get_size() == 4)
return TypeRef(cpptypeinfo.Int32(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.LONG: # long
assert (t.get_size() == 4)
return TypeRef(cpptypeinfo.Int32(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.LONGLONG: # long long
assert (t.get_size() == 8)
return TypeRef(cpptypeinfo.Int64(), t.is_const_qualified())
# unsigned
elif t.kind == cindex.TypeKind.UCHAR: # unsigned char
assert (t.get_size() == 1)
return TypeRef(cpptypeinfo.UInt8(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.WCHAR: # wchar_t
assert (t.get_size() == 2)
return TypeRef(cpptypeinfo.UInt16(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.USHORT: # unsigned short
assert (t.get_size() == 2)
return TypeRef(cpptypeinfo.UInt16(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.UINT: # unsigned int
assert (t.get_size() == 4)
return TypeRef(cpptypeinfo.UInt32(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.ULONG: # unsigned long
assert (t.get_size() == 4)
return TypeRef(cpptypeinfo.UInt32(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.ULONGLONG: # unsigned __int64
assert (t.get_size() == 8)
return TypeRef(cpptypeinfo.UInt64(), t.is_const_qualified())
# float
elif t.kind == cindex.TypeKind.FLOAT: # float
assert (t.get_size() == 4)
return TypeRef(cpptypeinfo.Float(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.DOUBLE: # double
assert (t.get_size() == 8)
return TypeRef(cpptypeinfo.Double(), t.is_const_qualified())
elif t.kind == cindex.TypeKind.LONGDOUBLE: # double
size = t.get_size()
assert (size == 8)
return TypeRef(cpptypeinfo.Double(), t.is_const_qualified())
return None
def __init__(self, cursor): super(ReturnType, self).__init__(cursor) self.name = 'output' self.type = Type.nameof(self.cursor.type.get_result()) self.typename = Type.typenameof(self.cursor.type.get_result())
def nameof(ctype):
utype = ctype.get_canonical()
ukind = utype.kind
bits = int(Type.bits.replace('bit', ''))
qualifiers = []
if ctype.is_const_qualified():
qualifiers += ['const']
if ctype.is_volatile_qualified():
qualifiers += ['volatile']
if ctype.is_restrict_qualified():
qualifiers += ['restrict']
if len(qualifiers) > 0:
qualifier = ' ' + ' '.join(qualifiers)
else:
qualifier = ''
if ukind == TypeKind.INVALID:
return '__invalid' + qualifier
elif ukind == TypeKind.UNEXPOSED:
return '__unexposed' + qualifier
elif ukind == TypeKind.VOID:
return 'void' + qualifier
elif ukind == TypeKind.BOOL:
return 'bool' + qualifier
elif ukind == TypeKind.CHAR_U:
return 'uchar' + qualifier
elif ukind == TypeKind.UCHAR:
return 'uint8' + qualifier
elif ukind == TypeKind.CHAR16:
return 'char16' + qualifier
elif ukind == TypeKind.CHAR32:
return 'char32' + qualifier
elif ukind == TypeKind.USHORT:
return 'uint16' + qualifier
elif ukind == TypeKind.UINT:
return 'uint32' + qualifier
elif ukind == TypeKind.ULONG:
return 'uint%d' % (bits) + qualifier
elif ukind == TypeKind.ULONGLONG:
return 'uint64' + qualifier
elif ukind == TypeKind.UINT128:
return 'uint128' + qualifier
elif ukind == TypeKind.CHAR_S:
return 'char' + qualifier
elif ukind == TypeKind.SCHAR:
return 'int8' + qualifier
elif ukind == TypeKind.WCHAR:
return 'wchar' + qualifier
elif ukind == TypeKind.SHORT:
return 'int16' + qualifier
elif ukind == TypeKind.INT:
return 'int32' + qualifier
elif ukind == TypeKind.LONG:
return 'int%d' % (bits) + qualifier
elif ukind == TypeKind.LONGLONG:
return 'int64' + qualifier
elif ukind == TypeKind.INT128:
return 'int128' + qualifier
elif ukind == TypeKind.FLOAT:
return 'float32' + qualifier
elif ukind == TypeKind.DOUBLE:
return 'float64' + qualifier
elif ukind == TypeKind.LONGDOUBLE:
return 'float%d' % (bits + 64) + qualifier
elif ukind == TypeKind.NULLPTR:
return 'nullptr' + qualifier
elif ukind == TypeKind.OVERLOAD:
return '__overload' + qualifier
elif ukind == TypeKind.DEPENDENT:
return '__dependent' + qualifier
elif ukind == TypeKind.OBJCID:
return '__objcid' + qualifier
elif ukind == TypeKind.OBJCCLASS:
return '__objcclass' + qualifier
elif ukind == TypeKind.OBJCSEL:
return '__objcsel' + qualifier
elif ukind == TypeKind.COMPLEX:
return '__complex_%s' % Type.nameof(utype.element_type) + qualifier
elif ukind == TypeKind.POINTER:
return '%s*' % Type.nameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.BLOCKPOINTER:
return '__blockpointer' + qualifier
elif ukind == TypeKind.LVALUEREFERENCE:
return '%s&' % Type.typenameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.RVALUEREFERENCE:
return '%s&&' % Type.typenameof(ctype.get_pointee()) + qualifier
elif ukind == TypeKind.RECORD:
return utype.get_declaration().displayname + qualifier
elif ukind == TypeKind.ENUM:
return utype.get_declaration().displayname + qualifier
elif ukind == TypeKind.TYPEDEF:
return '_typedef' + qualifier
elif ukind == TypeKind.OBJCINTERFACE:
return '<objc-object-interface>' + qualifier
elif ukind == TypeKind.OBJCOBJECTPOINTER:
return '<objc-object-pointer>' + qualifier
elif ukind == TypeKind.FUNCTIONNOPROTO:
return '<function-no-proto>' + qualifier
elif ukind == TypeKind.FUNCTIONPROTO:
return '<function-proto>' + qualifier
elif ukind == TypeKind.CONSTANTARRAY:
return Type.nameof(utype.element_type) + '[%s]' % utype.element_count + qualifier
elif ukind == TypeKind.VECTOR:
return '__vector_%s' % Type.nameof(utype.element_type) + '[%s]' % utype.element_count + qualifier
else:
return '__unknown' + qualifier
def __init__(self, tp: cindex.Type):
super().__init__(tp)
self.pointee = TypeAdapter.create(tp.get_pointee())
