如何用libclang找出成员函数是常量还是易失性

Question

我有一个CXCursor的实例CXCursor_CXXMethod。我想找出函数是const还是volatile，例如：

class Foo {
public:
    void bar() const;
    void baz() volatile;
    void qux() const volatile;
};

我在 libclang 的文档中找不到任何有用的东西。我尝试了clang_isConstQualifiedType和clang_isVolatileQualifiedType但这些似乎总是在C++成员函数类型上返回0。

Answer 1

我可以想到两种方法：

使用libclang词法分析

这个SO答案中出现的代码对我有用;它使用libclang分词器将方法声明分开，然后记录方法括号之外的任何关键字。

它不访问代码的 AST，据我所知根本不涉及解析器。如果您确定您调查的代码是正确的C++，我相信这种方法是安全的。

缺点：这种解决方案似乎没有考虑预处理指令，所以代码必须首先处理（例如，通过cpp传递）。

示例代码（要解析的文件必须是程序的第一个参数，例如 ./a.out bla.cpp ）：

#include "clang-c/Index.h"
#include <string>
#include <set>
#include <iostream>
std::string GetClangString(CXString str)
{
  const char* tmp = clang_getCString(str);
  if (tmp == NULL) {
    return "";
  } else {
    std::string translated = std::string(tmp);
    clang_disposeString(str);
    return translated;
  }
}
void GetMethodQualifiers(CXTranslationUnit translationUnit,
                         std::set<std::string>& qualifiers,
                         CXCursor cursor) {
  qualifiers.clear();
  CXSourceRange range = clang_getCursorExtent(cursor);
  CXToken* tokens;
  unsigned int numTokens;
  clang_tokenize(translationUnit, range, &tokens, &numTokens);
  bool insideBrackets = false;
  for (unsigned int i = 0; i < numTokens; i++) {
    std::string token = GetClangString(clang_getTokenSpelling(translationUnit, tokens[i]));
    if (token == "(") {
      insideBrackets = true;
    } else if (token == "{" || token == ";") {
      break;
    } else if (token == ")") {
      insideBrackets = false;
    } else if (clang_getTokenKind(tokens[i]) == CXToken_Keyword && 
             !insideBrackets) {
      qualifiers.insert(token);
    }
  }
  clang_disposeTokens(translationUnit, tokens, numTokens);
}
int main(int argc, char *argv[]) {
  CXIndex Index = clang_createIndex(0, 0);
  CXTranslationUnit TU = clang_parseTranslationUnit(Index, 0, 
          argv, argc, 0, 0, CXTranslationUnit_None);
  // Set the file you're interested in, and the code location:
  CXFile file = clang_getFile(TU, argv[1]);
  int line = 5;
  int column = 6;
  CXSourceLocation location = clang_getLocation(TU, file, line, column);
  CXCursor cursor = clang_getCursor(TU, location);
  std::set<std::string> qualifiers;
  GetMethodQualifiers(TU, qualifiers, cursor);
  for (std::set<std::string>::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i) {
    std::cout << *i << std::endl;
  }
  clang_disposeTranslationUnit(TU);
  clang_disposeIndex(Index);
  return 0;
}

使用 libclang 的统一符号分辨率 （USR）

此方法涉及使用解析器本身，并从 AST 中提取限定符信息。

优点：似乎适用于带有预处理器指令的代码，至少对于简单情况。

缺点：我的解决方案解析 USR，该 USR 未记录，将来可能会更改。尽管如此，编写单元测试来防止这种情况还是很容易的。

看一下$(CLANG_SRC)/tools/libclang/CIndexUSRs.cpp，它包含生成 USR 的代码，因此包含解析 USR 字符串所需的信息。具体来说，第 523-529 行（在从 www.llvm.org 下载的 LLVM 3.1 源代码中）用于限定符部分。

在某处添加以下函数：

void parseUsrString(const std::string& usrString, bool* isVolatile, bool* isConst, bool *isRestrict) {
  size_t bangLocation = usrString.find("#");
  if (bangLocation == std::string::npos || bangLocation == usrString.length() - 1) {
    *isVolatile = *isConst = *isRestrict = false;
    return;
  }
  bangLocation++;
  int x = usrString[bangLocation];
  *isConst = x & 0x1;
  *isVolatile = x & 0x4;
  *isRestrict = x & 0x2;
}

而在main()，

CXString usr = clang_getCursorUSR(cursor);
const char *usr_string = clang_getCString(usr);
std::cout << usr_string << "n";
bool isVolatile, isConst, isRestrict;
parseUsrString(usr_string, &isVolatile, &isConst, &isRestrict);
printf("restrict, volatile, const: %d %d %dn", isRestrict, isVolatile, isConst);
clang_disposeString(usr);

在Foo::qux()上运行

#define BLA const
class Foo {
public:
    void bar() const;
    void baz() volatile;
    void qux() BLA volatile;
};

产生预期的结果

c:@C@Foo@F@qux#5
restrict, volatile, const: 0 1 1

警告：您可能已经注意到，libclang的源代码是我的代码应该是isVolatile = x & 0x2而不是0x4，所以可能是您应该用0x2替换0x4。我的实现（OS X）可能已经替换了它们。

Answer 2

您可以使用

clang_getCursorPrettyPrinted（）检测纯虚/常量函数.这个函数给你完整的方法/函数原型（虚拟，const，=0等 - 你在源代码中看到的一切）。如果你能得到所需函数/方法的光标就是您所需要的。之前的答案向您展示了如何获取光标。

下面的代码是用C++编写的，但你可以把它翻译成C，因为它使用libclang。

示例如何检查 const 方法（getAsStdString 定义如下）：

auto funcPrettyPrinted = getAsStdString(
        clang_getCursorPrettyPrinted(cursor, nullptr));
if (std::string::npos != funcPrettyPrinted.find(") const"))
{
    break;
}

示例如何检查虚拟函数：

auto funcPrettyPrinted = getAsStdString(
        clang_getCursorPrettyPrinted(cursor, nullptr));
if (std::string::npos != funcPrettyPrinted.find("virtual") &&
    std::string::npos != funcPrettyPrinted.find("= 0"))
{
    break;
}

下面是一个漂亮的打印输出示例：

virtual void one() = 0

不太重要但有用的辅助功能：

std::string getAsStdString(CXString str)
{
    auto cstr = clang_getCString(str);
    if (nullptr == cstr)
    {
       return "";
    }
    std::string stdStr{cstr};
    clang_disposeString(str);
    return stdStr;
}

当然，您可以使用正则表达式来确保搜索 100% 正确......如果需要的话。