From a9c452121a395908ed3f8e4034fc55254933bbd1 Mon Sep 17 00:00:00 2001 From: Nikola Smiljanic Date: Wed, 28 May 2014 11:19:43 +0000 Subject: [PATCH] Fix line endings. llvm-svn: 209727 --- clang/include/clang/AST/DeclCXX.h | 6 +- clang/lib/Analysis/ThreadSafetyLogical.cpp | 224 ++++++++++++++--------------- clang/lib/Parse/ParseDeclCXX.cpp | 18 +-- 3 files changed, 124 insertions(+), 124 deletions(-) diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h index 01af64a..56bbbb1 100644 --- a/clang/include/clang/AST/DeclCXX.h +++ b/clang/include/clang/AST/DeclCXX.h @@ -2767,9 +2767,9 @@ public: static UsingShadowDecl *CreateDeserialized(ASTContext &C, unsigned ID); typedef redeclarable_base::redecl_range redecl_range; - typedef redeclarable_base::redecl_iterator redecl_iterator; - using redeclarable_base::redecls_begin; - using redeclarable_base::redecls_end; + typedef redeclarable_base::redecl_iterator redecl_iterator; + using redeclarable_base::redecls_begin; + using redeclarable_base::redecls_end; using redeclarable_base::redecls; using redeclarable_base::getPreviousDecl; using redeclarable_base::getMostRecentDecl; diff --git a/clang/lib/Analysis/ThreadSafetyLogical.cpp b/clang/lib/Analysis/ThreadSafetyLogical.cpp index 51a8077..facfa11 100644 --- a/clang/lib/Analysis/ThreadSafetyLogical.cpp +++ b/clang/lib/Analysis/ThreadSafetyLogical.cpp @@ -1,112 +1,112 @@ -//===- ThreadSafetyLogical.cpp ---------------------------------*- C++ --*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// This file defines a representation for logical expressions with SExpr leaves -// that are used as part of fact-checking capability expressions. -//===----------------------------------------------------------------------===// - -#include "clang/Analysis/Analyses/ThreadSafetyLogical.h" - -using namespace llvm; -using namespace clang::threadSafety::lexpr; - -// Implication. We implement De Morgan's Laws by maintaining LNeg and RNeg -// to keep track of whether LHS and RHS are negated. -static bool implies(const LExpr *LHS, bool LNeg, const LExpr *RHS, bool RNeg) { - // In comments below, we write => for implication. - - // Calculates the logical AND implication operator. - const auto LeftAndOperator = [=](const BinOp *A) { - return implies(A->left(), LNeg, RHS, RNeg) && - implies(A->right(), LNeg, RHS, RNeg); - }; - const auto RightAndOperator = [=](const BinOp *A) { - return implies(LHS, LNeg, A->left(), RNeg) && - implies(LHS, LNeg, A->right(), RNeg); - }; - - // Calculates the logical OR implication operator. - const auto LeftOrOperator = [=](const BinOp *A) { - return implies(A->left(), LNeg, RHS, RNeg) || - implies(A->right(), LNeg, RHS, RNeg); - }; - const auto RightOrOperator = [=](const BinOp *A) { - return implies(LHS, LNeg, A->left(), RNeg) || - implies(LHS, LNeg, A->right(), RNeg); - }; - - // Recurse on right. - switch (RHS->kind()) { - case LExpr::And: - // When performing right recursion: - // C => A & B [if] C => A and C => B - // When performing right recursion (negated): - // C => !(A & B) [if] C => !A | !B [===] C => !A or C => !B - return RNeg ? RightOrOperator(cast(RHS)) - : RightAndOperator(cast(RHS)); - case LExpr::Or: - // When performing right recursion: - // C => (A | B) [if] C => A or C => B - // When performing right recursion (negated): - // C => !(A | B) [if] C => !A & !B [===] C => !A and C => !B - return RNeg ? RightAndOperator(cast(RHS)) - : RightOrOperator(cast(RHS)); - case LExpr::Not: - // Note that C => !A is very different from !(C => A). It would be incorrect - // to return !implies(LHS, RHS). - return implies(LHS, LNeg, cast(RHS)->exp(), !RNeg); - case LExpr::Terminal: - // After reaching the terminal, it's time to recurse on the left. - break; - } - - // RHS is now a terminal. Recurse on Left. - switch (LHS->kind()) { - case LExpr::And: - // When performing left recursion: - // A & B => C [if] A => C or B => C - // When performing left recursion (negated): - // !(A & B) => C [if] !A | !B => C [===] !A => C and !B => C - return LNeg ? LeftAndOperator(cast(LHS)) - : LeftOrOperator(cast(LHS)); - case LExpr::Or: - // When performing left recursion: - // A | B => C [if] A => C and B => C - // When performing left recursion (negated): - // !(A | B) => C [if] !A & !B => C [===] !A => C or !B => C - return LNeg ? LeftOrOperator(cast(LHS)) - : LeftAndOperator(cast(LHS)); - case LExpr::Not: - // Note that A => !C is very different from !(A => C). It would be incorrect - // to return !implies(LHS, RHS). - return implies(cast(LHS)->exp(), !LNeg, RHS, RNeg); - case LExpr::Terminal: - // After reaching the terminal, it's time to perform identity comparisons. - break; - } - - // A => A - // !A => !A - if (LNeg != RNeg) - return false; - - // FIXME -- this should compare SExprs for equality, not pointer equality. - return cast(LHS)->expr() == cast(RHS)->expr(); -} - -namespace clang { -namespace threadSafety { -namespace lexpr { - -bool implies(const LExpr *LHS, const LExpr *RHS) { - // Start out by assuming that LHS and RHS are not negated. - return ::implies(LHS, false, RHS, false); -} -} -} -} +//===- ThreadSafetyLogical.cpp ---------------------------------*- C++ --*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// This file defines a representation for logical expressions with SExpr leaves +// that are used as part of fact-checking capability expressions. +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/ThreadSafetyLogical.h" + +using namespace llvm; +using namespace clang::threadSafety::lexpr; + +// Implication. We implement De Morgan's Laws by maintaining LNeg and RNeg +// to keep track of whether LHS and RHS are negated. +static bool implies(const LExpr *LHS, bool LNeg, const LExpr *RHS, bool RNeg) { + // In comments below, we write => for implication. + + // Calculates the logical AND implication operator. + const auto LeftAndOperator = [=](const BinOp *A) { + return implies(A->left(), LNeg, RHS, RNeg) && + implies(A->right(), LNeg, RHS, RNeg); + }; + const auto RightAndOperator = [=](const BinOp *A) { + return implies(LHS, LNeg, A->left(), RNeg) && + implies(LHS, LNeg, A->right(), RNeg); + }; + + // Calculates the logical OR implication operator. + const auto LeftOrOperator = [=](const BinOp *A) { + return implies(A->left(), LNeg, RHS, RNeg) || + implies(A->right(), LNeg, RHS, RNeg); + }; + const auto RightOrOperator = [=](const BinOp *A) { + return implies(LHS, LNeg, A->left(), RNeg) || + implies(LHS, LNeg, A->right(), RNeg); + }; + + // Recurse on right. + switch (RHS->kind()) { + case LExpr::And: + // When performing right recursion: + // C => A & B [if] C => A and C => B + // When performing right recursion (negated): + // C => !(A & B) [if] C => !A | !B [===] C => !A or C => !B + return RNeg ? RightOrOperator(cast(RHS)) + : RightAndOperator(cast(RHS)); + case LExpr::Or: + // When performing right recursion: + // C => (A | B) [if] C => A or C => B + // When performing right recursion (negated): + // C => !(A | B) [if] C => !A & !B [===] C => !A and C => !B + return RNeg ? RightAndOperator(cast(RHS)) + : RightOrOperator(cast(RHS)); + case LExpr::Not: + // Note that C => !A is very different from !(C => A). It would be incorrect + // to return !implies(LHS, RHS). + return implies(LHS, LNeg, cast(RHS)->exp(), !RNeg); + case LExpr::Terminal: + // After reaching the terminal, it's time to recurse on the left. + break; + } + + // RHS is now a terminal. Recurse on Left. + switch (LHS->kind()) { + case LExpr::And: + // When performing left recursion: + // A & B => C [if] A => C or B => C + // When performing left recursion (negated): + // !(A & B) => C [if] !A | !B => C [===] !A => C and !B => C + return LNeg ? LeftAndOperator(cast(LHS)) + : LeftOrOperator(cast(LHS)); + case LExpr::Or: + // When performing left recursion: + // A | B => C [if] A => C and B => C + // When performing left recursion (negated): + // !(A | B) => C [if] !A & !B => C [===] !A => C or !B => C + return LNeg ? LeftOrOperator(cast(LHS)) + : LeftAndOperator(cast(LHS)); + case LExpr::Not: + // Note that A => !C is very different from !(A => C). It would be incorrect + // to return !implies(LHS, RHS). + return implies(cast(LHS)->exp(), !LNeg, RHS, RNeg); + case LExpr::Terminal: + // After reaching the terminal, it's time to perform identity comparisons. + break; + } + + // A => A + // !A => !A + if (LNeg != RNeg) + return false; + + // FIXME -- this should compare SExprs for equality, not pointer equality. + return cast(LHS)->expr() == cast(RHS)->expr(); +} + +namespace clang { +namespace threadSafety { +namespace lexpr { + +bool implies(const LExpr *LHS, const LExpr *RHS) { + // Start out by assuming that LHS and RHS are not negated. + return ::implies(LHS, false, RHS, false); +} +} +} +} diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index ddecd75..91ca58d 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -3251,15 +3251,15 @@ bool Parser::ParseCXX11AttributeArgs(IdentifierInfo *AttrName, // parsing an argument list, we need to determine whether this attribute // was allowed to have an argument list (such as [[deprecated]]), and how // many arguments were parsed (so we can diagnose on [[deprecated()]]). - if (Attr->getMaxArgs() && !NumArgs) { - // The attribute was allowed to have arguments, but none were provided - // even though the attribute parsed successfully. This is an error. - // FIXME: This is a good place for a fixit which removes the parens. - Diag(LParenLoc, diag::err_attribute_requires_arguments) << AttrName; - return false; - } else if (!Attr->getMaxArgs()) { - // The attribute parsed successfully, but was not allowed to have any - // arguments. It doesn't matter whether any were provided -- the + if (Attr->getMaxArgs() && !NumArgs) { + // The attribute was allowed to have arguments, but none were provided + // even though the attribute parsed successfully. This is an error. + // FIXME: This is a good place for a fixit which removes the parens. + Diag(LParenLoc, diag::err_attribute_requires_arguments) << AttrName; + return false; + } else if (!Attr->getMaxArgs()) { + // The attribute parsed successfully, but was not allowed to have any + // arguments. It doesn't matter whether any were provided -- the // presence of the argument list (even if empty) is diagnosed. Diag(LParenLoc, diag::err_cxx11_attribute_forbids_arguments) << AttrName; -- 2.7.4