| 1 |
//===- CXString.cpp - Routines for manipulating CXStrings -----------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file defines routines for manipulating CXStrings. It should be the |
| 10 |
// only file that has internal knowledge of the encoding of the data in |
| 11 |
// CXStrings. |
| 12 |
// |
| 13 |
//===----------------------------------------------------------------------===// |
| 14 |
|
| 15 |
#include "CXString.h" |
| 16 |
#include "CXTranslationUnit.h" |
| 17 |
#include "clang-c/Index.h" |
| 18 |
#include "clang/Frontend/ASTUnit.h" |
| 19 |
#include "llvm/Support/ErrorHandling.h" |
| 20 |
|
| 21 |
using namespace clang; |
| 22 |
|
| 23 |
/// Describes the kind of underlying data in CXString. |
| 24 |
enum CXStringFlag { |
| 25 |
/// CXString contains a 'const char *' that it doesn't own. |
| 26 |
CXS_Unmanaged, |
| 27 |
|
| 28 |
/// CXString contains a 'const char *' that it allocated with malloc(). |
| 29 |
CXS_Malloc, |
| 30 |
|
| 31 |
/// CXString contains a CXStringBuf that needs to be returned to the |
| 32 |
/// CXStringPool. |
| 33 |
CXS_StringBuf |
| 34 |
}; |
| 35 |
|
| 36 |
namespace clang { |
| 37 |
namespace cxstring { |
| 38 |
|
| 39 |
//===----------------------------------------------------------------------===// |
| 40 |
// Basic generation of CXStrings. |
| 41 |
//===----------------------------------------------------------------------===// |
| 42 |
|
| 43 |
CXString createEmpty() { |
| 44 |
CXString Str; |
| 45 |
Str.data = ""; |
| 46 |
Str.private_flags = CXS_Unmanaged; |
| 47 |
return Str; |
| 48 |
} |
| 49 |
|
| 50 |
CXString createNull() { |
| 51 |
CXString Str; |
| 52 |
Str.data = nullptr; |
| 53 |
Str.private_flags = CXS_Unmanaged; |
| 54 |
return Str; |
| 55 |
} |
| 56 |
|
| 57 |
CXString createRef(const char *String) { |
| 58 |
if (String && String[0] == '\0') |
| 59 |
return createEmpty(); |
| 60 |
|
| 61 |
CXString Str; |
| 62 |
Str.data = String; |
| 63 |
Str.private_flags = CXS_Unmanaged; |
| 64 |
return Str; |
| 65 |
} |
| 66 |
|
| 67 |
CXString createDup(const char *String) { |
| 68 |
if (!String) |
| 69 |
return createNull(); |
| 70 |
|
| 71 |
if (String[0] == '\0') |
| 72 |
return createEmpty(); |
| 73 |
|
| 74 |
CXString Str; |
| 75 |
Str.data = strdup(String); |
| 76 |
Str.private_flags = CXS_Malloc; |
| 77 |
return Str; |
| 78 |
} |
| 79 |
|
| 80 |
CXString createRef(StringRef String) { |
| 81 |
if (!String.data()) |
| 82 |
return createNull(); |
| 83 |
|
| 84 |
// If the string is empty, it might point to a position in another string |
| 85 |
// while having zero length. Make sure we don't create a reference to the |
| 86 |
// larger string. |
| 87 |
if (String.empty()) |
| 88 |
return createEmpty(); |
| 89 |
|
| 90 |
// If the string is not nul-terminated, we have to make a copy. |
| 91 |
|
| 92 |
// FIXME: This is doing a one past end read, and should be removed! For memory |
| 93 |
// we don't manage, the API string can become unterminated at any time outside |
| 94 |
// our control. |
| 95 |
|
| 96 |
if (String.data()[String.size()] != 0) |
| 97 |
return createDup(String); |
| 98 |
|
| 99 |
CXString Result; |
| 100 |
Result.data = String.data(); |
| 101 |
Result.private_flags = (unsigned) CXS_Unmanaged; |
| 102 |
return Result; |
| 103 |
} |
| 104 |
|
| 105 |
CXString createDup(StringRef String) { |
| 106 |
CXString Result; |
| 107 |
char *Spelling = static_cast<char *>(llvm::safe_malloc(String.size() + 1)); |
| 108 |
memmove(Spelling, String.data(), String.size()); |
| 109 |
Spelling[String.size()] = 0; |
| 110 |
Result.data = Spelling; |
| 111 |
Result.private_flags = (unsigned) CXS_Malloc; |
| 112 |
return Result; |
| 113 |
} |
| 114 |
|
| 115 |
CXString createCXString(CXStringBuf *buf) { |
| 116 |
CXString Str; |
| 117 |
Str.data = buf; |
| 118 |
Str.private_flags = (unsigned) CXS_StringBuf; |
| 119 |
return Str; |
| 120 |
} |
| 121 |
|
| 122 |
CXStringSet *createSet(const std::vector<std::string> &Strings) { |
| 123 |
CXStringSet *Set = new CXStringSet; |
| 124 |
Set->Count = Strings.size(); |
| 125 |
Set->Strings = new CXString[Set->Count]; |
| 126 |
for (unsigned SI = 0, SE = Set->Count; SI < SE; ++SI) |
| 127 |
Set->Strings[SI] = createDup(Strings[SI]); |
| 128 |
return Set; |
| 129 |
} |
| 130 |
|
| 131 |
|
| 132 |
//===----------------------------------------------------------------------===// |
| 133 |
// String pools. |
| 134 |
//===----------------------------------------------------------------------===// |
| 135 |
|
| 136 |
CXStringPool::~CXStringPool() { |
| 137 |
for (std::vector<CXStringBuf *>::iterator I = Pool.begin(), E = Pool.end(); |
| 138 |
I != E; ++I) { |
| 139 |
delete *I; |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
CXStringBuf *CXStringPool::getCXStringBuf(CXTranslationUnit TU) { |
| 144 |
if (Pool.empty()) |
| 145 |
return new CXStringBuf(TU); |
| 146 |
|
| 147 |
CXStringBuf *Buf = Pool.back(); |
| 148 |
Buf->Data.clear(); |
| 149 |
Pool.pop_back(); |
| 150 |
return Buf; |
| 151 |
} |
| 152 |
|
| 153 |
CXStringBuf *getCXStringBuf(CXTranslationUnit TU) { |
| 154 |
return TU->StringPool->getCXStringBuf(TU); |
| 155 |
} |
| 156 |
|
| 157 |
void CXStringBuf::dispose() { |
| 158 |
TU->StringPool->Pool.push_back(this); |
| 159 |
} |
| 160 |
|
| 161 |
bool isManagedByPool(CXString str) { |
| 162 |
return ((CXStringFlag) str.private_flags) == CXS_StringBuf; |
| 163 |
} |
| 164 |
|
| 165 |
} // end namespace cxstring |
| 166 |
} // end namespace clang |
| 167 |
|
| 168 |
//===----------------------------------------------------------------------===// |
| 169 |
// libClang public APIs. |
| 170 |
//===----------------------------------------------------------------------===// |
| 171 |
|
| 172 |
const char *clang_getCString(CXString string) { |
| 173 |
if (string.private_flags == (unsigned) CXS_StringBuf) { |
| 174 |
return static_cast<const cxstring::CXStringBuf *>(string.data)->Data.data(); |
| 175 |
} |
| 176 |
return static_cast<const char *>(string.data); |
| 177 |
} |
| 178 |
|
| 179 |
void clang_disposeString(CXString string) { |
| 180 |
switch ((CXStringFlag) string.private_flags) { |
| 181 |
case CXS_Unmanaged: |
| 182 |
break; |
| 183 |
case CXS_Malloc: |
| 184 |
if (string.data) |
| 185 |
free(const_cast<void *>(string.data)); |
| 186 |
break; |
| 187 |
case CXS_StringBuf: |
| 188 |
static_cast<cxstring::CXStringBuf *>( |
| 189 |
const_cast<void *>(string.data))->dispose(); |
| 190 |
break; |
| 191 |
} |
| 192 |
} |
| 193 |
|
| 194 |
void clang_disposeStringSet(CXStringSet *set) { |
| 195 |
for (unsigned SI = 0, SE = set->Count; SI < SE; ++SI) |
| 196 |
clang_disposeString(set->Strings[SI]); |
| 197 |
delete[] set->Strings; |
| 198 |
delete set; |
| 199 |
} |
| 200 |
|