for (const_diag_iterator I = diag_begin, E = diag_end; I != E; ++I)
fprintf(stderr, " Line %d: %s\n",
- SourceMgr.getLogicalLineNumber(I->first),
+ SourceMgr.getInstantiationLineNumber(I->first),
I->second.c_str());
return true;
DiagList DiffList;
for (const_diag_iterator I = d1_begin, E = d1_end; I != E; ++I) {
- unsigned LineNo1 = SourceMgr.getLogicalLineNumber(I->first);
+ unsigned LineNo1 = SourceMgr.getInstantiationLineNumber(I->first);
const std::string &Diag1 = I->second;
bool Found = false;
for (const_diag_iterator II = d2_begin, IE = d2_end; II != IE; ++II) {
- unsigned LineNo2 = SourceMgr.getLogicalLineNumber(II->first);
+ unsigned LineNo2 = SourceMgr.getInstantiationLineNumber(II->first);
if (LineNo1 != LineNo2) continue;
const std::string &Diag2 = II->second;
/// #line directive. This returns false if already at the specified line, true
/// if some newlines were emitted.
bool PrintPPOutputPPCallbacks::MoveToLine(SourceLocation Loc) {
- unsigned LineNo = PP.getSourceManager().getLogicalLineNumber(Loc);
+ unsigned LineNo = PP.getSourceManager().getInstantiationLineNumber(Loc);
if (DisableLineMarkers) {
if (LineNo == CurLine) return false;
if (LineNo-CurLine == 1)
OS << '\n';
else if (LineNo == CurLine)
- return false; // Spelling line moved, but logical line didn't.
+ return false; // Spelling line moved, but instantiation line didn't.
else {
const char *NewLines = "\n\n\n\n\n\n\n\n";
OS.write(NewLines, LineNo-CurLine);
// strange behavior.
}
- Loc = SourceMgr.getLogicalLoc(Loc);
+ Loc = SourceMgr.getInstantiationLoc(Loc);
CurLine = SourceMgr.getLineNumber(Loc);
if (DisableLineMarkers) return;
/// is called for the first token on each new line. If this really is the start
/// of a new logical line, handle it and return true, otherwise return false.
/// This may not be the start of a logical line because the "start of line"
-/// marker is set for spelling lines, not logical ones.
+/// marker is set for spelling lines, not instantiation ones.
bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) {
// Figure out what line we went to and insert the appropriate number of
// newline characters.
// Print out space characters so that the first token on a line is
// indented for easy reading.
const SourceManager &SourceMgr = PP.getSourceManager();
- unsigned ColNo = SourceMgr.getLogicalColumnNumber(Tok.getLocation());
+ unsigned ColNo = SourceMgr.getInstantiationColumnNumber(Tok.getLocation());
// This hack prevents stuff like:
// #define HASH #
// #included file. If the former, rewrite it now. If the later, check to see
// if we rewrote the #include/#import.
SourceLocation Loc = D->getLocation();
- Loc = SM->getLogicalLoc(Loc);
+ Loc = SM->getInstantiationLoc(Loc);
// If this is for a builtin, ignore it.
if (Loc.isInvalid()) return;
// that aren't in the preprocessed view, we have macros that expand to no
// tokens, or macro arguments etc.
while (RawTok.isNot(tok::eof) || PPTok.isNot(tok::eof)) {
- SourceLocation PPLoc = SM.getLogicalLoc(PPTok.getLocation());
+ SourceLocation PPLoc = SM.getInstantiationLoc(PPTok.getLocation());
// If PPTok is from a different source file, ignore it.
if (!SM.isFromMainFile(PPLoc)) {
while (PPOffs < RawOffs) {
Expansion += ' ' + PP.getSpelling(PPTok);
PP.Lex(PPTok);
- PPLoc = SM.getLogicalLoc(PPTok.getLocation());
+ PPLoc = SM.getInstantiationLoc(PPTok.getLocation());
PPOffs = SM.getFullFilePos(PPLoc);
}
Expansion += ' ';
// #included file. If the former, rewrite it now. If the later, check to see
// if we rewrote the #include/#import.
SourceLocation Loc = D->getLocation();
- Loc = SM->getLogicalLoc(Loc);
+ Loc = SM->getInstantiationLoc(Loc);
// If this is for a builtin, ignore it.
if (Loc.isInvalid()) return;
return *SrcMgr;
}
- FullSourceLoc getLogicalLoc() const;
+ FullSourceLoc getInstantiationLoc() const;
FullSourceLoc getSpellingLoc() const;
FullSourceLoc getIncludeLoc() const;
unsigned getLineNumber() const;
unsigned getColumnNumber() const;
- unsigned getLogicalLineNumber() const;
- unsigned getLogicalColumnNumber() const;
+ unsigned getInstantiationLineNumber() const;
+ unsigned getInstantiationColumnNumber() const;
unsigned getSpellingLineNumber() const;
unsigned getSpellingColumnNumber() const;
/// is a byte offset from the start of this.
///
/// FileID's are used to compute the location of a character in memory as well
- /// as the logical source location, which can be differ from the spelling
- /// location. It is different when #line's are active or when macros have
- /// been expanded.
+ /// as the instantiation source location, which can be differ from the
+ /// spelling location. It is different when #line's are active or when macros
+ /// have been expanded.
///
/// Each FileID has include stack information, indicating where it came from.
/// For the primary translation unit, it comes from SourceLocation() aka 0.
/// files and assigns unique FileID's for each unique #include chain.
///
/// The SourceManager can be queried for information about SourceLocation
-/// objects, turning them into either spelling or logical locations. Spelling
-/// locations represent where the bytes corresponding to a token came from and
-/// logical locations represent where the location is in the user's view. In
-/// the case of a macro expansion, for example, the spelling location indicates
-/// where the expanded token came from and the logical location specifies where
-/// it was expanded. Logical locations are also influenced by #line directives,
-/// etc.
+/// objects, turning them into either spelling or instantiation locations.
+/// Spelling locations represent where the bytes corresponding to a token came
+/// from and instantiation locations represent where the location is in the
+/// user's view. In the case of a macro expansion, for example, the spelling
+/// location indicates where the expanded token came from and the instantiation
+/// location specifies where it was expanded.
class SourceManager {
/// FileInfos - Memoized information about all of the files tracked by this
/// SourceManager. This set allows us to merge ContentCache entries based
/// SourceLocation. If this is a macro expansion, this transparently figures
/// out which file includes the file being expanded into.
SourceLocation getIncludeLoc(SourceLocation ID) const {
- return getFIDInfo(getLogicalLoc(ID).getFileID())->getIncludeLoc();
+ return getFIDInfo(getInstantiationLoc(ID).getFileID())->getIncludeLoc();
}
/// getCharacterData - Return a pointer to the start of the specified location
/// getColumnNumber - Return the column # for the specified file position.
/// This is significantly cheaper to compute than the line number. This
/// returns zero if the column number isn't known. This may only be called on
- /// a file sloc, so you must choose a spelling or logical location before
- /// calling this method.
+ /// a file sloc, so you must choose a spelling or instantiation location
+ /// before calling this method.
unsigned getColumnNumber(SourceLocation Loc) const;
unsigned getSpellingColumnNumber(SourceLocation Loc) const {
return getColumnNumber(getSpellingLoc(Loc));
}
- unsigned getLogicalColumnNumber(SourceLocation Loc) const {
- return getColumnNumber(getLogicalLoc(Loc));
+ unsigned getInstantiationColumnNumber(SourceLocation Loc) const {
+ return getColumnNumber(getInstantiationLoc(Loc));
}
/// about to emit a diagnostic.
unsigned getLineNumber(SourceLocation Loc) const;
- unsigned getLogicalLineNumber(SourceLocation Loc) const {
- return getLineNumber(getLogicalLoc(Loc));
+ unsigned getInstantiationLineNumber(SourceLocation Loc) const {
+ return getLineNumber(getInstantiationLoc(Loc));
}
unsigned getSpellingLineNumber(SourceLocation Loc) const {
return getLineNumber(getSpellingLoc(Loc));
/// etc.
const char *getSourceName(SourceLocation Loc) const;
- /// Given a SourceLocation object, return the logical location referenced by
- /// the ID. This logical location is subject to #line directives, etc.
- SourceLocation getLogicalLoc(SourceLocation Loc) const {
+ /// Given a SourceLocation object, return the instantiation location
+ /// referenced by the ID.
+ SourceLocation getInstantiationLoc(SourceLocation Loc) const {
// File locations work.
if (Loc.isFileID()) return Loc;
/// getFullFilePos - This (efficient) method returns the offset from the start
/// of the file that the specified spelling SourceLocation represents. This
- /// returns the location of the actual character data, not the logical file
+ /// returns the location of the actual character data, not the instantiation
/// position.
unsigned getFullFilePos(SourceLocation SpellingLoc) const {
return getDecomposedFileLoc(SpellingLoc).second;
os << ' ';
os << "Execution continues on line "
- << SMgr.getLogicalLineNumber(S->getLocStart()) << '.';
+ << SMgr.getInstantiationLineNumber(S->getLocStart()) << '.';
}
std::ostringstream os;
os << "Control jumps to line "
- << SMgr.getLogicalLineNumber(S->getLocStart()) << ".\n";
+ << SMgr.getInstantiationLineNumber(S->getLocStart()) << ".\n";
PD.push_front(new PathDiagnosticPiece(L, os.str()));
break;
if (Stmt* S = Dst->getLabel())
switch (S->getStmtClass()) {
-
- default: {
+ default:
os << "No cases match in the switch statement. "
"Control jumps to line "
- << SMgr.getLogicalLineNumber(S->getLocStart()) << ".\n";
- break;
- }
-
- case Stmt::DefaultStmtClass: {
+ << SMgr.getInstantiationLineNumber(S->getLocStart()) << ".\n";
+ break;
+ case Stmt::DefaultStmtClass:
os << "Control jumps to the 'default' case at line "
- << SMgr.getLogicalLineNumber(S->getLocStart()) << ".\n";
-
+ << SMgr.getInstantiationLineNumber(S->getLocStart()) << ".\n";
break;
- }
case Stmt::CaseStmtClass: {
-
os << "Control jumps to 'case ";
CaseStmt* Case = cast<CaseStmt>(S);
}
os << ":' at line "
- << SMgr.getLogicalLineNumber(S->getLocStart()) << ".\n";
+ << SMgr.getInstantiationLineNumber(S->getLocStart()) << ".\n";
break;
-
}
}
else {
Stmt* FirstStmt = cast<PostStmt>(AllocNode->getLocation()).getStmt();
SourceManager& SMgr = BR.getContext().getSourceManager();
- unsigned AllocLine = SMgr.getLogicalLineNumber(FirstStmt->getLocStart());
+ unsigned AllocLine =SMgr.getInstantiationLineNumber(FirstStmt->getLocStart());
// Get the leak site. We may have multiple ExplodedNodes (one with the
// leak) that occur on the same line number; if the node with the leak
Stmt* S = getStmt(BR); // This is the statement where the leak occured.
assert (S);
- unsigned EndLine = SMgr.getLogicalLineNumber(S->getLocStart());
+ unsigned EndLine = SMgr.getInstantiationLineNumber(S->getLocStart());
// Look in the *trimmed* graph at the immediate predecessor of EndN. Does
// it occur on the same line?
Stmt* SPred = PredPS->getStmt();
// Predecessor at same line?
- if (SMgr.getLogicalLineNumber(SPred->getLocStart()) != EndLine) {
+ if (SMgr.getInstantiationLineNumber(SPred->getLocStart()) != EndLine) {
Hint = PathDiagnosticPiece::Below;
S = SPred;
}
const CompoundLiteralExpr* CL = CR->getLiteralExpr();
os << "Address of stack memory associated with a compound literal "
"declared on line "
- << BR.getSourceManager().getLogicalLineNumber(CL->getLocStart())
+ << BR.getSourceManager()
+ .getInstantiationLineNumber(CL->getLocStart())
<< " returned.";
R = CL->getSourceRange();
R = ARE->getSourceRange();
os << "Address of stack memory allocated by call to alloca() on line "
- << BR.getSourceManager().getLogicalLineNumber(L)
+ << BR.getSourceManager().getInstantiationLineNumber(L)
<< " returned.";
}
else {
return SourceRange(A,B);
}
-FullSourceLoc FullSourceLoc::getLogicalLoc() const {
+FullSourceLoc FullSourceLoc::getInstantiationLoc() const {
assert (isValid());
- return FullSourceLoc(SrcMgr->getLogicalLoc(Loc), *SrcMgr);
+ return FullSourceLoc(SrcMgr->getInstantiationLoc(Loc), *SrcMgr);
}
FullSourceLoc FullSourceLoc::getSpellingLoc() const {
}
-unsigned FullSourceLoc::getLogicalLineNumber() const {
+unsigned FullSourceLoc::getInstantiationLineNumber() const {
assert (isValid());
- return SrcMgr->getLogicalLineNumber(Loc);
+ return SrcMgr->getInstantiationLineNumber(Loc);
}
-unsigned FullSourceLoc::getLogicalColumnNumber() const {
+unsigned FullSourceLoc::getInstantiationColumnNumber() const {
assert (isValid());
- return SrcMgr->getLogicalColumnNumber(Loc);
+ return SrcMgr->getInstantiationColumnNumber(Loc);
}
unsigned FullSourceLoc::getSpellingLineNumber() const {
}
if (isFileID()) {
- // The logical and spelling pos is identical for file locs.
+ // The instantiation and spelling pos is identical for file locs.
fprintf(stderr, "File Loc from '%s': %d: %d\n",
- getSourceName(), getLogicalLineNumber(),
- getLogicalColumnNumber());
+ getSourceName(), getInstantiationLineNumber(),
+ getInstantiationColumnNumber());
} else {
fprintf(stderr, "Macro Loc (\n Spelling: ");
getSpellingLoc().dump();
- fprintf(stderr, " Logical: ");
- getLogicalLoc().dump();
+ fprintf(stderr, " Instantiation: ");
+ getInstantiationLoc().dump();
fprintf(stderr, ")\n");
}
}
// where the characters are actually located.
SpellingLoc = getSpellingLoc(SpellingLoc);
- // Resolve InstantLoc down to a real logical location.
- InstantLoc = getLogicalLoc(InstantLoc);
+ // Resolve InstantLoc down to a real instantiation location.
+ InstantLoc = getInstantiationLoc(InstantLoc);
// If the last macro id is close to the currently requested location, try to
void CGDebugInfo::setLocation(SourceLocation Loc) {
if (Loc.isValid())
- CurLoc = M->getContext().getSourceManager().getLogicalLoc(Loc);
+ CurLoc = M->getContext().getSourceManager().getInstantiationLoc(Loc);
}
/// getOrCreateCompileUnit - Get the compile unit from the cache or create a new
llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
SourceManager &SM = M->getContext().getSourceManager();
- uint64_t Line = SM.getLogicalLineNumber(DefLoc);
+ uint64_t Line = SM.getInstantiationLineNumber(DefLoc);
return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef, Unit,
TyName, DefUnit, Line, 0, 0, 0, 0, Src);
std::string Name = Decl->getNameAsString();
llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation());
- uint64_t Line = SM.getLogicalLineNumber(Decl->getLocation());
+ unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
// Records and classes and unions can all be recursive. To handle them, we
// Get the location for the field.
SourceLocation FieldDefLoc = Field->getLocation();
llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
- uint64_t FieldLine = SM.getLogicalLineNumber(FieldDefLoc);
+ unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc);
// Bit size, align and offset of the type.
uint64_t FieldSize = M->getContext().getTypeSize(Ty);
- uint64_t FieldAlign = M->getContext().getTypeAlign(Ty);
+ unsigned FieldAlign = M->getContext().getTypeAlign(Ty);
uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
// Create a DW_TAG_member node to remember the offset of this field in the
SourceLocation DefLoc = Decl->getLocation();
llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
SourceManager &SM = M->getContext().getSourceManager();
- uint64_t Line = SM.getLogicalLineNumber(DefLoc);
+ unsigned Line = SM.getInstantiationLineNumber(DefLoc);
// Size and align of the type.
uint64_t Size = M->getContext().getTypeSize(Ty);
- uint64_t Align = M->getContext().getTypeAlign(Ty);
+ unsigned Align = M->getContext().getTypeAlign(Ty);
return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type,
Unit, EnumName, DefUnit, Line,
// FIXME: Why is this using CurLoc???
llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
SourceManager &SM = M->getContext().getSourceManager();
- uint64_t LineNo = SM.getLogicalLineNumber(CurLoc);
+ unsigned LineNo = SM.getInstantiationLineNumber(CurLoc);
llvm::DISubprogram SP =
DebugFactory.CreateSubprogram(Unit, Name, Name, "", Unit, LineNo,
// Get the appropriate compile unit.
llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
- DebugFactory.InsertStopPoint(Unit, SM.getLogicalLineNumber(CurLoc),
- SM.getLogicalColumnNumber(CurLoc),
+ DebugFactory.InsertStopPoint(Unit, SM.getInstantiationLineNumber(CurLoc),
+ SM.getInstantiationColumnNumber(CurLoc),
Builder.GetInsertBlock());
}
// Get location information.
SourceManager &SM = M->getContext().getSourceManager();
- uint64_t Line = SM.getLogicalLineNumber(Decl->getLocation());
+ unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
// Create the descriptor for the variable.
// Create global variable debug descriptor.
llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
SourceManager &SM = M->getContext().getSourceManager();
- uint64_t LineNo = SM.getLogicalLineNumber(Decl->getLocation());
+ unsigned LineNo = SM.getInstantiationLineNumber(Decl->getLocation());
std::string Name = Decl->getNameAsString();
if (const AnnotateAttr *AA = D.getAttr<AnnotateAttr>()) {
SourceManager &SM = CGM.getContext().getSourceManager();
llvm::Constant *Ann =
- CGM.EmitAnnotateAttr(GV, AA, SM.getLogicalLineNumber(D.getLocation()));
+ CGM.EmitAnnotateAttr(GV, AA,
+ SM.getInstantiationLineNumber(D.getLocation()));
CGM.AddAnnotation(Ann);
}
if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
SourceManager &SM = Context.getSourceManager();
AddAnnotation(EmitAnnotateAttr(GV, AA,
- SM.getLogicalLineNumber(D->getLocation())));
+ SM.getInstantiationLineNumber(D->getLocation())));
}
GV->setInitializer(Init);
bool FileIDInitialized = false;
// Verify that the entire path is from the same FileID.
- for (PathDiagnostic::const_iterator I=D.begin(), E=D.end(); I != E; ++I) {
-
- FullSourceLoc L = I->getLocation().getLogicalLoc();
+ for (PathDiagnostic::const_iterator I = D.begin(), E = D.end(); I != E; ++I) {
+ FullSourceLoc L = I->getLocation().getInstantiationLoc();
if (!L.isFileID())
return; // FIXME: Emit a warning?
for (PathDiagnosticPiece::range_iterator RI=I->ranges_begin(),
RE=I->ranges_end(); RI!=RE; ++RI) {
- SourceLocation L = SMgr.getLogicalLoc(RI->getBegin());
+ SourceLocation L = SMgr.getInstantiationLoc(RI->getBegin());
if (!L.isFileID())
return; // FIXME: Emit a warning?
if (SMgr.getCanonicalFileID(L) != FileID)
return; // FIXME: Emit a warning?
- L = SMgr.getLogicalLoc(RI->getEnd());
+ L = SMgr.getInstantiationLoc(RI->getEnd());
if (!L.isFileID())
return; // FIXME: Emit a warning?
<< html::EscapeText(Entry->getName())
<< "</td></tr>\n<tr><td class=\"rowname\">Location:</td><td>"
"<a href=\"#EndPath\">line "
- << (*D.rbegin()).getLocation().getLogicalLineNumber()
+ << (*D.rbegin()).getLocation().getInstantiationLineNumber()
<< ", column "
- << (*D.rbegin()).getLocation().getLogicalColumnNumber()
+ << (*D.rbegin()).getLocation().getInstantiationColumnNumber()
<< "</a></td></tr>\n"
"<tr><td class=\"rowname\">Description:</td><td>"
<< D.getDescription() << "</td></tr>\n";
{
std::string s;
llvm::raw_string_ostream os(s);
- os << "\n<!-- BUGLINE " << D.back()->getLocation().getLogicalLineNumber()
- << " -->\n";
+ os << "\n<!-- BUGLINE "
+ << D.back()->getLocation().getInstantiationLineNumber() << " -->\n";
R.InsertStrBefore(SourceLocation::getFileLoc(FileID, 0), os.str());
}
return;
SourceManager& SM = R.getSourceMgr();
- FullSourceLoc LPos = Pos.getLogicalLoc();
+ FullSourceLoc LPos = Pos.getInstantiationLoc();
unsigned FileID = SM.getCanonicalFileID(LPos.getLocation());
assert (&LPos.getManager() == &SM && "SourceManagers are different!");
// of the line.
unsigned ColNo = LPos.getColumnNumber();
- const char *TokLogicalPtr = LPos.getCharacterData();
- const char *LineStart = TokLogicalPtr-ColNo;
+ const char *TokInstantiationPtr = LPos.getCharacterData();
+ const char *LineStart = TokInstantiationPtr-ColNo;
// Only compute LineEnd if we display below a line.
- const char *LineEnd = TokLogicalPtr;
+ const char *LineEnd = TokInstantiationPtr;
if (P.getDisplayHint() == PathDiagnosticPiece::Below) {
const char* FileEnd = Buf->getBufferEnd();
unsigned PosNo = 0;
- for (const char* c = LineStart; c != TokLogicalPtr; ++c)
+ for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
PosNo += *c == '\t' ? 8 : 1;
// Create the html for the message.
SourceManager& SM = R.getSourceMgr();
- SourceLocation LogicalStart = SM.getLogicalLoc(Range.getBegin());
- unsigned StartLineNo = SM.getLineNumber(LogicalStart);
+ SourceLocation InstantiationStart = SM.getInstantiationLoc(Range.getBegin());
+ unsigned StartLineNo = SM.getLineNumber(InstantiationStart);
- SourceLocation LogicalEnd = SM.getLogicalLoc(Range.getEnd());
- unsigned EndLineNo = SM.getLineNumber(LogicalEnd);
+ SourceLocation InstantiationEnd = SM.getInstantiationLoc(Range.getEnd());
+ unsigned EndLineNo = SM.getLineNumber(InstantiationEnd);
if (EndLineNo < StartLineNo)
return;
- if (SM.getCanonicalFileID(LogicalStart) != BugFileID ||
- SM.getCanonicalFileID(LogicalEnd) != BugFileID)
+ if (SM.getCanonicalFileID(InstantiationStart) != BugFileID ||
+ SM.getCanonicalFileID(InstantiationEnd) != BugFileID)
return;
// Compute the column number of the end.
- unsigned EndColNo = SM.getColumnNumber(LogicalEnd);
+ unsigned EndColNo = SM.getColumnNumber(InstantiationEnd);
unsigned OldEndColNo = EndColNo;
if (EndColNo) {
// Highlight the range. Make the span tag the outermost tag for the
// selected range.
- SourceLocation E = LogicalEnd.getFileLocWithOffset(EndColNo - OldEndColNo);
+ SourceLocation E =
+ InstantiationEnd.getFileLocWithOffset(EndColNo - OldEndColNo);
- html::HighlightRange(R, LogicalStart, E,
+ html::HighlightRange(R, InstantiationStart, E,
"<span class=\"mrange\">", "</span>");
}
llvm::SmallVectorImpl<unsigned>& V,
SourceManager& SM, SourceLocation L) {
- unsigned fid = SM.getCanonicalFileID(SM.getLogicalLoc(L));
+ unsigned fid = SM.getCanonicalFileID(SM.getInstantiationLoc(L));
FIDMap::iterator I = FIDs.find(fid);
if (I != FIDs.end()) return;
FIDs[fid] = V.size();
static unsigned GetFID(const FIDMap& FIDs,
SourceManager& SM, SourceLocation L) {
-
- unsigned fid = SM.getCanonicalFileID(SM.getLogicalLoc(L));
+ unsigned fid = SM.getCanonicalFileID(SM.getInstantiationLoc(L));
FIDMap::const_iterator I = FIDs.find(fid);
assert (I != FIDs.end());
return I->second;
Indent(o, indent) << "<dict>\n";
Indent(o, indent) << " <key>line</key><integer>"
- << SM.getLogicalLineNumber(L) << "</integer>\n";
+ << SM.getInstantiationLineNumber(L) << "</integer>\n";
Indent(o, indent) << " <key>col</key><integer>"
- << SM.getLogicalColumnNumber(L) << "</integer>\n";
+ << SM.getInstantiationColumnNumber(L) << "</integer>\n";
Indent(o, indent) << " <key>file</key><integer>"
<< GetFID(FM, SM, L) << "</integer>\n";
Indent(o, indent) << "</dict>\n";
PrintIncludeStack(FullSourceLoc Pos) {
if (Pos.isInvalid()) return;
- Pos = Pos.getLogicalLoc();
+ Pos = Pos.getInstantiationLoc();
// Print out the other include frames first.
PrintIncludeStack(Pos.getIncludeLoc());
"Expect a correspondence between source and caret line!");
if (!R.isValid()) return;
- SourceLocation LogicalStart = SourceMgr.getLogicalLoc(R.getBegin());
- unsigned StartLineNo = SourceMgr.getLineNumber(LogicalStart);
- if (StartLineNo > LineNo || LogicalStart.getFileID() != FileID)
+ SourceLocation InstantiationStart =
+ SourceMgr.getInstantiationLoc(R.getBegin());
+ unsigned StartLineNo = SourceMgr.getLineNumber(InstantiationStart);
+ if (StartLineNo > LineNo || InstantiationStart.getFileID() != FileID)
return; // No intersection.
- SourceLocation LogicalEnd = SourceMgr.getLogicalLoc(R.getEnd());
- unsigned EndLineNo = SourceMgr.getLineNumber(LogicalEnd);
- if (EndLineNo < LineNo || LogicalEnd.getFileID() != FileID)
+ SourceLocation InstantiationEnd = SourceMgr.getInstantiationLoc(R.getEnd());
+ unsigned EndLineNo = SourceMgr.getLineNumber(InstantiationEnd);
+ if (EndLineNo < LineNo || InstantiationEnd.getFileID() != FileID)
return; // No intersection.
// Compute the column number of the start.
unsigned StartColNo = 0;
if (StartLineNo == LineNo) {
- StartColNo = SourceMgr.getLogicalColumnNumber(R.getBegin());
+ StartColNo = SourceMgr.getInstantiationColumnNumber(R.getBegin());
if (StartColNo) --StartColNo; // Zero base the col #.
}
// Compute the column number of the end.
unsigned EndColNo = CaretLine.size();
if (EndLineNo == LineNo) {
- EndColNo = SourceMgr.getLogicalColumnNumber(R.getEnd());
+ EndColNo = SourceMgr.getInstantiationColumnNumber(R.getEnd());
if (EndColNo) {
--EndColNo; // Zero base the col #.
const FullSourceLoc &Pos = Info.getLocation();
if (Pos.isValid()) {
- FullSourceLoc LPos = Pos.getLogicalLoc();
+ FullSourceLoc LPos = Pos.getInstantiationLoc();
LineNo = LPos.getLineNumber();
FileID = LPos.getLocation().getFileID();
// Compute the column number. Rewind from the current position to the start
// of the line.
ColNo = LPos.getColumnNumber();
- const char *TokLogicalPtr = LPos.getCharacterData();
- LineStart = TokLogicalPtr-ColNo+1; // Column # is 1-based
+ const char *TokInstantiationPtr = LPos.getCharacterData();
+ LineStart = TokInstantiationPtr-ColNo+1; // Column # is 1-based
// Compute the line end. Scan forward from the error position to the end of
// the line.
const llvm::MemoryBuffer *Buffer = LPos.getBuffer();
const char *BufEnd = Buffer->getBufferEnd();
- LineEnd = TokLogicalPtr;
+ LineEnd = TokInstantiationPtr;
while (LineEnd != BufEnd &&
*LineEnd != '\n' && *LineEnd != '\r')
++LineEnd;
const SourceManager &SM) {
// If this comes from a macro expansion, we really do want the macro name, not
// the token this macro expanded to.
- Loc = SM.getLogicalLoc(Loc);
+ Loc = SM.getInstantiationLoc(Loc);
const char *StrData = SM.getCharacterData(Loc);
// spelling location.
SourceManager &SourceMgr = PP.getSourceManager();
- // Create a new SLoc which is expanded from logical(FileLoc) but whose
+ // Create a new SLoc which is expanded from Instantiation(FileLoc) but whose
// characters come from spelling(FileLoc)+Offset.
- SourceLocation VirtLoc = SourceMgr.getLogicalLoc(FileLoc);
+ SourceLocation InstLoc = SourceMgr.getInstantiationLoc(FileLoc);
SourceLocation SpellingLoc = SourceMgr.getSpellingLoc(FileLoc);
SpellingLoc = SourceLocation::getFileLoc(SpellingLoc.getFileID(), CharNo);
- return SourceMgr.getInstantiationLoc(SpellingLoc, VirtLoc);
+ return SourceMgr.getInstantiationLoc(SpellingLoc, InstLoc);
}
/// getSourceLocation - Return a source location identifier for the specified
Identifier.setFlagValue(Token::StartOfLine , isAtStartOfLine);
Identifier.setFlagValue(Token::LeadingSpace, hasLeadingSpace);
- // Update the tokens location to include both its logical and physical
+ // Update the tokens location to include both its instantiation and physical
// locations.
SourceLocation Loc =
SourceMgr.getInstantiationLoc(Identifier.getLocation(), InstantiateLoc);
// it will tokenize as a number (and not run into stuff after it in the temp
// buffer).
sprintf(TmpBuffer, "%u ",
- SourceMgr.getLogicalLineNumber(Tok.getLocation()));
+ SourceMgr.getInstantiationLineNumber(Tok.getLocation()));
unsigned Length = strlen(TmpBuffer)-1;
Tok.setKind(tok::numeric_constant);
Tok.setLength(Length);
}
// Escape this filename. Turn '\' -> '\\' '"' -> '\"'
- std::string FN = SourceMgr.getSourceName(SourceMgr.getLogicalLoc(Loc));
+ std::string FN =SourceMgr.getSourceName(SourceMgr.getInstantiationLoc(Loc));
FN = '"' + Lexer::Stringify(FN) + '"';
Tok.setKind(tok::string_literal);
Tok.setLength(FN.size());
}
void Preprocessor::DumpLocation(SourceLocation Loc) const {
- SourceLocation LogLoc = SourceMgr.getLogicalLoc(Loc);
+ SourceLocation LogLoc = SourceMgr.getInstantiationLoc(Loc);
llvm::cerr << SourceMgr.getSourceName(LogLoc) << ':'
<< SourceMgr.getLineNumber(LogLoc) << ':'
<< SourceMgr.getColumnNumber(LogLoc);
// confusing.
if (CharNo == 0 || TokStart.isMacroID()) return TokStart;
- // Figure out how many physical characters away the specified logical
+ // Figure out how many physical characters away the specified instantiation
// character is. This needs to take into consideration newlines and
// trigraphs.
const char *TokPtr = SourceMgr.getCharacterData(TokStart);
// that the rest of the line is an assembly-language statement.
SourceManager &SrcMgr = PP.getSourceManager();
SourceLocation TokLoc = Tok.getLocation();
- unsigned lineNo = SrcMgr.getLogicalLineNumber(TokLoc);
+ unsigned LineNo = SrcMgr.getInstantiationLineNumber(TokLoc);
do {
ConsumeAnyToken();
TokLoc = Tok.getLocation();
- } while ((SrcMgr.getLogicalLineNumber(TokLoc) == lineNo) &&
+ } while ((SrcMgr.getInstantiationLineNumber(TokLoc) == LineNo) &&
Tok.isNot(tok::r_brace) && Tok.isNot(tok::semi) &&
Tok.isNot(tok::eof));
}
void html::HighlightRange(Rewriter &R, SourceLocation B, SourceLocation E,
const char *StartTag, const char *EndTag) {
SourceManager &SM = R.getSourceMgr();
- B = SM.getLogicalLoc(B);
- E = SM.getLogicalLoc(E);
+ B = SM.getInstantiationLoc(B);
+ E = SM.getInstantiationLoc(E);
unsigned FileID = SM.getCanonicalFileID(B);
assert(SM.getCanonicalFileID(E) == FileID && "B/E not in the same file!");
continue;
}
- // Ignore tokens whose logical location was not the main file.
- SourceLocation LLoc = SourceMgr.getLogicalLoc(Tok.getLocation());
+ // Ignore tokens whose instantiation location was not the main file.
+ SourceLocation LLoc = SourceMgr.getInstantiationLoc(Tok.getLocation());
std::pair<unsigned, unsigned> LLocInfo =
SourceMgr.getDecomposedFileLoc(LLoc);
// instantiation. It would be really nice to pop up a window with all the
// spelling of the tokens or something.
while (!Tok.is(tok::eof) &&
- SourceMgr.getLogicalLoc(Tok.getLocation()) == LLoc) {
+ SourceMgr.getInstantiationLoc(Tok.getLocation()) == LLoc) {
// Insert a newline if the macro expansion is getting large.
if (LineLen > 60) {
Expansion += "<br>";
projects / clang / commitdiff