src/commons/check.h

#ifndef COMMONS_CHECK_H
#define COMMONS_CHECK_H

#include <exception>
#include <sstream>
#include <string>
#include <commons/die.h>
#include <boost/lexical_cast.hpp>

// TODO: rename:
// - chk(x): verifies and return x; if not, throw strerror
//   - chk(x, msg...): prepend "$msg: " to strerror
//   - chk(x, false): don't use errno/strerror
//   - chk(x, false, msg...)
// - chknoret(x): doesn't return x and doesn't use strerror
// - chk0(x): verifies !x; if not, throw strerror
//   - same overloads as chk
// - chkpos(x): returns x; if not positive, throw strerror
//   - same overloads as chk
// - chknneg(x): returns x; if negative, throw strerror
//   - same overloads as chk
// - chkeq(x,y): if x!=y, throw; if x<0, throw strerror
//
// - chkr(): same as chk but returns -1 instead of throwing

// TODO: incorporate __PRETTY_FUNCTION__

namespace commons
{

  enum { buflen = 4096 };

  // TODO: deal with va args
  // TODO: provide strerror in other functions too
  // TODO: better way to deal with errno? (rather than resetting it)

  using namespace boost;
  using namespace std;

  class check_exception : public std::exception
  {
  public:
    check_exception(const string & name) : name(name) {}
    virtual ~check_exception() throw() {}
    virtual const char *what() const throw() { return name.c_str(); }
  private:
    const string name;
  };

  __attribute__((format(printf, 4, 0))) inline void
  _vcheck(bool cond, const char *file, int line, const char *fmt, va_list ap)
  {
    if (!cond) {
      stringstream ss;
      ss << "failed check in " << file << ':' << line << ": ";
      if (fmt != NULL) {
        char buf[buflen];
        vsnprintf(buf, buflen, fmt, ap);
        ss << buf;
      }
      throw check_exception(ss.str());
    }
  }

  __attribute__((format(printf, 4, 5))) void
  _check(bool cond, const char *file, int line, const char *fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    _vcheck(cond, file, line, fmt, ap);
    va_end(ap);
  }

  inline void
  _check(bool cond, const char *file, int line)
  {
    _check(cond, file, line, NULL);
  }

  template<typename T> inline T
  _checkpass(T x, const char *file, int line)
  {
    _check(x, file, line);
    return x;
  }

  template<typename T> inline T
  _checknneg(T x, const char *file, int line)
  {
    if (x < 0) {
      stringstream ss;
      ss << "expecting non-negative, got " << x;
      _check(false, file, line, "%s", ss.str().c_str());
    }
    return x;
  }

  template<typename T> inline T
  _checknnegerr(T x, const char *file, int line)
  {
    if (x < 0) {
      int e = errno;
      errno = 0;
      stringstream ss;
      ss << "expecting >=0, got " << x << ": " << strerror(e);
      _check(false, file, line, "%s", ss.str().c_str());
    }
    return x;
  }

  template<typename T> inline T
  _checkerr(T x, const char *file, int line)
  {
    if (!x) {
      int e = errno;
      errno = 0;
      stringstream ss;
      ss << "expecting !=0, got " << x << ": " << strerror(e);
      _check(false, file, line, "%s", ss.str().c_str());
    }
    return x;
  }

  template<typename T> inline void
  _check0(T x, const char *file, int line)
  {
    // Valid error numbers are all non-zero; errno is never set to zero by any
    // library function. We reset errno here.
    if (errno == 0) {
      _check(x == 0, file, line, "expecting 0, got %d", x);
    } else {
      int e = errno;
      errno = 0;
      _check(x == 0, file, line, "expecting 0, got %d: %s", x,
             strerror(e));
    }
  }

  template<typename T, typename U> inline void
  _checkeq(T l, U r, const char *file, int line)
  {
    if (l != r) {
      stringstream ss;
      ss << "expecting " << l << " == " << r;
      _check(false, file, line, "%s", ss.str().c_str());
    }
  }

  template<typename T, typename U> inline void
  _checkeqnneg(T l, U r, const char *file, int line)
  {
    if (l < 0) {
      int e = errno;
      errno = 0;
      stringstream ss;
      ss << "expecting " << r << ", got " << l << ": " << strerror(e);
      _check(l == r, file, line, "%s", ss.str().c_str());
    } else {
      _checkeq(l, r, file, line);
    }
  }

}

#define check(cond, msg...) _check(cond, __FILE__, __LINE__, ## msg)

#define checkpass(expr, msg...) _checkpass(expr, __FILE__, __LINE__, ## msg)

#define checkerr(expr) _checkerr(expr, __FILE__, __LINE__)

#define checknneg(expr, msg...) _checknneg(expr, __FILE__, __LINE__, ## msg)

#define checknnegerr(expr) _checknnegerr(expr, __FILE__, __LINE__)

#define check0x(expr, msg...) _check0(expr, __FILE__, __LINE__, ## msg)

#define checkeq(l, r, msg...) _checkeq(l, r, __FILE__, __LINE__, ## msg)

#define checkeqnneg(l, r, msg...) \
  _checkeqnneg(l, r, __FILE__, __LINE__, ## msg)

#if 0
#define checkmsg(cond, msg)                                           \
    bool b__ = cond;                                                  \
    if (!b__) _check(b__, (msg), __FILE__, __LINE__)

#define checkmsgf(cond, msg...)                                       \
  do {                                                                \
    bool b__ = cond;                                                  \
    if (!b__) {                                                       \
      char s__[4096];                                                 \
      snprintf(s, msg);                                               \
      _check(b__, s__, __FILE__, __LINE__);                           \
    }                                                                 \
  } while (0)
#endif

#define check0(expr)                                                  \
  do {                                                                \
    typeof(expr) r__ = expr;                                          \
    if (r__) {                                                        \
      return r__;                                                     \
    }                                                                 \
  } while (0)

#define checkdie(expr, msg...)                                        \
  do {                                                                \
    if (!expr) {                                                      \
      die(msg);                                                       \
    }                                                                 \
  } while (0)

#endif

---