/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Rewrite/TokenRewriter.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===- TokenRewriter.cpp - Token-based code rewriting interface -----------===// |
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 implements the TokenRewriter class, which is used for code |
10 | | // transformations. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #include "clang/Rewrite/Core/TokenRewriter.h" |
15 | | #include "clang/Basic/SourceManager.h" |
16 | | #include "clang/Lex/Lexer.h" |
17 | | #include "clang/Lex/ScratchBuffer.h" |
18 | | #include "clang/Lex/Token.h" |
19 | | #include <cassert> |
20 | | #include <cstring> |
21 | | #include <map> |
22 | | #include <utility> |
23 | | |
24 | | using namespace clang; |
25 | | |
26 | | TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM, |
27 | 0 | const LangOptions &LangOpts) { |
28 | 0 | ScratchBuf.reset(new ScratchBuffer(SM)); |
29 | | |
30 | | // Create a lexer to lex all the tokens of the main file in raw mode. |
31 | 0 | llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID); |
32 | 0 | Lexer RawLex(FID, FromFile, SM, LangOpts); |
33 | | |
34 | | // Return all comments and whitespace as tokens. |
35 | 0 | RawLex.SetKeepWhitespaceMode(true); |
36 | | |
37 | | // Lex the file, populating our datastructures. |
38 | 0 | Token RawTok; |
39 | 0 | RawLex.LexFromRawLexer(RawTok); |
40 | 0 | while (RawTok.isNot(tok::eof)) { |
41 | | #if 0 |
42 | | if (Tok.is(tok::raw_identifier)) { |
43 | | // Look up the identifier info for the token. This should use |
44 | | // IdentifierTable directly instead of PP. |
45 | | PP.LookUpIdentifierInfo(Tok); |
46 | | } |
47 | | #endif |
48 | |
|
49 | 0 | AddToken(RawTok, TokenList.end()); |
50 | 0 | RawLex.LexFromRawLexer(RawTok); |
51 | 0 | } |
52 | 0 | } |
53 | | |
54 | 0 | TokenRewriter::~TokenRewriter() = default; |
55 | | |
56 | | /// RemapIterator - Convert from token_iterator (a const iterator) to |
57 | | /// TokenRefTy (a non-const iterator). |
58 | 0 | TokenRewriter::TokenRefTy TokenRewriter::RemapIterator(token_iterator I) { |
59 | 0 | if (I == token_end()) return TokenList.end(); |
60 | | |
61 | | // FIXME: This is horrible, we should use our own list or something to avoid |
62 | | // this. |
63 | 0 | std::map<SourceLocation, TokenRefTy>::iterator MapIt = |
64 | 0 | TokenAtLoc.find(I->getLocation()); |
65 | 0 | assert(MapIt != TokenAtLoc.end() && "iterator not in rewriter?"); |
66 | 0 | return MapIt->second; |
67 | 0 | } |
68 | | |
69 | | /// AddToken - Add the specified token into the Rewriter before the other |
70 | | /// position. |
71 | | TokenRewriter::TokenRefTy |
72 | 0 | TokenRewriter::AddToken(const Token &T, TokenRefTy Where) { |
73 | 0 | Where = TokenList.insert(Where, T); |
74 | |
|
75 | 0 | bool InsertSuccess = TokenAtLoc.insert(std::make_pair(T.getLocation(), |
76 | 0 | Where)).second; |
77 | 0 | assert(InsertSuccess && "Token location already in rewriter!"); |
78 | 0 | (void)InsertSuccess; |
79 | 0 | return Where; |
80 | 0 | } |
81 | | |
82 | | TokenRewriter::token_iterator |
83 | 0 | TokenRewriter::AddTokenBefore(token_iterator I, const char *Val) { |
84 | 0 | unsigned Len = strlen(Val); |
85 | | |
86 | | // Plop the string into the scratch buffer, then create a token for this |
87 | | // string. |
88 | 0 | Token Tok; |
89 | 0 | Tok.startToken(); |
90 | 0 | const char *Spelling; |
91 | 0 | Tok.setLocation(ScratchBuf->getToken(Val, Len, Spelling)); |
92 | 0 | Tok.setLength(Len); |
93 | | |
94 | | // TODO: Form a whole lexer around this and relex the token! For now, just |
95 | | // set kind to tok::unknown. |
96 | 0 | Tok.setKind(tok::unknown); |
97 | |
|
98 | 0 | return AddToken(Tok, RemapIterator(I)); |
99 | 0 | } |