|
From: Roman <rom...@us...> - 2006-04-20 10:11:34
|
Update of /cvsroot/pygccxml/source/pygccxml/declarations In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1204/pygccxml/declarations Modified Files: __init__.py namespace.py scopedef.py Added Files: mdecl_wrapper.py Log Message: moving select interface to pygccxml classes. Previous code should work unchanged, because I just moved it in hierarchy tree. --- NEW FILE: mdecl_wrapper.py --- # Copyright 2004 Roman Yakovenko. # Distributed under the Boost Software License, Version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) class call_redirector_t( object ): """Internal class used to call some function of objects""" def __init__( self, name, decls ): object.__init__( self ) self.name = name self.decls = decls def __call__( self, *arguments, **keywords ): for d in self.decls: callable_ = getattr(d, self.name) callable_( *arguments, **keywords ) class mdecl_wrapper_t( object ): """Multiple declarations wrapper. The main purpose of this class is to allow an user to work on many declarations, as they were only one single declaration. Example: mb = module_builder_t( ... ) #lets say we want to exclude all member functions, that returns reference to int: mb.member_functions( return_type='int &' ).exclude() "exclude" function will be called on every function that match the criteria. """ def __init__( self, decls ): """@param decls: list of declarations to operate on. @type decls: list of L{declaration wrappers<decl_wrapper_t>} """ object.__init__( self ) self.__dict__['_decls'] = decls def __len__( self ): """returns the number of declarations""" return len( self._decls ) def __getitem__( self, index ): """provides access to declaration""" return self._decls[index] def __ensure_attribute( self, name ): invalid_decls = filter( lambda d: not hasattr( d, name ), self._decls ) if invalid_decls: raise RuntimeError( "Not all declarations have '%s' attribute." % name ) def __setattr__( self, name, value ): """Updates the value of attribute on all declarations. @param name: name of attribute @param value: new value of attribute """ self.__ensure_attribute( name ) for d in self._decls: setattr( d, name, value ) def __getattr__( self, name ): """@param name: name of method """ return call_redirector_t( name, self._decls ) Index: namespace.py =================================================================== RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/namespace.py,v retrieving revision 1.10 retrieving revision 1.11 diff -C2 -d -r1.10 -r1.11 *** namespace.py 22 Mar 2006 10:38:29 -0000 1.10 --- namespace.py 20 Apr 2006 10:11:25 -0000 1.11 *************** *** 57,58 **** --- 57,116 ---- #if not keep_parent: # decl.parent=None + + def namespace( self, name=None, function=None, recursive=None ): + return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ] + , name=name + , function=function + , recursive=recursive ) + + def namespaces( self, name=None, function=None, recursive=None ): + return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ] + , name=name + , function=function + , recursive=recursive ) + + def free_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ namespace_t.free_function ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def free_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ namespace_t.free_function ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def free_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ namespace_t.free_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def free_operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ namespace_t.free_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) \ No newline at end of file Index: __init__.py =================================================================== RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/__init__.py,v retrieving revision 1.37 retrieving revision 1.38 diff -C2 -d -r1.37 -r1.38 *** __init__.py 16 Mar 2006 06:31:29 -0000 1.37 --- __init__.py 20 Apr 2006 10:11:25 -0000 1.38 *************** *** 149,152 **** from matcher import matcher from decl_printer import decl_printer_t ! from decl_printer import print_declarations \ No newline at end of file --- 149,229 ---- from matcher import matcher + from mdecl_wrapper import mdecl_wrapper_t + from decl_printer import decl_printer_t ! from decl_printer import print_declarations ! ! ! #implementation details: I need this trick in order to prevent recursive imports ! import scopedef ! ! scopedef.scopedef_t._impl_all_decl_types = [ ! scopedef.scopedef_t ! , enumeration_t ! , namespace_t ! , class_t ! , class_declaration_t ! , typedef_t ! , variable_t ! , calldef_t ! , member_calldef_t ! , free_calldef_t ! , operator_t ! , member_function_t ! , constructor_t ! , destructor_t ! , member_operator_t ! , casting_operator_t ! , free_function_t ! , free_operator_t ! ] ! ! impl_matchers = scopedef.scopedef_t._impl_matchers ! impl_decl_types = scopedef.scopedef_t._impl_decl_types ! ! impl_matchers[ scopedef.scopedef_t.decl ] = declaration_matcher_t ! ! impl_matchers[ scopedef.scopedef_t.class_ ] = declaration_matcher_t ! impl_decl_types[ scopedef.scopedef_t.class_ ] = class_t ! ! impl_matchers[ scopedef.scopedef_t.variable ] = variable_matcher_t ! ! impl_matchers[ scopedef.scopedef_t.calldef ] = calldef_matcher_t ! impl_decl_types[ scopedef.scopedef_t.calldef ] = calldef_t ! ! impl_matchers[ scopedef.scopedef_t.operator ] = operator_matcher_t ! ! impl_matchers[ scopedef.scopedef_t.member_function ] = calldef_matcher_t ! impl_decl_types[ scopedef.scopedef_t.member_function ] = member_function_t ! ! impl_matchers[ scopedef.scopedef_t.constructor ] = calldef_matcher_t ! impl_decl_types[ scopedef.scopedef_t.constructor ] = constructor_t ! ! impl_matchers[ scopedef.scopedef_t.member_operator ] = operator_matcher_t ! impl_decl_types[ scopedef.scopedef_t.member_operator ] = member_operator_t ! ! impl_matchers[ scopedef.scopedef_t.member_operator ] = operator_matcher_t ! impl_decl_types[ scopedef.scopedef_t.member_operator ] = member_operator_t ! ! impl_matchers[ scopedef.scopedef_t.casting_operator ] = calldef_matcher_t ! impl_decl_types[ scopedef.scopedef_t.casting_operator ] = casting_operator_t ! ! impl_matchers[ scopedef.scopedef_t.enumeration ] = declaration_matcher_t ! impl_decl_types[ scopedef.scopedef_t.enumeration ] = enumeration_t ! ! impl_matchers[ namespace_t.namespace ] = namespace_matcher_t ! ! impl_matchers[ namespace_t.free_function ] = calldef_matcher_t ! impl_decl_types[ namespace_t.free_function ] = free_function_t ! ! impl_matchers[ namespace_t.free_operator ] = operator_matcher_t ! impl_decl_types[ namespace_t.free_operator ] = free_operator_t ! ! ! ! ! ! ! ! ! Index: scopedef.py =================================================================== RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/scopedef.py,v retrieving revision 1.10 retrieving revision 1.11 diff -C2 -d -r1.10 -r1.11 *** scopedef.py 15 Mar 2006 10:27:40 -0000 1.10 --- scopedef.py 20 Apr 2006 10:11:25 -0000 1.11 *************** *** 8,12 **** --- 8,18 ---- """ + import time + import algorithm + import filtering import declaration + import mdecl_wrapper + from pygccxml import utils + import matcher as matcher_module class scopedef_t( declaration.declaration_t ): *************** *** 16,23 **** --- 22,80 ---- children nodes. The children can be accessed via the C{declarations} property. + + Also this class provides "get/select/find" interface. Using this class you + can get instance or instances of internal declaration(s). + + You can find declaration(s) using next criteria: + 1. name - declaration name, could be full qualified name + 2. header_dir - directory, to which belongs file, that the declaration was declarated in. + header_dir should be absolute path. + 3. header_file - file that the declaration was declarated in. + 4. function - user ( your ) custom criteria. The interesting thing is that + this function will be joined with other arguments ( criteria ). + 5. recursive - the search declaration range, if True will be search in + internal declarations too. + + Every "select" API you can invoke and pass as first argument at declaration + name or function. This class will find out correctly what argument represents. + + Example:: + ns - referers to global namespace + ns.member_function( "do_something ) - will return reference to member + function named "do_something". If there is no such function exception + will be raised. If there is more then one function exception will be + raised too. + + Example 2:: + ns - referers to global namespace + do_smths = ns.member_functions( "do_something ) - will return instance + of L{mdecl_wrapper_t} object. This object allows you few things: + + 1. To iterate on selected declarations + 2. To set some property to desired value using one line of code only: + do_smths.call_policies = x + 3. To call some function on every instance using one line of code: + do_smths.exclude() + + Pay attention: you can not use "get" functions or properties. """ + + RECURSIVE_DEFAULT = True + ALLOW_EMPTY_MDECL_WRAPPER = False + + _impl_matchers = {} #this class variable is used to prevent recursive imports + _impl_decl_types = {} #this class variable is used to prevent recursive imports + _impl_all_decl_types = [] #this class variable is used to prevent recursive imports + def __init__( self, name='', parent=''): declaration.declaration_t.__init__( self, name, parent ) + self._optimized = False + self._type2decls = {} + self._type2name2decls = {} + self._type2decls_nr = {} + self._type2name2decls_nr = {} + self._all_decls = None + def _get__cmp__scope_items(self): raise NotImplementedError() *************** *** 46,47 **** --- 103,495 ---- def remove_declaration( self, decl ): raise NotImplementedError() + + + def __decl_types( self, decl ): + types = [] + bases = list( decl.__class__.__bases__ ) + visited = set() + if 'pygccxml' in decl.__class__.__module__: + types.append( decl.__class__ ) + while bases: + base = bases.pop() + if base is declaration.declaration_t: + continue + if base in visited: + continue + if 'pygccxml' not in base.__module__: + continue + types.append( base ) + bases.extend( base.__bases__ ) + return types + + def clear_optimizer(self): + """Cleans query optimizer state""" + self._optimized = False + self._type2decls = {} + self._type2name2decls = {} + self._type2decls_nr = {} + self._type2name2decls_nr = {} + self._all_decls = None + + map( lambda decl: decl.clear_optimizer() + , filter( lambda decl: isinstance( decl, scopedef_t ) + , self.declarations ) ) + + def init_optimizer(self): + """Initializes query optimizer state. + There are 4 internals hash tables: + 1. from type to declarations + 2. from type to declarations for non-recursive queries + 3. from type to name to declarations + 4. from type to name to declarations for non-recursive queries + + Almost every query includes declaration type information. Also very + common query is to search some declaration(s) by name or full name. + Those hashtables allows to search declaration very quick. + """ + utils.logger.debug( "preparing data structures for query optimizer - started" ) + start_time = time.clock() + + self.clear_optimizer() + + for dtype in scopedef_t._impl_all_decl_types: + self._type2decls[ dtype ] = [] + self._type2decls_nr[ dtype ] = [] + self._type2name2decls[ dtype ] = {} + self._type2name2decls_nr[ dtype ] = {} + + self._all_decls = algorithm.make_flatten( self.declarations ) + for decl in self._all_decls: + types = self.__decl_types( decl ) + for type_ in types: + self._type2decls[ type_ ].append( decl ) + name2decls = self._type2name2decls[ type_ ] + if not name2decls.has_key( decl.name ): + name2decls[ decl.name ] = [] + name2decls[ decl.name ].append( decl ) + if self is decl.parent: + self._type2decls_nr[ type_ ].append( decl ) + name2decls_nr = self._type2name2decls_nr[ type_ ] + if not name2decls_nr.has_key( decl.name ): + name2decls_nr[ decl.name ] = [] + name2decls_nr[ decl.name ].append( decl ) + + map( lambda decl: decl.init_optimizer() + , filter( lambda decl: isinstance( decl, scopedef_t ), self.declarations ) ) + + utils.logger.debug( "preparing data structures for query optimizer - done( %f seconds ). " + % ( time.clock() - start_time ) ) + self._optimized = True + + + def __normalize_args( self, **keywds ): + if callable( keywds['name'] ) and None is keywds['function']: + keywds['function'] = keywds['name'] + keywds['name'] = None + return keywds + + def __findout_recursive( self, **keywds ): + if None is keywds[ 'recursive' ]: + return self.RECURSIVE_DEFAULT + else: + return keywds[ 'recursive' ] + + def __findout_decl_type( self, match_class, **keywds ): + if keywds.has_key( 'decl_type' ): + return keywds['decl_type'] + + matcher_args = keywds.copy() + del matcher_args['function'] + del matcher_args['recursive'] + + matcher = match_class( **matcher_args ) + if matcher.decl_type: + return matcher.decl_type + return None + + def __create_matcher( self, match_class, **keywds ): + matcher_args = keywds.copy() + del matcher_args['function'] + del matcher_args['recursive'] + + matcher = match_class( **matcher_args ) + if keywds['function']: + utils.logger.info( 'running query: %s and <user defined function>' % str( matcher ) ) + return lambda decl: matcher( decl ) and keywds['function'](decl) + else: + utils.logger.info( 'running query: %s' % str( matcher ) ) + return matcher + + def __findout_range( self, name, decl_type, recursive ): + if not self._optimized: + utils.logger.info( 'running non optimized query - optimization has not been done' ) + decls = self.declarations + if recursive: + decls = algorithm.make_flatten( self.declarations ) + return decls + + if name and decl_type: + matcher = scopedef_t._impl_matchers[ scopedef_t.decl ]( name=name ) + if matcher.is_full_name(): + name = matcher.decl_name_only + if recursive: + utils.logger.info( 'query has been optimized on type and name' ) + return self._type2name2decls[decl_type][name] + else: + utils.logger.info( 'non recursive query has been optimized on type and name' ) + return self._type2name2decls_nr[decl_type][name] + elif decl_type: + if recursive: + utils.logger.info( 'query has been optimized on type' ) + return self._type2decls[ decl_type ] + else: + utils.logger.info( 'non recursive query has been optimized on type' ) + return self._type2decls_nr[ decl_type ] + else: + if recursive: + utils.logger.info( 'query has not been optimized ( hint: query does not contain type and/or name )' ) + return self._all_decls + else: + utils.logger.info( 'non recursive query has not been optimized ( hint: query does not contain type and/or name )' ) + return self.declarations + + def _find_single( self, match_class, **keywds ): + utils.logger.info( 'find single query execution - started' ) + start_time = time.clock() + norm_keywds = self.__normalize_args( **keywds ) + matcher = self.__create_matcher( match_class, **norm_keywds ) + dtype = self.__findout_decl_type( match_class, **norm_keywds ) + recursive_ = self.__findout_recursive( **norm_keywds ) + decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ ) + found = matcher_module.matcher.get_single( matcher, decls, False ) + utils.logger.info( 'find single query execution - done( %f seconds )' % ( time.clock() - start_time ) ) + return found + + def _find_multiple( self, match_class, **keywds ): + utils.logger.info( 'find all query execution - started' ) + start_time = time.clock() + norm_keywds = self.__normalize_args( **keywds ) + matcher = self.__create_matcher( match_class, **norm_keywds ) + dtype = self.__findout_decl_type( match_class, **norm_keywds ) + recursive_ = self.__findout_recursive( **norm_keywds ) + decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ ) + found = matcher_module.matcher.find( matcher, decls, False ) + mfound = mdecl_wrapper.mdecl_wrapper_t( found ) + utils.logger.info( '%d declaration(s) that match query' % len(mfound) ) + utils.logger.info( 'find single query execution - done( %f seconds )' + % ( time.clock() - start_time ) ) + if not mfound and not self.ALLOW_EMPTY_MDECL_WRAPPER: + raise RuntimeError( "Multi declaration query returned 0 declarations." ) + return mfound + + + def decl( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + """Finds any declaration by criteria. Please see L{scopedef_t} for full explanation.""" + return self._find_single( self._impl_matchers[ scopedef_t.decl ] + , name=name + , function=function + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def decls( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.decl ] + , name=name + , function=function + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def class_( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.class_ ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.class_ ] + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def classes( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.class_ ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.class_ ] + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def variable( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.variable ] + , name=name + , function=function + , type=type + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def variables( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.variable ] + , name=name + , function=function + , type=type + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def calldef( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.calldef ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.calldef ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def calldefs( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.calldef ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.calldef ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, decl_type=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, decl_type=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def member_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.member_function ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.member_function ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def member_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.member_function ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.member_function ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def constructor( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.constructor ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.constructor ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def constructors( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.constructor ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.constructor ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def member_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.member_operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.member_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def member_operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.member_operator ] + , name=name + , symbol=symbol + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.member_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def casting_operator( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.casting_operator ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive ) + + def casting_operators( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.casting_operator ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ] + , return_type=return_type + , arg_types=arg_types + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + + def enumeration( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + return self._find_single( self._impl_matchers[ scopedef_t.enumeration ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.enumeration ] + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + #adding small aliase + enum = enumeration + + def enumerations( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ): + return self._find_multiple( self._impl_matchers[ scopedef_t.enumeration ] + , name=name + , function=function + , decl_type=self._impl_decl_types[ scopedef_t.enumeration ] + , header_dir=header_dir + , header_file=header_file + , recursive=recursive) + #adding small aliase + enums = enumerations \ No newline at end of file |
