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_Cursor_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(BaseEnumeration):
     """
     Describes the access of a C++ class member
     """
 
     # The unique kind objects, index by id.

include/clang-c/Index.h

  *
  * 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);
 
 /**
+ * \brief Represents the storage classes as declared in the source. CX_SC_Invalid
+ * was added for the clase that the passed cursor in not a declaration.
+ */
+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
+};
+
+/**
+ * \brief Returns the storage class for a function or variable declaration.
+ *
+ * If the passed in Cursor is not a function or variable declaration,
+ * CX_SC_Invalid is returned else the storage class.
+ */
+CINDEX_LINKAGE enum CX_StorageClass clang_Cursor_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

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_Cursor_getStorageClass(CXCursor C) {
+  StorageClass sc = SC_None;
+  const Decl *D = getCursorDecl(C);
+  if (D) {
+    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+      sc = FD->getStorageClass();
+    } else if (const VarDecl *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_Cursor_getTranslationUnit
 clang_Cursor_getReceiverType
 clang_Cursor_isBitField
 clang_Cursor_isDynamicCall
 clang_Cursor_isNull
 clang_Cursor_isObjCOptional
 clang_Cursor_isVariadic
 clang_Cursor_getModule
+clang_Cursor_getStorageClass
 clang_File_isEqual
 clang_Module_getASTFile
 clang_Module_getParent
 clang_Module_getName
 clang_Module_getFullName
 clang_Module_getNumTopLevelHeaders
 clang_Module_getTopLevelHeader
 clang_Module_isSystem