Added function to retrieve storage class in libclang.

[RedX2501]

Summary

Added function clang_getStorageClass(CXCursor) to be able to retrieve the storage class of function decls and variable decls.

Also added the corresponding interface to cindex.py.

[RedX2501]

Added cfe-commits as mailing list.

[RedX2501]

Added check for if getCursorDecl returns a valid object.

[RedX2501]

Ping!

[akyrtzi]

Hi, sorry for the delay!

+ /**
+ * \brief The storage class for functions and variables.
+ *
+ */
+ CXCursor_StorageClass = 51,
+

This doesn't need a new cursor kind, and I don't see this kind getting set for a cursor in your patch.

+CINDEX_LINKAGE enum CX_StorageClass clang_getStorageClass(CXCursor);

I suggest renaming to clang_Cursor_getStorageClass

Some style issues the make the code inconsistent with the rest of the codebase:

+ Decl const * D = getCursorDecl(C);
Change to "const Decl *D = .."
Same for similar cases later on.

+ if(D){
Space after 'if' and before the brace

+ }else{
Spaces between the braces.

+ switch(sc){
+ case SC_None :
Space after 'switch' and before brace, and 'case' should have same indentation as 'switch'.

[RedX2501]

Mady stylistic changes as recommended by Argyrios Kyrtzidis.
Added comments to C function.

[akyrtzi]

Please also correct style in all places in clang_Cursor_getStorageClass, specifically

• Put a space before the left braces
• "const Decl * D" -> "const Decl *D" (note no space between star and variable)
• "FunctionDecl const * FD" -> "const FunctionDecl *FD"
• "VarDecl const * VD" -> "const VarDecl *VD"

[RedX2501]

Fixed raised style concerns.

[akyrtzi]

Committed in r219809, thanks!

[RedX2501]

This was accepted into r219809.

[RedX2501]

Accepted into r219809.

bindings/python/clang/cindex.py

def extent(self):
         pointed at by the cursor.
         """
         if not hasattr(self, '_extent'):
             self._extent = conf.lib.clang_getCursorExtent(self)
 
         return self._extent
 
     @property
+    def storage_class(self):
+        """
+        Retrieves the storage class (if any) of the entity pointed at by the
+        cursor.
+        """
+        if not hasattr(self, '_storage_class'):
+            self._storage_class = conf.lib.clang_getStorageClass(self)
+
+        return StorageClass.from_id(self._storage_class)
+
+    @property
     def access_specifier(self):
         """
         Retrieves the access specifier (if any) of the entity pointed at by the
         cursor.
         """
         if not hasattr(self, '_access_specifier'):
             self._access_specifier = conf.lib.clang_getCXXAccessSpecifier(self)
 
class Cursor(Structure):
     def from_cursor_result(res, fn, args):
         assert isinstance(res, Cursor)
         if res == conf.lib.clang_getNullCursor():
             return None
 
         res._tu = args[0]._tu
         return res
 
+class StorageClass(object):
+    """
+    Describes the storage class of a declaration
+    """
+
+    # The unique kind objects, index by id.
+    _kinds = []
+    _name_map = None
+
+    def __init__(self, value):
+        if value >= len(StorageClass._kinds):
+            StorageClass._kinds += [None] * (value - len(StorageClass._kinds) + 1)
+        if StorageClass._kinds[value] is not None:
+            raise ValueError,'StorageClass already loaded'
+        self.value = value
+        StorageClass._kinds[value] = self
+        StorageClass._name_map = None
+
+    def from_param(self):
+        return self.value
+
+    @property
+    def name(self):
+        """Get the enumeration name of this storage class."""
+        if self._name_map is None:
+            self._name_map = {}
+            for key,value in StorageClass.__dict__.items():
+                if isinstance(value,StorageClass):
+                    self._name_map[value] = key
+        return self._name_map[self]
+
+    @staticmethod
+    def from_id(id):
+        if id >= len(StorageClass._kinds) or not StorageClass._kinds[id]:
+            raise ValueError,'Unknown storage class %d' % id
+        return StorageClass._kinds[id]
+
+    def __repr__(self):
+        return 'StorageClass.%s' % (self.name,)
+
+StorageClass.INVALID = StorageClass(0)
+StorageClass.NONE = StorageClass(1)
+StorageClass.EXTERN = StorageClass(2)
+StorageClass.STATIC = StorageClass(3)
+StorageClass.PRIVATEEXTERN = StorageClass(4)
+StorageClass.OPENCLWORKGROUPLOCAL = StorageClass(5)
+StorageClass.AUTO = StorageClass(6)
+StorageClass.REGISTER = StorageClass(7)
+
+
 ### C++ access specifiers ###
 
 class AccessSpecifier(object):
     """
     Describes the access of a C++ class member
     """
 
     # The unique kind objects, index by id.

include/clang-c/Index.h

enum CXCursorKind {
   /**
    * \brief A reference to a variable that occurs in some non-expression 
    * context, e.g., a C++ lambda capture list.
    */
   CXCursor_VariableRef                   = 50,
   
   CXCursor_LastRef                       = CXCursor_VariableRef,
 
+  /**
+   * \brief The storage class for functions and variables.
+   *
+   */
+  CXCursor_StorageClass                  = 51,
+
   /* Error conditions */
   CXCursor_FirstInvalid                  = 70,
   CXCursor_InvalidFile                   = 70,
   CXCursor_NoDeclFound                   = 71,
   CXCursor_NotImplemented                = 72,
   CXCursor_InvalidCode                   = 73,
   CXCursor_LastInvalid                   = CXCursor_InvalidCode,
 

  * \brief Returns the access control level for the referenced object.
  *
  * If the cursor refers to a C++ declaration, its access control level within its
  * parent scope is returned. Otherwise, if the cursor refers to a base specifier or
  * access specifier, the specifier itself is returned.
  */
 CINDEX_LINKAGE enum CX_CXXAccessSpecifier clang_getCXXAccessSpecifier(CXCursor);
 
+enum CX_StorageClass {
+  CX_SC_Invalid,
+  CX_SC_None,
+  CX_SC_Extern,
+  CX_SC_Static,
+  CX_SC_PrivateExtern,
+  CX_SC_OpenCLWorkGroupLocal,
+  CX_SC_Auto,
+  CX_SC_Register
+};
+
+CINDEX_LINKAGE enum CX_StorageClass clang_getStorageClass(CXCursor);
+
 /**
  * \brief Determine the number of overloaded declarations referenced by a 
  * \c CXCursor_OverloadedDeclRef cursor.
  *
  * \param cursor The cursor whose overloaded declarations are being queried.
  *
  * \returns The number of overloaded declarations referenced by \c cursor. If it
  * is not a \c CXCursor_OverloadedDeclRef cursor, returns 0.

tools/libclang/CIndex.cpp

CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_UsingDeclaration:
     return cxstring::createRef("UsingDeclaration");
   case CXCursor_TypeAliasDecl:
     return cxstring::createRef("TypeAliasDecl");
   case CXCursor_ObjCSynthesizeDecl:
     return cxstring::createRef("ObjCSynthesizeDecl");
   case CXCursor_ObjCDynamicDecl:
     return cxstring::createRef("ObjCDynamicDecl");
+  case CXCursor_StorageClass:
+    return cxstring::createRef("StorageClass");
   case CXCursor_CXXAccessSpecifier:
     return cxstring::createRef("CXXAccessSpecifier");
   case CXCursor_ModuleImportDecl:
     return cxstring::createRef("ModuleImport");
   case CXCursor_OMPParallelDirective:
     return cxstring::createRef("OMPParallelDirective");
   case CXCursor_OMPSimdDirective:
     return cxstring::createRef("OMPSimdDirective");
static const Decl *maybeGetTemplateCursor(const Decl *D) {
 
   if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
     if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
       return ClassTmpl;
 
   return D;
 }
 
+
+enum CX_StorageClass clang_getStorageClass(CXCursor C){
+  StorageClass sc = SC_None;
+  Decl const * D = getCursorDecl(C);
+  if(D){
+    if(FunctionDecl const * FD = dyn_cast<FunctionDecl>(D)){
+      sc = FD->getStorageClass();
+    }else if(VarDecl const * VD = dyn_cast<VarDecl>(D)){
+      sc = VD->getStorageClass();
+    }else{
+      return CX_SC_Invalid;
+    }
+  }else{
+    return CX_SC_Invalid;
+  }
+  switch(sc){
+    case SC_None  :
+      return CX_SC_None;
+    case SC_Extern  :
+      return CX_SC_Extern;
+    case SC_Static  :
+      return CX_SC_Static;
+    case SC_PrivateExtern   :
+      return CX_SC_PrivateExtern;
+    case SC_OpenCLWorkGroupLocal  :
+      return CX_SC_OpenCLWorkGroupLocal;
+    case SC_Auto  :
+      return CX_SC_Auto;
+    case SC_Register :
+      return CX_SC_Register;
+    default:
+      return CX_SC_Invalid;
+  }
+}
+
 CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
   if (clang_isDeclaration(cursor.kind)) {
     if (const Decl *D = getCursorDecl(cursor)) {
       const DeclContext *DC = D->getDeclContext();
       if (!DC)
         return clang_getNullCursor();
 
       return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 

tools/libclang/libclang.exports

 clang_findReferencesInFileWithBlock
 clang_formatDiagnostic
 clang_getArgType
 clang_getArrayElementType
 clang_getArraySize
 clang_getBuildSessionTimestamp
 clang_getCString
 clang_getCXTUResourceUsage
+clang_getStorageClass
 clang_getCXXAccessSpecifier
 clang_getCanonicalCursor
 clang_getCanonicalType
 clang_getChildDiagnostics
 clang_getClangVersion
 clang_getCompletionAnnotation
 clang_getCompletionAvailability
 clang_getCompletionBriefComment