def __parse_declarations( self, files, gccxml_config, compilation_mode, cache, indexing_suite_version ): if None is gccxml_config: gccxml_config = parser.gccxml_configuration_t() if None is compilation_mode: compilation_mode = parser.COMPILATION_MODE.FILE_BY_FILE start_time = time.clock() self.logger.debug( 'parsing files - started' ) reader = parser.project_reader_t( gccxml_config, cache, decl_wrappers.dwfactory_t() ) decls = reader.read_files( files, compilation_mode ) self.logger.debug( 'parsing files - done( %f seconds )' % ( time.clock() - start_time ) ) self.logger.debug( 'settings declarations defaults - started' ) global_ns = decls_package.matcher.get_single( decls_package.namespace_matcher_t( name='::' ) , decls ) if indexing_suite_version != 1: for cls in global_ns.classes(): cls.indexing_suite_version = indexing_suite_version for cls in global_ns.decls(decl_type=decls_package.class_declaration_t): cls.indexing_suite_version = indexing_suite_version start_time = time.clock() self.__apply_decls_defaults(decls) self.logger.debug( 'settings declarations defaults - done( %f seconds )' % ( time.clock() - start_time ) ) return global_ns
def __parse_declarations( self, files, gccxml_config, compilation_mode=None, cache=None ): if None is gccxml_config: gccxml_config = parser.gccxml_configuration_t() if None is compilation_mode: compilation_mode = parser.COMPILATION_MODE.FILE_BY_FILE start_time = time.clock() self.logger.debug( 'parsing files - started' ) reader = parser.project_reader_t( gccxml_config, cache, decl_wrappers.dwfactory_t() ) decls = reader.read_files( files, compilation_mode ) self.logger.debug( 'parsing files - done( %f seconds )' % ( time.clock() - start_time ) ) return decls_package.matcher.get_single( decls_package.namespace_matcher_t( name='::' ) , decls )
def __parse_declarations(self, files, gccxml_config, compilation_mode=None, cache=None): if None is gccxml_config: gccxml_config = parser.gccxml_configuration_t() if None is compilation_mode: compilation_mode = parser.COMPILATION_MODE.FILE_BY_FILE start_time = time.clock() self.logger.debug('parsing files - started') reader = parser.project_reader_t(gccxml_config, cache, decl_wrappers.dwfactory_t()) decls = reader.read_files(files, compilation_mode) self.logger.debug('parsing files - done( %f seconds )' % (time.clock() - start_time)) return decls_package.matcher.get_single( decls_package.namespace_matcher_t(name='::'), decls)
def __init__( self , files , gccxml_path='' , working_directory='.' , include_paths=None , define_symbols=None , undefine_symbols=None , start_with_declarations=None , compilation_mode=None , cache=None , optimize_queries=True , ignore_gccxml_output=False , indexing_suite_version=1 , cflags="" , encoding='ascii' , compiler=None , gccxml_config=None): """ :param files: list of files, declarations from them you want to export :type files: list of strings or :class:`parser.file_configuration_t` instances :param gccxml_path: path to gccxml binary. If you don't pass this argument, pygccxml parser will try to locate it using you environment PATH variable :type gccxml_path: str :param include_paths: additional header files location. You don't have to specify system and standard directories. :type include_paths: list of strings :param define_symbols: list of symbols to be defined for preprocessor. :param define_symbols: list of strings :param undefine_symbols: list of symbols to be undefined for preprocessor. :param undefine_symbols: list of strings :param cflags: Raw string to be added to gccxml command line. :param gccxml_config: instance of pygccxml.parser.gccxml_configuration_t class, holds gccxml( compiler ) configuration. You can use this argument instead of passing the compiler configuration separately. """ module_builder.module_builder_t.__init__( self, global_ns=None, encoding=encoding ) if not gccxml_config: gccxml_config = parser.gccxml_configuration_t( gccxml_path=gccxml_path , working_directory=working_directory , include_paths=include_paths , define_symbols=define_symbols , undefine_symbols=undefine_symbols , start_with_declarations=start_with_declarations , ignore_gccxml_output=ignore_gccxml_output , cflags=cflags , compiler=compiler) #may be in future I will add those directories to user_defined_directories to self.__code_creator. self.__parsed_files = list(map( pygccxml_utils.normalize_path , parser.project_reader_t.get_os_file_names( files ) )) tmp = [os.path.split( file_ )[0] for file_ in self.__parsed_files] self.__parsed_dirs = [_f for _f in tmp if _f] self.global_ns = self.__parse_declarations( files , gccxml_config , compilation_mode , cache , indexing_suite_version) self.global_ns.decls(recursive=True, allow_empty=True)._code_generator = decl_wrappers.CODE_GENERATOR_TYPES.CTYPES self.__code_creator = None if optimize_queries: self.run_query_optimizer() self.__declarations_code_head = [] self.__declarations_code_tail = [] self.__registrations_code_head = [] self.__registrations_code_tail = []
import os import sys import project_env from pygccxml import utils from pygccxml import parser from pygccxml import declarations from pyplusplus.module_builder import ctypes_module_builder_t gccxml_cfg = parser.gccxml_configuration_t( gccxml_path=project_env.settings.gccxml_path) mb = ctypes_module_builder_t([project_env.gmp.header_file], project_env.gmp.symbols_file, gccxml_cfg) #there is a bug in the code generator has_varargs = lambda f: f.arguments \ and isinstance( f.arguments[-1].type, declarations.ellipsis_t ) mb.calldefs(has_varargs).exclude() #gmp uses strange convention: every function name starts with __gmp and than, it #introduces define, which aliass __gmpy to gmpy for f in mb.calldefs(lambda x: x.name.startswith('__gmp')): f.alias = f.name[2:] for v in mb.vars(lambda x: x.name.startswith('__gmp')): v.alias = v.name[2:] #those structs are private implementation of FILE
def __init__(self, filename): self.filename = filename self.ns = parser.parse([filename], parser.gccxml_configuration_t())[0]
import os import sys import project_env from pygccxml import utils from pygccxml import parser from pygccxml import declarations from pyplusplus.module_builder import ctypes_module_builder_t gccxml_cfg = parser.gccxml_configuration_t( gccxml_path=project_env.settings.gccxml_path, include_paths=project_env.libmemcached.include_paths) mb = ctypes_module_builder_t([project_env.libmemcached.header_file], project_env.libmemcached.symbols_file, gccxml_cfg) #there is a bug in the code generator has_varargs = lambda f: f.arguments \ and isinstance( f.arguments[-1].type, declarations.ellipsis_t ) mb.calldefs(has_varargs).exclude() #libmemcached uses strange convention: every function name starts with __gmp and than, it #introduces define, which aliass __gmpy to gmpy #for f in mb.calldefs( lambda x: x.name.startswith('__gmp') ): # f.alias = f.name[2:] #for v in mb.vars( lambda x: x.name.startswith( '__gmp' ) ): # v.alias = v.name[2:]
import os import sys import project_env from pygccxml import utils from pygccxml import parser from pygccxml import declarations from pyplusplus.module_builder import ctypes_module_builder_t gccxml_cfg = parser.gccxml_configuration_t( gccxml_path=project_env.settings.gccxml_path , include_paths=project_env.libmemcached.include_paths) mb = ctypes_module_builder_t( [project_env.libmemcached.header_file] , project_env.libmemcached.symbols_file, gccxml_cfg ) #there is a bug in the code generator has_varargs = lambda f: f.arguments \ and isinstance( f.arguments[-1].type, declarations.ellipsis_t ) mb.calldefs( has_varargs ).exclude() #libmemcached uses strange convention: every function name starts with __gmp and than, it #introduces define, which aliass __gmpy to gmpy #for f in mb.calldefs( lambda x: x.name.startswith('__gmp') ): # f.alias = f.name[2:] #for v in mb.vars( lambda x: x.name.startswith( '__gmp' ) ): # v.alias = v.name[2:]
import os import sys import project_env from pygccxml import utils from pygccxml import parser from pygccxml import declarations from pyplusplus.module_builder import ctypes_module_builder_t gccxml_cfg = parser.gccxml_configuration_t( gccxml_path=project_env.settings.gccxml_path ) mb = ctypes_module_builder_t( [project_env.gmp.header_file], project_env.gmp.symbols_file, gccxml_cfg ) #there is a bug in the code generator has_varargs = lambda f: f.arguments \ and isinstance( f.arguments[-1].type, declarations.ellipsis_t ) mb.calldefs( has_varargs ).exclude() #gmp uses strange convention: every function name starts with __gmp and than, it #introduces define, which aliass __gmpy to gmpy for f in mb.calldefs( lambda x: x.name.startswith('__gmp') ): f.alias = f.name[2:] for v in mb.vars( lambda x: x.name.startswith( '__gmp' ) ): v.alias = v.name[2:] #those structs are private implementation of FILE mb.class_( '_IO_FILE' ).opaque = True
# Find out the file location within the sources tree this_module_dir_path = os.path.abspath( os.path.dirname(sys.modules[__name__].__file__)) # Find out gccxml location gccxml_09_path = os.path.join( this_module_dir_path, '..', '..', '..', 'gccxml_bin', 'v09', sys.platform, 'bin') # Add pygccxml package to Python path sys.path.append(os.path.join(this_module_dir_path, '..', '..')) from pygccxml import parser from pygccxml import declarations # Configure GCC-XML parser config = parser.gccxml_configuration_t( gccxml_path=gccxml_09_path, compiler='gcc') # Parsing source file decls = parser.parse([this_module_dir_path + '/example.hpp'], config) global_ns = declarations.get_global_namespace(decls) # Get object that describes unittests namespace unittests = global_ns.namespace('unittests') print('"unittests" declarations: \n') declarations.print_declarations(unittests) # Print all base and derived class names for class_ in unittests.classes(): print('class "%s" hierarchy information:' % class_.name) print('\tbase classes : ', repr([