clang/lib/Rewrite/TokenRewriter.cpp

   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                              const LangOptions &LangOpts) {
  28   ScratchBuf.reset(new ScratchBuffer(SM));
  29
  30   // Create a lexer to lex all the tokens of the main file in raw mode.
  31   llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
  32   Lexer RawLex(FID, FromFile, SM, LangOpts);
  33
  34   // Return all comments and whitespace as tokens.
  35   RawLex.SetKeepWhitespaceMode(true);
  36
  37   // Lex the file, populating our datastructures.
  38   Token RawTok;
  39   RawLex.LexFromRawLexer(RawTok);
  40   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     AddToken(RawTok, TokenList.end());
  50     RawLex.LexFromRawLexer(RawTok);
  51   }
  52 }
  53
  54 TokenRewriter::~TokenRewriter() = default;
  55
  56 /// RemapIterator - Convert from token_iterator (a const iterator) to
  57 /// TokenRefTy (a non-const iterator).
  58 TokenRewriter::TokenRefTy TokenRewriter::RemapIterator(token_iterator I) {
  59   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   std::map<SourceLocation, TokenRefTy>::iterator MapIt =
  64     TokenAtLoc.find(I->getLocation());
  65   assert(MapIt != TokenAtLoc.end() && "iterator not in rewriter?");
  66   return MapIt->second;
  67 }
  68
  69 /// AddToken - Add the specified token into the Rewriter before the other
  70 /// position.
  71 TokenRewriter::TokenRefTy
  72 TokenRewriter::AddToken(const Token &T, TokenRefTy Where) {
  73   Where = TokenList.insert(Where, T);
  74
  75   bool InsertSuccess = TokenAtLoc.insert(std::make_pair(T.getLocation(),
  76                                                         Where)).second;
  77   assert(InsertSuccess && "Token location already in rewriter!");
  78   (void)InsertSuccess;
  79   return Where;
  80 }
  81
  82 TokenRewriter::token_iterator
  83 TokenRewriter::AddTokenBefore(token_iterator I, const char *Val) {
  84   unsigned Len = strlen(Val);
  85
  86   // Plop the string into the scratch buffer, then create a token for this
  87   // string.
  88   Token Tok;
  89   Tok.startToken();
  90   const char *Spelling;
  91   Tok.setLocation(ScratchBuf->getToken(Val, Len, Spelling));
  92   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   Tok.setKind(tok::unknown);
  97
  98   return AddToken(Tok, RemapIterator(I));
  99 }