示例#1
0
 void Manager::View::cleanClause(Clause & clause) {
   exprView.sort(clause.begin(), clause.end());
   for (Clause::iterator it = clause.begin(); it != clause.end(); ) {
     if (*it == exprView.btrue())
       // [true lit]
       throw Trivial(true);
     else if (*it == exprView.bfalse())
       // [false lit]
       clause.erase(it);
     else if (it+1 != clause.end()) {
       if (*it == *(it+1)) {
         // [repetition of lit]
         clause.erase(it);
       }
       else if (*it == exprView.apply(Expr::Not, *(it+1)))
         // [var with both phases]
         // Relies on how Expr handles negation, so possibly a hack.
         // However, I meant for this property to be usable, so it
         // will be maintained.
         throw Trivial(true);
       else
         it++;
     }
     else
       it++;
   }
   if (clause.size() == 0)
     // empty clause
     throw Trivial(false);
 }
void test() {
  int i = 0;
  const int k = 0;

  auto captures_nothing = [] {};

  auto captures_nothing_by_value = [=] {};
  auto captures_nothing_by_reference = [&] {};

  auto implicit_by_value = [=]() mutable { i++; };
  auto implicit_by_reference = [&] { i++; };

  auto explicit_by_value_used = [i] { return i + 1; };
  auto explicit_by_value_used_void = [i] { (void)i; };
  auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
  auto explicit_by_value_unused_sizeof = [i] { return sizeof(i); }; // expected-warning{{lambda capture 'i' is not required to be captured for this use}}
  auto explicit_by_value_unused_decltype = [i] { decltype(i) j = 0; }; // expected-warning{{lambda capture 'i' is not required to be captured for this use}}
  auto explicit_by_value_unused_const = [k] { return k + 1; };         // expected-warning{{lambda capture 'k' is not required to be captured for this use}}

  auto explicit_by_reference_used = [&i] { i++; };
  auto explicit_by_reference_unused = [&i] {}; // expected-warning{{lambda capture 'i' is not used}}

  auto explicit_initialized_reference_used = [&j = i] { return j + 1; };
  auto explicit_initialized_reference_unused = [&j = i]{}; // expected-warning{{lambda capture 'j' is not used}}

  auto explicit_initialized_value_used = [j = 1] { return j + 1; };
  auto explicit_initialized_value_unused = [j = 1] {}; // expected-warning{{lambda capture 'j' is not used}}
  auto explicit_initialized_value_non_trivial_constructor = [j = NonTrivialConstructor()]{};
  auto explicit_initialized_value_non_trivial_destructor = [j = NonTrivialDestructor()]{};
  auto explicit_initialized_value_trivial_init = [j = Trivial()]{}; // expected-warning{{lambda capture 'j' is not used}}
  auto explicit_initialized_value_non_trivial_init = [j = Trivial(42)]{};
  auto explicit_initialized_value_with_side_effect = [j = side_effect()]{};

  auto nested = [&i] {
    auto explicit_by_value_used = [i] { return i + 1; };
    auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
  };

  Trivial trivial;
  auto explicit_by_value_trivial = [trivial] {}; // expected-warning{{lambda capture 'trivial' is not used}}

  NonTrivialConstructor cons;
  auto explicit_by_value_non_trivial_constructor = [cons] {}; // expected-warning{{lambda capture 'cons' is not used}}

  NonTrivialCopyConstructor copy_cons;
  auto explicit_by_value_non_trivial_copy_constructor = [copy_cons] {};

  NonTrivialDestructor dest;
  auto explicit_by_value_non_trivial_destructor = [dest] {};

  volatile int v;
  auto explicit_by_value_volatile = [v] {};
}
示例#3
0
const Trivial &getTrivialRef() {
  return Trivial(42); // expected-warning {{Address of stack memory associated with temporary object of type 'Trivial' returned to caller}}
}
示例#4
0
Trivial getTrivial() {
  return Trivial(42); // no-warning
}
示例#5
0
文件: Group.cpp 项目: foadnh/groups
 Group Group::trivial()         {return Group(Trivial()); }