Lines Matching refs:that
87 "We assume that the input buffer has a null character at the end"
132 /// assumes that the associated file buffer and Preprocessor objects will
145 /// suitable for calls to 'LexFromRawLexer'. This lexer assumes that the text
157 /// suitable for calls to 'LexFromRawLexer'. This lexer assumes that the text
173 /// _Pragma expansion. This has a variety of magic semantics that this method
174 /// sets up. It returns a new'd Lexer that must be delete'd when done.
177 /// spelling loc that indicates the bytes to be lexed for the token and an
178 /// expansion location that indicates where all lexed tokens should be
182 /// normal lexer that remaps tokens as they fly by. This would require making
183 /// Preprocessor::Lex virtual. Given that, we could just dump in a magic lexer
184 /// interface that could handle this stuff. This would pull GetMappedTokenLoc
198 // Now that the lexer is created, change the start/end locations so that we
199 // just lex the subsection of the file that we want. This is lexing from a
207 // Set the SourceLocation with the remapping information. This ensures that
213 // Ensure that the lexer thinks it is inside a directive, so that end \n will
316 "NeedsCleaning flag set on token that didn't need cleaning!");
393 /// Note that this method may do two possible things: it may either fill in
444 /// that are part of that.
488 /// Returns the pointer that points to the beginning of line that contains
521 // (or the buffer). We'll relex from that point.
533 // Lex tokens until we find the token that contains the source location.
541 // return the beginning of that token.
546 // that it points into whitespace. We're done here.
586 // Create a lexer starting at the beginning of the file. Note that we use a
587 // "fake" file source location at offset 1 so that the lexer will track our
639 // and we're about to exceed that limit, we're done.
698 // directive or it was one that can't occur in the preamble at this
703 // We hit a token that we don't recognize as being in the
734 // The usual case is that tokens don't contain anything interesting. Skip
745 // If we have a character that may be a trigraph or escaped newline, use a
757 // detail of this is that the escape may be made by a trigraph.
767 /// This routine can be used to produce a source location that
770 /// token where it expected something different that it received. If
990 // For macro arguments we need to check that the argument did not come
1016 // name so that we can render it into the expansion note.
1041 // name so that we can render it into the expansion note.
1138 // Otherwise, this is the _Pragma lexer case, which pretends that all of the
1154 /// GetTrigraphCharForLetter - Given a character that occurs after a ?? pair,
1267 /// Checks that the given token is the first token that occurs after the
1312 /// know that we can accumulate into Size, and that we have already incremented
1330 // Remember that this token needs to be cleaned.
1354 // Remember that this token needs to be cleaned.
1370 /// getCharAndSizeNoWarn method. Here we know that we can accumulate into Size,
1371 /// and that we have already incremented Ptr by Size bytes.
1420 /// Routine that indiscriminately sets the offset into the source file.
1512 /// source character that is unlikely to be an intentional identifier
1669 // Note that we have to call PP->LookUpIdentifierInfo() even for code
1680 // an identifier (i.e. at the start, in the middle, at the end). Note that
1685 // Note that code completion token is not added as a separate character
1696 // Finally, now that we know we have an identifier, pass this off to the
1844 // that does not start with an underscore is ill-formed. As a conforming
1847 // likely to be a ud-suffix than a macro, however, and accept that.
1998 // there's not much we can do about that.
2247 /// newline character that terminates the comment. Then update BufferPtr and
2264 // Scan over the body of the comment. The common case, when scanning, is that
2269 // character that ends the line comment.
2327 // Okay, we found a // comment that ends in a newline, if the next
2369 // return immediately, so that the lexer can return this as an EOD token.
2377 // contribute to another token), it isn't needed for correctness. Note that
2379 /// comment above in that mode.
2420 /// a diagnostic if so. We know that the newline is inside of a block comment.
2457 // If no trigraphs are enabled, warn that we ignored this trigraph and
2486 /// We have just read from input the / and * characters that started a comment.
2487 /// Read until we find the * and / characters that terminate the comment.
2488 /// Note that we don't bother decoding trigraphs or escaped newlines in block
2490 /// that can happen is the comment could end with an escaped newline between
2651 // Otherwise, just return so that the next character will be lexed as a token.
2736 // that put us in raw mode handle the event.
2796 // Switch to 'skipping' mode. This will ensure that we can lex a token
2801 // Save state that can be changed while lexing so that we can restore it.
2811 // Restore state that may have changed.
2911 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
3118 // Note that we can /only/ do this when the non-ASCII character is actually
3119 // spelled as Unicode, not written as a UCN. The standard requires that
3122 // characters that allows us to map these particular characters to, say,
3131 // Otherwise, we have an explicit UCN or a character that's unlikely to show
3142 // Note that this doesn't affect IsAtPhysicalStartOfLine.
3176 /// extremely performance critical piece of code. This assumes that the buffer
3179 /// that the Flags of result have been cleared before calling this.
3317 // Notify MIOpt that we read a non-whitespace/non-comment token.
3322 // Notify MIOpt that we read a non-whitespace/non-comment token.
3380 // Notify MIOpt that we read a non-whitespace/non-comment token.
3409 // Notify MIOpt that we read a non-whitespace/non-comment token.
3425 // Notify MIOpt that we read a non-whitespace/non-comment token.
3459 // Notify MIOpt that we read a non-whitespace/non-comment token.
3467 // Notify MIOpt that we read a non-whitespace/non-comment token.
3477 // Notify MIOpt that we read a non-whitespace/non-comment token.
3483 // Notify MIOpt that we read a non-whitespace/non-comment token.
3514 // Notify MIOpt that we read a non-whitespace/non-comment token.
3599 // that in one particular corner case, this can change the behavior of the
3603 // If so, we will lex that as a "/" instead of the start of a comment.
3939 // Notify MIOpt that we read a non-whitespace/non-comment token.