Coverage Report

Created: 2021-09-21 08:58

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Format/MacroExpander.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- MacroExpander.cpp - Format C++ code --------------------*- 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
/// \file
10
/// This file contains the implementation of MacroExpander, which handles macro
11
/// configuration and expansion while formatting.
12
///
13
//===----------------------------------------------------------------------===//
14
15
#include "Macros.h"
16
17
#include "Encoding.h"
18
#include "FormatToken.h"
19
#include "FormatTokenLexer.h"
20
#include "clang/Basic/TokenKinds.h"
21
#include "clang/Format/Format.h"
22
#include "clang/Lex/HeaderSearch.h"
23
#include "clang/Lex/HeaderSearchOptions.h"
24
#include "clang/Lex/Lexer.h"
25
#include "clang/Lex/ModuleLoader.h"
26
#include "clang/Lex/Preprocessor.h"
27
#include "clang/Lex/PreprocessorOptions.h"
28
#include "llvm/ADT/StringSet.h"
29
#include "llvm/Support/ErrorHandling.h"
30
31
namespace clang {
32
namespace format {
33
34
struct MacroExpander::Definition {
35
  StringRef Name;
36
  SmallVector<FormatToken *, 8> Params;
37
  SmallVector<FormatToken *, 8> Body;
38
39
  // Map from each argument's name to its position in the argument list.
40
  // With "M(x, y) x + y":
41
  //   x -> 0
42
  //   y -> 1
43
  llvm::StringMap<size_t> ArgMap;
44
45
  bool ObjectLike = true;
46
};
47
48
class MacroExpander::DefinitionParser {
49
public:
50
20
  DefinitionParser(ArrayRef<FormatToken *> Tokens) : Tokens(Tokens) {
51
20
    assert(!Tokens.empty());
52
0
    Current = Tokens[0];
53
20
  }
54
55
  // Parse the token stream and return the corresponding Definition object.
56
  // Returns an empty definition object with a null-Name on error.
57
20
  MacroExpander::Definition parse() {
58
20
    if (!Current->is(tok::identifier))
59
0
      return {};
60
20
    Def.Name = Current->TokenText;
61
20
    nextToken();
62
20
    if (Current->is(tok::l_paren)) {
63
17
      Def.ObjectLike = false;
64
17
      if (!parseParams())
65
7
        return {};
66
17
    }
67
13
    if (!parseExpansion())
68
0
      return {};
69
70
13
    return Def;
71
13
  }
72
73
private:
74
17
  bool parseParams() {
75
17
    assert(Current->is(tok::l_paren));
76
0
    nextToken();
77
23
    while (Current->is(tok::identifier)) {
78
18
      Def.Params.push_back(Current);
79
18
      Def.ArgMap[Def.Params.back()->TokenText] = Def.Params.size() - 1;
80
18
      nextToken();
81
18
      if (Current->isNot(tok::comma))
82
12
        break;
83
6
      nextToken();
84
6
    }
85
17
    if (Current->isNot(tok::r_paren))
86
7
      return false;
87
10
    nextToken();
88
10
    return true;
89
17
  }
90
91
13
  bool parseExpansion() {
92
13
    if (!Current->isOneOf(tok::equal, tok::eof))
93
0
      return false;
94
13
    if (Current->is(tok::equal))
95
10
      nextToken();
96
13
    parseTail();
97
13
    return true;
98
13
  }
99
100
13
  void parseTail() {
101
42
    while (Current->isNot(tok::eof)) {
102
29
      Def.Body.push_back(Current);
103
29
      nextToken();
104
29
    }
105
13
    Def.Body.push_back(Current);
106
13
  }
107
108
110
  void nextToken() {
109
110
    if (Pos + 1 < Tokens.size())
110
110
      ++Pos;
111
110
    Current = Tokens[Pos];
112
110
    Current->Finalized = true;
113
110
  }
114
115
  size_t Pos = 0;
116
  FormatToken *Current = nullptr;
117
  Definition Def;
118
  ArrayRef<FormatToken *> Tokens;
119
};
120
121
MacroExpander::MacroExpander(
122
    const std::vector<std::string> &Macros, clang::SourceManager &SourceMgr,
123
    const FormatStyle &Style,
124
    llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
125
    IdentifierTable &IdentTable)
126
    : SourceMgr(SourceMgr), Style(Style), Allocator(Allocator),
127
7
      IdentTable(IdentTable) {
128
20
  for (const std::string &Macro : Macros) {
129
20
    parseDefinition(Macro);
130
20
  }
131
7
}
132
133
7
MacroExpander::~MacroExpander() = default;
134
135
20
void MacroExpander::parseDefinition(const std::string &Macro) {
136
20
  Buffers.push_back(
137
20
      llvm::MemoryBuffer::getMemBufferCopy(Macro, "<scratch space>"));
138
20
  clang::FileID FID = SourceMgr.createFileID(Buffers.back()->getMemBufferRef());
139
20
  FormatTokenLexer Lex(SourceMgr, FID, 0, Style, encoding::Encoding_UTF8,
140
20
                       Allocator, IdentTable);
141
20
  const auto Tokens = Lex.lex();
142
20
  if (!Tokens.empty()) {
143
20
    DefinitionParser Parser(Tokens);
144
20
    auto Definition = Parser.parse();
145
20
    Definitions[Definition.Name] = std::move(Definition);
146
20
  }
147
20
}
148
149
28
bool MacroExpander::defined(llvm::StringRef Name) const {
150
28
  return Definitions.find(Name) != Definitions.end();
151
28
}
152
153
4
bool MacroExpander::objectLike(llvm::StringRef Name) const {
154
4
  return Definitions.find(Name)->second.ObjectLike;
155
4
}
156
157
llvm::SmallVector<FormatToken *, 8> MacroExpander::expand(FormatToken *ID,
158
14
                                                          ArgsList Args) const {
159
14
  assert(defined(ID->TokenText));
160
0
  SmallVector<FormatToken *, 8> Result;
161
14
  const Definition &Def = Definitions.find(ID->TokenText)->second;
162
163
  // Expand each argument at most once.
164
14
  llvm::StringSet<> ExpandedArgs;
165
166
  // Adds the given token to Result.
167
52
  auto pushToken = [&](FormatToken *Tok) {
168
52
    Tok->MacroCtx->ExpandedFrom.push_back(ID);
169
52
    Result.push_back(Tok);
170
52
  };
171
172
  // If Tok references a parameter, adds the corresponding argument to Result.
173
  // Returns false if Tok does not reference a parameter.
174
46
  auto expandArgument = [&](FormatToken *Tok) -> bool {
175
    // If the current token references a parameter, expand the corresponding
176
    // argument.
177
46
    if (!Tok->is(tok::identifier) || 
ExpandedArgs.contains(Tok->TokenText)18
)
178
30
      return false;
179
16
    ExpandedArgs.insert(Tok->TokenText);
180
16
    auto I = Def.ArgMap.find(Tok->TokenText);
181
16
    if (I == Def.ArgMap.end())
182
2
      return false;
183
    // If there are fewer arguments than referenced parameters, treat the
184
    // parameter as empty.
185
    // FIXME: Potentially fully abort the expansion instead.
186
14
    if (I->getValue() >= Args.size())
187
1
      return true;
188
20
    
for (FormatToken *Arg : Args[I->getValue()])13
{
189
      // A token can be part of a macro argument at multiple levels.
190
      // For example, with "ID(x) x":
191
      // in ID(ID(x)), 'x' is expanded first as argument to the inner
192
      // ID, then again as argument to the outer ID. We keep the macro
193
      // role the token had from the inner expansion.
194
20
      if (!Arg->MacroCtx)
195
18
        Arg->MacroCtx = MacroExpansion(MR_ExpandedArg);
196
20
      pushToken(Arg);
197
20
    }
198
13
    return true;
199
14
  };
200
201
  // Expand the definition into Result.
202
46
  for (FormatToken *Tok : Def.Body) {
203
46
    if (expandArgument(Tok))
204
14
      continue;
205
    // Create a copy of the tokens from the macro body, i.e. were not provided
206
    // by user code.
207
32
    FormatToken *New = new (Allocator.Allocate()) FormatToken;
208
32
    New->copyFrom(*Tok);
209
32
    assert(!New->MacroCtx);
210
    // Tokens that are not part of the user code are not formatted.
211
0
    New->MacroCtx = MacroExpansion(MR_Hidden);
212
32
    pushToken(New);
213
32
  }
214
14
  assert(Result.size() >= 1 && Result.back()->is(tok::eof));
215
14
  if (Result.size() > 1) {
216
11
    ++Result[0]->MacroCtx->StartOfExpansion;
217
11
    ++Result[Result.size() - 2]->MacroCtx->EndOfExpansion;
218
11
  }
219
14
  return Result;
220
14
}
221
222
} // namespace format
223
} // namespace clang