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
isASTUnitSourceLocation(const CXSourceLocation & L)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
clang_getNullLocation()41 CXSourceLocation clang_getNullLocation() {
42 CXSourceLocation Result = { { nullptr, nullptr }, 0 };
43 return Result;
44 }
45
clang_equalLocations(CXSourceLocation loc1,CXSourceLocation loc2)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
clang_getNullRange()52 CXSourceRange clang_getNullRange() {
53 CXSourceRange Result = { { nullptr, nullptr }, 0, 0 };
54 return Result;
55 }
56
clang_getRange(CXSourceLocation begin,CXSourceLocation end)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
clang_equalRanges(CXSourceRange range1,CXSourceRange range2)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
clang_Range_isNull(CXSourceRange range)82 int clang_Range_isNull(CXSourceRange range) {
83 return clang_equalRanges(range, clang_getNullRange());
84 }
85
86
clang_getRangeStart(CXSourceRange range)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
clang_getRangeEnd(CXSourceRange range)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
clang_getLocation(CXTranslationUnit TU,CXFile file,unsigned line,unsigned column)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
clang_getLocationForOffset(CXTranslationUnit TU,CXFile file,unsigned offset)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
createNullLocation(CXFile * file,unsigned * line,unsigned * column,unsigned * offset)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
createNullLocation(CXString * filename,unsigned * line,unsigned * column,unsigned * offset=nullptr)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
clang_Location_isInSystemHeader(CXSourceLocation location)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
clang_Location_isFromMainFile(CXSourceLocation location)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
clang_getExpansionLocation(CXSourceLocation location,CXFile * file,unsigned * line,unsigned * column,unsigned * offset)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
clang_getPresumedLocation(CXSourceLocation location,CXString * filename,unsigned * line,unsigned * column)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
clang_getInstantiationLocation(CXSourceLocation location,CXFile * file,unsigned * line,unsigned * column,unsigned * offset)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
clang_getSpellingLocation(CXSourceLocation location,CXFile * file,unsigned * line,unsigned * column,unsigned * offset)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
clang_getFileLocation(CXSourceLocation location,CXFile * file,unsigned * line,unsigned * column,unsigned * offset)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