def test_all_mem_and_free_funs( self ): ns = self.global_ns.ns( '::declarations::calldef' ) for f in ns.mem_funs(): decls = parser.parse_string( self.template % f.decl_string, self.config ) self.failUnless( decls, "Created decl_string for member function containes mistake" ) for f in ns.free_funs(): decls = parser.parse_string( self.template % f.decl_string, self.config ) self.failUnless( decls, "Created decl_string for member function containes mistake" )
def test_all_mem_and_free_funs(self): ns = self.global_ns.ns('::declarations::calldef') for f in ns.mem_funs(): decls = parser.parse_string(self.template % f.decl_string, self.config) self.failUnless( decls, "Created decl_string for member function containes mistake") for f in ns.free_funs(): decls = parser.parse_string(self.template % f.decl_string, self.config) self.failUnless( decls, "Created decl_string for member function containes mistake")
def test(self): config = autoconfig.xml_generator_config code = [] code.append('struct a{};') code.append('struct b{};') code.append('struct c{};') code.append('struct d : public a{};') code.append('struct e : public a, public b{};') code.append('struct f{};') code.append('struct g : public d, public f{};') code.append('struct h : public f{};') code.append('struct i : public h, public g{};') code.append('struct j{};') code.append('struct k{};') global_ns = parser.parse_string(os.linesep.join(code), config) decls = global_ns[0].declarations dorder = creators_factory.findout_desired_order(decls) self.assertTrue( len(code) == len(dorder), 'all classes should stay within the list') for i in range(1, len(dorder)): bases = set(self._findout_base_classes(dorder[i])) exported = set(dorder[:i]) self.assertTrue( bases.issubset(exported), 'for derived class %s not all base classes have been exported' % dorder[i].name)
def test_get_declaration(self): code = """ namespace A{ struct B{ int c; }; template <class T> struct C: public T{ int d; }; template <class T> struct D{ int dD; }; typedef C<B> easy; typedef D<easy> Deasy; inline void instantiate(){ int val = sizeof(easy); } } """ global_ns = parser.parse_string(code, autoconfig.cxx_parsers_cfg.config) global_ns = declarations.get_global_namespace(global_ns) easy = global_ns.typedef('easy') declarations.class_traits.get_declaration(easy) deasy = global_ns.typedef('Deasy') d_a = declarations.class_traits.get_declaration(deasy) self.assertTrue(isinstance(d_a, declarations.class_types))
def test(self): code = """ namespace A{ struct B{ int c; }; template <class T> struct C: public T{ int d; }; template <class T> struct D{ int dD; }; typedef C<B> easy; typedef D<easy> Deasy; inline void instantiate(){ sizeof(easy); } } """ global_ns = parser.parse_string( code, autoconfig.cxx_parsers_cfg.gccxml) global_ns = declarations.get_global_namespace( global_ns ) easy = global_ns.typedef( 'easy' ) c_a = declarations.class_traits.get_declaration( easy ) #this works very well deasy = global_ns.typedef( 'Deasy' ) d_a = declarations.class_traits.get_declaration( deasy ) self.failUnless( isinstance( d_a, declarations.class_types ) )
def test_free_function(self): return_default_args = self.global_ns.free_fun('return_default_args') decls = parser.parse_string( self.template % return_default_args.decl_string, self.config) self.assertTrue( decls, "Created decl_string for global function contains mistake")
def test_member_function(self): member_inline_call = self.global_ns.mem_fun('member_inline_call') decls = parser.parse_string( self.template % member_inline_call.decl_string, self.config) self.assertTrue( decls, "Created decl_string for member function contains mistake")
def test_free_function(self): return_default_args = self.global_ns.free_fun('return_default_args') decls = parser.parse_string( self.template % return_default_args.decl_string, self.config) self.failUnless( decls, "Created decl_string for global function containes mistake")
def test_member_function(self): member_inline_call = self.global_ns.mem_fun('member_inline_call') decls = parser.parse_string( self.template % member_inline_call.decl_string, self.config) self.failUnless( decls, "Created decl_string for member function containes mistake")
def test(self): decls = parser.parse_string(code, self.config) global_ns = declarations.get_global_namespace(decls) # TODO: demangled attribute does not existe for castxml # and will not be added. Remove this test once gccxml # support is dropped. if self.config.xml_generator_from_xml_file.is_gccxml: global_ns.decl('A<int>') f = global_ns.free_function('f') self.assertTrue(f.demangled == 'void f<int>(A<int> const&)')
def test(self): config = autoconfig.cxx_parsers_cfg.gccxml code = "struct const_item{ const int values[10]; };" global_ns = parser.parse_string(code, config)[0] ci = global_ns.class_('const_item') if 'CastXML' in utils.xml_generator: # Constructor, copy constructor, destructor, variable self.assertTrue(len(ci.declarations) == 4) else: # Copy constructor, destructor, variable self.assertTrue(len(ci.declarations) == 3)
def test(self): config = autoconfig.cxx_parsers_cfg.gccxml code = "struct const_item{ const int values[10]; };" global_ns = parser.parse_string(code, config)[0] ci = global_ns.class_('const_item') if ("CastXML" not in utils.xml_generator or utils.xml_output_version >= 1.138): # Prior to version 1.138, CastXML would incorrect create a default # constructor definition. # See https://github.com/CastXML/CastXML/issues/55 # Copy constructor, destructor, variable self.assertEqual(len(ci.declarations), 3)
def test(self): config = autoconfig.cxx_parsers_cfg.config code = "struct const_item{ const int values[10]; };" global_ns = parser.parse_string(code, config)[0] ci = global_ns.class_('const_item') generator = config.xml_generator_from_xml_file if generator.is_castxml1 or (generator.is_castxml and float( generator.xml_output_version) >= 1.138): # Prior to version 1.138, CastXML would incorrectly create a # default constructor definition. # See https://github.com/CastXML/CastXML/issues/55 # Copy constructor, destructor, variable self.assertEqual(len(ci.declarations), 3)
def test(self): config = autoconfig.cxx_parsers_cfg.config code = "struct const_item{ const int values[10]; };" global_ns = parser.parse_string(code, config)[0] ci = global_ns.class_('const_item') generator = config.xml_generator_from_xml_file if generator.is_castxml1 or ( generator.is_castxml and float(generator.xml_output_version) >= 1.138): # Prior to version 1.138, CastXML would incorrectly create a # default constructor definition. # See https://github.com/CastXML/CastXML/issues/55 # Copy constructor, destructor, variable self.assertEqual(len(ci.declarations), 3)
def test_castxml_epic_version_check(self): """ Test using a forbidden value for the castxml epic version. """ if self.config.castxml_epic_version != 1: # Run this test only with castxml epic version == 1 return self.config.castxml_epic_version = 2 self.assertRaises( RuntimeError, lambda: parser.parse_string("", self.config)) # Reset castxml epic version self.config.castxml_epic_version = 1
def test(self): """ The purpose of this test was to check if changes to GCCXML would lead to changes in the outputted xml file (Meaning the bug was fixed). GCCXML wrongly outputted partial template specialization. CastXML does not have this bug. In this case we check if the template specialization can not be found; which is the expected/wanted behaviour. https://github.com/CastXML/CastXML/issues/20 """ decls = parser.parse_string(code, self.config) global_ns = declarations.get_global_namespace(decls) self.assertRaises(declarations.declaration_not_found_t, lambda: global_ns.class_('A<const char [N]>'))
def test_config(self): """Test config setup with wrong xml generator setups.""" # Some code to parse for the example code = "int a;" # Find the location of the xml generator (castxml or gccxml) generator_path, name = utils.find_xml_generator() # No xml generator path config = parser.xml_generator_configuration_t(xml_generator=name) self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config)) # Invalid path config = parser.xml_generator_configuration_t( xml_generator_path="wrong/path", xml_generator=name) self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config)) # None path config = parser.xml_generator_configuration_t( xml_generator_path=None, xml_generator=name) self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config)) # No name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path) self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config)) # Random name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator="not_a_generator") self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config)) # None name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator=None) self.assertRaises( RuntimeError, lambda: parser.parse_string(code, config))
def try_pygccxml(): from pygccxml import declarations from pygccxml import utils from pygccxml import parser # Find out the c++ parser. This should resolve to the castxml # version installed in Docker. generator_path, generator_name = utils.find_xml_generator() # Configure the xml generator config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator=generator_name, include_paths=["/usr/include/eigen3"], # TODO(eric.cousineau): Why is `compiler_path` necessary? compiler_path=generator_path, start_with_declarations=["ns"], ) t_start = time.time() (global_ns, ) = parser.parse_string(code, config) dt = time.time() - t_start return dt
def test(self): config = parser.config_t( gccxml_path=autoconfig.gccxml.executable ) code = [] code.append('struct a{};') code.append('struct b{};') code.append('struct c{};') code.append('struct d : public a{};') code.append('struct e : public a, public b{};') code.append('struct f{};') code.append('struct g : public d, public f{};') code.append('struct h : public f{};') code.append('struct i : public h, public g{};') code.append('struct j{};') code.append('struct k{};') global_ns = parser.parse_string( os.linesep.join( code ), config ) decls = global_ns[0].declarations dorder = module_creator.findout_desired_order( decls ) self.failUnless( len( code ) == len( dorder ), 'all classes should stay within the list' ) for i in range( 1, len(dorder) ): bases = set( self._findout_base_classes( dorder[i] ) ) exported = set( dorder[:i]) self.failUnless( bases.issubset( exported ) , 'for derived class %s not all base classes have been exported' % dorder[i].name )
def test(self): config = parser.config_t( gccxml_path=autoconfig.gccxml.executable, compiler=pygccxml.utils.native_compiler.get_gccxml_compiler() ) code = [] code.append('struct a{};') code.append('struct b{};') code.append('struct c{};') code.append('struct d : public a{};') code.append('struct e : public a, public b{};') code.append('struct f{};') code.append('struct g : public d, public f{};') code.append('struct h : public f{};') code.append('struct i : public h, public g{};') code.append('struct j{};') code.append('struct k{};') global_ns = parser.parse_string( os.linesep.join( code ), config ) decls = global_ns[0].declarations dorder = creators_factory.findout_desired_order( decls ) self.failUnless( len( code ) == len( dorder ), 'all classes should stay within the list' ) for i in range( 1, len(dorder) ): bases = set( self._findout_base_classes( dorder[i] ) ) exported = set( dorder[:i]) self.failUnless( bases.issubset( exported ) , 'for derived class %s not all base classes have been exported' % dorder[i].name )
def test_get_declaration(self): code = """ namespace A{ struct B{ int c; }; template <class T> struct C: public T{ int d; }; template <class T> struct D{ int dD; }; typedef C<B> easy; typedef D<easy> Deasy; inline void instantiate(){ int val = sizeof(easy); } } """ global_ns = parser.parse_string( code, autoconfig.cxx_parsers_cfg.config) global_ns = declarations.get_global_namespace(global_ns) easy = global_ns.typedef('easy') declarations.class_traits.get_declaration(easy) deasy = global_ns.typedef('Deasy') d_a = declarations.class_traits.get_declaration(deasy) self.assertTrue(isinstance(d_a, declarations.class_types))
def test(self): """ The purpose of this test was to check if changes to GCCXML would lead to changes in the outputted xml file (Meaning the bug was fixed). GCCXML wrongly outputted partial template specialization. CastXML does not have this bug. In this case we check if the template specialization can not be found; which is the expected/wanted behaviour. https://github.com/CastXML/CastXML/issues/20 """ decls = parser.parse_string(code, self.config) global_ns = declarations.get_global_namespace(decls) if self.config.xml_generator_from_xml_file.is_gccxml: a = global_ns.class_('A<const char [N]>') a.member_function('size') elif self.config.xml_generator_from_xml_file.is_castxml: self.assertRaises( declarations.declaration_not_found_t, lambda: global_ns.class_('A<const char [N]>'))
def test_config(self): """Test config setup with wrong xml generator setups.""" # Some code to parse for the example code = "int a;" # Find the location of the xml generator (castxml or gccxml) generator_path, name = utils.find_xml_generator() # No xml generator path config = parser.xml_generator_configuration_t(xml_generator=name) self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config)) # Invalid path config = parser.xml_generator_configuration_t( xml_generator_path="wrong/path", xml_generator=name) self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config)) # None path config = parser.xml_generator_configuration_t(xml_generator_path=None, xml_generator=name) self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config)) # No name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path) self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config)) # Random name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator="not_a_generator") self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config)) # None name config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator=None) self.assertRaises(RuntimeError, lambda: parser.parse_string(code, config))
def test(self): decls = parser.parse_string(code, self.config) global_ns = declarations.get_global_namespace(decls) self.assertTrue(global_ns.variable('a').bits == 1) self.assertTrue(global_ns.variable('unused').bits == 31)
return dat[:16] def get_formatted(self, data): return repr(data)[1:] with open(os.path.join(os.path.dirname(__file__), "../stm/src/common/slots.h"), "r") as f: full_text = f.read() # parse the file gp, gn = utils.find_xml_generator() xml_generator_config = parser.xml_generator_configuration_t( xml_generator_path=gp, xml_generator=gn) declarations_in_file = parser.parse_string(full_text, xml_generator_config) def _convert_opaque_to_token(x): """ convert either a string from re or a value from pygccxml to a struct token """ if type(x) is str: return { "BOOL": "?", "UINT8_T": "B", "INT8_T": "b", "UINT16_T": "H", "INT16_T": "h", "UINT32_T": "I",
def test(self): config = autoconfig.cxx_parsers_cfg.gccxml code = "struct const_item{ const int values[10]; };" global_ns = parser.parse_string(code, config)[0] ci = global_ns.class_('const_item') self.failUnless(len(ci.declarations) == 3)
# Copyright 2014-2016 Insight Software Consortium. # Distributed under the Boost Software License, Version 1.0. # See http://www.boost.org/LICENSE_1_0.txt from pygccxml import utils from pygccxml import declarations from pygccxml import parser import warnings warnings.simplefilter("error", Warning) # Find the location of the xml generator (castxml or gccxml) generator_path, generator_name = utils.find_xml_generator() # Configure the xml generator xml_generator_config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator=generator_name) # Write a string containing some c++ code code = """ class MyClass { int a; }; """ # Parse the code decls = parser.parse_string(code, xml_generator_config) # Get access to the global namespace global_ns = declarations.get_global_namespace(decls)
# Distributed under the Boost Software License, Version 1.0. # See http://www.boost.org/LICENSE_1_0.txt from pygccxml import utils from pygccxml import declarations from pygccxml import parser import warnings warnings.simplefilter("error", Warning) # Find the location of the xml generator (castxml or gccxml) generator_path, generator_name = utils.find_xml_generator() # Configure the xml generator xml_generator_config = parser.xml_generator_configuration_t( xml_generator_path=generator_path, xml_generator=generator_name) # Write a string containing some c++ code code = """ class MyClass { int a; }; """ # Parse the code decls = parser.parse_string(code, xml_generator_config) # Get access to the global namespace global_ns = declarations.get_global_namespace(decls)