Coverage Report

Created: 2019-02-23 12:57

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/VariadicMacroSupport.h
Line
Count
Source
1
//===- VariadicMacroSupport.h - state machines and scope guards -*- 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 support types to help with preprocessing variadic macro
10
// (i.e. macros that use: ellipses __VA_ARGS__ ) definitions and
11
// expansions.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_LEX_VARIADICMACROSUPPORT_H
16
#define LLVM_CLANG_LEX_VARIADICMACROSUPPORT_H
17
18
#include "clang/Lex/Preprocessor.h"
19
#include "llvm/ADT/SmallVector.h"
20
21
namespace clang {
22
  class Preprocessor;
23
24
  /// An RAII class that tracks when the Preprocessor starts and stops lexing
25
  /// the definition of a (ISO C/C++) variadic macro.  As an example, this is
26
  /// useful for unpoisoning and repoisoning certain identifiers (such as
27
  /// __VA_ARGS__) that are only allowed in this context.  Also, being a friend
28
  /// of the Preprocessor class allows it to access PP's cached identifiers
29
  /// directly (as opposed to performing a lookup each time).
30
  class VariadicMacroScopeGuard {
31
    const Preprocessor &PP;
32
    IdentifierInfo *const Ident__VA_ARGS__;
33
    IdentifierInfo *const Ident__VA_OPT__;
34
35
  public:
36
    VariadicMacroScopeGuard(const Preprocessor &P)
37
        : PP(P), Ident__VA_ARGS__(PP.Ident__VA_ARGS__),
38
23.8M
          Ident__VA_OPT__(PP.Ident__VA_OPT__) {
39
23.8M
      assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned "
40
23.8M
                                              "outside an ISO C/C++ variadic "
41
23.8M
                                              "macro definition!");
42
23.8M
      assert(
43
23.8M
          !Ident__VA_OPT__ ||
44
23.8M
          (Ident__VA_OPT__->isPoisoned() && "__VA_OPT__ should be poisoned!"));
45
23.8M
    }
46
47
    /// Client code should call this function just before the Preprocessor is
48
    /// about to Lex tokens from the definition of a variadic (ISO C/C++) macro.
49
69.7k
    void enterScope() {
50
69.7k
      Ident__VA_ARGS__->setIsPoisoned(false);
51
69.7k
      if (Ident__VA_OPT__)
52
32
        Ident__VA_OPT__->setIsPoisoned(false);
53
69.7k
    }
54
55
    /// Client code should call this function as soon as the Preprocessor has
56
    /// either completed lexing the macro's definition tokens, or an error
57
    /// occurred and the context is being exited.  This function is idempotent
58
    /// (might be explicitly called, and then reinvoked via the destructor).
59
23.8M
    void exitScope() {
60
23.8M
      Ident__VA_ARGS__->setIsPoisoned(true);
61
23.8M
      if (Ident__VA_OPT__)
62
30.0k
        Ident__VA_OPT__->setIsPoisoned(true);
63
23.8M
    }
64
65
23.8M
    ~VariadicMacroScopeGuard() { exitScope(); }
66
  };
67
68
  /// A class for tracking whether we're inside a VA_OPT during a
69
  /// traversal of the tokens of a variadic macro definition.
70
  class VAOptDefinitionContext {
71
    /// Contains all the locations of so far unmatched lparens.
72
    SmallVector<SourceLocation, 8> UnmatchedOpeningParens;
73
74
    const IdentifierInfo *const Ident__VA_OPT__;
75
76
77
  public:
78
    VAOptDefinitionContext(Preprocessor &PP)
79
7.71M
        : Ident__VA_OPT__(PP.Ident__VA_OPT__) {}
80
81
108M
    bool isVAOptToken(const Token &T) const {
82
108M
      return Ident__VA_OPT__ && 
T.getIdentifierInfo() == Ident__VA_OPT__4.25k
;
83
108M
    }
84
85
    /// Returns true if we have seen the __VA_OPT__ and '(' but before having
86
    /// seen the matching ')'.
87
112M
    bool isInVAOpt() const { return UnmatchedOpeningParens.size(); }
88
89
    /// Call this function as soon as you see __VA_OPT__ and '('.
90
74
    void sawVAOptFollowedByOpeningParens(const SourceLocation LParenLoc) {
91
74
      assert(!isInVAOpt() && "Must NOT be within VAOPT context to call this");
92
74
      UnmatchedOpeningParens.push_back(LParenLoc);
93
74
94
74
    }
95
96
2
    SourceLocation getUnmatchedOpeningParenLoc() const {
97
2
      assert(isInVAOpt() && "Must be within VAOPT context to call this");
98
2
      return UnmatchedOpeningParens.back();
99
2
    }
100
101
    /// Call this function each time an rparen is seen.  It returns true only if
102
    /// the rparen that was just seen was the eventual (non-nested) closing
103
    /// paren for VAOPT, and ejects us out of the VAOPT context.
104
70
    bool sawClosingParen() {
105
70
      assert(isInVAOpt() && "Must be within VAOPT context to call this");
106
70
      UnmatchedOpeningParens.pop_back();
107
70
      return !UnmatchedOpeningParens.size();
108
70
    }
109
110
    /// Call this function each time an lparen is seen.
111
5
    void sawOpeningParen(SourceLocation LParenLoc) {
112
5
      assert(isInVAOpt() && "Must be within VAOPT context to call this");
113
5
      UnmatchedOpeningParens.push_back(LParenLoc);
114
5
    }
115
116
  };
