These are unnecessary, the declarations already carry the 'extern C' property, and if there is mismatch
between declaration and definition then we will get linker errors via libclang.exports.
llvm-svn: 290025
// libClang public APIs.
//===----------------------------------------------------------------------===//
-extern "C" {
-
CXRemapping clang_getRemappings(const char *migrate_dir_path) {
#ifndef CLANG_ENABLE_ARCMT
llvm::errs() << "error: feature not enabled in this build\n";
void clang_remap_dispose(CXRemapping map) {
delete static_cast<Remap *>(map);
}
-
-} // end: extern "C"
static llvm::ManagedStatic<RegisterFatalErrorHandler> RegisterFatalErrorHandlerOnce;
-extern "C" {
CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
int displayDiagnostics) {
// We use crash recovery to make some of our APIs more reliable, implicitly
return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// CXFile Operations.
//===----------------------------------------------------------------------===//
-extern "C" {
CXString clang_getFileName(CXFile SFile) {
if (!SFile)
return cxstring::createNull();
return FEnt1->getUniqueID() == FEnt2->getUniqueID();
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// CXCursor Operations.
//===----------------------------------------------------------------------===//
return E->getLocStart();
}
-extern "C" {
-
unsigned clang_visitChildren(CXCursor parent,
CXCursorVisitor visitor,
CXClientData client_data) {
return cxloc::translateSourceLocation(getCursorContext(C), Loc);
}
-} // end extern "C"
-
CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
assert(TU);
return getRawCursorExtent(C);
}
-extern "C" {
-
CXSourceRange clang_getCursorExtent(CXCursor C) {
SourceRange R = getRawCursorExtent(C);
if (R.isInvalid())
llvm::llvm_execute_on_thread(fn, user_data, stack_size);
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// Token-based Operations.
//===----------------------------------------------------------------------===//
* ptr_data: for identifiers and keywords, an IdentifierInfo*.
* otherwise unused.
*/
-extern "C" {
-
CXTokenKind clang_getTokenKind(CXToken CXTok) {
return static_cast<CXTokenKind>(CXTok.int_data[0]);
}
free(Tokens);
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// Token annotation APIs.
//===----------------------------------------------------------------------===//
}
}
-extern "C" {
-
void clang_annotateTokens(CXTranslationUnit TU,
CXToken *Tokens, unsigned NumTokens,
CXCursor *Cursors) {
}
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// Operations for querying linkage of a cursor.
//===----------------------------------------------------------------------===//
-extern "C" {
CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
if (!clang_isDeclaration(cursor.kind))
return CXLinkage_Invalid;
return CXLinkage_Invalid;
}
-} // end: extern "C"
//===----------------------------------------------------------------------===//
// Operations for querying visibility of a cursor.
//===----------------------------------------------------------------------===//
-extern "C" {
CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) {
if (!clang_isDeclaration(cursor.kind))
return CXVisibility_Invalid;
return CXVisibility_Invalid;
}
-} // end: extern "C"
//===----------------------------------------------------------------------===//
// Operations for querying language of a cursor.
return CXLanguage_C;
}
-extern "C" {
-
static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) {
if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
return CXAvailability_NotAvailable;
return nullptr;
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// C++ AST instrospection.
//===----------------------------------------------------------------------===//
-extern "C" {
-
unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
if (!clang_isDeclaration(C.kind))
return 0;
D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
return (Method && Method->isVirtual()) ? 1 : 0;
}
-} // end: extern "C"
//===----------------------------------------------------------------------===//
// Attribute introspection.
//===----------------------------------------------------------------------===//
-extern "C" {
CXType clang_getIBOutletCollectionType(CXCursor C) {
if (C.kind != CXCursor_IBOutletCollectionAttr)
return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));
return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));
}
-} // end: extern "C"
//===----------------------------------------------------------------------===//
// Inspecting memory usage.
entries.push_back(entry);
}
-extern "C" {
-
const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
const char *str = "";
switch (kind) {
}
}
-} // end extern "C"
-
void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
for (unsigned I = 0; I != Usage.numEntries; ++I)
return checkForMacroInMacroDefinition(MI, Tok, TU);
}
-extern "C" {
-
CXString clang_getClangVersion() {
return cxstring::createDup(getClangFullVersion());
}
-} // end: extern "C"
-
Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) {
if (TU) {
if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
using namespace clang;
using namespace clang::cxcursor;
-extern "C" {
-
unsigned clang_isVirtualBase(CXCursor C) {
if (C.kind != CXCursor_CXXBaseSpecifier)
return 0;
return MakeCXCursor(Template, getCursorTU(C));
}
-
-} // end extern "C"
using namespace clang;
using namespace clang::cxindex;
-extern "C" {
-
enum CXCompletionChunkKind
clang_getCompletionChunkKind(CXCompletionString completion_string,
unsigned chunk_number) {
fprintf(stderr, "--- %u completion results\n",
--CodeCompletionResultObjects);
}
-
-} // end extern "C"
static unsigned long long getContextsForContextKind(
enum CodeCompletionContext::Kind kind,
return Results;
}
-extern "C" {
CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
const char *complete_filename,
unsigned complete_line,
return cxstring::createDup(Results->Selector);
}
-} // end extern "C"
-
/// \brief Simple utility function that appends a \p New string to the given
/// \p Old string, using the \p Buffer for storage.
///
};
}
-extern "C" {
- void clang_sortCodeCompletionResults(CXCompletionResult *Results,
- unsigned NumResults) {
- std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
- }
+void clang_sortCodeCompletionResults(CXCompletionResult *Results,
+ unsigned NumResults) {
+ std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
}
//-----------------------------------------------------------------------------
// C Interface Routines
//-----------------------------------------------------------------------------
-extern "C" {
-
unsigned clang_getNumDiagnostics(CXTranslationUnit Unit) {
if (cxtu::isNotUsableTU(Unit)) {
LOG_BAD_TU(Unit);
return D->getNumDiagnostics();
return 0;
}
-
-} // end extern "C"
// libclang public APIs.
//===----------------------------------------------------------------------===//
-extern "C" {
-
CXResult clang_findReferencesInFile(CXCursor cursor, CXFile file,
CXCursorAndRangeVisitor visitor) {
LogRef Log = Logger::make(__func__);
return clang_findIncludesInFile(TU, file, visitor);
}
-} // end: extern "C"
-
}
-extern "C" {
void clang_getInclusions(CXTranslationUnit TU, CXInclusionVisitor CB,
CXClientData clientData) {
if (cxtu::isNotUsableTU(TU)) {
getInclusions(&SourceManager::getLocalSLocEntry, n, TU, CB, clientData);
}
-} // end extern C
return generateUSRForDecl(D, Buf);
}
-extern "C" {
-
CXString clang_getCursorUSR(CXCursor C) {
const CXCursorKind &K = clang_getCursorKind(C);
generateUSRForObjCProperty(property, /*isClassProp=*/false, OS);
return cxstring::createDup(OS.str());
}
-
-} // end extern "C"
using namespace clang::comments;
using namespace clang::cxcomment;
-extern "C" {
-
CXComment clang_Cursor_getParsedComment(CXCursor C) {
using namespace clang::cxcursor;
return cxstring::createDup(XML.str());
}
-} // end extern "C"
-
using namespace clang;
using namespace clang::tooling;
-extern "C" {
-
// FIXME: do something more useful with the error message
CXCompilationDatabase
clang_CompilationDatabase_fromDirectory(const char *BuildDir,
return cxstring::createRef(Cmd->MappedSources[I].second.c_str());
}
-
-} // end: extern "C"
// libclang CXCursor APIs
//===----------------------------------------------------------------------===//
-extern "C" {
-
int clang_Cursor_isNull(CXCursor cursor) {
return clang_equalCursors(cursor, clang_getNullCursor());
}
return TA.getAsIntegral().getZExtValue();
}
-} // end: extern "C"
-
//===----------------------------------------------------------------------===//
// CXCursorSet.
//===----------------------------------------------------------------------===//
};
}
-extern "C" {
CXCursorSet clang_createCXCursorSet() {
return packCXCursorSet(new CXCursorSet_Impl());
}
}
return nullptr;
}
-} // end: extern C.
namespace {
struct OverridenCursorsPool {
delete static_cast<OverridenCursorsPool*>(pool);
}
-extern "C" {
void clang_getOverriddenCursors(CXCursor cursor,
CXCursor **overridden,
unsigned *num_overridden) {
return cxtype::MakeCXType(QualType(), TU);
}
-
-} // end: extern "C"
return std::error_code();
}
-extern "C" {
CXDiagnosticSet clang_loadDiagnostics(const char *file,
enum CXLoadDiag_Error *error,
CXString *errorString) {
DiagLoader L(error, errorString);
return L.load(file);
}
-} // end extern 'C'.
// Basic construction and comparison of CXSourceLocations and CXSourceRanges.
//===----------------------------------------------------------------------===//
-extern "C" {
-
CXSourceLocation clang_getNullLocation() {
CXSourceLocation Result = { { nullptr, nullptr }, 0 };
return Result;
return Result;
}
-} // end extern "C"
-
//===----------------------------------------------------------------------===//
// Getting CXSourceLocations and CXSourceRanges from a translation unit.
//===----------------------------------------------------------------------===//
-extern "C" {
-
CXSourceLocation clang_getLocation(CXTranslationUnit TU,
CXFile file,
unsigned line,
return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
}
-} // end extern "C"
-
//===----------------------------------------------------------------------===//
// Routines for expanding and manipulating CXSourceLocations, regardless
// of their origin.
*offset = 0;
}
-extern "C" {
-
int clang_Location_isInSystemHeader(CXSourceLocation location) {
const SourceLocation Loc =
SourceLocation::getFromRawEncoding(location.int_data);
if (offset)
*offset = FileOffset;
}
-
-} // end extern "C"
// libClang public APIs.
//===----------------------------------------------------------------------===//
-extern "C" {
const char *clang_getCString(CXString string) {
if (string.private_flags == (unsigned) CXS_StringBuf) {
return static_cast<const cxstring::CXStringBuf *>(string.data)->Data.data();
delete set;
}
-} // end: extern "C"
-
return None;
}
-extern "C" {
-
CXType clang_getCursorType(CXCursor C) {
using namespace cxcursor;
return MakeCXType(QualType(), GetTU(CT));
}
-
-} // end: extern "C"
// libclang public APIs.
//===----------------------------------------------------------------------===//
-extern "C" {
-
int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
}
return cxloc::translateSourceLocation(DataConsumer.getASTContext(), Loc);
}
-} // end: extern "C"
-
projects / platform / upstream / llvm.git / commitdiff