sphinx

Author: roman_yakovenko

pygccxml/__init__.py

@@ -7,7 +7,7 @@
 
 This package provides functionality to extract and inspect
 declarations from C/C++ header files. This is accomplished
-by invoking the external tool U{gccxml<http://www.gccxml.org/>}
+by invoking the external tool `gccxml <http://www.gccxml.org/>`_
 which parses a header file and dumps the declarations as a
 XML file. This XML file is then read by pygccxml and the contents
 are made available as appropriate Python objects.

pygccxml/declarations/algorithm.py

@@ -227,7 +227,11 @@ def does_match_exist(self, inst):
         return answer
 
     def __call__(self, inst):
-        """C{return self.does_match_exist(inst)}"""
+        """
+        .. code-block:: python
+        
+           return self.does_match_exist(inst)
+        """
         return self.does_match_exist(inst)
 
 def find_all_declarations( declarations

pygccxml/declarations/cpptypes.py

@@ -354,7 +354,7 @@ def __init__( self ):
 ## Compaund types:
 
 class compound_t( type_t ):
-    """class that allows to represent compound types like C{const int*}"""
+    """class that allows to represent compound types like `const int*`"""
     def __init__( self, base ):
         type_t.__init__( self )
         self._base = base
@@ -368,7 +368,7 @@ def _set_base(self, new_base):
                      , doc="reference to internal/base class")
 
 class volatile_t( compound_t ):
-    """represents C{volatile whatever} type"""
+    """represents `volatile whatever` type"""
     def __init__( self, base ):
         compound_t.__init__( self, base)
 
@@ -379,7 +379,7 @@ def _clone_impl( self ):
         return volatile_t( self.base.clone() )
 
 class restrict_t( compound_t ):
-    """represents C{restrict whatever} type"""
+    """represents `restrict whatever` type"""
 
     #The restrict keyword can be considered an extension to the strict aliasing
     #rule. It allows the programmer to declare that pointers which share the same
@@ -400,7 +400,7 @@ def _clone_impl( self ):
         return restrict_t( self.base.clone() )
 
 class const_t( compound_t ):
-    """represents C{whatever const} type"""
+    """represents `whatever const` type"""
     def __init__( self, base ):
         compound_t.__init__( self, base )
 
@@ -411,7 +411,7 @@ def _clone_impl( self ):
         return const_t( self.base.clone() )
 
 class pointer_t( compound_t ):
-    """represents C{whatever*} type"""
+    """represents `whatever*` type"""
     def __init__( self, base ):
         compound_t.__init__( self, base )
 
@@ -422,7 +422,7 @@ def _clone_impl( self ):
         return pointer_t( self.base.clone() )
 
 class reference_t( compound_t ):
-    """represents C{whatever&} type"""
+    """represents `whatever&` type"""
     def __init__( self, base ):
         compound_t.__init__( self, base)
 

pygccxml/declarations/declaration.py

@@ -128,9 +128,11 @@ def __ne__( self, other):
 
     def __lt__(self, other):
         """
-        C{if not isinstance( other, self.__class__ ):}
-        C{    return self.__class__.__name__ < other.__class__.__name__}
-        C{return self._get__cmp__data() < other._get__cmp__data()}
+        .. code-block:: python
+        
+           if not isinstance( other, self.__class__ ):
+               return self.__class__.__name__ < other.__class__.__name__
+           return self._get__cmp__data() < other._get__cmp__data()          
         """
         if not isinstance( other, self.__class__ ):
             return self.__class__.__name__ < other.__class__.__name__

pygccxml/declarations/matchers.py

@@ -94,12 +94,14 @@ def __str__(self):
 
 
 class not_matcher_t(matcher_base_t):
-    """Return the inverse result of matcher, using "~"
+    """
+    return the inverse result of a matcher
 
-    For example: find all private and protected declarations
+    For example: find all public and protected declarations
 
-    C{ matcher = ~access_type_matcher_t( 'private' ) }
+	.. code-block:: python
 
+       matcher = ~access_type_matcher_t( 'private' )
     """
     def __init__(self, matcher):
         matcher_base_t.__init__(self)
@@ -343,7 +345,6 @@ def __init__( self, name=None, return_type=None, arg_types=None, decl_type=None,
         reference to integer and second any
 
         :type arg_types: list
-
         """
         if None is decl_type:
             decl_type = calldef.calldef_t

pygccxml/declarations/mdecl_wrapper.py

@@ -17,15 +17,15 @@ class call_redirector_t( object ):
     def __init__( self, name, decls ):
         """creates call_redirector_t instance.
 
-        :param name: name of method, to be called on every object in C{decls} list
+        :param name: name of method, to be called on every object in the `decls` list
         :param decls: list of objects
         """
         object.__init__( self )
         self.name = name
         self.decls = decls
 
     def __call__( self, *arguments, **keywords ):
-        """calls method C{self.name} on every object within C{self.decls} list"""
+        """calls method :attr:`call_redirector_t.name` on every object within the :attr:`call_redirector_t.decls` list"""
         for d in self.decls:
             callable_ = getattr(d, self.name)
             callable_( *arguments, **keywords )

pygccxml/declarations/scopedef.py

@@ -18,7 +18,7 @@ class scopedef_t( declaration.declaration_t ):
     Base class for :class:`namespace_t` and :class:`class_t` classes.
 
     This is the base class for all declaration classes that may have
-    children nodes. The children can be accessed via the C{declarations}
+    children nodes. The children can be accessed via the :attr:`scopedef_t.declarations`
     property.
 
     Also this class provides "get/select/find" interface. Using this class you
@@ -84,7 +84,7 @@ def __init__( self, name=''):
 
     def _get_logger( self ):
         return utils.loggers.queries_engine
-    _logger = property( _get_logger, doc="reference to C{queries_engine} logger" )
+    _logger = property( _get_logger, doc="reference to :attr:`pygccxml.utils.loggers.queries_engine` logger" )
 
     def _get__cmp__scope_items(self):
         """implementation details"""

pygccxml/declarations/templates.py

@@ -8,9 +8,9 @@
 
 This module implements all functionality necessary to parse C++ template
 instantiations.In other words this module is able to extract next information from
-the string like this C{ std::vector<int> }.
-    - name ( std::vector )
-    - list of arguments ( int )
+the string like this `std::vector<int>`.
+    - name ( `std::vector` )
+    - list of arguments ( `int` )
 
 This module also defines few convenience function like :func:split and :func:join.
 """

pygccxml/declarations/type_traits.py

@@ -84,7 +84,7 @@ def decompose_class(type):
 def base_type(type):
     """returns base type.
 
-    For C{const int} will return C{int}
+    For `const int` will return `int`
     """
     types = decompose_type( type )
     return types[-1]
@@ -115,15 +115,15 @@ def does_match_definition(given, main, secondary ):
         return False
 
 def is_bool( type_ ):
-    """returns True, if type represents C{bool}, False otherwise"""
+    """returns True, if type represents `bool`, False otherwise"""
     return remove_alias( type_ ) in create_cv_types( cpptypes.bool_t() )
 
 def is_void( type ):
-    """returns True, if type represents C{void}, False otherwise"""
+    """returns True, if type represents `void`, False otherwise"""
     return remove_alias( type ) in create_cv_types( cpptypes.void_t() )
 
 def is_void_pointer( type ):
-    """returns True, if type represents C{void*}, False otherwise"""
+    """returns True, if type represents `void*`, False otherwise"""
     return is_same( type, cpptypes.pointer_t( cpptypes.void_t() ) )
 
 def is_integral( type ):
@@ -889,8 +889,9 @@ def is_noncopyable( class_ ):
         return __is_noncopyable_single( class_ )
 
 def is_defined_in_xxx( xxx, cls ):
-    """small helper function, that checks whether class ( C{cls} ) is defined
-    under C{::xxx} namespace"""
+    """
+    small helper function, that checks whether the class `cls` is defined under `::xxx` namespace
+    """    
     if not cls.parent:
         return False
 

pygccxml/parser/__init__.py

@@ -40,12 +40,12 @@ def parse( files
     :param files: The header files that should be parsed
     :type files: list of str
     :param config: Configuration object or None
-    :type config: L{config_t}
+    :type config: :class:`parser.config_t`
     :param compilation_mode: Determines whether the files are parsed individually or as one single chunk
-    :type compilation_mode: L{COMPILATION_MODE}
+    :type compilation_mode: :class:`parser.COMPILATION_MODE`
     :param cache: Declaration cache (None=no cache)
-    :type cache: L{cache_base_t} or str
-    :rtype: Declarations
+    :type cache: :class:`parser.cache_base_t` or str
+    :rtype: list of :class:`declarations.declaration_t`
     """
     if not config:
         config = config_t()