CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
if (!CTUnit)
- return createCXString("");
+ return cxstring::createEmpty();
ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
return createCXString(CXXUnit->getOriginalSourceFileName(), true);
static CXString getDeclSpelling(const Decl *D) {
if (!D)
- return createCXString("");
+ return cxstring::createEmpty();
const NamedDecl *ND = dyn_cast<NamedDecl>(D);
if (!ND) {
if (Module *Mod = ImportD->getImportedModule())
return createCXString(Mod->getFullModuleName());
- return createCXString("");
+ return cxstring::createEmpty();
}
if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
return createCXString(CIMP->getIdentifier()->getNameStart());
if (isa<UsingDirectiveDecl>(D))
- return createCXString("");
+ return cxstring::createEmpty();
SmallString<1024> S;
llvm::raw_svector_ostream os(S);
if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
return createCXString(ND->getNameAsString());
- return createCXString("");
+ return cxstring::createEmpty();
}
if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
return createCXString(E->getName().getAsString());
OverloadedTemplateStorage *Ovl
= Storage.get<OverloadedTemplateStorage*>();
if (Ovl->size() == 0)
- return createCXString("");
+ return cxstring::createEmpty();
return createCXString((*Ovl->begin())->getNameAsString());
}
const Decl *D = getDeclFromExpr(getCursorExpr(C));
if (D)
return getDeclSpelling(D);
- return createCXString("");
+ return cxstring::createEmpty();
}
if (clang_isStatement(C.kind)) {
if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
return createCXString(Label->getName());
- return createCXString("");
+ return cxstring::createEmpty();
}
if (C.kind == CXCursor_MacroExpansion)
return createCXString(AA->getLabel());
}
- return createCXString("");
+ return cxstring::createEmpty();
}
CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C,
const Decl *D = getCursorDecl(C);
if (!D)
- return createCXString("");
+ return cxstring::createEmpty();
PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
// deconstructing the source location.
ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
if (!CXXUnit)
- return createCXString("");
+ return cxstring::createEmpty();
SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
std::pair<FileID, unsigned> LocInfo
StringRef Buffer
= CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
if (Invalid)
- return createCXString("");
+ return cxstring::createEmpty();
return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
}
if (always_deprecated)
*always_deprecated = 0;
if (deprecated_message)
- *deprecated_message = cxstring::createCXString("", /*DupString=*/false);
+ *deprecated_message = cxstring::createEmpty();
if (always_unavailable)
*always_unavailable = 0;
if (unavailable_message)
- *unavailable_message = cxstring::createCXString("", /*DupString=*/false);
+ *unavailable_message = cxstring::createEmpty();
if (!clang_isDeclaration(cursor.kind))
return 0;
CXString clang_Module_getName(CXModule CXMod) {
if (!CXMod)
- return createCXString("");
+ return cxstring::createEmpty();
Module *Mod = static_cast<Module*>(CXMod);
return createCXString(Mod->Name);
}
CXString clang_Module_getFullName(CXModule CXMod) {
if (!CXMod)
- return createCXString("");
+ return cxstring::createEmpty();
Module *Mod = static_cast<Module*>(CXMod);
return createCXString(Mod->getFullModuleName());
}
case CodeCompletionString::CK_Optional:
// Note: treated as an empty text block.
- return createCXString("");
+ return cxstring::createEmpty();
}
llvm_unreachable("Invalid CodeCompletionString Kind!");
CodeCompletionAllocator(new clang::GlobalCodeCompletionAllocator),
Contexts(CXCompletionContext_Unknown),
ContainerKind(CXCursor_InvalidCode),
- ContainerUSR(createCXString("")),
+ ContainerUSR(cxstring::createEmpty()),
ContainerIsIncomplete(1)
{
if (getenv("LIBCLANG_OBJTRACKING")) {
}
else {
AllocatedResults.ContainerKind = CXCursor_InvalidCode;
- AllocatedResults.ContainerUSR = createCXString("");
+ AllocatedResults.ContainerUSR = cxstring::createEmpty();
AllocatedResults.ContainerIsIncomplete = 1;
}
}
AllocatedCXCodeCompleteResults *Results =
static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
if (!Results)
- return createCXString("");
+ return cxstring::createEmpty();
return createCXString(clang_getCString(Results->ContainerUSR));
}
AllocatedCXCodeCompleteResults *Results =
static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
if (!Results)
- return createCXString("");
+ return cxstring::createEmpty();
return createCXString(Results->Selector);
}
CXString getDiagnosticOption(CXString *Disable) const {
if (Disable)
- *Disable = createCXString("", false);
- return createCXString("", false);
+ *Disable = cxstring::createEmpty();
+ return cxstring::createEmpty();
}
unsigned getCategory() const { return 0; }
- CXString getCategoryText() const { return createCXString(""); }
+ CXString getCategoryText() const { return cxstring::createEmpty(); }
unsigned getNumRanges() const { return 0; }
CXSourceRange getRange(unsigned Range) const { return clang_getNullRange(); }
CXString getFixIt(unsigned FixIt, CXSourceRange *ReplacementRange) const {
if (ReplacementRange)
*ReplacementRange = clang_getNullRange();
- return createCXString("", false);
+ return cxstring::createEmpty();
}
};
CXString clang_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options) {
if (!Diagnostic)
- return createCXString("");
+ return cxstring::createEmpty();
CXDiagnosticSeverity Severity = clang_getDiagnosticSeverity(Diagnostic);
CXString clang_getDiagnosticSpelling(CXDiagnostic Diag) {
if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
return D->getSpelling();
- return createCXString("");
+ return cxstring::createEmpty();
}
CXString clang_getDiagnosticOption(CXDiagnostic Diag, CXString *Disable) {
if (Disable)
- *Disable = createCXString("");
+ *Disable = cxstring::createEmpty();
if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
return D->getDiagnosticOption(Disable);
- return createCXString("");
+ return cxstring::createEmpty();
}
unsigned clang_getDiagnosticCategory(CXDiagnostic Diag) {
CXString clang_getDiagnosticCategoryText(CXDiagnostic Diag) {
if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
return D->getCategoryText();
- return createCXString("");
+ return cxstring::createEmpty();
}
unsigned clang_getDiagnosticNumRanges(CXDiagnostic Diag) {
if (!D || FixIt >= D->getNumFixIts()) {
if (ReplacementRange)
*ReplacementRange = clang_getNullRange();
- return createCXString("");
+ return cxstring::createEmpty();
}
return D->getFixIt(FixIt, ReplacementRange);
}
if (clang_isDeclaration(K)) {
const Decl *D = cxcursor::getCursorDecl(C);
if (!D)
- return createCXString("");
+ return cxstring::createEmpty();
CXTranslationUnit TU = cxcursor::getCursorTU(C);
if (!TU)
- return createCXString("");
+ return cxstring::createEmpty();
CXStringBuf *buf = cxstring::getCXStringBuf(TU);
if (!buf)
- return createCXString("");
+ return cxstring::createEmpty();
bool Ignore = cxcursor::getDeclCursorUSR(D, buf->Data);
if (Ignore) {
buf->dispose();
- return createCXString("");
+ return cxstring::createEmpty();
}
// Return the C-string, but don't make a copy since it is already in
if (K == CXCursor_MacroDefinition) {
CXTranslationUnit TU = cxcursor::getCursorTU(C);
if (!TU)
- return createCXString("");
+ return cxstring::createEmpty();
CXStringBuf *buf = cxstring::getCXStringBuf(TU);
if (!buf)
- return createCXString("");
+ return cxstring::createEmpty();
{
USRGenerator UG(&cxcursor::getCursorASTUnit(C)->getASTContext(),
return createCXString(buf);
}
- return createCXString("");
+ return cxstring::createEmpty();
}
CXString clang_constructUSR_ObjCIvar(const char *name, CXString classUSR) {
CXString CXLoadedDiagnostic::getDiagnosticOption(CXString *Disable) const {
if (DiagOption.empty())
- return createCXString("");
+ return cxstring::createEmpty();
// FIXME: possibly refactor with logic in CXStoredDiagnostic.
if (Disable)
if (error)
*error = CXLoadDiag_None;
if (errorString)
- *errorString = createCXString("");
+ *errorString = cxstring::createEmpty();
}
CXDiagnosticSet load(const char *file);
static void createNullLocation(CXString *filename, unsigned *line,
unsigned *column, unsigned *offset = 0) {
if (filename)
- *filename = createCXString("");
+ *filename = cxstring::createEmpty();
if (line)
*line = 0;
if (column)
return createCXString("-ferror-limit=");
}
- return createCXString("");
+ return cxstring::createEmpty();
}
unsigned CXStoredDiagnostic::getCategory() const {
// Basic generation of CXStrings.
//===----------------------------------------------------------------------===//
+CXString cxstring::createEmpty() {
+ CXString Str;
+ Str.data = "";
+ Str.private_flags = CXS_Unmanaged;
+ return Str;
+}
+
CXString cxstring::createNull() {
CXString Str;
Str.data = 0;
struct CXStringBuf;
+/// \brief Create a CXString object for an empty "" string.
+CXString createEmpty();
+
/// \brief Create a CXString object for an NULL string.
CXString createNull();
CXString clang_getDeclObjCTypeEncoding(CXCursor C) {
if (!clang_isDeclaration(C.kind))
- return cxstring::createCXString("");
+ return cxstring::createEmpty();
const Decl *D = static_cast<const Decl*>(C.data[0]);
ASTUnit *AU = cxcursor::getCursorASTUnit(C);