117
118
  /// A class for tracking whether we're inside a VA_OPT during a
119
  /// traversal of the tokens of a macro during macro expansion.
120
  class VAOptExpansionContext : VAOptDefinitionContext {
121
122
    Token SyntheticEOFToken;
123
124
    // The (spelling) location of the current __VA_OPT__ in the replacement list
125
    // of the function-like macro being expanded.
126
    SourceLocation VAOptLoc;
127
128
    // NumOfTokensPriorToVAOpt : when != -1, contains the index *of* the first
129
    // token of the current VAOPT contents (so we know where to start eager
130
    // token-pasting and stringification) *within*  the substituted tokens of
131
    // the function-like macro's new replacement list.
132
    int NumOfTokensPriorToVAOpt = -1;
133
134
    unsigned LeadingSpaceForStringifiedToken : 1;
135
136
    unsigned StringifyBefore : 1;
137
    unsigned CharifyBefore : 1;
138
139
140
40
    bool hasStringifyBefore() const {
141
40
      assert(!isReset() &&
142
40
             "Must only be called if the state has not been reset");
143
40
      return StringifyBefore;
144
40
    }
145
146
    bool isReset() const {
147
      return NumOfTokensPriorToVAOpt == -1 ||
148
             VAOptLoc.isInvalid();
149
    }
150
151
  public:
152
    VAOptExpansionContext(Preprocessor &PP)
153
        : VAOptDefinitionContext(PP), LeadingSpaceForStringifiedToken(false),
154
4.19M
          StringifyBefore(false), CharifyBefore(false) {
155
4.19M
      SyntheticEOFToken.startToken();
156
4.19M
      SyntheticEOFToken.setKind(tok::eof);
157
4.19M
    }
158
159
40
    void reset() {
160
40
      VAOptLoc = SourceLocation();
161
40
      NumOfTokensPriorToVAOpt = -1;
162
40
      LeadingSpaceForStringifiedToken = false;
163
40
      StringifyBefore = false;
164
40
      CharifyBefore = false;
165
40
    }
166
167
14
    const Token &getEOFTok() const { return SyntheticEOFToken; }
168
169
    void sawHashOrHashAtBefore(const bool HasLeadingSpace,
170
14
                               const bool IsHashAt) {
171
14
172
14
      StringifyBefore = !IsHashAt;
173
14
      CharifyBefore = IsHashAt;
174
14
      LeadingSpaceForStringifiedToken = HasLeadingSpace;
175
14
    }
176
177
178
179
40
    bool hasCharifyBefore() const {
180
40
      assert(!isReset() &&
181
40
             "Must only be called if the state has not been reset");
182
40
      return CharifyBefore;
183
40
    }
184
40
    bool hasStringifyOrCharifyBefore() const {
185
40
      return hasStringifyBefore() || 
hasCharifyBefore()26
;
186
40
    }
187
188
41
    unsigned int getNumberOfTokensPriorToVAOpt() const {
189
41
      assert(!isReset() &&
190
41
             "Must only be called if the state has not been reset");
191
41
      return NumOfTokensPriorToVAOpt;
192
41
    }
193
194
14
    bool getLeadingSpaceForStringifiedToken() const {
195
14
      assert(hasStringifyBefore() &&
196
14
             "Must only be called if this has been marked for stringification");
197
14
      return LeadingSpaceForStringifiedToken;
198
14
    }
199
200
    void sawVAOptFollowedByOpeningParens(const SourceLocation VAOptLoc,
201
40
                                         const unsigned int NumPriorTokens) {
202
40
      assert(VAOptLoc.isFileID() && "Must not come from a macro expansion");
203
40
      assert(isReset() && "Must only be called if the state has been reset");
204
40
      VAOptDefinitionContext::sawVAOptFollowedByOpeningParens(SourceLocation());
205
40
      this->VAOptLoc = VAOptLoc;
206
40
      NumOfTokensPriorToVAOpt = NumPriorTokens;
207
40
      assert(NumOfTokensPriorToVAOpt > -1 &&
208
40
             "Too many prior tokens");
209
40
    }
210
211
14
    SourceLocation getVAOptLoc() const {
212
14
      assert(!isReset() &&
213
14
             "Must only be called if the state has not been reset");
214
14
      assert(VAOptLoc.isValid() && "__VA_OPT__ location must be valid");
215
14
      return VAOptLoc;
216
14
    }
217
    using VAOptDefinitionContext::isVAOptToken;
218
    using VAOptDefinitionContext::isInVAOpt;
219
    using VAOptDefinitionContext::sawClosingParen;
220
    using VAOptDefinitionContext::sawOpeningParen;
221
222
  };
223
}  // end namespace clang
224
225
#endif