API.cpp

Go to the documentation of this file.

//===- ExtractAPI/API.cpp ---------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements the APIRecord and derived record structs,
/// and the APISet class.
///
//===----------------------------------------------------------------------===//
 
#include "clang/ExtractAPI/API.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"
#include <memory>
 
using namespace clang::extractapi;
using namespace llvm;
 
SymbolReference::SymbolReference(const APIRecord *R)
    : Name(R->Name), USR(R->USR), Record(R) {}
 
APIRecord *APIRecord::castFromRecordContext(const RecordContext *Ctx) {
  switch (Ctx->getKind()) {
#define RECORD_CONTEXT(CLASS, KIND)                                            \
  case KIND:                                                                   \
    return static_cast<CLASS *>(const_cast<RecordContext *>(Ctx));
#include "clang/ExtractAPI/APIRecords.inc"
  default:
    return nullptr;
    // llvm_unreachable("RecordContext derived class isn't propertly
    // implemented");
  }
}
 
RecordContext *APIRecord::castToRecordContext(const APIRecord *Record) {
  if (!Record)
    return nullptr;
  switch (Record->getKind()) {
#define RECORD_CONTEXT(CLASS, KIND)                                            \
  case KIND:                                                                   \
    return static_cast<CLASS *>(const_cast<APIRecord *>(Record));
#include "clang/ExtractAPI/APIRecords.inc"
  default:
    return nullptr;
    // llvm_unreachable("RecordContext derived class isn't propertly
    // implemented");
  }
}
 
bool RecordContext::IsWellFormed() const {
  // Check that First and Last are both null or both non-null.
  return (First == nullptr) == (Last == nullptr);
}
 
void RecordContext::stealRecordChain(RecordContext &Other) {
  assert(IsWellFormed());
  // Other's record chain is empty, nothing to do
  if (Other.First == nullptr && Other.Last == nullptr)
    return;
 
  // If we don't have an empty chain append Other's chain into ours.
  if (First)
    Last->NextInContext = Other.First;
  else
    First = Other.First;
 
  Last = Other.Last;
 
  for (auto *StolenRecord = Other.First; StolenRecord != nullptr;
       StolenRecord = StolenRecord->getNextInContext())
    StolenRecord->Parent = SymbolReference(cast<APIRecord>(this));
 
  // Delete Other's chain to ensure we don't accidentally traverse it.
  Other.First = nullptr;
  Other.Last = nullptr;
}
 
void RecordContext::addToRecordChain(APIRecord *Record) const {
  assert(IsWellFormed());
  if (!First) {
    First = Record;
    Last = Record;
    return;
  }
 
  Last->NextInContext = Record;
  Last = Record;
}
 
void RecordContext::removeFromRecordChain(APIRecord *Record) {
  APIRecord *Prev = nullptr;
  for (APIRecord *Curr = First; Curr != Record; Curr = Curr->NextInContext)
    Prev = Curr;
 
  if (Prev)
    Prev->NextInContext = Record->NextInContext;
  else
    First = Record->NextInContext;
 
  if (Last == Record)
    Last = Prev;
 
  Record->NextInContext = nullptr;
}
 
APIRecord *APISet::findRecordForUSR(StringRef USR) const {
  if (USR.empty())
    return nullptr;
 
  auto FindIt = USRBasedLookupTable.find(USR);
  if (FindIt != USRBasedLookupTable.end())
    return FindIt->getSecond().get();
 
  return nullptr;
}
 
StringRef APISet::copyString(StringRef String) {
  if (String.empty())
    return {};
 
  // No need to allocate memory and copy if the string has already been stored.
  if (Allocator.identifyObject(String.data()))
    return String;
 
  void *Ptr = Allocator.Allocate(String.size(), 1);
  memcpy(Ptr, String.data(), String.size());
  return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
}
 
SymbolReference APISet::createSymbolReference(StringRef Name, StringRef USR,
                                              StringRef Source) {
  return SymbolReference(copyString(Name), copyString(USR), copyString(Source));
}
 
void APISet::removeRecord(StringRef USR) {
  auto Result = USRBasedLookupTable.find(USR);
  if (Result != USRBasedLookupTable.end()) {
    auto *Record = Result->getSecond().get();
    auto &ParentReference = Record->Parent;
    auto *ParentRecord = const_cast<APIRecord *>(ParentReference.Record);
    if (!ParentRecord)
      ParentRecord = findRecordForUSR(ParentReference.USR);
 
    if (auto *ParentCtx = llvm::cast_if_present<RecordContext>(ParentRecord)) {
      ParentCtx->removeFromRecordChain(Record);
      if (auto *RecordAsCtx = llvm::dyn_cast<RecordContext>(Record))
        ParentCtx->stealRecordChain(*RecordAsCtx);
    } else {
      TopLevelRecords.erase(Record);
      if (auto *RecordAsCtx = llvm::dyn_cast<RecordContext>(Record)) {
        for (const auto *Child = RecordAsCtx->First; Child != nullptr;
             Child = Child->getNextInContext())
          TopLevelRecords.insert(Child);
      }
    }
    USRBasedLookupTable.erase(Result);
  }
}
 
void APISet::removeRecord(APIRecord *Record) { removeRecord(Record->USR); }
 
APIRecord::~APIRecord() {}
TagRecord::~TagRecord() {}
RecordRecord::~RecordRecord() {}
RecordFieldRecord::~RecordFieldRecord() {}
ObjCContainerRecord::~ObjCContainerRecord() {}
ObjCMethodRecord::~ObjCMethodRecord() {}
ObjCPropertyRecord::~ObjCPropertyRecord() {}
CXXMethodRecord::~CXXMethodRecord() {}
 
void GlobalFunctionRecord::anchor() {}
void GlobalVariableRecord::anchor() {}
void EnumConstantRecord::anchor() {}
void EnumRecord::anchor() {}
void StructFieldRecord::anchor() {}
void StructRecord::anchor() {}
void UnionFieldRecord::anchor() {}
void UnionRecord::anchor() {}
void CXXFieldRecord::anchor() {}
void CXXClassRecord::anchor() {}
void CXXConstructorRecord::anchor() {}
void CXXDestructorRecord::anchor() {}
void CXXInstanceMethodRecord::anchor() {}
void CXXStaticMethodRecord::anchor() {}
void ObjCInstancePropertyRecord::anchor() {}
void ObjCClassPropertyRecord::anchor() {}
void ObjCInstanceVariableRecord::anchor() {}
void ObjCInstanceMethodRecord::anchor() {}
void ObjCClassMethodRecord::anchor() {}
void ObjCCategoryRecord::anchor() {}
void ObjCInterfaceRecord::anchor() {}
void ObjCProtocolRecord::anchor() {}
void MacroDefinitionRecord::anchor() {}
void TypedefRecord::anchor() {}