/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Lex/MacroArgs.h
Line | Count | Source |
1 | | //===--- MacroArgs.h - Formal argument info for Macros ----------*- 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 the MacroArgs interface. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_CLANG_LEX_MACROARGS_H |
14 | | #define LLVM_CLANG_LEX_MACROARGS_H |
15 | | |
16 | | #include "clang/Basic/LLVM.h" |
17 | | #include "clang/Lex/Token.h" |
18 | | #include "llvm/ADT/ArrayRef.h" |
19 | | #include "llvm/Support/TrailingObjects.h" |
20 | | #include <vector> |
21 | | |
22 | | namespace clang { |
23 | | class MacroInfo; |
24 | | class Preprocessor; |
25 | | class SourceLocation; |
26 | | |
27 | | /// MacroArgs - An instance of this class captures information about |
28 | | /// the formal arguments specified to a function-like macro invocation. |
29 | | class MacroArgs final |
30 | | : private llvm::TrailingObjects<MacroArgs, Token> { |
31 | | |
32 | | friend TrailingObjects; |
33 | | /// NumUnexpArgTokens - The number of raw, unexpanded tokens for the |
34 | | /// arguments. All of the actual argument tokens are allocated immediately |
35 | | /// after the MacroArgs object in memory. This is all of the arguments |
36 | | /// concatenated together, with 'EOF' markers at the end of each argument. |
37 | | unsigned NumUnexpArgTokens; |
38 | | |
39 | | /// VarargsElided - True if this is a C99 style varargs macro invocation and |
40 | | /// there was no argument specified for the "..." argument. If the argument |
41 | | /// was specified (even empty) or this isn't a C99 style varargs function, or |
42 | | /// if in strict mode and the C99 varargs macro had only a ... argument, this |
43 | | /// is false. |
44 | | bool VarargsElided; |
45 | | |
46 | | /// PreExpArgTokens - Pre-expanded tokens for arguments that need them. Empty |
47 | | /// if not yet computed. This includes the EOF marker at the end of the |
48 | | /// stream. |
49 | | std::vector<std::vector<Token> > PreExpArgTokens; |
50 | | |
51 | | /// ArgCache - This is a linked list of MacroArgs objects that the |
52 | | /// Preprocessor owns which we use to avoid thrashing malloc/free. |
53 | | MacroArgs *ArgCache; |
54 | | |
55 | | /// MacroArgs - The number of arguments the invoked macro expects. |
56 | | unsigned NumMacroArgs; |
57 | | |
58 | | MacroArgs(unsigned NumToks, bool varargsElided, unsigned MacroArgs) |
59 | | : NumUnexpArgTokens(NumToks), VarargsElided(varargsElided), |
60 | 80.5k | ArgCache(nullptr), NumMacroArgs(MacroArgs) {} |
61 | 39.5k | ~MacroArgs() = default; |
62 | | |
63 | | public: |
64 | | /// MacroArgs ctor function - Create a new MacroArgs object with the specified |
65 | | /// macro and argument info. |
66 | | static MacroArgs *create(const MacroInfo *MI, |
67 | | ArrayRef<Token> UnexpArgTokens, |
68 | | bool VarargsElided, Preprocessor &PP); |
69 | | |
70 | | /// destroy - Destroy and deallocate the memory for this object. |
71 | | /// |
72 | | void destroy(Preprocessor &PP); |
73 | | |
74 | | /// ArgNeedsPreexpansion - If we can prove that the argument won't be affected |
75 | | /// by pre-expansion, return false. Otherwise, conservatively return true. |
76 | | bool ArgNeedsPreexpansion(const Token *ArgTok, Preprocessor &PP) const; |
77 | | |
78 | | /// getUnexpArgument - Return a pointer to the first token of the unexpanded |
79 | | /// token list for the specified formal. |
80 | | /// |
81 | | const Token *getUnexpArgument(unsigned Arg) const; |
82 | | |
83 | | /// getArgLength - Given a pointer to an expanded or unexpanded argument, |
84 | | /// return the number of tokens, not counting the EOF, that make up the |
85 | | /// argument. |
86 | | static unsigned getArgLength(const Token *ArgPtr); |
87 | | |
88 | | /// getPreExpArgument - Return the pre-expanded form of the specified |
89 | | /// argument. |
90 | | const std::vector<Token> & |
91 | | getPreExpArgument(unsigned Arg, Preprocessor &PP); |
92 | | |
93 | | /// getNumMacroArguments - Return the number of arguments the invoked macro |
94 | | /// expects. |
95 | 49.8M | unsigned getNumMacroArguments() const { return NumMacroArgs; } |
96 | | |
97 | | /// isVarargsElidedUse - Return true if this is a C99 style varargs macro |
98 | | /// invocation and there was no argument specified for the "..." argument. If |
99 | | /// the argument was specified (even empty) or this isn't a C99 style varargs |
100 | | /// function, or if in strict mode and the C99 varargs macro had only a ... |
101 | | /// argument, this returns false. |
102 | 28.0M | bool isVarargsElidedUse() const { return VarargsElided; } |
103 | | |
104 | | /// Returns true if the macro was defined with a variadic (ellipsis) parameter |
105 | | /// AND was invoked with at least one token supplied as a variadic argument |
106 | | /// (after pre-expansion). |
107 | | /// |
108 | | /// \code |
109 | | /// #define F(a) a |
110 | | /// #define V(a, ...) __VA_OPT__(a) |
111 | | /// F() <-- returns false on this invocation. |
112 | | /// V(,a) <-- returns true on this invocation. |
113 | | /// V(,) <-- returns false on this invocation. |
114 | | /// V(,F()) <-- returns false on this invocation. |
115 | | /// \endcode |
116 | | /// |
117 | | bool invokedWithVariadicArgument(const MacroInfo *const MI, Preprocessor &PP); |
118 | | |
119 | | /// StringifyArgument - Implement C99 6.10.3.2p2, converting a sequence of |
120 | | /// tokens into the literal string token that should be produced by the C # |
121 | | /// preprocessor operator. If Charify is true, then it should be turned into |
122 | | /// a character literal for the Microsoft charize (#@) extension. |
123 | | /// |
124 | | static Token StringifyArgument(const Token *ArgToks, |
125 | | Preprocessor &PP, bool Charify, |
126 | | SourceLocation ExpansionLocStart, |
127 | | SourceLocation ExpansionLocEnd); |
128 | | |
129 | | |
130 | | /// deallocate - This should only be called by the Preprocessor when managing |
131 | | /// its freelist. |
132 | | MacroArgs *deallocate(); |
133 | | }; |
134 | | |
135 | | } // end namespace clang |
136 | | |
137 | | #endif |