1 //===- CXSourceLocation.cpp - CXSourceLocations APIs ------------*- C++ -*-===// 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 CXSourceLocations. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "CXSourceLocation.h" 14 #include "CIndexer.h" 15 #include "CLog.h" 16 #include "CXLoadedDiagnostic.h" 17 #include "CXString.h" 18 #include "CXTranslationUnit.h" 19 #include "clang/Basic/FileManager.h" 20 #include "clang/Frontend/ASTUnit.h" 21 #include "llvm/Support/Compiler.h" 22 #include "llvm/Support/Format.h" 23 24 using namespace clang; 25 using namespace clang::cxindex; 26 27 //===----------------------------------------------------------------------===// 28 // Internal predicates on CXSourceLocations. 29 //===----------------------------------------------------------------------===// 30 31 static bool isASTUnitSourceLocation(const CXSourceLocation &L) { 32 // If the lowest bit is clear then the first ptr_data entry is a SourceManager 33 // pointer, or the CXSourceLocation is a null location. 34 return ((uintptr_t)L.ptr_data[0] & 0x1) == 0; 35 } 36 37 //===----------------------------------------------------------------------===// 38 // Basic construction and comparison of CXSourceLocations and CXSourceRanges. 39 //===----------------------------------------------------------------------===// 40 41 CXSourceLocation clang_getNullLocation() { 42 CXSourceLocation Result = { { nullptr, nullptr }, 0 }; 43 return Result; 44 } 45 46 unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) { 47 return (loc1.ptr_data[0] == loc2.ptr_data[0] && 48 loc1.ptr_data[1] == loc2.ptr_data[1] && 49 loc1.int_data == loc2.int_data); 50 } 51 52 CXSourceRange clang_getNullRange() { 53 CXSourceRange Result = { { nullptr, nullptr }, 0, 0 }; 54 return Result; 55 } 56 57 CXSourceRange clang_getRange(CXSourceLocation begin, CXSourceLocation end) { 58 if (!isASTUnitSourceLocation(begin)) { 59 if (isASTUnitSourceLocation(end)) 60 return clang_getNullRange(); 61 CXSourceRange Result = { { begin.ptr_data[0], end.ptr_data[0] }, 0, 0 }; 62 return Result; 63 } 64 65 if (begin.ptr_data[0] != end.ptr_data[0] || 66 begin.ptr_data[1] != end.ptr_data[1]) 67 return clang_getNullRange(); 68 69 CXSourceRange Result = { { begin.ptr_data[0], begin.ptr_data[1] }, 70 begin.int_data, end.int_data }; 71 72 return Result; 73 } 74 75 unsigned clang_equalRanges(CXSourceRange range1, CXSourceRange range2) { 76 return range1.ptr_data[0] == range2.ptr_data[0] 77 && range1.ptr_data[1] == range2.ptr_data[1] 78 && range1.begin_int_data == range2.begin_int_data 79 && range1.end_int_data == range2.end_int_data; 80 } 81 82 int clang_Range_isNull(CXSourceRange range) { 83 return clang_equalRanges(range, clang_getNullRange()); 84 } 85 86 87 CXSourceLocation clang_getRangeStart(CXSourceRange range) { 88 // Special decoding for CXSourceLocations for CXLoadedDiagnostics. 89 if ((uintptr_t)range.ptr_data[0] & 0x1) { 90 CXSourceLocation Result = { { range.ptr_data[0], nullptr }, 0 }; 91 return Result; 92 } 93 94 CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] }, 95 range.begin_int_data }; 96 return Result; 97 } 98 99 CXSourceLocation clang_getRangeEnd(CXSourceRange range) { 100 // Special decoding for CXSourceLocations for CXLoadedDiagnostics. 101 if ((uintptr_t)range.ptr_data[0] & 0x1) { 102 CXSourceLocation Result = { { range.ptr_data[1], nullptr }, 0 }; 103 return Result; 104 } 105 106 CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] }, 107 range.end_int_data }; 108 return Result; 109 } 110 111 //===----------------------------------------------------------------------===// 112 // Getting CXSourceLocations and CXSourceRanges from a translation unit. 113 //===----------------------------------------------------------------------===// 114 115 CXSourceLocation clang_getLocation(CXTranslationUnit TU, 116 CXFile file, 117 unsigned line, 118 unsigned column) { 119 if (cxtu::isNotUsableTU(TU)) { 120 LOG_BAD_TU(TU); 121 return clang_getNullLocation(); 122 } 123 if (!file) 124 return clang_getNullLocation(); 125 if (line == 0 || column == 0) 126 return clang_getNullLocation(); 127 128 LogRef Log = Logger::make(__func__); 129 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 130 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 131 const FileEntry *File = static_cast<const FileEntry *>(file); 132 SourceLocation SLoc = CXXUnit->getLocation(File, line, column); 133 if (SLoc.isInvalid()) { 134 if (Log) 135 *Log << llvm::format("(\"%s\", %d, %d) = invalid", 136 File->getName().str().c_str(), line, column); 137 return clang_getNullLocation(); 138 } 139 140 CXSourceLocation CXLoc = 141 cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc); 142 if (Log) 143 *Log << llvm::format("(\"%s\", %d, %d) = ", File->getName().str().c_str(), 144 line, column) 145 << CXLoc; 146 147 return CXLoc; 148 } 149 150 CXSourceLocation clang_getLocationForOffset(CXTranslationUnit TU, 151 CXFile file, 152 unsigned offset) { 153 if (cxtu::isNotUsableTU(TU)) { 154 LOG_BAD_TU(TU); 155 return clang_getNullLocation(); 156 } 157 if (!file) 158 return clang_getNullLocation(); 159 160 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 161 162 SourceLocation SLoc 163 = CXXUnit->getLocation(static_cast<const FileEntry *>(file), offset); 164 165 if (SLoc.isInvalid()) 166 return clang_getNullLocation(); 167 168 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc); 169 } 170 171 //===----------------------------------------------------------------------===// 172 // Routines for expanding and manipulating CXSourceLocations, regardless 173 // of their origin. 174 //===----------------------------------------------------------------------===// 175 176 static void createNullLocation(CXFile *file, unsigned *line, 177 unsigned *column, unsigned *offset) { 178 if (file) 179 *file = nullptr; 180 if (line) 181 *line = 0; 182 if (column) 183 *column = 0; 184 if (offset) 185 *offset = 0; 186 } 187 188 static void createNullLocation(CXString *filename, unsigned *line, 189 unsigned *column, unsigned *offset = nullptr) { 190 if (filename) 191 *filename = cxstring::createEmpty(); 192 if (line) 193 *line = 0; 194 if (column) 195 *column = 0; 196 if (offset) 197 *offset = 0; 198 } 199 200 int clang_Location_isInSystemHeader(CXSourceLocation location) { 201 const SourceLocation Loc = 202 SourceLocation::getFromRawEncoding(location.int_data); 203 if (Loc.isInvalid()) 204 return 0; 205 206 const SourceManager &SM = 207 *static_cast<const SourceManager*>(location.ptr_data[0]); 208 return SM.isInSystemHeader(Loc); 209 } 210 211 int clang_Location_isFromMainFile(CXSourceLocation location) { 212 const SourceLocation Loc = 213 SourceLocation::getFromRawEncoding(location.int_data); 214 if (Loc.isInvalid()) 215 return 0; 216 217 const SourceManager &SM = 218 *static_cast<const SourceManager*>(location.ptr_data[0]); 219 return SM.isWrittenInMainFile(Loc); 220 } 221 222 void clang_getExpansionLocation(CXSourceLocation location, 223 CXFile *file, 224 unsigned *line, 225 unsigned *column, 226 unsigned *offset) { 227 if (!isASTUnitSourceLocation(location)) { 228 CXLoadedDiagnostic::decodeLocation(location, file, line, column, offset); 229 return; 230 } 231 232 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 233 234 if (!location.ptr_data[0] || Loc.isInvalid()) { 235 createNullLocation(file, line, column, offset); 236 return; 237 } 238 239 const SourceManager &SM = 240 *static_cast<const SourceManager*>(location.ptr_data[0]); 241 SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc); 242 243 // Check that the FileID is invalid on the expansion location. 244 // This can manifest in invalid code. 245 FileID fileID = SM.getFileID(ExpansionLoc); 246 bool Invalid = false; 247 const SrcMgr::SLocEntry &sloc = SM.getSLocEntry(fileID, &Invalid); 248 if (Invalid || !sloc.isFile()) { 249 createNullLocation(file, line, column, offset); 250 return; 251 } 252 253 if (file) 254 *file = const_cast<FileEntry *>(SM.getFileEntryForSLocEntry(sloc)); 255 if (line) 256 *line = SM.getExpansionLineNumber(ExpansionLoc); 257 if (column) 258 *column = SM.getExpansionColumnNumber(ExpansionLoc); 259 if (offset) 260 *offset = SM.getDecomposedLoc(ExpansionLoc).second; 261 } 262 263 void clang_getPresumedLocation(CXSourceLocation location, 264 CXString *filename, 265 unsigned *line, 266 unsigned *column) { 267 if (!isASTUnitSourceLocation(location)) { 268 // Other SourceLocation implementations do not support presumed locations 269 // at this time. 270 createNullLocation(filename, line, column); 271 return; 272 } 273 274 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 275 276 if (!location.ptr_data[0] || Loc.isInvalid()) { 277 createNullLocation(filename, line, column); 278 return; 279 } 280 281 const SourceManager &SM = 282 *static_cast<const SourceManager *>(location.ptr_data[0]); 283 PresumedLoc PreLoc = SM.getPresumedLoc(Loc); 284 if (PreLoc.isInvalid()) { 285 createNullLocation(filename, line, column); 286 return; 287 } 288 289 if (filename) *filename = cxstring::createRef(PreLoc.getFilename()); 290 if (line) *line = PreLoc.getLine(); 291 if (column) *column = PreLoc.getColumn(); 292 } 293 294 void clang_getInstantiationLocation(CXSourceLocation location, 295 CXFile *file, 296 unsigned *line, 297 unsigned *column, 298 unsigned *offset) { 299 // Redirect to new API. 300 clang_getExpansionLocation(location, file, line, column, offset); 301 } 302 303 void clang_getSpellingLocation(CXSourceLocation location, 304 CXFile *file, 305 unsigned *line, 306 unsigned *column, 307 unsigned *offset) { 308 if (!isASTUnitSourceLocation(location)) { 309 CXLoadedDiagnostic::decodeLocation(location, file, line, 310 column, offset); 311 return; 312 } 313 314 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 315 316 if (!location.ptr_data[0] || Loc.isInvalid()) 317 return createNullLocation(file, line, column, offset); 318 319 const SourceManager &SM = 320 *static_cast<const SourceManager*>(location.ptr_data[0]); 321 // FIXME: This should call SourceManager::getSpellingLoc(). 322 SourceLocation SpellLoc = SM.getFileLoc(Loc); 323 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellLoc); 324 FileID FID = LocInfo.first; 325 unsigned FileOffset = LocInfo.second; 326 327 if (FID.isInvalid()) 328 return createNullLocation(file, line, column, offset); 329 330 if (file) 331 *file = const_cast<FileEntry *>(SM.getFileEntryForID(FID)); 332 if (line) 333 *line = SM.getLineNumber(FID, FileOffset); 334 if (column) 335 *column = SM.getColumnNumber(FID, FileOffset); 336 if (offset) 337 *offset = FileOffset; 338 } 339 340 void clang_getFileLocation(CXSourceLocation location, 341 CXFile *file, 342 unsigned *line, 343 unsigned *column, 344 unsigned *offset) { 345 if (!isASTUnitSourceLocation(location)) { 346 CXLoadedDiagnostic::decodeLocation(location, file, line, 347 column, offset); 348 return; 349 } 350 351 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data); 352 353 if (!location.ptr_data[0] || Loc.isInvalid()) 354 return createNullLocation(file, line, column, offset); 355 356 const SourceManager &SM = 357 *static_cast<const SourceManager*>(location.ptr_data[0]); 358 SourceLocation FileLoc = SM.getFileLoc(Loc); 359 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(FileLoc); 360 FileID FID = LocInfo.first; 361 unsigned FileOffset = LocInfo.second; 362 363 if (FID.isInvalid()) 364 return createNullLocation(file, line, column, offset); 365 366 if (file) 367 *file = const_cast<FileEntry *>(SM.getFileEntryForID(FID)); 368 if (line) 369 *line = SM.getLineNumber(FID, FileOffset); 370 if (column) 371 *column = SM.getColumnNumber(FID, FileOffset); 372 if (offset) 373 *offset = FileOffset; 374 } 375
Indexes created Tue Feb 24 08:35:24 UTC 2026