如何使用libclang找出成员函数是const还是volatile？

Question

我有一个实例CXCursor样的CXCursor_CXXMethod.我想知道函数是否是,const或者volatile,例如:

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

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

Answer 1

我可以想到两种方法:

使用libclang词法分析器

这个SO答案中出现的代码对我有用; 它使用libclangtokenizer来分解方法声明,然后在方法括号之外记录任何关键字.

它并没有访问代码的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,并且可能在将来发生变化.尽管如此,编写单元测试以防止这种情况仍然很容易.

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

在某处添加以下功能:

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 %d\n", 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,因此可能应该将0x4替换为0x2.我的实现(OS X)可能会替换它们.