def test(self):
fpath = os.path.join( autoconfig.data_directory, 'already_exposed_to_be_exported.hpp' )
mb = module_builder.module_builder_t( [module_builder.create_source_fc( fpath )]
, gccxml_path=autoconfig.gccxml.executable, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler() )
mb.global_ns.exclude()
mb.namespace( 'already_exposed' ).include()
mb.build_code_creator( 'already_exposed' )
already_exposed_dir = os.path.join( autoconfig.build_directory, 'already_exposed' )
mb.write_module( os.path.join( already_exposed_dir, 'already_exposed.cpp' ) )
#-----------------------------------------------------------------------
fpath = os.path.join( autoconfig.data_directory, 'already_exposed_2to_be_exported.hpp' )
mb = module_builder.module_builder_t( [module_builder.create_source_fc( fpath )]
, gccxml_path=autoconfig.gccxml.executable
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler() )
mb.global_ns.exclude()
mb.namespace( 'to_be_exposed' ).include()
mb.build_code_creator( 'to_be_exposed' )
mb.register_module_dependency( already_exposed_dir )
mb.build_code_creator( 'to_be_exposed' )
to_be_exposed_dir = os.path.join( autoconfig.build_directory, 'to_be_exposed' )
mb.write_module( os.path.join( to_be_exposed_dir, 'to_be_exposed.cpp' ) )
body = mb.code_creator.body
self.failUnless( 2 == len( body.creators ) )
ae_derived_code = body.creators[0].create()
self.failUnless( mb.class_( 'ae_base' ).decl_string in ae_derived_code )
def test(self):
fpath = os.path.join( autoconfig.data_directory, 'already_exposed_to_be_exported.hpp' )
mb = module_builder.module_builder_t( [module_builder.create_source_fc( fpath )]
, xml_generator_config=autoconfig.xml_generator_config )
mb.global_ns.exclude()
mb.namespace( 'already_exposed' ).include()
mb.build_code_creator( 'already_exposed' )
already_exposed_dir = os.path.join( autoconfig.build_directory, 'already_exposed' )
mb.write_module( os.path.join( already_exposed_dir, 'already_exposed.cpp' ) )
#-----------------------------------------------------------------------
fpath = os.path.join( autoconfig.data_directory, 'already_exposed_2to_be_exported.hpp' )
mb = module_builder.module_builder_t( [module_builder.create_source_fc( fpath )]
, xml_generator_config=autoconfig.xml_generator_config )
mb.global_ns.exclude()
mb.namespace( 'to_be_exposed' ).include()
mb.build_code_creator( 'to_be_exposed' )
mb.register_module_dependency( already_exposed_dir )
mb.build_code_creator( 'to_be_exposed' )
to_be_exposed_dir = os.path.join( autoconfig.build_directory, 'to_be_exposed' )
mb.write_module( os.path.join( to_be_exposed_dir, 'to_be_exposed.cpp' ) )
body = mb.code_creator.body
self.assertTrue( 2 == len( body.creators ) )
ae_derived_code = body.creators[0].create()
self.assertTrue( mb.class_( 'ae_base' ).decl_string in ae_derived_code )
def test(self):
mb = module_builder.module_builder_t( self._get_files()
, xml_generator_config=autoconfig.xml_generator_config
, include_paths=[autoconfig.boost.include]
, undefine_symbols=['__MINGW32__'] )
writer = lambda decl: None
module_builder.print_declarations( mb.global_ns, writer=writer )
def _create_extension_source_file(self):
global LICENSE
#xml_file = os.path.split( self.__to_be_exported_header )[1]
#xml_file = os.path.join( autoconfig.build_dir, xml_file + '.xml' )
#xml_cached_fc = parser.create_cached_source_fc( self.__to_be_exported_header, xml_file )
#mb = module_builder.module_builder_t( [xml_cached_fc]
mb = module_builder.module_builder_t( [self.__to_be_exported_header]
, gccxml_path=autoconfig.gccxml.executable
, include_paths=[autoconfig.boost.include]
, undefine_symbols=['__MINGW32__']
, indexing_suite_version=self.__indexing_suite_version)
for decl in mb.decls():
decl.documentation = '"documentation"'
self.customize( mb )
doc_extractor = lambda decl: decl.documentation
if not mb.has_code_creator():
mb.build_code_creator( self.__module_name, doc_extractor=doc_extractor )
mb.code_creator.std_directories.extend( autoconfig.scons_config.cpppath )
mb.code_creator.user_defined_directories.append( autoconfig.data_directory )
mb.code_creator.precompiled_header = "boost/python.hpp"
mb.code_creator.license = LICENSE
self.generate_source_files( mb )
self.__test_already_exposed( mb )
def __init__(self):
self.__file = os.path.join(random_settings.working_dir,
'random_export.hpp')
self.__mb = module_builder.module_builder_t(
[
parser.create_cached_source_fc(
self.__file,
os.path.join(random_settings.generated_files_dir,
'random.xml'))
],
gccxml_path=random_settings.gccxml.executable,
include_paths=[random_settings.boost.include],
define_symbols=random_settings.defined_symbols,
undefine_symbols=random_settings.undefined_symbols,
indexing_suite_version=2)
self.generators = [
"ecuyer1988", "hellekalek1995", "kreutzer1986",
"lagged_fibonacci1279", "lagged_fibonacci19937",
"lagged_fibonacci2281", "lagged_fibonacci23209",
"lagged_fibonacci3217", "lagged_fibonacci4423",
"lagged_fibonacci44497", "lagged_fibonacci607",
"lagged_fibonacci9689", "minstd_rand", "minstd_rand0", "mt11213b",
"mt19937", "ranlux3", "ranlux3_01", "ranlux4", "ranlux4_01",
"ranlux64_3_01", "ranlux64_4_01", "taus88"
]
self.no_min_max = [
'py_cauchy_distribution', 'py_bernoulli_distribution',
'py_binomial_distribution', 'py_poisson_distribution',
'py_normal_distribution', 'py_gamma_distribution',
'py_triangle_distribution', 'py_uniform_on_sphere',
'py_exponential_distribution', 'py_geometric_distribution',
'py_lognormal_distribution'
]
def create_module():
parser_config = parser.config_t( )
fx_xml = os.path.join( settings.xml_files, 'fx.xml' )
mb = module_builder.module_builder_t( [ parser.create_cached_source_fc( 'fx.h', fx_xml ) ]
, gccxml_path=settings.gccxml_path
, include_paths=[settings.boost_path, settings.tnfox_include_path]
, define_symbols=settings.defined_symbols_gccxml )
mb.run_query_optimizer()
print 'filtering declarations'
filter_decls( mb )
print 'filtering declarations - done'
print 'set call policies'
set_call_policies( mb )
print 'set call policies - done'
print 'customize declarations'
customize_decls( mb )
print 'customize declarations - done'
print 'creating module'
mb.build_code_creator(settings.module_name )
print 'creating module - done'
print 'customizing module'
customize_module( mb )
print 'customizing module - done'
return mb
def _generate_code(self):
global save_header_name
try:
config = self._parser_configurator.parser_configuration()
header_file = self._header_file_configurator.header_file()
if not header_file or not os.path.isfile( header_file ):
raise RuntimeError( 'Header file "%s" does not exist or should be valid file name.' % header_file )
gui_config_t.save_header_name( header_file )
config.include_paths.append( os.path.split( header_file )[0] )
start_time = time.clock()
mb = module_builder.module_builder_t(
[ header_file ]
, gccxml_path=config.gccxml_path
, working_directory=os.path.split( header_file )[0]
, include_paths=config.include_paths
, define_symbols=config.define_symbols )
parsed_time = time.clock() - start_time
mb.build_code_creator( "pyplusplus" )
mb.code_creator.user_defined_directories.extend( config.include_paths )
code = mb.code_creator.create()
code = code.replace( '\n\r', '\n' )
code = code.replace( '\r\n', '\n' )
code_generated_time = time.clock() - start_time - parsed_time
self._generated_code.set_generated_code( code )
self._statistics.set_parse_time( parsed_time )
self._statistics.set_code_generation_time( code_generated_time )
except Exception, error:
user_msg = [ 'Error occured during code generation process!' ]
user_msg.append( 'Error:' )
user_msg.append( str( error ) )
self._generated_code.set_generated_code( '\n'.join( user_msg ) )
def test(self):
code = """
namespace xyz{
struct good{};
typedef void (*ff1)( int, int );
void f_bad( ff1 );
}
"""
mb = module_builder.module_builder_t(
[module_builder.create_text_fc(code)],
xml_generator_config=autoconfig.xml_generator_config)
xyz = mb.namespace(name='xyz')
xyz.include()
xyz.exclude(compilation_errors=True)
self.assertTrue(xyz.ignore == False)
self.assertTrue(xyz.class_('good').ignore == False)
self.assertTrue(xyz.free_function('f_bad').ignore == True)
def generate_code():
code_tree = parser.create_cached_source_fc(
os.path.join(root_dir, "Engine.h"), "BootCache.xml")
defined_symbols = ['B_NO_INTERLOCKED_INTRINSICS']
include_dirs = [
os.path.join(root_dir, "..", "..", "..", "Engine", "Common"),
os.path.join(root_dir, "..", "..", "..", "Engine", "Graphics"),
os.path.join(root_dir, "..", "..", "..", "Engine", "FileSystem")
]
mb = module_builder.module_builder_t([code_tree],
gccxml_path=gccxml_bin,
working_directory=root_dir,
include_paths=include_dirs,
define_symbols=defined_symbols,
undefine_symbols=[],
indexing_suite_version=2,
cflags='')
#ns = mb.global_ns
#ns.exclude()
return mb
def _create_extension_source_file(self):
global LICENSE
#xml_file = os.path.split( self.__to_be_exported_header )[1]
#xml_file = os.path.join( autoconfig.build_dir, xml_file + '.xml' )
#xml_cached_fc = parser.create_cached_source_fc( self.__to_be_exported_header, xml_file )
#mb = module_builder.module_builder_t( [xml_cached_fc]
mb = module_builder.module_builder_t(
[self.__to_be_exported_header],
gccxml_path=autoconfig.gccxml.executable,
include_paths=[autoconfig.boost.include],
undefine_symbols=['__MINGW32__'],
indexing_suite_version=self.__indexing_suite_version)
for decl in mb.decls():
decl.documentation = '"documentation"'
self.customize(mb)
doc_extractor = lambda decl: decl.documentation
if not mb.has_code_creator():
mb.build_code_creator(self.__module_name,
doc_extractor=doc_extractor)
mb.code_creator.std_directories.extend(autoconfig.scons_config.cpppath)
mb.code_creator.user_defined_directories.append(
autoconfig.data_directory)
mb.code_creator.precompiled_header = "boost/python.hpp"
mb.code_creator.license = LICENSE
self.generate_source_files(mb)
self.__test_already_exposed(mb)
def test(self):
code = """
namespace xyz{
struct Y;
struct X{
X();
X( const X& );
X( Y* );
};
}
"""
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( code ) ]
, gccxml_path=autoconfig.gccxml.executable )
x = mb.class_( 'X' )
x.include()
x.constructors().body = ' //all constructors body'
x.null_constructor_body = ' //null constructor body'
x.copy_constructor_body = ' //copy constructor body'
mb.build_code_creator( 'XXX' )
code = mb.code_creator.create()
tmp = code.split( x.null_constructor_body )
self.failUnless( len( tmp ) == 2 )
tmp = code.split( x.copy_constructor_body )
self.failUnless( len( tmp ) == 2 )
tmp = code.split( ' //all constructors body' )
self.failUnless( len( tmp ) == 2 )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( self.CODE )]
, gccxml_path=autoconfig.gccxml.executable )
d = mb.class_( 'derived' )
f = d.mem_fun( 'f' )
self.failUnless( f.create_with_signature == True )
def test(self):
code = """
namespace xyz{
struct Y;
struct X{
X();
X( const X& );
X( Y* );
};
}
"""
mb = module_builder.module_builder_t(
[module_builder.create_text_fc(code)],
xml_generator_config=autoconfig.xml_generator_config)
x = mb.class_('X')
x.include()
x.constructors().body = ' //all constructors body'
x.null_constructor_body = ' //null constructor body'
x.copy_constructor_body = ' //copy constructor body'
mb.build_code_creator('XXX')
code = mb.code_creator.create()
tmp = code.split(x.null_constructor_body)
self.assertTrue(len(tmp) == 2)
tmp = code.split(x.copy_constructor_body)
self.assertTrue(len(tmp) == 2)
tmp = code.split(' //all constructors body')
self.assertTrue(len(tmp) == 2)
def test(self):
mb = module_builder.module_builder_t(
[module_builder.create_text_fc(self.CODE)],
xml_generator_config=autoconfig.xml_generator_config)
d = mb.class_('derived')
f = d.member_function('f')
self.assertTrue(f.create_with_signature == True)
def __init__(self, files):
# Parse code generation parameters from (optional) command line arguments
# Otherwise hard code paths from my particular dev machine... (yuck)
parser = argparse.ArgumentParser(description='Generates boost-python wrapping code for an OSG module.')
parser.add_argument('--gccxml_path',
default="C:/Program Files (x86)/gccxml/bin/gccxml.exe",
help="path to the GCCXML executable program",)
parser.add_argument('--osg_include_path',
default="C:/Program Files (x86)/OpenSceneGraph323vs2008/include",
help="path to the OpenSceneGraph C++ header files",)
default_compiler = "msvc9"
parser.add_argument('--gccxml_compiler',
default=default_compiler,
help="name of C++ compiler",)
args = parser.parse_args()
#
gccxml_path = args.gccxml_path
osg_include_path = args.osg_include_path
compiler = args.gccxml_compiler
#
self.max_arity = 18
define_symbols = []
if compiler == 'msvc9':
define_symbols.append("_HAS_TR1=0") # avoid boost compiler errors on windows
define_symbols.append("BOOST_PYTHON_MAX_ARITY=%d" % self.max_arity)
#
self.mb = module_builder.module_builder_t(
files = files,
gccxml_path = gccxml_path,
include_paths = [osg_include_path,],
define_symbols=define_symbols,
indexing_suite_version=2,
compiler=compiler,
)
self.mb.BOOST_PYTHON_MAX_ARITY = self.max_arity # Prevents warnings on 10-18 argument methods
def test(self):
code = """
namespace xyz{
struct good{};
typedef void (*ff1)( int, int );
void f_bad( ff1 );
}
"""
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( code ) ]
, gccxml_path=autoconfig.gccxml.executable )
xyz = mb.namespace( name='xyz' )
xyz.include()
xyz.exclude(compilation_errors=True)
self.failUnless( xyz.ignore == False )
self.failUnless( xyz.class_( 'good' ).ignore == False )
self.failUnless( xyz.free_fun( 'f_bad' ).ignore == True )
def test(self):
module_builder.set_logger_level( logging.CRITICAL )
messages.disable( *messages.all_warning_msgs )
xml_file = parser.create_gccxml_fc( os.path.join( autoconfig.data_directory, 'particleuniverse.xml' ) )
mb = module_builder.module_builder_t(
[ xml_file ]
, gccxml_path=autoconfig.gccxml.executable
, indexing_suite_version=2
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())
mb.global_ns.exclude()
mb.namespace('ParticleUniverse').include()
mb.namespace('Ogre').include()
mb.namespace('Ogre').classes().already_exposed = True
target_dir = os.path.join( autoconfig.build_directory, 'particle_universe' )
#~ if os.path.exists( target_dir ):
#~ shutil.rmtree( target_dir )
#~ os.mkdir( target_dir )
psp = mb.class_( '::ParticleUniverse::ParticleScriptParser' )
declarations.print_declarations( psp )
mb.build_code_creator( 'PU' )
mb.split_module( target_dir )
def __init__(self, name, deps=None, replacement_dict=default_replacement,
indexing_suite_version=2):
"""Constructor.
@name name of the python module
@dep name of another module this module depends on"""
# create a separate thread that prints out a message every 60 seconds
# to let build bots know the build is not stuck.
self.heartbeat = threading.Thread(target=Heartbeat(60))
self.heartbeat.daemon = True
self.heartbeat.start()
xml_generator_config = parser.load_xml_generator_configuration("/Users/mmoll/build/omplapp/1.4.2/castxml.cfg")
self.mb = module_builder.module_builder_t(
files=['bindings/' + name + '.h'],
# cache is not used with compilation_mode = parser.COMPILATION_MODE.ALL_AT_ONCE
#cache = '/Users/mmoll/build/omplapp/1.4.2/pyplusplus_'+name+'.cache',
xml_generator_config=xml_generator_config,
start_with_declarations=['ompl::' + name],
compilation_mode=parser.COMPILATION_MODE.ALL_AT_ONCE,
indexing_suite_version=indexing_suite_version)
self.replacement = {} if replacement_dict is None else replacement_dict
self.mb.classes().always_expose_using_scope = True
self.mb.add_registration_code('PyEval_InitThreads();', tail=False)
self.std_ns = self.mb.namespace('std')
self.ompl_ns = self.mb.namespace('ompl')
self.call_policies()
self.filter_declarations()
if deps != None:
for dep in deps:
self.mb.register_module_dependency(dep)
self.mb.build_code_creator(module_name='_' + name)
self.mb.split_module('bindings/' + name, use_files_sum_repository=True)
def main(args):
from pyplusplus import module_builder
from pyplusplus.module_builder import call_policies
if args.chdir:
from os import chdir
chdir(args.chdir)
builder = module_builder.module_builder_t(args.input,
include_paths=args.include)
if args.mangle:
from runpy import runpy
M = runpy(args.mangle)
M['mangle'](builder)
#eg. things a mangle might do
#Cell = builder.class_('Cell')
#Cell.member_function('getelem').call_policies = call_policies.return_internal_reference()
# The Elem* pointer passed to setelem(P) is now "owned" by the Cell
#Cell.member_function('setelem').call_policies = call_policies.with_custodian_and_ward(1,2)
#Cell.var('elem').expost_value = False
builder.build_code_creator(module_name=args.name)
builder.write_module(args.output)
def test(self):
module_builder.set_logger_level( logging.CRITICAL )
messages.disable( *messages.all_warning_msgs )
ogre_file = autoconfig.data_directory.replace( 'pyplusplus_dev', 'pygccxml_dev' )
ogre_file = parser.create_gccxml_fc( os.path.join( ogre_file, 'ogre.1.7.xml' ) )
mb = module_builder.module_builder_t(
[ ogre_file ]
, xml_generator_config=autoconfig.xml_generator_config
, indexing_suite_version=2)
mb.global_ns.exclude()
mb.namespace('Ogre').include()
x = mb.global_ns.decls( lambda d: 'Animation*' in d.name and 'MapIterator' in d.name )
for y in x:
print(y.name)
print(y.partial_name)
print(declarations.full_name( y, with_defaults=False ))
target_dir = os.path.join( autoconfig.build_directory, 'ogre' )
#~ if os.path.exists( target_dir ):
#~ shutil.rmtree( target_dir )
#~ os.mkdir( target_dir )
mb.build_code_creator( 'Ogre3d' )
mb.split_module( target_dir )
def test(self):
module_builder.set_logger_level( logging.CRITICAL )
messages.disable( *messages.all_warning_msgs )
ogre_file = autoconfig.data_directory.replace( 'pyplusplus_dev', 'pygccxml_dev' )
ogre_file = parser.create_gccxml_fc( os.path.join( ogre_file, 'ogre.1.7.xml' ) )
mb = module_builder.module_builder_t(
[ ogre_file ]
, gccxml_path=autoconfig.gccxml.executable
, indexing_suite_version=2
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())
mb.global_ns.exclude()
mb.namespace('Ogre').include()
x = mb.global_ns.decls( lambda d: 'Animation*' in d.name and 'MapIterator' in d.name )
for y in x:
print y.name
print y.partial_name
print declarations.full_name( y, with_defaults=False )
target_dir = os.path.join( autoconfig.build_directory, 'ogre' )
#~ if os.path.exists( target_dir ):
#~ shutil.rmtree( target_dir )
#~ os.mkdir( target_dir )
mb.build_code_creator( 'Ogre3d' )
mb.split_module( target_dir )
def gen_cpp(params, q_result, q_error):
'''
Generate cpp (Boost.Python) code
@param params: List of parameters [gccxml,incPath,macros]
@param q_result: python queue to put result in
@param q_error: python queue to put error in
@return None (isn't evaluated)
'''
try:
header_file = params[3]
include_paths = params[1]
include_paths.append( os.path.split( header_file )[0] )
mb = module_builder.module_builder_t(
[ header_file ]
, gccxml_path=params[0]
, working_directory=os.path.split( header_file )[0]
, include_paths=include_paths
, define_symbols=params[2] )
mb.build_code_creator( "pyplusplus" )
mb.code_creator.user_defined_directories.extend( include_paths )
code = mb.code_creator.create()
code = code.replace( '\n\r', '\n' )
code = code.replace( '\r\n', '\n' )
q_result.put( code )
except Exception, error:
q_result.put(str( error ))
q_error.put(str( error ))
def test(self):
mb = module_builder.module_builder_t( self._get_files()
, gccxml_path=autoconfig.gccxml.executable
, include_paths=[autoconfig.boost.include]
, undefine_symbols=['__MINGW32__'])
writer = lambda decl: None
module_builder.print_declarations( mb.global_ns, writer=writer )
def _create_extension_source_file(self):
global LICENSE
if os.path.exists( self.__generated_source_file_name + '.xml' ):
os.remove( self.__generated_source_file_name + '.xml' )
test_header_cfg \
= pygccxml.parser.create_cached_source_fc( self.__to_be_exported_header
, self.__generated_source_file_name + '.xml' )
mb = module_builder.module_builder_t( [ test_header_cfg ]
#, undefine_symbols=['__MINGW32__']
, indexing_suite_version=self.__indexing_suite_version
, gccxml_config=autoconfig.cxx_parsers_cfg.gccxml)
for decl in mb.decls():
decl.documentation = '"documentation"'
self.customize( mb )
doc_extractor = lambda decl: decl.documentation
if not mb.has_code_creator():
mb.build_code_creator( self.__module_name, doc_extractor=doc_extractor )
mb.code_creator.std_directories.extend( autoconfig.scons_config.cpppath )
mb.code_creator.user_defined_directories.append( autoconfig.data_directory )
mb.code_creator.precompiled_header = "boost/python.hpp"
mb.code_creator.license = LICENSE
self.generate_source_files( mb )
self.__test_already_exposed( mb )
def export():
global license
header_file = os.path.join(settings.easybmp_path, 'EasyBMP.h')
#create configuration for GCC-XML parser
#initialize module builder
mb = module_builder.module_builder_t(
[header_file],
gccxml_path=settings.gccxml_path,
working_directory=settings.easybmp_path)
bmp_class = mb.class_('BMP')
call_operator = bmp_class.operator(symbol='()', recursive=False)
call_operator.alias = 'GetRGBAPixel'
call_operator.call_policies = module_builder.call_policies.return_internal_reference(
)
#customizing code, before generation
mb.build_code_creator(settings.module_name)
mb.code_creator.license = license
mb.code_creator.user_defined_directories.append(settings.easybmp_path)
mb.code_creator.precompiled_header = 'boost/python.hpp'
mb.code_creator.replace_included_headers([header_file])
mb.write_module(
os.path.join(settings.generated_files_dir,
settings.module_name + '.cpp'))
def __init__(self,
module_name = '',
call_policies = (),
function_call_policies = (),
excluded_classes = (),
excluded_members = (),
included_members = (),
excluded_constructors = (),
already_exposed = (),
headers = [],
extra_headers = [],
extra_declarations = [],
extra_registrations = [],
extra_member_registrations = [],
held_types = [],
ownership_transfers = [],
):
self.module_name = module_name
self.headers = headers
self.call_policies = call_policies
self.function_call_policies = function_call_policies
self.excluded_classes = excluded_classes
self.excluded_members = excluded_members
self.included_members = included_members
self.excluded_constructors = excluded_constructors
self.already_exposed = already_exposed
self.extra_headers = extra_headers
self.extra_declarations = extra_declarations
self.extra_member_registrations = extra_member_registrations
self.extra_registrations = extra_registrations
self.held_types = held_types
self.ownership_transfers = ownership_transfers
self.bindings_dir = "."
# If only generating the list of dependences, do not create
# the module builder, because it would compile all the headers
# with gccxml.
if len(sys.argv) == 2 and sys.argv[1] == '--generate-dependences':
pass
else:
#try:
# os.mkdir(self.bindings_dir)
#except OSError:
# pass
hh = map(os.path.abspath, headers)
header_file_name = "%s/%s_headers.hpp" % (self.bindings_dir,
self.module_name)
f = open(header_file_name, 'w')
for h in hh:
f.write('#include <%s>\n'% h)
f.close()
self.module_builder = module_builder.module_builder_t(
[os.path.abspath(header_file_name)]
, gccxml_path=r"/usr/bin/gccxml"
, include_paths=include_paths
, define_symbols=['TCE_PYTHON_BINDINGS']
, indexing_suite_version=2)
def __init__(
self,
module_name='',
call_policies=(),
function_call_policies=(),
excluded_classes=(),
excluded_members=(),
included_members=(),
excluded_constructors=(),
already_exposed=(),
headers=[],
extra_headers=[],
extra_declarations=[],
extra_registrations=[],
extra_member_registrations=[],
held_types=[],
ownership_transfers=[],
):
self.module_name = module_name
self.headers = headers
self.call_policies = call_policies
self.function_call_policies = function_call_policies
self.excluded_classes = excluded_classes
self.excluded_members = excluded_members
self.included_members = included_members
self.excluded_constructors = excluded_constructors
self.already_exposed = already_exposed
self.extra_headers = extra_headers
self.extra_declarations = extra_declarations
self.extra_member_registrations = extra_member_registrations
self.extra_registrations = extra_registrations
self.held_types = held_types
self.ownership_transfers = ownership_transfers
self.bindings_dir = "."
# If only generating the list of dependences, do not create
# the module builder, because it would compile all the headers
# with gccxml.
if len(sys.argv) == 2 and sys.argv[1] == '--generate-dependences':
pass
else:
#try:
# os.mkdir(self.bindings_dir)
#except OSError:
# pass
hh = map(os.path.abspath, headers)
header_file_name = "%s/%s_headers.hpp" % (self.bindings_dir,
self.module_name)
f = open(header_file_name, 'w')
for h in hh:
f.write('#include <%s>\n' % h)
f.close()
self.module_builder = module_builder.module_builder_t(
[os.path.abspath(header_file_name)],
gccxml_path=r"/usr/bin/gccxml",
include_paths=include_paths,
define_symbols=['TCE_PYTHON_BINDINGS'],
indexing_suite_version=2)
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'namespace arr{ struct x{ x( int arr[3][3], int ){} x( const x arr[3][3], int ){} }; }' )]
, gccxml_path=autoconfig.gccxml.executable )
arr = mb.namespace( name='arr' )
mem_funs = arr.calldefs( 'x', arg_types=[None,None] )
for x in mem_funs:
self.failUnless( x.exportable == False )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'namespace enums{ enum { OK=1 }; }' ) ]
, gccxml_path=autoconfig.gccxml.executable )
mb.namespace( name='::enums' ).include()
mb.build_code_creator('dummy')
flatten = code_creators.make_flatten(mb.code_creator.creators)
self.failUnless( filter( lambda inst: isinstance( inst, code_creators.unnamed_enum_t ), flatten ) )
def test(self):
mb = module_builder.module_builder_t( self._get_files()
, gccxml_path=autoconfig.gccxml.executable
, include_paths=[autoconfig.boost.include]
, undefine_symbols=['__MINGW32__']
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())
writer = lambda decl: None
module_builder.print_declarations( mb.global_ns, writer=writer )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( self.CODE )]
, gccxml_path=autoconfig.gccxml.executable )
xxx = mb.namespace( name='xxx' )
fun = xxx.calldef( 'do_smth' )
self.failUnless( fun.readme() == [] )
minus_minus = xxx.operator( symbol='--' )
self.failUnless( 1 == len( minus_minus.readme() ), os.linesep.join( minus_minus.readme() ) )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'struct x{};' ) ]
, xml_generator_config=autoconfig.xml_generator_config
, encoding='UTF-8')
mb.build_code_creator( module_name='unicode_bug' )
mb.code_creator.license = "//абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
mb.write_module( os.path.join( autoconfig.build_dir, 'unicode_bug.cpp' ) )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'namespace enums{ enum { OK=1 }; }' ) ]
, gccxml_path=autoconfig.gccxml.executable
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler() )
mb.namespace( name='::enums' ).include()
mb.build_code_creator('dummy')
flatten = code_creators.make_flatten(mb.code_creator.creators)
self.failUnless( [inst for inst in flatten if isinstance( inst, code_creators.unnamed_enum_t )] )
def test(self):
mb = module_builder.module_builder_t(
[module_builder.create_text_fc(self.CODE)],
xml_generator_config=autoconfig.xml_generator_config)
xxx = mb.namespace(name='xxx')
fun = xxx.calldef('do_smth')
self.assertTrue(fun.readme() == [])
minus_minus = xxx.operator(symbol='--')
self.assertTrue(1 == len(minus_minus.readme()),
os.linesep.join(minus_minus.readme()))
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'struct x{};' ) ]
, gccxml_path=autoconfig.gccxml.executable
, encoding='UTF-8'
, compiler=autoconfig.cxx_parsers_cfg.gccxml.compiler)
mb.build_code_creator( module_name='unicode_bug' )
mb.code_creator.license = "//абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
mb.write_module( os.path.join( autoconfig.build_dir, 'unicode_bug.cpp' ) )
def test(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'struct x{};' ) ]
, gccxml_path=autoconfig.gccxml.executable
, encoding='UTF-8'
, compiler=autoconfig.cxx_parsers_cfg.gccxml.compiler)
mb.build_code_creator( module_name='unicode_bug' )
mb.code_creator.license = "//абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
mb.write_module( os.path.join( autoconfig.build_dir, 'unicode_bug.cpp' ) )
def createModuleBuilder(input_file, defined_symbols):
ret = module_builder.module_builder_t(files=[input_file],
gccxml_path=GCCXML_PATH,
include_paths=INCLUDE_PATHS,
define_symbols=defined_symbols,
indexing_suite_version=2)
ret.BOOST_PYTHON_MAX_ARITY = 25
ret.classes().always_expose_using_scope = True
return ret
def test_find_by_class_instance(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'namespace enums{ enum color{ red = 1}; }' )]
, gccxml_path=autoconfig.gccxml.executable )
mb.namespace( name='::enums' ).include()
mb.build_code_creator('dummy')
enum_found = code_creators.creator_finder.find_by_class_instance(
code_creators.enum_t
, mb.code_creator.creators
, recursive=True)
self.failUnless( enum_found )
def __init__(self):
self.__file = os.path.join(crc_settings.working_dir, "crc_export.hpp")
self.__mb = module_builder.module_builder_t(
[parser.create_cached_source_fc(self.__file, os.path.join(crc_settings.generated_files_dir, "crc.xml"))],
gccxml_path=crc_settings.gccxml.executable,
include_paths=[crc_settings.boost.include],
define_symbols=crc_settings.defined_symbols,
undefine_symbols=crc_settings.undefined_symbols,
indexing_suite_version=2,
)
def test_find_by_declaration(self):
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( 'namespace enums{ enum color{ red = 1}; }' )]
, gccxml_path=autoconfig.gccxml.executable )
mb.namespace( name='::enums' ).include()
enum_matcher = declarations.match_declaration_t( name='color' )
mb.build_code_creator( 'dummy' )
enum_found = code_creators.creator_finder.find_by_declaration(
enum_matcher
, mb.code_creator.creators )
self.failUnless( enum_found )
def test(self):
fpath = os.path.join(autoconfig.data_directory,
'already_exposed_to_be_exported.hpp')
mb = module_builder.module_builder_t(
[module_builder.create_source_fc(fpath)],
gccxml_path=autoconfig.gccxml.executable,
compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())
mb.global_ns.exclude()
mb.namespace('already_exposed').include()
mb.build_code_creator('already_exposed')
already_exposed_dir = os.path.join(autoconfig.build_directory,
'already_exposed')
mb.write_module(
os.path.join(already_exposed_dir, 'already_exposed.cpp'))
#-----------------------------------------------------------------------
fpath = os.path.join(autoconfig.data_directory,
'already_exposed_2to_be_exported.hpp')
mb = module_builder.module_builder_t(
[module_builder.create_source_fc(fpath)],
gccxml_path=autoconfig.gccxml.executable,
compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())
mb.global_ns.exclude()
mb.namespace('to_be_exposed').include()
mb.build_code_creator('to_be_exposed')
mb.register_module_dependency(already_exposed_dir)
mb.build_code_creator('to_be_exposed')
to_be_exposed_dir = os.path.join(autoconfig.build_directory,
'to_be_exposed')
mb.write_module(os.path.join(to_be_exposed_dir, 'to_be_exposed.cpp'))
body = mb.code_creator.body
self.failUnless(2 == len(body.creators))
ae_derived_code = body.creators[0].create()
self.failUnless(mb.class_('ae_base').decl_string in ae_derived_code)
def __init__(self):
"Container for pyplusplus module builder for wrapping V3D"
# Look for "--win64" command line argument
parser = OptionParser()
parser.add_option("--win64", action="store_true", dest="win64", default=False, help="Whether we are building Windows 64-bit")
(options, args) = parser.parse_args()
includes = []
homedir = os.path.expanduser('~')
for path in ['.',
os.path.join(homedir, 'svn/v3d_cmake/v3d_main/basic_c_fun'),
os.path.join(homedir, 'svn/v3d/v3d_main/basic_c_fun'),
os.path.join(homedir, 'Documents/svn/v3d_cmake/v3d_main/basic_c_fun'),
os.path.abspath('../../../v3d_main/basic_c_fun'),
'/usr/include/Qt',
'/usr/include/QtCore',
'/usr/include/QtGui',
'/usr/include/qt4',
'/usr/include/qt4/QtCore',
'/usr/include/qt4/QtGui',
'/Library/Frameworks/QtCore.framework/Headers',
'/Library/Frameworks/QtGui.framework/Headers',
'C:/Qt/qt-64bit-4.7.2/include/QtCore/',
'C:/Qt/qt-64bit-4.7.2/include/QtGui/',
'C:/Qt/qt-64bit-4.7.2/include/Qt/',
'C:/Qt/qt-64bit-4.7.2/include/',
]:
if os.path.exists(path):
# keep command line short
abs_path = os.path.abspath(path)
rel_path = os.path.relpath(path)
# print abs_path
# print rel_path
if len(abs_path) > len(rel_path):
includes.append(rel_path)
else:
includes.append(abs_path)
gccxml_executable = self.find_gccxml()
gccxml_cflags = ' --gccxml-cxxflags "-m32"'
# gccxml_cflags = ''
define_symbols=[]
if sys.platform == 'win32':
define_symbols.append("_HAS_TR1=0")
if options.win64:
define_symbols.append("_WIN64")
self.mb = module_builder.module_builder_t(
files = ['wrappable_v3d.h',],
gccxml_path=gccxml_executable,
cflags=gccxml_cflags,
include_paths=includes,
indexing_suite_version=2,
# ignore_gccxml_output=True,
define_symbols=define_symbols,)
def __init__(self, name, deps=None, replacement_dict=default_replacement, indexing_suite_version = 2):
"""Constructor.
@name name of the python module
@dep name of another module this module depends on"""
module_builder.set_logger_level( logging.INFO )
candidate_include_paths = [ "/home/lucas/private_ompl/omplapp/ompl/src", "/home/lucas/private_ompl/omplapp/src",
"/usr/include/python2.7", "/usr/include", "/usr/local/include", ""]
# Adding standard windows headers
if platform == 'win32':
compiler = getenv('GCCXML_COMPILER')
# MinGW
if compiler != None and (compiler.lower().endswith('g++') or compiler.lower().endswith('c++')):
version = subprocess.Popen([compiler, '-dumpversion'],
stdout=subprocess.PIPE).communicate()[0].strip()
# Find whole path to MinGW
compiler_path = ""
for path in getenv('PATH').split(';'):
if exists(join(path, compiler + '.exe')):
compiler_path = path
break
if compiler_path is not "":
# Adding in necessary include paths
candidate_include_paths.append (join(compiler_path, "..", "include"))
candidate_include_paths.append (join(compiler_path, "..", "lib", "gcc", "mingw32", version, "include"))
candidate_include_paths.append (join(compiler_path, "..", "lib", "gcc", "mingw32", version, "include", "c++"))
candidate_include_paths.append (join(compiler_path, "..", "lib", "gcc", "mingw32", version, "include", "c++", "mingw32"))
include_paths = []
for path in candidate_include_paths:
if len(path)>0 and exists(path):
include_paths.append(path)
self.mb = module_builder.module_builder_t(
files = [ 'bindings/' + name + '.h' ],
cache = '/home/lucas/private_ompl/omplapp/build/pyplusplus_'+name+'.cache',
gccxml_path = "/usr/local/bin/gccxml",
include_paths = include_paths,
cflags="",
indexing_suite_version = indexing_suite_version )
self.replacement = {} if replacement_dict==None else replacement_dict
self.mb.classes().always_expose_using_scope = True
self.mb.add_registration_code('PyEval_InitThreads();', tail=False)
self.std_ns = self.mb.namespace('std')
self.ompl_ns = self.mb.namespace('ompl')
self.call_policies()
self.filter_declarations()
if deps!=None:
for dep in deps:
self.mb.register_module_dependency(dep)
self.mb.build_code_creator( module_name='_'+name )
self.mb.split_module('bindings/' + name, use_files_sum_repository=True)
def createModuleBuilder(input_file, defined_symbols):
ret = module_builder.module_builder_t(
files=[input_file],
gccxml_path=GCCXML_PATH,
include_paths=INCLUDE_PATHS,
define_symbols=defined_symbols,
indexing_suite_version=2,
)
ret.BOOST_PYTHON_MAX_ARITY = 25
ret.classes().always_expose_using_scope = True
return ret
def test__getitem__( self ):
mb = module_builder.module_builder_t( self._get_files()
, gccxml_path=autoconfig.gccxml.executable
, include_paths=[autoconfig.boost.include]
, undefine_symbols=['__MINGW32__']
, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler() )
public_bases = mb.classes( 'public_base_t' )
self.failUnless( 1 == len( public_bases ) )
public_bases.include()
self.failUnless( public_bases[0].ignore == False )
mb.global_ns[ 'public_base_t' ].exclude()
self.failUnless( public_bases[0].ignore == True )
def test(self):
code = """
namespace xyz{
void do_smth( int, ... );
}
"""
mb = module_builder.module_builder_t(
[ module_builder.create_text_fc( code ) ]
, gccxml_path=autoconfig.gccxml.executable )
do_smth = mb.free_fun( 'do_smth' )
self.failUnless( do_smth.exportable == False )
print do_smth.why_not_exportable()
def __init__(self):
self.__file = os.path.join( random_settings.working_dir, 'random_export.hpp' )
self.__mb = module_builder.module_builder_t(
[ parser.create_cached_source_fc(
self.__file
, os.path.join( random_settings.generated_files_dir, 'random.xml' ) ) ]
, gccxml_path=random_settings.gccxml.executable
, include_paths=[random_settings.boost.include]
, define_symbols=random_settings.defined_symbols
, undefine_symbols=random_settings.undefined_symbols
, indexing_suite_version=2)
self.generators = [ "ecuyer1988"
, "hellekalek1995"
, "kreutzer1986"
, "lagged_fibonacci1279"
, "lagged_fibonacci19937"
, "lagged_fibonacci2281"
, "lagged_fibonacci23209"
, "lagged_fibonacci3217"
, "lagged_fibonacci4423"
, "lagged_fibonacci44497"
, "lagged_fibonacci607"
, "lagged_fibonacci9689"
, "minstd_rand"
, "minstd_rand0"
, "mt11213b"
, "mt19937"
, "ranlux3"
, "ranlux3_01"
, "ranlux4"
, "ranlux4_01"
, "ranlux64_3_01"
, "ranlux64_4_01"
, "taus88" ]
self.no_min_max = [ 'py_cauchy_distribution'
, 'py_bernoulli_distribution'
, 'py_binomial_distribution'
, 'py_poisson_distribution'
, 'py_normal_distribution'
, 'py_gamma_distribution'
, 'py_triangle_distribution'
, 'py_uniform_on_sphere'
, 'py_exponential_distribution'
, 'py_geometric_distribution'
, 'py_lognormal_distribution'
]
def test__getitem__(self):
mb = module_builder.module_builder_t(
self._get_files(),
gccxml_path=autoconfig.gccxml.executable,
include_paths=[autoconfig.boost.include],
undefine_symbols=["__MINGW32__"],
)
public_bases = mb.classes("public_base_t")
self.failUnless(1 == len(public_bases))
public_bases.include()
self.failUnless(public_bases[0].ignore == False)
mb.global_ns["public_base_t"].exclude()
self.failUnless(public_bases[0].ignore == True)
def do_main():
op_parser = OptionParser()
op_parser.add_option("-o","--outputfile",type="string",dest="outputfile",action="store")
op_parser.add_option("-m","--modulename",type="string",dest="modulename",action="store")
op_parser.add_option("-I","--includepaths",type="string",dest="include_paths",action="store",default='')
op_parser.add_option("-D","--define",type="string",dest="define_symbols",action="store",default='')
op_parser.add_option("--gccxml_bin",type="string",dest="gccxml_bin",action="store",default='/usr/bin/gccxml')
(options,input_files) = op_parser.parse_args(sys.argv)
if options.outputfile == None :
op_parser.error("Output file not specified")
if options.modulename == None:
op_parser.error("Module name not specified")
if os.path.exists(options.outputfile):
os.remove(options.outputfile)
print 'parsing input files',input_files[1:len(input_files)]
mb = module_builder.module_builder_t(
files = input_files[1:len(input_files)]
, gccxml_path= options.gccxml_bin
, include_paths = [options.include_paths]
, define_symbols = [options.define_symbols]
)
#framework.is_abstract = True;
#number.add_fake_constructors( number.calldefs( 'create' ) )
#Now it is the time to give a name to our module
mb.build_code_creator( module_name=options.modulename )
#It is common requirement in software world - each file should have license
mb.code_creator.license = '//Boost Software License( http://boost.org/more/license_info.html )'
#I don't want absolute includes within code
mb.code_creator.user_defined_directories.append( os.path.abspath('.') )
#And finally we can write code to the disk
mb.write_module( os.path.join( os.path.abspath('.'), options.outputfile ) )
