Remove manual conditional error handling code.
llvm-svn: 38540
diff --git a/clang/Lex/Preprocessor.cpp b/clang/Lex/Preprocessor.cpp
index 7398e7e..7f3a0c6 100644
--- a/clang/Lex/Preprocessor.cpp
+++ b/clang/Lex/Preprocessor.cpp
@@ -110,23 +110,23 @@
/// Diag - Forwarding function for diagnostics. This emits a diagnostic at
/// the specified LexerToken's location, translating the token's start
/// position in the current buffer into a SourcePosition object for rendering.
-bool Preprocessor::Diag(SourceLocation Loc, unsigned DiagID,
+void Preprocessor::Diag(SourceLocation Loc, unsigned DiagID,
const std::string &Msg) {
// If we are in a '#if 0' block, don't emit any diagnostics for notes,
// warnings or extensions.
if (isSkipping() && Diagnostic::isNoteWarningOrExtension(DiagID))
- return false;
+ return;
- return Diags.Report(Loc, DiagID, Msg);
+ Diags.Report(Loc, DiagID, Msg);
}
-bool Preprocessor::Diag(const LexerToken &Tok, unsigned DiagID,
+void Preprocessor::Diag(const LexerToken &Tok, unsigned DiagID,
const std::string &Msg) {
// If we are in a '#if 0' block, don't emit any diagnostics for notes,
// warnings or extensions.
if (isSkipping() && Diagnostic::isNoteWarningOrExtension(DiagID))
- return false;
+ return;
- return Diag(Tok.getSourceLocation(), DiagID, Msg);
+ Diag(Tok.getSourceLocation(), DiagID, Msg);
}
void Preprocessor::PrintStats() {
@@ -251,8 +251,8 @@
}
/// EnterMacro - Add a Macro to the top of the include stack and start lexing
-/// tokens from it instead of the current buffer. Return true on failure.
-bool Preprocessor::EnterMacro(LexerToken &Tok) {
+/// tokens from it instead of the current buffer.
+void Preprocessor::EnterMacro(LexerToken &Tok) {
IdentifierTokenInfo *Identifier = Tok.getIdentifierInfo();
MacroInfo &MI = *Identifier->getMacroInfo();
SourceLocation ExpandLoc = Tok.getSourceLocation();
@@ -277,7 +277,6 @@
CurMacroExpander = new MacroExpander(MI, MacroID, *this,
Tok.isAtStartOfLine(),
Tok.hasLeadingSpace());
- return false;
}
@@ -288,12 +287,12 @@
/// HandleIdentifier - This callback is invoked when the lexer reads an
/// identifier. This callback looks up the identifier in the map and/or
/// potentially macro expands it or turns it into a named token (like 'for').
-bool Preprocessor::HandleIdentifier(LexerToken &Identifier) {
+void Preprocessor::HandleIdentifier(LexerToken &Identifier) {
if (Identifier.getIdentifierInfo() == 0) {
// If we are skipping tokens (because we are in a #if 0 block), there will
// be no identifier info, just return the token.
assert(isSkipping() && "Token isn't an identifier?");
- return false;
+ return;
}
IdentifierTokenInfo &ITI = *Identifier.getIdentifierInfo();
@@ -313,7 +312,7 @@
bool HadLeadingSpace = Identifier.hasLeadingSpace();
bool IsAtStartOfLine = Identifier.isAtStartOfLine();
- if (Lex(Identifier)) return true;
+ Lex(Identifier);
// If the identifier isn't on some OTHER line, inherit the leading
// whitespace/first-on-a-line property of this token. This handles
@@ -324,7 +323,7 @@
if (HadLeadingSpace) Identifier.SetFlag(LexerToken::LeadingSpace);
}
++NumFastMacroExpanded;
- return false;
+ return;
} else if (MI->getNumTokens() == 1 &&
// Don't handle identifiers, which might need recursive
@@ -353,12 +352,11 @@
// Since this is not an identifier token, it can't be macro expanded, so
// we're done.
++NumFastMacroExpanded;
- return false;
+ return;
}
// Start expanding the macro (FIXME, pass arguments).
- if (EnterMacro(Identifier))
- return true;
+ EnterMacro(Identifier);
// Now that the macro is at the top of the include stack, ask the
// preprocessor to read the next token from it.
@@ -371,15 +369,13 @@
Identifier.SetKind(ITI.getTokenID());
// If this is an extension token, diagnose its use.
- if (ITI.isExtensionToken() && Diag(Identifier, diag::ext_token_used))
- return true;
- return false;
+ if (ITI.isExtensionToken()) Diag(Identifier, diag::ext_token_used);
}
/// HandleEndOfFile - This callback is invoked when the lexer hits the end of
/// the current file. This either returns the EOF token or pops a level off
/// the include stack and keeps going.
-bool Preprocessor::HandleEndOfFile(LexerToken &Result) {
+void Preprocessor::HandleEndOfFile(LexerToken &Result) {
assert(!CurMacroExpander &&
"Ending a file when currently in a macro!");
@@ -392,7 +388,7 @@
Result.SetKind(tok::eof);
Result.SetStart(CurLexer->BufferEnd);
Result.SetEnd(CurLexer->BufferEnd);
- return false;
+ return;
}
// If this is a #include'd file, pop it off the include stack and continue
@@ -414,13 +410,11 @@
// We're done with the #included file.
delete CurLexer;
CurLexer = 0;
- return false;
}
/// HandleEndOfMacro - This callback is invoked when the lexer hits the end of
-/// the current macro. This either returns the EOF token or pops a level off
-/// the include stack and keeps going.
-bool Preprocessor::HandleEndOfMacro(LexerToken &Result) {
+/// the current macro line.
+void Preprocessor::HandleEndOfMacro(LexerToken &Result) {
assert(CurMacroExpander && !CurLexer &&
"Ending a macro when currently in a #include file!");
@@ -447,29 +441,26 @@
/// DiscardUntilEndOfDirective - Read and discard all tokens remaining on the
/// current line until the tok::eom token is found.
-bool Preprocessor::DiscardUntilEndOfDirective() {
+void Preprocessor::DiscardUntilEndOfDirective() {
LexerToken Tmp;
do {
- if (LexUnexpandedToken(Tmp)) return true;
+ LexUnexpandedToken(Tmp);
} while (Tmp.getKind() != tok::eom);
- return false;
}
/// ReadMacroName - Lex and validate a macro name, which occurs after a
/// #define or #undef. This sets the token kind to eom and discards the rest
/// of the macro line if the macro name is invalid.
-bool Preprocessor::ReadMacroName(LexerToken &MacroNameTok) {
+void Preprocessor::ReadMacroName(LexerToken &MacroNameTok) {
// Read the token, don't allow macro expansion on it.
- if (LexUnexpandedToken(MacroNameTok))
- return true;
+ LexUnexpandedToken(MacroNameTok);
// Missing macro name?
if (MacroNameTok.getKind() == tok::eom)
return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
if (MacroNameTok.getIdentifierInfo() == 0) {
- if (Diag(MacroNameTok, diag::err_pp_macro_not_identifier))
- return true;
+ Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
// Fall through on error.
} else if (0) {
// FIXME: Error if defining a C++ named operator.
@@ -479,7 +470,7 @@
// in C99 6.10.8.4.
} else {
// Okay, we got a good identifier node. Return it.
- return false;
+ return;
}
@@ -491,17 +482,15 @@
/// CheckEndOfDirective - Ensure that the next token is a tok::eom token. If
/// not, emit a diagnostic and consume up until the eom.
-bool Preprocessor::CheckEndOfDirective(const char *DirType) {
+void Preprocessor::CheckEndOfDirective(const char *DirType) {
LexerToken Tmp;
- if (Lex(Tmp)) return true;
+ Lex(Tmp);
// There should be no tokens after the directive, but we allow them as an
// extension.
if (Tmp.getKind() != tok::eom) {
- if (Diag(Tmp, diag::ext_pp_extra_tokens_at_eol, DirType) ||
- DiscardUntilEndOfDirective())
- return true;
+ Diag(Tmp, diag::ext_pp_extra_tokens_at_eol, DirType);
+ DiscardUntilEndOfDirective();
}
- return false;
}
@@ -514,7 +503,7 @@
/// is true, then #else directives are ok, if not, then we have already seen one
/// so a #else directive is a duplicate. When this returns, the caller can lex
/// the first valid token.
-bool Preprocessor::SkipExcludedConditionalBlock(const char *IfTokenLoc,
+void Preprocessor::SkipExcludedConditionalBlock(const char *IfTokenLoc,
bool FoundNonSkipPortion,
bool FoundElse) {
++NumSkipped;
@@ -536,7 +525,7 @@
SkippingContents = true;
LexerToken Tok;
while (1) {
- if (CurLexer->Lex(Tok)) return true;
+ CurLexer->Lex(Tok);
// If this is the end of the buffer, we have an error. The lexer will have
// already handled this error condition, so just return and let the caller
@@ -553,7 +542,7 @@
CurLexer->ParsingPreprocessorDirective = true;
// Read the next token, the directive flavor.
- if (LexUnexpandedToken(Tok)) return true;
+ LexUnexpandedToken(Tok);
// If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
// something bogus), skip it.
@@ -581,13 +570,13 @@
if (Directive == "if" || Directive == "ifdef" || Directive == "ifndef") {
// We know the entire #if/#ifdef/#ifndef block will be skipped, don't
// bother parsing the condition.
- if (DiscardUntilEndOfDirective()) return true;
+ DiscardUntilEndOfDirective();
CurLexer->pushConditionalLevel(Tok.getStart(), /*wasskipping*/true,
/*foundnonskip*/false,/*fnddelse*/false);
}
} else if (FirstChar == 'e') {
if (Directive == "endif") {
- if (CheckEndOfDirective("#endif")) return true;
+ CheckEndOfDirective("#endif");
PPConditionalInfo CondInfo;
CondInfo.WasSkipping = true; // Silence bogus warning.
bool InCond = CurLexer->popConditionalLevel(CondInfo);
@@ -600,12 +589,11 @@
// #else directive in a skipping conditional. If not in some other
// skipping conditional, and if #else hasn't already been seen, enter it
// as a non-skipping conditional.
- if (CheckEndOfDirective("#else")) return true;
+ CheckEndOfDirective("#else");
PPConditionalInfo &CondInfo = CurLexer->peekConditionalLevel();
// If this is a #else with a #else before it, report the error.
- if (CondInfo.FoundElse && Diag(Tok, diag::pp_err_else_after_else))
- return true;
+ if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
// Note that we've seen a #else in this conditional.
CondInfo.FoundElse = true;
@@ -623,7 +611,7 @@
// If this is in a skipping block or if we're already handled this #if
// block, don't bother parsing the condition.
if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
- if (DiscardUntilEndOfDirective()) return true;
+ DiscardUntilEndOfDirective();
ShouldEnter = false;
} else {
// Evaluate the #elif condition!
@@ -633,14 +621,12 @@
// looked up, etc, inside the #elif expression.
assert(SkippingContents && "We have to be skipping here!");
SkippingContents = false;
- if (EvaluateDirectiveExpression(ShouldEnter))
- return true;
+ EvaluateDirectiveExpression(ShouldEnter);
SkippingContents = true;
}
// If this is a #elif with a #else before it, report the error.
- if (CondInfo.FoundElse && Diag(Tok, diag::pp_err_elif_after_else))
- return true;
+ if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
// If this condition is true, enter it!
if (ShouldEnter) {
@@ -657,8 +643,6 @@
// of the file, just stop skipping and return to lexing whatever came after
// the #if block.
SkippingContents = false;
-
- return false;
}
//===----------------------------------------------------------------------===//
@@ -669,7 +653,7 @@
/// at the start of a line. This consumes the directive, modifies the
/// lexer/preprocessor state, and advances the lexer(s) so that the next token
/// read is the correct one.
-bool Preprocessor::HandleDirective(LexerToken &Result) {
+void Preprocessor::HandleDirective(LexerToken &Result) {
// FIXME: TRADITIONAL: # with whitespace before it not recognized by K&R?
// We just parsed a # character at the start of a line, so we're in directive
@@ -680,13 +664,12 @@
++NumDirectives;
// Read the next token, the directive flavor.
- if (LexUnexpandedToken(Result))
- return true; // Bail out.
+ LexUnexpandedToken(Result);
switch (Result.getKind()) {
default: break;
case tok::eom:
- return false; // null directive.
+ return; // null directive.
#if 0
case tok::numeric_constant:
@@ -737,10 +720,10 @@
#if 1
// Read the rest of the PP line.
do {
- if (Lex(Result)) return true;
+ Lex(Result);
} while (Result.getKind() != tok::eom);
- return false;
+ return;
#endif
} else if (Directive == "assert") {
isExtension = true;
@@ -749,9 +732,10 @@
case 7:
if (Directive == "include") // Handle #include.
return HandleIncludeDirective(Result);
- if (Directive == "warning")
- return Diag(Result, diag::ext_pp_warning_directive) ||
- HandleUserDiagnosticDirective(Result, true);
+ if (Directive == "warning") {
+ Diag(Result, diag::ext_pp_warning_directive);
+ HandleUserDiagnosticDirective(Result, true);
+ }
break;
case 8:
if (Directive == "unassert") {
@@ -767,19 +751,17 @@
}
// If we reached here, the preprocessing token is not valid!
- if (Diag(Result, diag::err_pp_invalid_directive))
- return true;
+ Diag(Result, diag::err_pp_invalid_directive);
// Read the rest of the PP line.
do {
- if (Lex(Result)) return true;
+ Lex(Result);
} while (Result.getKind() != tok::eom);
// Okay, we're done parsing the directive.
- return false;
}
-bool Preprocessor::HandleUserDiagnosticDirective(LexerToken &Result,
+void Preprocessor::HandleUserDiagnosticDirective(LexerToken &Result,
bool isWarning) {
// Read the rest of the line raw. We do this because we don't want macros
// to be expanded and we don't require that the tokens be valid preprocessing
@@ -796,17 +778,16 @@
/// file to be included from the lexer, then include it! This is a common
/// routine with functionality shared between #include, #include_next and
/// #import.
-bool Preprocessor::HandleIncludeDirective(LexerToken &IncludeTok,
+void Preprocessor::HandleIncludeDirective(LexerToken &IncludeTok,
const DirectoryLookup *LookupFrom,
bool isImport) {
++NumIncluded;
LexerToken FilenameTok;
- if (CurLexer->LexIncludeFilename(FilenameTok))
- return true;
+ CurLexer->LexIncludeFilename(FilenameTok);
// If the token kind is EOM, the error has already been diagnosed.
if (FilenameTok.getKind() == tok::eom)
- return false;
+ return;
// Check that we don't have infinite #include recursion.
if (IncludeStack.size() == MaxAllowedIncludeStackDepth-1)
@@ -853,12 +834,12 @@
FileInfo.isImport = true;
// Has this already been #import'ed or #include'd?
- if (FileInfo.NumIncludes) return false;
+ if (FileInfo.NumIncludes) return;
} else {
// Otherwise, if this is a #include of a file that was previously #import'd
// or if this is the second #include of a #pragma once file, ignore it.
if (FileInfo.isImport)
- return false;
+ return;
}
// Look up the file, create a File ID for it.
@@ -872,15 +853,12 @@
// Increment the number of times this file has been included.
++FileInfo.NumIncludes;
-
- return false;
}
/// HandleIncludeNextDirective - Implements #include_next.
///
-bool Preprocessor::HandleIncludeNextDirective(LexerToken &IncludeNextTok) {
- if (Diag(IncludeNextTok, diag::ext_pp_include_next_directive))
- return true;
+void Preprocessor::HandleIncludeNextDirective(LexerToken &IncludeNextTok) {
+ Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
// #include_next is like #include, except that we start searching after
// the current found directory. If we can't do this, issue a
@@ -888,11 +866,9 @@
const DirectoryLookup *Lookup = CurNextDirLookup;
if (IncludeStack.empty()) {
Lookup = 0;
- if (Diag(IncludeNextTok, diag::pp_include_next_in_primary))
- return true;
+ Diag(IncludeNextTok, diag::pp_include_next_in_primary);
} else if (Lookup == 0) {
- if (Diag(IncludeNextTok, diag::pp_include_next_absolute_path))
- return true;
+ Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
}
return HandleIncludeDirective(IncludeNextTok, Lookup);
@@ -900,8 +876,8 @@
/// HandleImportDirective - Implements #import.
///
-bool Preprocessor::HandleImportDirective(LexerToken &ImportTok) {
- if (Diag(ImportTok, diag::ext_pp_import_directive)) return true;
+void Preprocessor::HandleImportDirective(LexerToken &ImportTok) {
+ Diag(ImportTok, diag::ext_pp_import_directive);
return HandleIncludeDirective(ImportTok, 0, true);
}
@@ -909,35 +885,32 @@
/// HandleDefineDirective - Implements #define. This consumes the entire macro
/// line then lets the caller lex the next real token.
///
-bool Preprocessor::HandleDefineDirective(LexerToken &DefineTok) {
+void Preprocessor::HandleDefineDirective(LexerToken &DefineTok) {
++NumDefined;
LexerToken MacroNameTok;
- if (ReadMacroName(MacroNameTok))
- return true;
+ ReadMacroName(MacroNameTok);
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.getKind() == tok::eom)
- return false;
+ return;
MacroInfo *MI = new MacroInfo(MacroNameTok.getSourceLocation());
LexerToken Tok;
- if (LexUnexpandedToken(Tok)) return true;
+ LexUnexpandedToken(Tok);
if (Tok.getKind() == tok::eom) {
// If there is no body to this macro, we have no special handling here.
} else if (Tok.getKind() == tok::l_paren && !Tok.hasLeadingSpace()) {
// This is a function-like macro definition.
//assert(0 && "Function-like macros not implemented!");
-#warning function like macros
return DiscardUntilEndOfDirective();
} else if (!Tok.hasLeadingSpace()) {
// C99 requires whitespace between the macro definition and the body. Emit
// a diagnostic for something like "#define X+".
if (Features.C99) {
- if (Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name))
- return true;
+ Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
} else {
// FIXME: C90/C++ do not get this diagnostic, but it does get a similar
// one in some cases!
@@ -955,7 +928,7 @@
// FIXME: See create_iso_definition.
// Get the next token of the macro.
- if (LexUnexpandedToken(Tok)) return true;
+ LexUnexpandedToken(Tok);
}
// Finally, if this identifier already had a macro defined for it, verify that
@@ -968,30 +941,28 @@
}
MacroNameTok.getIdentifierInfo()->setMacroInfo(MI);
- return false;
}
/// HandleUndefDirective - Implements #undef.
///
-bool Preprocessor::HandleUndefDirective(LexerToken &UndefTok) {
+void Preprocessor::HandleUndefDirective(LexerToken &UndefTok) {
++NumUndefined;
LexerToken MacroNameTok;
- if (ReadMacroName(MacroNameTok))
- return true;
+ ReadMacroName(MacroNameTok);
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.getKind() == tok::eom)
- return false;
+ return;
// Check to see if this is the last token on the #undef line.
- if (CheckEndOfDirective("#undef")) return true;
+ CheckEndOfDirective("#undef");
// Okay, we finally have a valid identifier to undef.
MacroInfo *MI = MacroNameTok.getIdentifierInfo()->getMacroInfo();
// If the macro is not defined, this is a noop undef, just return.
- if (MI == 0) return false;
+ if (MI == 0) return;
#if 0 // FIXME: implement warn_unused_macros.
if (CPP_OPTION (pfile, warn_unused_macros))
@@ -1001,72 +972,67 @@
// Free macro definition.
delete MI;
MacroNameTok.getIdentifierInfo()->setMacroInfo(0);
- return false;
}
/// HandleIfdefDirective - Implements the #ifdef/#ifndef directive. isIfndef is
/// true when this is a #ifndef directive.
///
-bool Preprocessor::HandleIfdefDirective(LexerToken &Result, bool isIfndef) {
+void Preprocessor::HandleIfdefDirective(LexerToken &Result, bool isIfndef) {
++NumIf;
LexerToken DirectiveTok = Result;
LexerToken MacroNameTok;
- if (ReadMacroName(MacroNameTok))
- return true;
+ ReadMacroName(MacroNameTok);
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.getKind() == tok::eom)
- return false;
+ return;
// Check to see if this is the last token on the #if[n]def line.
- if (CheckEndOfDirective("#ifdef")) return true;
+ CheckEndOfDirective("#ifdef");
// Should we include the stuff contained by this directive?
if (!MacroNameTok.getIdentifierInfo()->getMacroInfo() == isIfndef) {
// Yes, remember that we are inside a conditional, then lex the next token.
CurLexer->pushConditionalLevel(DirectiveTok.getStart(), /*wasskip*/false,
/*foundnonskip*/true, /*foundelse*/false);
- return false;
} else {
// No, skip the contents of this block and return the first token after it.
- return SkipExcludedConditionalBlock(DirectiveTok.getStart(),
- /*Foundnonskip*/false,
- /*FoundElse*/false);
+ SkipExcludedConditionalBlock(DirectiveTok.getStart(),
+ /*Foundnonskip*/false,
+ /*FoundElse*/false);
}
}
/// HandleIfDirective - Implements the #if directive.
///
-bool Preprocessor::HandleIfDirective(LexerToken &IfToken) {
+void Preprocessor::HandleIfDirective(LexerToken &IfToken) {
++NumIf;
const char *Start = CurLexer->BufferPtr;
bool ConditionalTrue = false;
- if (EvaluateDirectiveExpression(ConditionalTrue))
- return true;
+ EvaluateDirectiveExpression(ConditionalTrue);
// Should we include the stuff contained by this directive?
if (ConditionalTrue) {
// Yes, remember that we are inside a conditional, then lex the next token.
CurLexer->pushConditionalLevel(IfToken.getStart(), /*wasskip*/false,
/*foundnonskip*/true, /*foundelse*/false);
- return false;
} else {
// No, skip the contents of this block and return the first token after it.
- return SkipExcludedConditionalBlock(IfToken.getStart(),
- /*Foundnonskip*/false,
- /*FoundElse*/false);
+ SkipExcludedConditionalBlock(IfToken.getStart(),
+ /*Foundnonskip*/false,
+ /*FoundElse*/false);
}
}
/// HandleEndifDirective - Implements the #endif directive.
///
-bool Preprocessor::HandleEndifDirective(LexerToken &EndifToken) {
+void Preprocessor::HandleEndifDirective(LexerToken &EndifToken) {
++NumEndif;
// Check that this is the whole directive.
- if (CheckEndOfDirective("#endif")) return true;
+ CheckEndOfDirective("#endif");
PPConditionalInfo CondInfo;
if (CurLexer->popConditionalLevel(CondInfo)) {
@@ -1076,22 +1042,20 @@
assert(!CondInfo.WasSkipping && !isSkipping() &&
"This code should only be reachable in the non-skipping case!");
- return false;
}
-bool Preprocessor::HandleElseDirective(LexerToken &Result) {
+void Preprocessor::HandleElseDirective(LexerToken &Result) {
++NumElse;
// #else directive in a non-skipping conditional... start skipping.
- if (CheckEndOfDirective("#else")) return true;
+ CheckEndOfDirective("#else");
PPConditionalInfo CI;
if (CurLexer->popConditionalLevel(CI))
return Diag(Result, diag::pp_err_else_without_if);
// If this is a #else with a #else before it, report the error.
- if (CI.FoundElse && Diag(Result, diag::pp_err_else_after_else))
- return true;
+ if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
// Finally, skip the rest of the contents of this block and return the first
// token after it.
@@ -1099,20 +1063,19 @@
/*FoundElse*/true);
}
-bool Preprocessor::HandleElifDirective(LexerToken &ElifToken) {
+void Preprocessor::HandleElifDirective(LexerToken &ElifToken) {
++NumElse;
// #elif directive in a non-skipping conditional... start skipping.
// We don't care what the condition is, because we will always skip it (since
// the block immediately before it was included).
- if (DiscardUntilEndOfDirective()) return true;
+ DiscardUntilEndOfDirective();
PPConditionalInfo CI;
if (CurLexer->popConditionalLevel(CI))
return Diag(ElifToken, diag::pp_err_elif_without_if);
// If this is a #elif with a #else before it, report the error.
- if (CI.FoundElse && Diag(ElifToken, diag::pp_err_elif_after_else))
- return true;
+ if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
// Finally, skip the rest of the contents of this block and return the first
// token after it.