#define NULL ((void *)0)

namespace std {
struct nothrow_t {};
typedef unsigned long size_t;

class exception {};
class bad_alloc : public exception {};

extern const std::nothrow_t nothrow;
} // namespace std

using namespace std;

void *operator new(std::size_t);
void *operator new[](std::size_t);
void *operator new(std::size_t, const std::nothrow_t &) noexcept;
void *operator new[](std::size_t, const std::nothrow_t &) noexcept;

void bad_new_in_condition() {
  if (!(new int)) { // $ Alert // BAD
    return;
  }
}

void foo(int**);

void bad_new_missing_exception_handling() {
  int *p1 = new int[100]; // $ Alert // BAD
  if (p1 == 0)
    return;

  int *p2 = new int[100]; // $ Alert // BAD
  if (!p2)
    return;

  int *p3 = new int[100]; // $ Alert // BAD
  if (p3 == NULL)
    return;

  int *p4 = new int[100]; // $ Alert // BAD
  if (p4 == nullptr)
    return;

  int *p5 = new int[100]; // $ Alert // BAD
  if (p5) {} else return;

  int *p6;
  p6 = new int[100]; // $ Alert // BAD
  if (p6 == 0) return;

  int *p7;
  p7 = new int[100]; // $ Alert // BAD
  if (!p7)
    return;

  int *p8;
  p8 = new int[100]; // $ Alert // BAD
  if (p8 == NULL)
    return;

  int *p9;
  p9 = new int[100]; // $ Alert // BAD
  if (p9 != nullptr) {
  } else
    return;

  int *p10;
  p10 = new int[100]; // $ Alert // BAD
  if (p10 != 0) {
  }

  int *p11;
  do {
    p11 = new int[100]; // $ Alert // BAD
  } while (!p11);

  int* p12 = new int[100];
  foo(&p12);
  if(p12) {} else return; // GOOD: p12 is probably modified in foo, so it's
                          // not the return value of the new that's checked.

  int* p13 = new int[100];
  foo(&p13);
  if(!p13) {
      return;
  } else { }; // GOOD: same as above.
}

void bad_new_nothrow_in_exception_body() {
  try {
    new (std::nothrow) int[100];           // $ Alert // BAD
    int *p1 = new (std::nothrow) int[100]; // $ Alert // BAD

    int *p2;
    p2 = new (std::nothrow) int[100]; // $ Alert // BAD
  } catch (const std::bad_alloc &) {
  }
}

void good_new_has_exception_handling() {
  try {
    int *p1 = new int[100]; // GOOD
  } catch (...) {
  }
}

void good_new_handles_nullptr() {
  int *p1 = new (std::nothrow) int[100]; // GOOD
  if (p1 == nullptr)
    return;

  int *p2;
  p2 = new (std::nothrow) int[100]; // GOOD
  if (p2 == nullptr)
    return;

  int *p3;
  p3 = new (std::nothrow) int[100]; // GOOD
  if (p3 != nullptr) {
  }

  int *p4;
  p4 = new (std::nothrow) int[100]; // GOOD
  if (p4) {
  } else
    return;

  int *p5;
  p5 = new (std::nothrow) int[100]; // GOOD
  if (p5 != nullptr) {
  } else
    return;

  if (new (std::nothrow) int[100] == nullptr)
    return; // GOOD
}

// ---

void* operator new(std::size_t count, void*) noexcept;
void* operator new[](std::size_t count, void*) noexcept;

struct Foo {
  Foo() noexcept;
  Foo(int);

  operator bool();
};

struct Bar {
  Bar();

  operator bool();
};

void bad_placement_new_with_exception_handling() {
  char buffer[1024];

  try { new (buffer) Foo; } // $ Alert // BAD (placement new should not fail)
  catch (...) {  }
}

