Chris Lattner | d217773 | 2007-07-20 16:59:19 +0000 | [diff] [blame] | 1 | //===--- Token.h - Token interface ------------------------------*- C++ -*-===// |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Chris Lattner | d217773 | 2007-07-20 16:59:19 +0000 | [diff] [blame] | 10 | // This file defines the Token interface. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame^] | 14 | #ifndef LLVM_CLANG_LEX_TOKEN_H |
| 15 | #define LLVM_CLANG_LEX_TOKEN_H |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 16 | |
Chandler Carruth | 30a2e16 | 2012-12-04 09:18:49 +0000 | [diff] [blame] | 17 | #include "clang/Basic/OperatorKinds.h" |
| 18 | #include "clang/Basic/SourceLocation.h" |
Douglas Gregor | 39a8de1 | 2009-02-25 19:37:18 +0000 | [diff] [blame] | 19 | #include "clang/Basic/TemplateKinds.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 20 | #include "clang/Basic/TokenKinds.h" |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 21 | #include "llvm/ADT/StringRef.h" |
Douglas Gregor | ac1afdc | 2009-02-25 19:48:02 +0000 | [diff] [blame] | 22 | #include <cstdlib> |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 23 | |
| 24 | namespace clang { |
| 25 | |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 26 | class IdentifierInfo; |
| 27 | |
Chris Lattner | d217773 | 2007-07-20 16:59:19 +0000 | [diff] [blame] | 28 | /// Token - This structure provides full information about a lexed token. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 29 | /// It is not intended to be space efficient, it is intended to return as much |
| 30 | /// information as possible about each returned token. This is expected to be |
| 31 | /// compressed into a smaller form if memory footprint is important. |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 32 | /// |
| 33 | /// The parser can create a special "annotation token" representing a stream of |
| 34 | /// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>" |
| 35 | /// can be represented by a single typename annotation token that carries |
| 36 | /// information about the SourceRange of the tokens and the type object. |
Chris Lattner | d217773 | 2007-07-20 16:59:19 +0000 | [diff] [blame] | 37 | class Token { |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 38 | /// The location of the token. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 39 | SourceLocation Loc; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 40 | |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 41 | // Conceptually these next two fields could be in a union. However, this |
| 42 | // causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical |
| 43 | // routine. Keeping as separate members with casts until a more beautiful fix |
| 44 | // presents itself. |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 45 | |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 46 | /// UintData - This holds either the length of the token text, when |
| 47 | /// a normal token, or the end of the SourceRange when an annotation |
| 48 | /// token. |
| 49 | unsigned UintData; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 50 | |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 51 | /// PtrData - This is a union of four different pointer types, which depends |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 52 | /// on what type of token this is: |
| 53 | /// Identifiers, keywords, etc: |
| 54 | /// This is an IdentifierInfo*, which contains the uniqued identifier |
| 55 | /// spelling. |
| 56 | /// Literals: isLiteral() returns true. |
| 57 | /// This is a pointer to the start of the token in a text buffer, which |
| 58 | /// may be dirty (have trigraphs / escaped newlines). |
| 59 | /// Annotations (resolved type names, C++ scopes, etc): isAnnotation(). |
| 60 | /// This is a pointer to sema-specific data for the annotation token. |
| 61 | /// Other: |
| 62 | /// This is null. |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 63 | void *PtrData; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 64 | |
| 65 | /// Kind - The actual flavor of token this is. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 66 | tok::TokenKind Kind; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 67 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 68 | /// Flags - Bits we track about this token, members of the TokenFlags enum. |
Daniel Dunbar | 082fb9a | 2009-11-04 00:34:40 +0000 | [diff] [blame] | 69 | unsigned char Flags; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 70 | public: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 71 | |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 72 | // Various flags set per token: |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 73 | enum TokenFlags { |
Eli Friedman | d2f9308 | 2013-09-19 00:41:32 +0000 | [diff] [blame] | 74 | StartOfLine = 0x01, // At start of line or only after whitespace |
| 75 | // (considering the line after macro expansion). |
| 76 | LeadingSpace = 0x02, // Whitespace exists before this token (considering |
| 77 | // whitespace after macro expansion). |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 78 | DisableExpand = 0x04, // This identifier may never be macro expanded. |
Jordan Rose | c7629d9 | 2013-01-24 20:50:46 +0000 | [diff] [blame] | 79 | NeedsCleaning = 0x08, // Contained an escaped newline or trigraph. |
Richard Smith | 99831e4 | 2012-03-06 03:21:47 +0000 | [diff] [blame] | 80 | LeadingEmptyMacro = 0x10, // Empty macro exists before this token. |
Jordan Rose | c7629d9 | 2013-01-24 20:50:46 +0000 | [diff] [blame] | 81 | HasUDSuffix = 0x20, // This string or character literal has a ud-suffix. |
Reid Kleckner | 11be064 | 2013-06-26 17:16:08 +0000 | [diff] [blame] | 82 | HasUCN = 0x40, // This identifier contains a UCN. |
Nico Weber | 2ccf698 | 2013-06-26 17:31:55 +0000 | [diff] [blame] | 83 | IgnoredComma = 0x80 // This comma is not a macro argument separator (MS). |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 84 | }; |
| 85 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 86 | tok::TokenKind getKind() const { return Kind; } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 87 | void setKind(tok::TokenKind K) { Kind = K; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 88 | |
Chris Lattner | 0007322 | 2007-10-09 17:23:58 +0000 | [diff] [blame] | 89 | /// is/isNot - Predicates to check if this token is a specific kind, as in |
| 90 | /// "if (Tok.is(tok::l_brace)) {...}". |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 91 | bool is(tok::TokenKind K) const { return Kind == K; } |
| 92 | bool isNot(tok::TokenKind K) const { return Kind != K; } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 93 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 94 | /// \brief Return true if this is a raw identifier (when lexing |
Abramo Bagnara | c4bf2b9 | 2010-12-22 08:23:18 +0000 | [diff] [blame] | 95 | /// in raw mode) or a non-keyword identifier (when lexing in non-raw mode). |
| 96 | bool isAnyIdentifier() const { |
Alexander Kornienko | 66da0ab | 2012-09-28 22:24:03 +0000 | [diff] [blame] | 97 | return tok::isAnyIdentifier(getKind()); |
Abramo Bagnara | c4bf2b9 | 2010-12-22 08:23:18 +0000 | [diff] [blame] | 98 | } |
| 99 | |
Alexander Kornienko | 66da0ab | 2012-09-28 22:24:03 +0000 | [diff] [blame] | 100 | /// \brief Return true if this is a "literal", like a numeric |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 101 | /// constant, string, etc. |
| 102 | bool isLiteral() const { |
Alexander Kornienko | 66da0ab | 2012-09-28 22:24:03 +0000 | [diff] [blame] | 103 | return tok::isLiteral(getKind()); |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 104 | } |
| 105 | |
Alexander Kornienko | 66da0ab | 2012-09-28 22:24:03 +0000 | [diff] [blame] | 106 | /// \brief Return true if this is any of tok::annot_* kind tokens. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 107 | bool isAnnotation() const { |
Alexander Kornienko | 66da0ab | 2012-09-28 22:24:03 +0000 | [diff] [blame] | 108 | return tok::isAnnotation(getKind()); |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 109 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 110 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 111 | /// \brief Return a source location identifier for the specified |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 112 | /// offset in the current file. |
| 113 | SourceLocation getLocation() const { return Loc; } |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 114 | unsigned getLength() const { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 115 | assert(!isAnnotation() && "Annotation tokens have no length field"); |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 116 | return UintData; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 117 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 118 | |
| 119 | void setLocation(SourceLocation L) { Loc = L; } |
Chris Lattner | 79ed16e | 2009-01-06 05:25:04 +0000 | [diff] [blame] | 120 | void setLength(unsigned Len) { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 121 | assert(!isAnnotation() && "Annotation tokens have no length field"); |
Chris Lattner | 79ed16e | 2009-01-06 05:25:04 +0000 | [diff] [blame] | 122 | UintData = Len; |
| 123 | } |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 124 | |
| 125 | SourceLocation getAnnotationEndLoc() const { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 126 | assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token"); |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 127 | return SourceLocation::getFromRawEncoding(UintData); |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 128 | } |
| 129 | void setAnnotationEndLoc(SourceLocation L) { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 130 | assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token"); |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 131 | UintData = L.getRawEncoding(); |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 132 | } |
| 133 | |
Sebastian Redl | 39d6711 | 2010-02-08 19:35:18 +0000 | [diff] [blame] | 134 | SourceLocation getLastLoc() const { |
| 135 | return isAnnotation() ? getAnnotationEndLoc() : getLocation(); |
| 136 | } |
| 137 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 138 | /// \brief SourceRange of the group of tokens that this annotation token |
| 139 | /// represents. |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 140 | SourceRange getAnnotationRange() const { |
| 141 | return SourceRange(getLocation(), getAnnotationEndLoc()); |
| 142 | } |
| 143 | void setAnnotationRange(SourceRange R) { |
| 144 | setLocation(R.getBegin()); |
| 145 | setAnnotationEndLoc(R.getEnd()); |
| 146 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 147 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 148 | const char *getName() const { return tok::getTokenName(Kind); } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 149 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 150 | /// \brief Reset all flags to cleared. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 151 | void startToken() { |
Chris Lattner | 79ed16e | 2009-01-06 05:25:04 +0000 | [diff] [blame] | 152 | Kind = tok::unknown; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 153 | Flags = 0; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 154 | PtrData = nullptr; |
Chris Lattner | c54539c | 2010-06-15 21:06:38 +0000 | [diff] [blame] | 155 | UintData = 0; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 156 | Loc = SourceLocation(); |
| 157 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 158 | |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 159 | IdentifierInfo *getIdentifierInfo() const { |
Abramo Bagnara | c4bf2b9 | 2010-12-22 08:23:18 +0000 | [diff] [blame] | 160 | assert(isNot(tok::raw_identifier) && |
| 161 | "getIdentifierInfo() on a tok::raw_identifier token!"); |
| 162 | assert(!isAnnotation() && |
| 163 | "getIdentifierInfo() on an annotation token!"); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 164 | if (isLiteral()) return nullptr; |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 165 | return (IdentifierInfo*) PtrData; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 166 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 167 | void setIdentifierInfo(IdentifierInfo *II) { |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 168 | PtrData = (void*) II; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 169 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 170 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 171 | /// getRawIdentifier - For a raw identifier token (i.e., an identifier |
| 172 | /// lexed in raw mode), returns a reference to the text substring in the |
| 173 | /// buffer if known. |
| 174 | StringRef getRawIdentifier() const { |
Abramo Bagnara | c4bf2b9 | 2010-12-22 08:23:18 +0000 | [diff] [blame] | 175 | assert(is(tok::raw_identifier)); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 176 | return StringRef(reinterpret_cast<const char *>(PtrData), getLength()); |
Abramo Bagnara | c4bf2b9 | 2010-12-22 08:23:18 +0000 | [diff] [blame] | 177 | } |
| 178 | void setRawIdentifierData(const char *Ptr) { |
| 179 | assert(is(tok::raw_identifier)); |
| 180 | PtrData = const_cast<char*>(Ptr); |
| 181 | } |
| 182 | |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 183 | /// getLiteralData - For a literal token (numeric constant, string, etc), this |
| 184 | /// returns a pointer to the start of it in the text buffer if known, null |
| 185 | /// otherwise. |
| 186 | const char *getLiteralData() const { |
| 187 | assert(isLiteral() && "Cannot get literal data of non-literal"); |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 188 | return reinterpret_cast<const char*>(PtrData); |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 189 | } |
| 190 | void setLiteralData(const char *Ptr) { |
| 191 | assert(isLiteral() && "Cannot set literal data of non-literal"); |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 192 | PtrData = const_cast<char*>(Ptr); |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 193 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 194 | |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 195 | void *getAnnotationValue() const { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 196 | assert(isAnnotation() && "Used AnnotVal on non-annotation token"); |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 197 | return PtrData; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 198 | } |
| 199 | void setAnnotationValue(void *val) { |
Chris Lattner | 47246be | 2009-01-26 19:29:26 +0000 | [diff] [blame] | 200 | assert(isAnnotation() && "Used AnnotVal on non-annotation token"); |
Daniel Dunbar | b28d6de | 2008-11-20 08:01:39 +0000 | [diff] [blame] | 201 | PtrData = val; |
Argyrios Kyrtzidis | 3604e38 | 2008-11-08 16:17:04 +0000 | [diff] [blame] | 202 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 203 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 204 | /// \brief Set the specified flag. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 205 | void setFlag(TokenFlags Flag) { |
| 206 | Flags |= Flag; |
| 207 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 208 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 209 | /// \brief Unset the specified flag. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 210 | void clearFlag(TokenFlags Flag) { |
| 211 | Flags &= ~Flag; |
| 212 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 213 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 214 | /// \brief Return the internal represtation of the flags. |
| 215 | /// |
| 216 | /// This is only intended for low-level operations such as writing tokens to |
| 217 | /// disk. |
Ted Kremenek | ef3b215 | 2008-10-21 03:32:15 +0000 | [diff] [blame] | 218 | unsigned getFlags() const { |
| 219 | return Flags; |
| 220 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 221 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 222 | /// \brief Set a flag to either true or false. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 223 | void setFlagValue(TokenFlags Flag, bool Val) { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 224 | if (Val) |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 225 | setFlag(Flag); |
| 226 | else |
| 227 | clearFlag(Flag); |
| 228 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 229 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 230 | /// isAtStartOfLine - Return true if this token is at the start of a line. |
| 231 | /// |
Chris Lattner | b812814 | 2007-09-03 18:28:41 +0000 | [diff] [blame] | 232 | bool isAtStartOfLine() const { return (Flags & StartOfLine) ? true : false; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 233 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 234 | /// \brief Return true if this token has whitespace before it. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 235 | /// |
Chris Lattner | b812814 | 2007-09-03 18:28:41 +0000 | [diff] [blame] | 236 | bool hasLeadingSpace() const { return (Flags & LeadingSpace) ? true : false; } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 237 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 238 | /// \brief Return true if this identifier token should never |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 239 | /// be expanded in the future, due to C99 6.10.3.4p2. |
Ted Kremenek | 8e748ab | 2008-02-23 01:05:54 +0000 | [diff] [blame] | 240 | bool isExpandDisabled() const { |
| 241 | return (Flags & DisableExpand) ? true : false; |
| 242 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 243 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 244 | /// \brief Return true if we have an ObjC keyword identifier. |
Steve Naroff | 861cf3e | 2007-08-23 18:16:40 +0000 | [diff] [blame] | 245 | bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 246 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 247 | /// \brief Return the ObjC keyword kind. |
Steve Naroff | 861cf3e | 2007-08-23 18:16:40 +0000 | [diff] [blame] | 248 | tok::ObjCKeywordKind getObjCKeywordID() const; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 249 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 250 | /// \brief Return true if this token has trigraphs or escaped newlines in it. |
Sean Hunt | 6cf7502 | 2010-08-30 17:47:05 +0000 | [diff] [blame] | 251 | bool needsCleaning() const { return (Flags & NeedsCleaning) ? true : false; } |
Argyrios Kyrtzidis | 44aa1f3 | 2010-11-20 02:04:01 +0000 | [diff] [blame] | 252 | |
| 253 | /// \brief Return true if this token has an empty macro before it. |
| 254 | /// |
| 255 | bool hasLeadingEmptyMacro() const { |
| 256 | return (Flags & LeadingEmptyMacro) ? true : false; |
| 257 | } |
| 258 | |
Richard Smith | 99831e4 | 2012-03-06 03:21:47 +0000 | [diff] [blame] | 259 | /// \brief Return true if this token is a string or character literal which |
| 260 | /// has a ud-suffix. |
| 261 | bool hasUDSuffix() const { return (Flags & HasUDSuffix) ? true : false; } |
Jordan Rose | c7629d9 | 2013-01-24 20:50:46 +0000 | [diff] [blame] | 262 | |
| 263 | /// Returns true if this token contains a universal character name. |
| 264 | bool hasUCN() const { return (Flags & HasUCN) ? true : false; } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 265 | }; |
| 266 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 267 | /// \brief Information about the conditional stack (\#if directives) |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 268 | /// currently active. |
| 269 | struct PPConditionalInfo { |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 270 | /// \brief Location where the conditional started. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 271 | SourceLocation IfLoc; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 272 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 273 | /// \brief True if this was contained in a skipping directive, e.g., |
| 274 | /// in a "\#if 0" block. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 275 | bool WasSkipping; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 276 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 277 | /// \brief True if we have emitted tokens already, and now we're in |
| 278 | /// an \#else block or something. Only useful in Skipping blocks. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 279 | bool FoundNonSkip; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 280 | |
James Dennett | a1e92ac | 2012-06-17 05:49:13 +0000 | [diff] [blame] | 281 | /// \brief True if we've seen a \#else in this block. If so, |
| 282 | /// \#elif/\#else directives are not allowed. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 283 | bool FoundElse; |
| 284 | }; |
| 285 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 286 | } // end namespace clang |
| 287 | |
Benjamin Kramer | 1c573cb | 2010-06-08 11:23:26 +0000 | [diff] [blame] | 288 | namespace llvm { |
| 289 | template <> |
| 290 | struct isPodLike<clang::Token> { static const bool value = true; }; |
| 291 | } // end namespace llvm |
| 292 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 293 | #endif |