r209727 - Fix line endings.
Nikola Smiljanic
popizdeh at gmail.com
Wed May 28 04:19:44 PDT 2014
Author: nikola
Date: Wed May 28 06:19:43 2014
New Revision: 209727
URL: http://llvm.org/viewvc/llvm-project?rev=209727&view=rev
Log:
Fix line endings.
Modified:
cfe/trunk/include/clang/AST/DeclCXX.h
cfe/trunk/lib/Analysis/ThreadSafetyLogical.cpp
cfe/trunk/lib/Parse/ParseDeclCXX.cpp
Modified: cfe/trunk/include/clang/AST/DeclCXX.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/DeclCXX.h?rev=209727&r1=209726&r2=209727&view=diff
==============================================================================
--- cfe/trunk/include/clang/AST/DeclCXX.h (original)
+++ cfe/trunk/include/clang/AST/DeclCXX.h Wed May 28 06:19:43 2014
@@ -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;
Modified: cfe/trunk/lib/Analysis/ThreadSafetyLogical.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/ThreadSafetyLogical.cpp?rev=209727&r1=209726&r2=209727&view=diff
==============================================================================
--- cfe/trunk/lib/Analysis/ThreadSafetyLogical.cpp (original)
+++ cfe/trunk/lib/Analysis/ThreadSafetyLogical.cpp Wed May 28 06:19:43 2014
@@ -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<And>(RHS))
- : RightAndOperator(cast<And>(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<Or>(RHS))
- : RightOrOperator(cast<Or>(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<Not>(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<And>(LHS))
- : LeftOrOperator(cast<And>(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<Or>(LHS))
- : LeftAndOperator(cast<Or>(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<Not>(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<Terminal>(LHS)->expr() == cast<Terminal>(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<And>(RHS))
+ : RightAndOperator(cast<And>(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<Or>(RHS))
+ : RightOrOperator(cast<Or>(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<Not>(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<And>(LHS))
+ : LeftOrOperator(cast<And>(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<Or>(LHS))
+ : LeftAndOperator(cast<Or>(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<Not>(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<Terminal>(LHS)->expr() == cast<Terminal>(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);
+}
+}
+}
+}
Modified: cfe/trunk/lib/Parse/ParseDeclCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseDeclCXX.cpp?rev=209727&r1=209726&r2=209727&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseDeclCXX.cpp (original)
+++ cfe/trunk/lib/Parse/ParseDeclCXX.cpp Wed May 28 06:19:43 2014
@@ -3251,15 +3251,15 @@ bool Parser::ParseCXX11AttributeArgs(Ide
// 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;
More information about the cfe-commits
mailing list