def on_finish_unit():
def dump_integer_type(t):
print('gcc.Type: %r' % str(t))
print(' t.const: %r' % t.const)
print(' t.unsigned: %r' % t.unsigned)
print(' t.precision: %r' % t.precision)
assert isinstance(t.min_value, gcc.IntegerCst)
assert isinstance(t.max_value, gcc.IntegerCst)
print(' t.min_value.constant: %r' % t.min_value.constant)
print(' t.max_value.constant: %r' % t.max_value.constant)
assert isinstance(t.sizeof, int)
print(' t.sizeof: %r' % t.sizeof)
# gccutils.pprint(t)
# Pick some types that ought to be arch-independent and thus suitable
# for a unit test
dump_integer_type(gcc.Type.unsigned_char())
dump_integer_type(gcc.Type.signed_char())
print(gcc.Type.char().const)
print(gcc.Type.char().const_equivalent.const)
print(gcc.Type.char().const_equivalent.restrict_equivalent.const)
print(gcc.Type.char().const_equivalent.volatile_equivalent.const)
print(gcc.Type.char().const_equivalent.volatile_equivalent.
unqualified_equivalent.const)
def dump_real_type(t):
print('gcc.Type: %r' % str(t))
print(' t.const: %r' % t.const)
print(' t.precision: %r' % t.precision)
assert isinstance(t.sizeof, int)
print(' t.sizeof: %r' % t.sizeof)
dump_real_type(gcc.Type.float())
dump_real_type(gcc.Type.double())
def dump_typedef(td):
t = td.type
print('gcc.TypeDecl: %r' % str(td))
print(' td.original_type: %r' % td.original_type)
print(' td.original_type is gcc.Type.int(): %r' %
(td.original_type is gcc.Type.int()))
mytype = gccutils.get_global_typedef('mytype')
print(' td.original_type.name: %r' % td.original_type.name)
print(' td.original_type.name is mytype: %r' %
(td.original_type.name is mytype))
dump_integer_type(t)
dump_typedef(gccutils.get_global_typedef('mytype'))
dump_typedef(gccutils.get_global_typedef('nestedtype'))
def get_type_for_typeobject(typeobject):
check_isinstance(typeobject, gcc.VarDecl)
if typeobject.name not in type_dict:
return None
type_name = type_dict[typeobject.name]
return get_global_typedef(type_name)
def is_py3k():
"""
Is the Python.h we're compiling against python 3?
"""
if get_global_typedef('PyStringObject'):
return False
else:
return True
def dump_typedef(td):
t = td.type
print('gcc.TypeDecl: %r' % str(td))
print(' td.original_type: %r' % td.original_type)
print(' td.original_type is gcc.Type.int(): %r' %
(td.original_type is gcc.Type.int()))
mytype = gccutils.get_global_typedef('mytype')
print(' td.original_type.name: %r' % td.original_type.name)
print(' td.original_type.name is mytype: %r' %
(td.original_type.name is mytype))
dump_integer_type(t)
def on_finish_unit():
for i in range(0, 4):
fn_type_decl = gccutils.get_global_typedef('example%i' % i)
assert isinstance(fn_type_decl, gcc.TypeDecl)
print('fn_type_decl.name: %r' % fn_type_decl.name)
fn_type = fn_type_decl.type
assert isinstance(fn_type, gcc.FunctionType)
print('str(fn_type): %r' % str(fn_type))
print('str(fn_type.type): %r' % str(fn_type.type))
assert isinstance(fn_type.argument_types, tuple)
print('argument_types: %r' % [str(t) for t in fn_type.argument_types])
print('fn_type.attributes: %r' % fn_type.attributes)
print('gccutils.get_nonnull_arguments(fn_type): %r' % gccutils.get_nonnull_arguments(fn_type))
print('-----------------------------------------------------\n')
def on_finish_unit():
for i in range(0, 4):
fn_type_decl = gccutils.get_global_typedef('example%i' % i)
assert isinstance(fn_type_decl, gcc.TypeDecl)
print('fn_type_decl.name: %r' % fn_type_decl.name)
fn_type = fn_type_decl.type
assert isinstance(fn_type, gcc.FunctionType)
print('str(fn_type): %r' % str(fn_type))
print('str(fn_type.type): %r' % str(fn_type.type))
assert isinstance(fn_type.argument_types, tuple)
print('argument_types: %r' % [str(t) for t in fn_type.argument_types])
print('fn_type.attributes: %r' % fn_type.attributes)
print('gccutils.get_nonnull_arguments(fn_type): %r' %
gccutils.get_nonnull_arguments(fn_type))
print('-----------------------------------------------------\n')
def on_finish_unit():
fn_type_decl = gccutils.get_global_typedef('example_fn_type')
assert isinstance(fn_type_decl, gcc.TypeDecl)
print('fn_type_decl.name: %r' % fn_type_decl.name)
fn_type = fn_type_decl.type
assert isinstance(fn_type, gcc.FunctionType)
print('str(fn_type): %r' % str(fn_type))
print('str(fn_type.type): %r' % str(fn_type.type))
assert isinstance(fn_type.argument_types, tuple)
print('argument_types: %r' % [str(t) for t in fn_type.argument_types])
try:
fn_type.sizeof
assert 0 # an exception should have been raised
except:
err = sys.exc_info()[1]
print('err: %s' % err)
def on_finish_unit():
fn_type_decl = gccutils.get_global_typedef('example_fn_type')
assert isinstance(fn_type_decl, gcc.TypeDecl)
print('fn_type_decl.name: %r' % fn_type_decl.name)
fn_type = fn_type_decl.type
assert isinstance(fn_type, gcc.FunctionType)
print('str(fn_type): %r' % str(fn_type))
print('str(fn_type.type): %r' % str(fn_type.type))
assert isinstance(fn_type.argument_types, tuple)
print('argument_types: %r' % [str(t) for t in fn_type.argument_types])
try:
fn_type.sizeof
assert 0 # an exception should have been raised
except:
err = sys.exc_info()[1]
print('err: %s' % err)
def check_fn_type(name):
fn_type_decl = gccutils.get_global_typedef(name)
assert isinstance(fn_type_decl, gcc.TypeDecl)
print("fn_type_decl.name: %r" % fn_type_decl.name)
fn_type = fn_type_decl.type
assert isinstance(fn_type, gcc.FunctionType)
print("str(fn_type): %r" % str(fn_type))
print("str(fn_type.type): %r" % str(fn_type.type))
assert isinstance(fn_type.argument_types, tuple)
print("argument_types: %r" % [str(t) for t in fn_type.argument_types])
print("is_variadic: %r" % fn_type.is_variadic)
try:
fn_type.sizeof
assert 0 # an exception should have been raised
except:
err = sys.exc_info()[1]
print("err: %s" % err)
def on_pass_execution(p, data):
if p.name == 'visibility':
print('len(gcc.get_translation_units()): %i' % len(gcc.get_translation_units()))
u = gcc.get_translation_units()[0]
print('type(u): %s' % type(u))
print('u.language: %r' % u.language)
print('type(u.block): %s' % type(u.block))
for v in u.block.vars:
if v.name == 'test_typedef':
print('v.name: %r' % v.name)
print('type(v): %r' % v)
if v.name == 'test_var':
print('v.name: %r' % v.name)
print('type(v): %r' % v)
#print 'u.block: %s' % u.block
#u.block.debug()
td = get_global_typedef('test_typedef')
print('td: %r' % td)
print('td.name: %r' % td.name)
print('type(td.type): %s' % type(td.type))
def on_pass_execution(p, data):
if p.name == 'visibility':
print('len(gcc.get_translation_units()): %i' %
len(gcc.get_translation_units()))
u = gcc.get_translation_units()[0]
print('type(u): %s' % type(u))
print('u.language: %r' % u.language)
print('type(u.block): %s' % type(u.block))
for v in u.block.vars:
if v.name == 'test_typedef':
print('v.name: %r' % v.name)
print('type(v): %r' % v)
if v.name == 'test_var':
print('v.name: %r' % v.name)
print('type(v): %r' % v)
#print 'u.block: %s' % u.block
#u.block.debug()
td = get_global_typedef('test_typedef')
print('td: %r' % td)
print('td.name: %r' % td.name)
print('type(td.type): %s' % type(td.type))
def get_PyTypeObject():
return get_global_typedef('PyTypeObject')
def check_typedef(typedef):
print('typedef: %r' % typedef)
decl = get_global_typedef(typedef)
ptr_type = decl.type.pointer
print(' ptr_type: %s' % ptr_type)
print(' is PyObject* subclass?: %s\n' % type_is_pyobjptr_subclass(ptr_type))
def is_debug_build():
"""
Is the Python.h we're compiling against configured --with-pydebug ?
"""
obj = get_global_typedef('PyObject')
return obj.type.fields[0].name == '_ob_next'
def get_Py_ssize_t():
return get_global_typedef('Py_ssize_t')
def get_Py_buffer():
return get_global_typedef('Py_buffer')
def Py_UNICODE():
return get_global_typedef('Py_UNICODE')
def get_PyBytesObject():
return get_global_typedef('PyBytesObject')
def get_Py_complex():
return get_global_typedef('Py_complex')
def get_PyUnicodeObject():
return get_global_typedef('PyUnicodeObject')
def get_PyStringObject():
return get_global_typedef('PyStringObject')
def get_PyObjectPtr():
return get_global_typedef('PyObject').pointer