void good_placement_new_with_exception_handling() {
  char buffer[1024];

  try { new (buffer) Foo(42); } // GOOD: Foo constructor might throw
  catch (...) {  }

  try { new (buffer) Bar; } // GOOD: Bar constructor might throw
  catch (...) {  }
}

template<typename F> F *test_template_platement_new() {
  char buffer[1024];

  try {
    return new (buffer) F; // GOOD: `F` constructor might throw (when `F` is `Bar`)
  } catch (...) {
    return 0;
  }
}

void test_template_platement_new_caller() {
  test_template_platement_new<Foo>();
  test_template_platement_new<Bar>();
}

// ---

int unknown_value_without_exceptions() noexcept;

void may_throw() {
  if(unknown_value_without_exceptions()) {
    throw "bad luck exception!";
  }
}

void unknown_code_that_may_throw(int*);
void unknown_code_that_will_not_throw(int*) noexcept;

void calls_throwing_code(int* p) {
  if(unknown_value_without_exceptions()) unknown_code_that_may_throw(p);
}

void calls_non_throwing(int* p) {
  if (unknown_value_without_exceptions()) unknown_code_that_will_not_throw(p);
}

void good_new_with_throwing_call() {
  try {
    int* p1 = new(std::nothrow) int; // GOOD
    may_throw();
  } catch(...) {  }

  try {
    int* p2 = new(std::nothrow) int; // GOOD
    Foo f(10);
  } catch(...) {  }

  try {
    int* p3 = new(std::nothrow) int; // GOOD
    calls_throwing_code(p3);
  } catch(...) {  }
}

void bad_new_with_nonthrowing_call() {
  try {
    int* p1 = new(std::nothrow) int; // $ Alert // BAD
    calls_non_throwing(p1);
  } catch(...) {  }

  try {
    int* p2 = new(std::nothrow) int; // GOOD: boolean conversion constructor might throw
    Foo f;
    if(f) { }
  } catch(...) {  }
}

void bad_new_catch_baseclass_of_bad_alloc() {
  try {
    int* p = new(std::nothrow) int; // $ Alert // BAD
  } catch(const std::exception&) { }
}

void good_new_catch_exception_in_assignment() {
  int* p;
  try {
    p = new int; // GOOD
  } catch(const std::bad_alloc&) { }
}

void good_new_catch_exception_in_conversion() {
  try {
    long* p = (long*) new int; // GOOD
  } catch(const std::bad_alloc&) { }
}

// The 'n' parameter is just to distinquish it from the overload further up in this file.
void *operator new(std::size_t, int n, const std::nothrow_t &);

void test_operator_new_without_exception_spec() {
  int* p = new(42, std::nothrow) int; // GOOD
  if(p == nullptr) {}
}

namespace std {
  void *memset(void *s, int c, size_t n);
}

// from the qhelp:
namespace qhelp {
  // BAD: the allocation will throw an unhandled exception
  // instead of returning a null pointer.
  void bad1(std::size_t length) noexcept {
    int* dest = new int[length]; // $ Alert
    if(!dest) {
      return;
    }
    std::memset(dest, 0, length);
    // ...
  }

  // BAD: the allocation won't throw an exception, but
  // instead return a null pointer.
  void bad2(std::size_t length) noexcept {
    try {
      int* dest = new(std::nothrow) int[length]; // $ Alert
      std::memset(dest, 0, length);
      // ...
    } catch(std::bad_alloc&) {
      // ...
    }
  }

  // GOOD: the allocation failure is handled appropriately.
  void good1(std::size_t length) noexcept {
    try {
      int* dest = new int[length];
      std::memset(dest, 0, length);
      // ...
    } catch(std::bad_alloc&) {
      // ...
    }
  }

  // GOOD: the allocation failure is handled appropriately.
  void good2(std::size_t length) noexcept {
    int* dest = new(std::nothrow) int[length];
    if(!dest) {
      return;
    }
    std::memset(dest, 0, length);
    // ...
  }
}
