---

more/diag/debug.h

Go to the documentation of this file.

//  Copyright (C) 1999--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: debug.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $



#ifndef MORE_DIAG_DEBUG_H
#define MORE_DIAG_DEBUG_H

#include <iostream>
#include <iomanip>
#include <string>
#include <memory>
#include <more/io/fwd.h>


#define MORE_SHOW(x) \
    ((void)(std::clog << __FILE__ << ":" << __LINE__ << ": info: " \
                      << #x << " = " << x << std::endl))
#define MORE_ECHO(x) \
    ((void)(std::clog << __FILE__ << ":" << __LINE__ << ": info: " \
                      << #x << std::endl, (x)))
#define MORE_SHOW_SOMETIMES(x) \
    ((more::diag::show_sometimes_helper())? MORE_SHOW(x) : (void)0)
#define MORE_HERE \
    (std::cerr << __FILE__ << ":" << __LINE__ << ": info: Here!" << std::endl)

/** \def MORE_CHECK
 **
 ** Check that a logical expression is true. This is similar to assert,
 ** but instead of aborting, it keeps a count of the number of
 ** failures.  See check_exit_status. */
#define MORE_CHECK(x) \
    ((x)? (void)0 : ::more::diag::bits::check_failed(__FILE__, __LINE__, #x))

/** \def MORE_CHECK_EQ
 **
 ** Check that <tt>x == y</tt>.  If the check fails, the LHS and RHS
 ** are printed to <tt>std::cerr</tt>. */
#define MORE_CHECK_EQ(x, y) \
    (((x) == (y))? (void)0 : \
     (::more::diag::bits::check_failed(__FILE__, __LINE__, #x " == " #y), \
      std::cerr << "    LHS = " << (x) << "\n    RHS = " << (y) << std::endl, \
      (void)0))

#define MORE_CHECK_FAILED(msg) \
    more::diag::bits::check_failed(__FILE__, __LINE__, (msg))

#ifdef MORE_CHECK_ALLOCATIONS
#  define MORE_NEW(T, args...) \
    (::new(::more::diag::checkmem::alloc(sizeof(T), __FILE__, __LINE__)) \
        T(args))
#  define MORE_DELETE(T, ptr) \
    do { \
        if (T* p = (ptr)) { \
            p->~T(); \
            ::more::diag::checkmem::free(p, __FILE__, __LINE__); \
        } \
    } while (0)
#else
#  define MORE_NEW(T, args...) new T(args)
#  define MORE_DELETE(T, ptr) delete (ptr)
#endif



namespace more {
namespace diag {
  ///\if bits
  namespace bits {
    void check_failed(char const*, int, char const*);
  }
  ///\endif

  /** If MORE_CHECK has failed at least once, reports the number of
      fails, and returns nonzero, otherwise return err. */
  int check_exit_status(int err = 0);

  /** report a fatal error and abort. */
  void fatal(char const*);

  std::ostream& cdbg(int);
  void set_debug_level(int);
  void parse_debug_level_from_cmdline(int& argc, char**& argv);
  void debug_init(io::cmdline&);
  bool show_sometimes_helper();

  /** Used to force earlier activation of the allocation checker.  If
      static destructors deallocate memory with MORE_FREE, you may get
      bogus reports of unallocated memory.  To fix this try to make a
      static instance of this class in the source file to be checked.
      There is no standard way to ensure that the checker is
      initialized before all other static initializers, so you may
      have to expreimet with placing it before or after in the same
      source file, or even name the variable starting with "AA" or
      "zz".  Wrap the declaration in #ifdef MORE_CHECK_ALLOCATIONS for
      zero overhead when not debugging. */
  struct checkmem {
      struct header {
          unsigned long magic0;
          unsigned long magic1;
          header* next;
          header* prev;
          unsigned long serial;
          const char* file;
          int line;
      };

      checkmem() { init(); }

      static void* alloc(std::size_t, char const* = 0, int = 0);
      static void free(void*, char const* = 0, int = 0);
      static void init();
      static void finalize();

    private:
      static bool is_init;
      static long alloc_count;
      static unsigned long serial;
      static header link;
      static unsigned long magic0;
      static unsigned long magic1;
  };
  struct checkmem_tag {};


  /** A slightly simplified auto_ptr which uses MORE_DELETE. */
  template <typename T>
    struct auto_ptr {
        auto_ptr(T* p = 0) : m_p(p) {}
        auto_ptr(auto_ptr& ap) : m_p(ap.release()) {}
        auto_ptr& operator=(auto_ptr& ap) { reset(ap.release()); return *this; }
        ~auto_ptr() { MORE_DELETE(T, m_p); }
        T* operator->() { return m_p; }
        T& operator*() { return *m_p; }
        T* get() { return m_p; }
        T* release() { T* p = m_p; m_p = 0; return p; }
        void reset(T* p = 0) { MORE_DELETE(T, m_p); m_p = p; }
      private:
        T* m_p;
    };
}}


#endif

---