def AutoExclude( mb ):
""" Automaticaly exclude a range of things that don't convert well from C++ to Python
"""
global_ns = mb.global_ns
for ns in NAMESPACES:
main_ns = global_ns.namespace( ns )
# vars that are static consts but have their values set in the header file are bad
Remove_Static_Consts ( main_ns )
## Exclude protected and private that are not pure virtual
query = declarations.access_type_matcher_t( 'private' ) \
& ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL )
try:
non_public_non_pure_virtual = main_ns.calldefs( query )
non_public_non_pure_virtual.exclude()
except:
pass
#Virtual functions that return reference could not be overriden from Python
query = declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.VIRTUAL ) \
& declarations.custom_matcher_t( lambda decl: declarations.is_reference( decl.return_type ) )
try:
main_ns.calldefs( query ).virtuality = declarations.VIRTUALITY_TYPES.NOT_VIRTUAL
except:
pass
def parse(self):
xml_generator_config = parser.xml_generator_configuration_t(xml_generator_path=self.castxml_binary,
xml_generator="castxml",
cflags="-std=c++11",
include_paths=self.source_includes)
print ("INFO: Parsing Code")
decls = parser.parse([self.wrapper_header_collection], xml_generator_config,
compilation_mode=parser.COMPILATION_MODE.ALL_AT_ONCE)
# Get access to the global namespace
self.global_ns = declarations.get_global_namespace(decls)
# Clean decls to only include those for which file locations exist
print ("INFO: Cleaning Decls")
query = declarations.custom_matcher_t(lambda decl: decl.location is not None)
decls_loc_not_none = self.global_ns.decls(function=query)
# Identify decls in our source tree
def check_loc(loc):
return (self.source_root in loc) or ("wrapper_header_collection" in loc)
source_decls = [decl for decl in decls_loc_not_none if check_loc(decl.location.file_name)]
self.source_ns = declarations.namespace_t("source", source_decls)
print ("INFO: Optimizing Decls")
self.source_ns.init_optimizer()
def AutoExclude( mb ):
""" Automaticaly exclude a range of things that don't convert well from C++ to Python
"""
global_ns = mb.global_ns
main_ns = global_ns # No namespaces in NxPhysics
#Virtual functions that return reference could not be overriden from Python
query = declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.VIRTUAL ) \
& declarations.custom_matcher_t( lambda decl: declarations.is_reference( decl.return_type ) )
try:
main_ns.calldefs( query ).virtuality = declarations.VIRTUALITY_TYPES.NOT_VIRTUAL
except:
pass
def redefined_funcs( self ):
"""
returns list of member functions that should be defined in the class wrapper
It comes useful in 3 tier hierarchy:
.. code-block:: c++
struct base{
virtual void do_nothing() = 0;
};
struct derived{
virtual void do_something() = 0;
};
struct concrete{
virtual void do_nothing(){}
virtual void do_something(){}
};
The wrapper for class `derived`, should define `do_nothing` function,
otherwise the generated code will not compile
"""
if isinstance( self._redefined_funcs, list ):
return self._redefined_funcs
all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable )
all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included
all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL )
all_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.VIRTUAL ) \
& ( declarations.access_type_matcher_t( 'public' ) \
| declarations.access_type_matcher_t( 'protected' ))
all_not_pure_virtual = ~all_pure_virtual
query = all_protected | all_pure_virtual
mf_query = query | all_virtual
relevant_opers = declarations.custom_matcher_t( lambda decl: decl.symbol in ('()', '[]') )
funcs = []
defined_funcs = []
for base in self.recursive_bases:
if base.access == ACCESS_TYPES.PRIVATE:
continue
base_cls = base.related_class
funcs.extend( base_cls.member_functions( mf_query, recursive=False, allow_empty=True ) )
funcs.extend( base_cls.member_operators( relevant_opers & query, recursive=False, allow_empty=True ) )
defined_funcs.extend( base_cls.member_functions( all_not_pure_virtual, recursive=False, allow_empty=True ) )
defined_funcs.extend( base_cls.member_operators( all_not_pure_virtual & relevant_opers, recursive=False, allow_empty=True ) )
not_reimplemented_funcs = set()
is_same_function = declarations.is_same_function
for f in funcs:
cls_fs = self.calldefs( name=f.name, recursive=False, allow_empty=True )
for cls_f in cls_fs:
if is_same_function( f, cls_f ):
break
else:
#should test whether this function has been added or not
for f_impl in not_reimplemented_funcs:
if is_same_function( f, f_impl ):
if declarations.is_base_and_derived( f_impl.parent, f.parent ):
#add function from the most derived class
not_reimplemented_funcs.remove( f_impl )
not_reimplemented_funcs.add( f )
break
else:
#should test whether this function is implemented in base class
if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL:
not_reimplemented_funcs.add( f )
else:
for f_defined in defined_funcs:
if is_same_function( f, f_defined ):
break
else:
not_reimplemented_funcs.add( f )
functions = [f for f in list( not_reimplemented_funcs ) if ( False == f.ignore and True == f.exportable )
or all_pure_virtual( f )]
#Boost.Python is not able to call for non-virtual function, from the base
#class if there is a virtual function with the same within base class
#See override_bug tester for more information
def buggy_bpl_filter( f ):
if f.parent is self:
return False
if f.access_type != ACCESS_TYPES.PUBLIC:
return False
if f.virtuality != VIRTUALITY_TYPES.NOT_VIRTUAL:
return False
#we need to check that we don't have "same" function in this class
this_funs = self.decls( name=f.name
, decl_type=declarations.calldef_t
, recursive=False
, allow_empty=True )
for this_f in this_funs:
if is_same_function( this_f, f ):
#there is already the function in the class, so no need to redefined it
return False
else:
return True
tmp = {} # id : f
for redefined_f in functions:
#redefined is virtual, I am not interested in virtual functions
for rfo in redefined_f.overloads:
if id(rfo) in tmp:
continue
if buggy_bpl_filter( rfo ):
tmp[ id(rfo) ] = rfo
functions.extend( list(tmp.values()) )
functions.sort( key=lambda f: ( f.name, f.location.as_tuple() ) )
self._redefined_funcs = functions
return self._redefined_funcs
def redefined_funcs( self ):
"""returns list of member functions that should be defined in class wrapper
It comes useful in 3 tier hierarchy:
struct base{
virtual void do_nothing() = 0;
};
struct derived{
virtual void do_something() = 0;
};
struct concrete{
virtual void do_nothing(){}
virtual void do_something(){}
};
derived_wrapper should define do_nothing function, otherwise the generated
code will not compile
"""
if isinstance( self._redefined_funcs, list ):
return self._redefined_funcs
all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable )
all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included
all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL )
all_not_pure_virtual = ~all_pure_virtual
query = all_protected | all_pure_virtual
relevant_opers = declarations.custom_matcher_t( lambda decl: decl.symbol in ('()', '[]') )
funcs = set()
defined_funcs = set()
for base in self.recursive_bases:
if base.access == ACCESS_TYPES.PRIVATE:
continue
base_cls = base.related_class
funcs.update( base_cls.member_functions( query, recursive=False, allow_empty=True ) )
funcs.update( base_cls.member_operators( relevant_opers & query, recursive=False, allow_empty=True ) )
defined_funcs.update( base_cls.member_functions( all_not_pure_virtual, recursive=False, allow_empty=True ) )
defined_funcs.update( base_cls.member_operators( all_not_pure_virtual & relevant_opers, recursive=False, allow_empty=True ) )
not_reimplemented_funcs = set()
is_same_function = declarations.is_same_function
for f in funcs:
cls_fs = self.calldefs( name=f.name, recursive=False, allow_empty=True )
for cls_f in cls_fs:
if is_same_function( f, cls_f ):
break
else:
#should test whether this function has been added or not
for f_impl in not_reimplemented_funcs:
if is_same_function( f, f_impl ):
if declarations.is_base_and_derived( f_impl.parent, f.parent ):
#add function from the most derived class
not_reimplemented_funcs.remove( f_impl )
not_reimplemented_funcs.add( f )
break
else:
#should test whether this function is implemented in base class
if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL:
not_reimplemented_funcs.add( f )
else:
for f_defined in defined_funcs:
if is_same_function( f, f_defined ):
break
else:
not_reimplemented_funcs.add( f )
functions = list( not_reimplemented_funcs )
functions.sort( cmp=lambda f1, f2: cmp( ( f1.name, f1.location.as_tuple() )
, ( f2.name, f2.location.as_tuple() ) ) )
self._redefined_funcs = functions
return self._redefined_funcs
def get_header_info(self):
"""
PyGCCXML header code parser
magic happens here!
: returns the parsed header data in python dict
: return dict keys: namespace, class, io_signature, make,
properties, methods
: Can be used as an CLI command or an external API
"""
gr = self.modname.split('-')[0]
module = self.modname.split('-')[-1]
self.parsed_data['module_name'] = module
generator_path, generator_name = utils.find_xml_generator()
xml_generator_config = parser.xml_generator_configuration_t(
xml_generator_path=generator_path,
xml_generator=generator_name,
include_paths=self.include_paths,
compiler='gcc',
define_symbols=['BOOST_ATOMIC_DETAIL_EXTRA_BACKEND_GENERIC'],
cflags='-std=c++11')
decls = parser.parse([self.target_file], xml_generator_config)
global_namespace = declarations.get_global_namespace(decls)
# namespace
try:
self.parsed_data['namespace'] = []
ns = global_namespace.namespace(gr)
if ns is None:
raise BlockToolException
main_namespace = ns.namespace(module)
if main_namespace is None:
raise BlockToolException('namespace cannot be none')
self.parsed_data['namespace'] = [gr, module]
if main_namespace.declarations:
for _namespace in main_namespace.declarations:
if isinstance(_namespace, declarations.namespace_t):
if Constants.KERNEL not in str(_namespace):
main_namespace = _namespace
self.parsed_data['namespace'].append(
str(_namespace).split('::')[-1].split(' ')[0])
except RuntimeError:
raise BlockToolException(
'Invalid namespace format in the block header file')
# class
try:
self.parsed_data['class'] = ''
for _class in main_namespace.declarations:
if isinstance(_class, declarations.class_t):
expected_class_name = self.filename.split('.')[0]
if expected_class_name in str(_class):
main_class = _class
self.parsed_data['class'] = str(_class).split(
'::')[2].split(' ')[0]
# in more complicated blocks, there are many classes included in this declaration
# Break after the first class - safe to assume this is the "main class"?
if len(main_class.bases) > 0:
self.parsed_data['block_type'] = main_class.bases[
0].declaration_path[-1]
break
except RuntimeError:
raise BlockToolException(
'Block header namespace {} must consist of a valid class instance'
.format(module))
# io_signature, message_ports
self.parsed_data['io_signature'] = {}
self.parsed_data['message_port'] = {}
if os.path.isfile(self.impl_file) and exist_comments(self):
self.parsed_data['io_signature'] = io_signature(self.impl_file)
self.parsed_data['message_port'] = message_port(self.impl_file)
read_comments(self)
elif os.path.isfile(self.impl_file) and not exist_comments(self):
self.parsed_data['io_signature'] = io_signature(self.impl_file)
self.parsed_data['message_port'] = message_port(self.impl_file)
if self.addcomments:
add_comments(self)
elif not os.path.isfile(self.impl_file) and exist_comments(self):
read_comments(self)
else:
self.parsed_data['io_signature'] = {"input": [], "output": []}
self.parsed_data['message_port'] = self.parsed_data['io_signature']
# make
try:
self.parsed_data['make'] = {}
self.parsed_data['make']['arguments'] = []
query_m = declarations.custom_matcher_t(
lambda mem_fun: mem_fun.name.startswith('make'))
query_make = query_m & declarations.access_type_matcher_t('public')
make_func = main_class.member_functions(
function=query_make,
allow_empty=True,
header_file=self.target_file)
criteria = declarations.calldef_matcher(name='make')
_make_fun = declarations.matcher.get_single(criteria, main_class)
_make_fun = str(_make_fun).split('make')[-1].split(')')[0].split(
'(')[1].lstrip().rstrip().split(',')
if make_func:
for arg in make_func[0].arguments:
make_arguments = None
'''
for _arg in _make_fun:
if str(arg.name) in _arg:
make_arguments = {
"name": str(arg.name),
"dtype": str(arg.decl_type),
"default": ""
}
if re.findall(r'[-+]?\d*\.\d+|\d+', _arg):
make_arguments['default'] = re.findall(
r'[-+]?\d*\.\d+|\d+', _arg)[0]
elif re.findall(r'\"(.+?)\"', _arg):
make_arguments['default'] = re.findall(
r'\"(.+?)\"', _arg)[0]
elif "true" in _arg:
make_arguments['default'] = "True"
elif "false" in _arg:
make_arguments['default'] = "False"
'''
# In case the search did not find an argument in the inner loop
# This happens while parsing digital/symbol_sync_cc.h
if make_arguments:
self.parsed_data['make']['arguments'].append(
make_arguments.copy())
else:
self.parsed_data['make']['arguments'].append({
"name":
str(arg.name),
"dtype":
str(arg.decl_type),
"default":
arg.
default_value # can we get default argument directly from arg
})
except RuntimeError:
self.parsed_data['make'] = {}
self.parsed_data['make']['arguments'] = []
# setters
try:
self.parsed_data['methods'] = []
query_methods = declarations.access_type_matcher_t('public')
setters = main_class.member_functions(function=query_methods,
allow_empty=True,
header_file=self.target_file)
getter_arguments = []
if setters:
for setter in setters:
if str(setter.name).startswith(
'set_') and setter.arguments:
setter_args = {
"name": str(setter.name),
"arguments_type": []
}
for argument in setter.arguments:
args = {
"name": str(argument.name),
"dtype": str(argument.decl_type)
}
getter_arguments.append(args['name'])
setter_args['arguments_type'].append(args.copy())
self.parsed_data['methods'].append(setter_args.copy())
except RuntimeError:
self.parsed_data['methods'] = []
# getters
try:
self.parsed_data['properties'] = []
query_properties = declarations.access_type_matcher_t('public')
getters = main_class.member_functions(function=query_properties,
allow_empty=True,
header_file=self.target_file)
if getters:
for getter in getters:
if not getter.arguments or getter.has_const:
getter_args = {
"name": str(getter.name),
"dtype": str(getter.return_type),
"read_only": True
}
if getter_args['name'] in getter_arguments:
getter_args["read_only"] = False
self.parsed_data['properties'].append(
getter_args.copy())
except RuntimeError:
self.parsed_data['properties'] = []
# all member functions
# setters and getters do not return all member functions for a block
try:
self.parsed_data['member_functions'] = []
query_methods = declarations.access_type_matcher_t('public')
functions = main_class.member_functions(
function=query_methods,
allow_empty=True,
header_file=self.target_file)
if functions:
for fcn in functions:
if str(fcn.name) not in [
main_class.name, '~' + main_class.name, 'make'
]:
fcn_args = {"name": str(fcn.name), "arguments": []}
for argument in fcn.arguments:
args = {
"name": str(argument.name),
"dtype": str(argument.decl_type),
"default": argument.default_value
}
fcn_args['arguments'].append(args.copy())
self.parsed_data['member_functions'].append(
fcn_args.copy())
except RuntimeError:
self.parsed_data['member_functions'] = []
# documentation
try:
_index = None
header_file = codecs.open(self.target_file, 'r', 'cp932')
self.parsed_data['docstring'] = re.compile(
r'//.*?$|/\*.*?\*/',
re.DOTALL | re.MULTILINE).findall(header_file.read())[2:]
header_file.close()
for doc in self.parsed_data['docstring']:
if Constants.BLOCKTOOL in doc:
_index = self.parsed_data['docstring'].index(doc)
if _index is not None:
self.parsed_data['docstring'] = self.parsed_data[
'docstring'][:_index]
except:
self.parsed_data['docstring'] = []
return self.parsed_data
def redefined_funcs(self):
"""
returns list of member functions that should be defined in the class wrapper
It comes useful in 3 tier hierarchy:
.. code-block:: c++
struct base{
virtual void do_nothing() = 0;
};
struct derived{
virtual void do_something() = 0;
};
struct concrete{
virtual void do_nothing(){}
virtual void do_something(){}
};
The wrapper for class `derived`, should define `do_nothing` function,
otherwise the generated code will not compile
"""
if isinstance(self._redefined_funcs, list):
return self._redefined_funcs
all_included = declarations.custom_matcher_t(
lambda decl: decl.ignore == False and decl.exportable)
all_protected = declarations.access_type_matcher_t(
'protected') & all_included
all_pure_virtual = declarations.virtuality_type_matcher_t(
VIRTUALITY_TYPES.PURE_VIRTUAL)
all_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.VIRTUAL ) \
& ( declarations.access_type_matcher_t( 'public' ) \
| declarations.access_type_matcher_t( 'protected' ))
all_not_pure_virtual = ~all_pure_virtual
query = all_protected | all_pure_virtual
mf_query = query | all_virtual
relevant_opers = declarations.custom_matcher_t(
lambda decl: decl.symbol in ('()', '[]'))
funcs = []
defined_funcs = []
for base in self.recursive_bases:
if base.access == ACCESS_TYPES.PRIVATE:
continue
base_cls = base.related_class
funcs.extend(
base_cls.member_functions(mf_query,
recursive=False,
allow_empty=True))
funcs.extend(
base_cls.member_operators(relevant_opers & query,
recursive=False,
allow_empty=True))
defined_funcs.extend(
base_cls.member_functions(all_not_pure_virtual,
recursive=False,
allow_empty=True))
defined_funcs.extend(
base_cls.member_operators(all_not_pure_virtual
& relevant_opers,
recursive=False,
allow_empty=True))
not_reimplemented_funcs = set()
is_same_function = declarations.is_same_function
for f in funcs:
cls_fs = self.calldefs(name=f.name,
recursive=False,
allow_empty=True)
for cls_f in cls_fs:
if is_same_function(f, cls_f):
break
else:
#should test whether this function has been added or not
for f_impl in not_reimplemented_funcs:
if is_same_function(f, f_impl):
if declarations.is_base_and_derived(
f_impl.parent, f.parent):
#add function from the most derived class
not_reimplemented_funcs.remove(f_impl)
not_reimplemented_funcs.add(f)
break
else:
#should test whether this function is implemented in base class
if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL:
not_reimplemented_funcs.add(f)
else:
for f_defined in defined_funcs:
if is_same_function(f, f_defined):
break
else:
not_reimplemented_funcs.add(f)
functions = filter(
lambda f: (False == f.ignore and True == f.exportable) or
all_pure_virtual(f), list(not_reimplemented_funcs))
#Boost.Python is not able to call for non-virtual function, from the base
#class if there is a virtual function with the same within base class
#See override_bug tester for more information
def buggy_bpl_filter(f):
if f.parent is self:
return False
if f.access_type != ACCESS_TYPES.PUBLIC:
return False
if f.virtuality != VIRTUALITY_TYPES.NOT_VIRTUAL:
return False
#we need to check that we don't have "same" function in this class
this_funs = self.decls(name=f.name,
decl_type=declarations.calldef_t,
recursive=False,
allow_empty=True)
for this_f in this_funs:
if is_same_function(this_f, f):
#there is already the function in the class, so no need to redefined it
return False
else:
return True
tmp = {} # id : f
for redefined_f in functions:
#redefined is virtual, I am not interested in virtual functions
for rfo in redefined_f.overloads:
if id(rfo) in tmp:
continue
if buggy_bpl_filter(rfo):
tmp[id(rfo)] = rfo
functions.extend(tmp.values())
functions.sort(cmp=lambda f1, f2: cmp((f1.name, f1.location.as_tuple(
)), (f2.name, f2.location.as_tuple())))
self._redefined_funcs = functions
return self._redefined_funcs
def get_header_info(self):
"""
PyGCCXML header code parser
magic happens here!
: returns the parsed header data in python dict
: return dict keys: namespace, class, io_signature, make,
properties, methods
: Can be used as an CLI command or an extenal API
"""
gr = self.modname.split('-')[0]
module = self.modname.split('-')[-1]
generator_path, generator_name = utils.find_xml_generator()
xml_generator_config = parser.xml_generator_configuration_t(
xml_generator_path=generator_path,
xml_generator=generator_name,
compiler='gcc')
decls = parser.parse(
[self.target_file], xml_generator_config)
global_namespace = declarations.get_global_namespace(decls)
# namespace
try:
self.parsed_data['namespace'] = []
ns = global_namespace.namespace(gr)
if ns is None:
raise BlockToolException
main_namespace = ns.namespace(module)
if main_namespace is None:
raise BlockToolException('namespace cannot be none')
self.parsed_data['namespace'] = [gr, module]
if main_namespace.declarations:
for _namespace in main_namespace.declarations:
if isinstance(_namespace, declarations.namespace_t):
if Constants.KERNEL not in str(_namespace):
main_namespace = _namespace
self.parsed_data['namespace'].append(
str(_namespace).split('::')[-1].split(' ')[0])
except RuntimeError:
raise BlockToolException(
'Invalid namespace format in the block header file')
# class
try:
self.parsed_data['class'] = ''
for _class in main_namespace.declarations:
if isinstance(_class, declarations.class_t):
main_class = _class
self.parsed_data['class'] = str(_class).split('::')[
2].split(' ')[0]
except RuntimeError:
raise BlockToolException(
'Block header namespace {} must consist of a valid class instance'.format(module))
# io_signature, message_ports
self.parsed_data['io_signature'] = {}
self.parsed_data['message_port'] = {}
if os.path.isfile(self.impl_file) and exist_comments(self):
self.parsed_data['io_signature'] = io_signature(
self.impl_file)
self.parsed_data['message_port'] = message_port(
self.impl_file)
read_comments(self)
elif os.path.isfile(self.impl_file) and not exist_comments(self):
self.parsed_data['io_signature'] = io_signature(
self.impl_file)
self.parsed_data['message_port'] = message_port(
self.impl_file)
if self.addcomments:
add_comments(self)
elif not os.path.isfile(self.impl_file) and exist_comments(self):
read_comments(self)
else:
self.parsed_data['io_signature'] = {
"input": [],
"output": []
}
self.parsed_data['message_port'] = self.parsed_data['io_signature']
# make
try:
self.parsed_data['make'] = {}
self.parsed_data['make']['arguments'] = []
query_m = declarations.custom_matcher_t(
lambda mem_fun: mem_fun.name.startswith('make'))
query_make = query_m & declarations.access_type_matcher_t('public')
make_func = main_class.member_functions(function=query_make,
allow_empty=True,
header_file=self.target_file)
criteria = declarations.calldef_matcher(name='make')
_make_fun = declarations.matcher.get_single(criteria, main_class)
_make_fun = str(_make_fun).split(
'make')[-1].split(')')[0].split('(')[1].lstrip().rstrip().split(',')
if make_func:
for arg in make_func[0].arguments:
for _arg in _make_fun:
if str(arg.name) in _arg:
make_arguments = {
"name": str(arg.name),
"dtype": str(arg.decl_type),
"default": ""
}
if re.findall(r'[-+]?\d*\.\d+|\d+', _arg):
make_arguments['default'] = re.findall(
r'[-+]?\d*\.\d+|\d+', _arg)[0]
elif re.findall(r'\"(.+?)\"', _arg):
make_arguments['default'] = re.findall(
r'\"(.+?)\"', _arg)[0]
elif "true" in _arg:
make_arguments['default'] = "True"
elif "false" in _arg:
make_arguments['default'] = "False"
self.parsed_data['make']['arguments'].append(
make_arguments.copy())
except RuntimeError:
self.parsed_data['make'] = {}
self.parsed_data['make']['arguments'] = []
# setters
try:
self.parsed_data['methods'] = []
query_methods = declarations.access_type_matcher_t('public')
setters = main_class.member_functions(function=query_methods,
allow_empty=True,
header_file=self.target_file)
getter_arguments = []
if setters:
for setter in setters:
if str(setter.name).startswith('set_') and setter.arguments:
setter_args = {
"name": str(setter.name),
"arguments_type": []
}
for argument in setter.arguments:
args = {
"name": str(argument.name),
"dtype": str(argument.decl_type)
}
getter_arguments.append(args['name'])
setter_args['arguments_type'].append(args.copy())
self.parsed_data['methods'].append(setter_args.copy())
except RuntimeError:
self.parsed_data['methods'] = []
# getters
try:
self.parsed_data['properties'] = []
query_properties = declarations.access_type_matcher_t('public')
getters = main_class.member_functions(function=query_properties,
allow_empty=True,
header_file=self.target_file)
if getters:
for getter in getters:
if not getter.arguments or getter.has_const:
getter_args = {
"name": str(getter.name),
"dtype": str(getter.return_type),
"read_only": True
}
if getter_args['name'] in getter_arguments:
getter_args["read_only"] = False
self.parsed_data['properties'].append(
getter_args.copy())
except RuntimeError:
self.parsed_data['properties'] = []
# documentation
try:
_index = None
header_file = codecs.open(self.target_file, 'r', 'cp932')
self.parsed_data['docstring'] = re.compile(
r'//.*?$|/\*.*?\*/', re.DOTALL | re.MULTILINE).findall(
header_file.read())[2:]
header_file.close()
for doc in self.parsed_data['docstring']:
if Constants.BLOCKTOOL in doc:
_index = self.parsed_data['docstring'].index(doc)
if _index is not None:
self.parsed_data['docstring'] = self.parsed_data['docstring'][: _index]
except:
self.parsed_data['docstring'] = []
return self.parsed_data
if isinstance(ty,declarations.cpptypes.declarated_t):
ty = ty.declaration
c = ty # baseTy # .declaration
if not isInPublicScope(c):
print 'exclude <template>', m
return False
if isInPublicScope(m):
return True
else:
print 'exclude', m
return False
else:
print 'exclude', m
return False
classList = sorted(global_ns.classes(header_dir=this_module_dir_path, function = declarations.custom_matcher_t(matcherFun) & (~(declarations.access_type_matcher_t( 'private' ) | declarations.access_type_matcher_t( 'protected' )) )), key=attrgetter('name'))
enumList = sorted(global_ns.enums(header_dir=this_module_dir_path), key=attrgetter('name'))
tyNone = 0
tyPrim = 1
tyGlue = 2
tyObj = 3
def isGlueType(ty):
ty = declarations.type_traits.remove_reference(declarations.type_traits.remove_cv(ty))
ty = declarations.type_traits.remove_cv(ty)
baseTy = declarations.type_traits.base_type(ty)
if (declarations.type_traits.is_fundamental(baseTy)) | (not declarations.type_traits.is_class(ty)) | (not declarations.type_traits.is_same(baseTy,ty)):
return False
if baseTy.declaration.name in glueMap:
return True
if not isInPublicScope(c):
print 'exclude <template>', m
return False
if isInPublicScope(m):
return True
else:
print 'exclude', m
return False
else:
print 'exclude', m
return False
classList = sorted(
global_ns.classes(header_dir=this_module_dir_path,
function=declarations.custom_matcher_t(matcherFun) &
(~(declarations.access_type_matcher_t('private')
| declarations.access_type_matcher_t('protected')))),
key=attrgetter('name'))
enumList = sorted(global_ns.enums(header_dir=this_module_dir_path),
key=attrgetter('name'))
tyNone = 0
tyPrim = 1
tyGlue = 2
tyObj = 3
def isGlueType(ty):
ty = declarations.type_traits.remove_reference(
declarations.type_traits.remove_cv(ty))
print '\nWhile Processing FILEs: \n' + str(sources) + '\nLines: ' + str(customCodeBlock) + '\n'
# Execute user-specified code
try:
for customCodeBlock in task.custom_code:
exec customCodeBlock in locals()
except:
import traceback
traceback.print_exc()
print '\nWhile Processing FILEs: \n' + str(sources) + '\nLines: ' + customCodeBlock + '\n'
return 1
# Now I protect the virtual member calls so that they behave correctly in a multi-threaded environment
members = mb.global_ns.calldefs( (declarations.virtuality_type_matcher(declarations.VIRTUALITY_TYPES.VIRTUAL) |
declarations.virtuality_type_matcher(declarations.VIRTUALITY_TYPES.PURE_VIRTUAL)) &
declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable ), allow_empty=True)
if( members ):
for member in members:
try:
member.add_override_precall_code('\npyplusplus::threading::gil_guard_t gil_guard( resp::sc_controller::getController().interactive );')
if not code_repository.gil_guard.file_name in task.ext_headers:
task.ext_headers.append(code_repository.gil_guard.file_name)
controller_path = os.path.join(task.srcpath, 'src', 'controller', 'controller.hpp')
if not controller_path in task.ext_headers:
task.ext_headers.append(controller_path)
if not os.path.exists(os.path.abspath(os.path.join( task.bldpath, os.path.dirname(task.outputs[0].bldpath(task.env)), code_repository.gil_guard.file_name) )):
guard = open(os.path.abspath(os.path.join( task.bldpath, os.path.dirname(task.outputs[0].bldpath(task.env)), code_repository.gil_guard.file_name) ), 'w')
guard.write(code_repository.gil_guard.code)
guard.close()
except AttributeError:
pass
