Attachment #907 for bug #933

View | Details | Raw Unified | Return to bug 933
Collapse All | Expand All

(-)a/src/core/abort.h (-29 / +99 lines)

Lines 1-6	Link Here

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

/*

 * Copyright (c) 2008 INRIA

 * Copyright (c) 2008 INRIA, 2010 NICTA

 * This program is free software; you can redistribute it and/or modify

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * it under the terms of the GNU General Public License version 2 as

Lines 15-64	Link Here

 * along with this program; if not, write to the Free Software

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * Author:  Original author unknown

 *          Quincy Tse <quincy.tse@nicta.com.au>

*/

*/

#ifndef NS3_ABORT_H

#ifndef NS3_ABORT_H

#define NS3_ABORT_H

#define NS3_ABORT_H

#include "fatal-error.h"

#include "fatal-error.h"

/**

 * \ingroup debugging

 * \brief Abnormal program termination

 * \param msg message to output when this macro is hit.

 * This macro is essentially equivalent to NS_FATAL_ERROR,

 * excepts it prepends the error message with the string

 * "aborted. ". When this macro is hit a runtime, the

 * program will be halted using std::terminate, which

 * triggers clean up code regestered by std::set_terminate.

 * This macro is enable unconditionally in all builds,

 * including debug and optimized builds.

 * \see NS_FATAL_ERROR

*/

#define NS_ABORT_MSG(msg)                                       \

#define NS_ABORT_MSG(msg)                                       \

  do {								\

  do {								                                          \

    std::cerr << "file=" << __FILE__ <<                         \

    std::cerr << "aborted. ";                                   \

      ", line=" << __LINE__ << ", abort, msg=\"" <<             \

    NS_FATAL_ERROR (msg);                                       \

      msg << "\"" << std::endl;                                 \

    int *a = 0;                                                 \

    *a = 0;							\

  } while (false)

  } while (false)

#define NS_ABORT_IF(cond)					\

/**

  do {								\

 * \ingroup debugging

    if (cond)							\

 * \brief Abnormal program termination if cond is true.

      {								\

	std::cerr << "file=" << __FILE__ <<			\

 * \param cond condition to be evaluated.

	  ", line=" << __LINE__ << ", abort on=\""#cond <<	\

            "\"" << std::endl;                                  \

 * This is similar to NS_ASSERT(!(cond)), except this check

	int *a = 0;						\

 * is enabled in all builds. If cond is evaluated to true,

	*a = 0;							\

 * the espression evaluating to true is printed to stderr,

      }								\

 * followed by a call to the NS_FATAL_ERROR_NO_MSG() macro

 * which prints the details of filename and line number to

 * stderr. The program will be halted by calling

 * std::terminate(), triggering any clean up code registered

 * by std::set_terminate (NS3 default is a stream-flushing

 * code, but may be overridden).

 * This macro is enable unconditionally in all builds,

 * including debug and optimized builds.

*/

#define NS_ABORT_IF(cond)					                              \

  do {								                                          \

    if (cond)							                                      \

      {								                                          \

	      std::cerr << "aborted. cond=\"" << #cond << ", ";       \

	      NS_FATAL_ERROR_NO_MSG ();                               \

      }								                                          \

  } while (false)

  } while (false)

#define NS_ABORT_MSG_IF(cond, msg)				\

/**

  do {								\

 * \ingroup debugging

    if (cond)							\

 * \brief Abnormal program termination if cond is true.

      {								\

	std::cerr << "file=" << __FILE__ <<			\

 * \param cond condition to be evaluated.

	  ", line=" << __LINE__ << ", abort on=\""#cond <<	\

 * \param msg message to output when cond is true.

	  "\", msg=\"" << msg << "\"" << std::endl;		\

	int *a = 0;						\

 * This is similar to NS_ASSERT_MSG(!(cond)), except this

	*a = 0;							\

 * check is enabled in all builds. If cond is evaluated to

      }								\

 * true, the espression evaluating to true is printed to

 * stderr, followed by a call to the NS_FATAL_ERROR() macro

 * which prints the user-specified error message, and details

 * of filename and line number to stderr. The program will

 * be halted by calling std::terminate(), triggering any

 * clean up code registered by std::set_terminate (NS3

 * default is a stream-flushing code, but may be overridden).

 * This macro is enable unconditionally in all builds,

 * including debug and optimized builds.

*/

#define NS_ABORT_MSG_IF(cond, msg)				                      \

  do {								                                          \

100

    if (cond)							                                      \

101

      {								                                          \

102

	      std::cerr << "aborted. cond=\"" << #cond << "\", ";       \

103

	      NS_FATAL_ERROR (msg);                                   \

104

      }								                                          \

  } while (false)

105

  } while (false)

106

#define NS_ABORT_UNLESS(cond)				\

107

/**

108

 * \ingroup debugging

109

 * \brief Abnormal program termination if cond is false.

110

111

 * \param cond condition to be evaluated.

112

113

 * This is an alias for NS_ABORT_IF(!(cond))

114

115

 * \see NS_ABORT_IF

116

*/

117

#define NS_ABORT_UNLESS(cond)				                            \

  NS_ABORT_IF(!(cond))

118

  NS_ABORT_IF(!(cond))

119

#define NS_ABORT_MSG_UNLESS(cond, msg)			\

120

/**

121

 * \ingroup debugging

122

 * \brief Abnormal program termination if cond is false.

123

124

 * \param cond condition to be evaluated.

125

 * \param msg message to output if cond is false.

126

127

 * This is an alias for NS_ABORT_MSG_IF(!(cond))

128

129

 * \see NS_ABORT_MSG_IF

130

*/

131

#define NS_ABORT_MSG_UNLESS(cond, msg)			                    \

  NS_ABORT_MSG_IF(!(cond),msg)

132

  NS_ABORT_MSG_IF(!(cond),msg)

133

#endif /* NS3_ABORT_H */

134

#endif /* NS3_ABORT_H */

(-)a/src/core/assert.h (-20 / +30 lines)

Lines 1-6	Link Here

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

/*

 * Copyright (c) 2006 INRIA

 * Copyright (c) 2006 INRIA, 2010 NICTA

 * This program is free software; you can redistribute it and/or modify

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * it under the terms of the GNU General Public License version 2 as

Lines 16-29	Link Here

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 *         Quincy Tse <quincy.tse@nicta.com.au>

*/

*/

#ifndef ASSERT_H

#ifndef NS_ASSERT_H

#define ASSERT_H

#define NS_ASSERT_H

#ifdef NS3_ASSERT_ENABLE

#ifdef NS3_ASSERT_ENABLE

#include <iostream>

#include <iostream>

#include "fatal-error.h"

/**

/**

 * \ingroup core

 * \ingroup core

 * \defgroup debugging Debugging

 * \defgroup debugging Debugging

Lines 39-44	Link Here

 * not true, the program halts. These checks are built

 * not true, the program halts. These checks are built

 * into the program only in debugging builds. They are

 * into the program only in debugging builds. They are

 * removed in optimized builds.

 * removed in optimized builds.

 * These macro are intended to check certain conditions

 * to be true. Do not put code that also have side effects

 * that your program relies on (eg. code that advances

 * an iterator and return false at end of file) because

 * the code will not be executed on release builds!!

 * If assertion-style checks are required for release

 * builds, use NS_ABORT_UNLESS and NS_ABORT_MSG_UNLESS.

*/

*/

/**

/**

Lines 47-64	Link Here

 * At runtime, in debugging builds, if this condition is not

 * At runtime, in debugging builds, if this condition is not

 * true, the program prints the source file, line number and

 * true, the program prints the source file, line number and

 * unverified condition and halts by dereferencing a null pointer.

 * unverified condition and halts by calling std::terminate

*/

*/

#define NS_ASSERT(condition)                                    \

#define NS_ASSERT(condition)                                    \

  do                                                            \

  do                                                            \

    {                                                           \

    {                                                           \

      if (!(condition))                                         \

      if (!(condition))                                         \

        {                                                       \

        {                                                       \

          std::cerr << "assert failed. file=" << __FILE__ <<    \

          std::cerr << "assert failed. cond=\"" <<              \

            ", line=" << __LINE__ << ", cond=\""#condition <<   \

            #condition << "\", ";                               \

            "\"" << std::endl;                                  \

          NS_FATAL_ERROR_NO_MSG();                              \

          int *a = 0;                                           \

          *a = 0;                                               \

        }                                                       \

        }                                                       \

    }                                                           \

    }                                                           \

  while (false)

  while (false)

Lines 71-88	Link Here

 * At runtime, in debugging builds, if this condition is not

 * At runtime, in debugging builds, if this condition is not

 * true, the program prints the message to output and

 * true, the program prints the message to output and

 * halts by dereferencing a null pointer.

 * halts by calling std::terminate.

*/

*/

#define NS_ASSERT_MSG(condition, message)       \

#define NS_ASSERT_MSG(condition, message)             \

  do                                            \

  do                                                  \

    {                                           \

    {                                                 \

      if (!(condition))                         \

      if (!(condition))                               \

        {                                       \

        {                                             \

          std::cerr << message << std::endl;    \

          std::cerr << "assert failed. cond=\"" <<    \

          int *a = 0;                           \

            #condition << "\", ";                     \

          *a = 0;                               \

          NS_FATAL_ERROR (message);                   \

        }                                       \

        }                                             \

    }                                           \

    }                                                 \

  while (false)

  while (false)

#else /* NS3_ASSERT_ENABLE */

#else /* NS3_ASSERT_ENABLE */




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2006 INRIA, 2010 NICTA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 *         Quincy Tse <quincy.tse@nicta.com.au>
 */
#ifndef NS3_FATAL_ERROR_H
#define NS3_FATAL_ERROR_H

#include <iostream>
#include <exception>
#include <cstdlib>

#include "fatal-impl.h"

/**
 * \ingroup debugging
 * \brief fatal error handling
 *
 * When this macro is hit at runtime, details of filename
 * and line number is printed to stderr, and the program
 * is halted by calling std::terminate(). This will
 * trigger any clean up code registered by
 * std::set_terminate (NS3 default is a stream-flushing
 * code), but may be overridden.
 *
 * This macro is enabled unconditionally in all builds,
 * including debug and optimized builds.
 */
#define NS_FATAL_ERROR_NO_MSG()                           \
  do                                                      \
    {                                                     \
      std::cerr << "file=" << __FILE__ << ", line=" <<    \
        __LINE__ << std::endl;                            \
      std::terminate ();                                  \
    }                                                     \
  while (false)

/**
 * \ingroup debugging

 *
 * \param msg message to output when this macro is hit.
 *
 * When this macro is hit at runtime, the user-specified
 * error message is printed to stderr, followed by a call
 * to the NS_FATAL_ERROR_NO_MSG() macro which prints the
 * details of filename and line number to stderr. The
 * program will be halted by calling std::terminate(),
 * triggering any clean up code registered by
 * std::set_terminate (NS3 default is a stream-flushing
 * code, but may be overridden).
 *
 * This macro is enabled unconditionally in all builds,
 * including debug and optimized builds.
 */
#define NS_FATAL_ERROR(msg)				                      \
  do                                                    \
    {                                                   \
      std::cerr << "msg=\"" << msg << "\", ";           \
      NS_FATAL_ERROR_NO_MSG();                          \
      *a = 0;                                           \
    }                                                   \
  while (false)

#define NS_FATAL_SET_CXX_VERBOSE()                                  \
  do                                                                \
    {                                                               \
      std::set_terminate (__gnu_cxx::__verbose_terminate_handler);  \
    }                                                               \
  while (false)

#define NS_FATAL_SET_CXX_SILENT()                   \
  do                                                \
    {                                               \
      std::set_terminate (std::abort);              \
    }                                               \
  while (false)

#define NS_FATAL_SET_DEFAULT()                      \
  do                                                \
    {                                               \
      std::set_terminate (ns3::_handleTerminate);   \
    }                                               \
  while (false)

#define NS_FATAL_SET_HANDLER(handler)                         \
  do                                                          \
    {                                                         \
      std::set_terminate (static_cast<void (*)()>(handler));  \
    }                                                         \
  while (false)

#define NS_FATAL_REGISTER_STREAM(stream)            \
  do                                                \
    {                                               \
      ns3::_registerStream (stream);                \
    }                                               \
  while (false)

#define NS_FATAL_UNREGISTER_STREAM(stream)          \
  do                                                \
    {                                               \
      ns3::_unregisterStream (stream);              \
    }                                               \
  while (false)

#endif /* FATAL_ERROR_H */




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2010 NICTA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program 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
 *
 * Author: Quincy Tse <quincy.tse@nicta.com.au>
 */
#include "fatal-impl.h"

#include <iostream>
#include <list>

#include <cstdlib>
#include <cstdio>

#include <csignal>

using std::list;
using std::ostream;

namespace ns3 {

/* File-scope */
namespace {
  list<ostream*> s_streams;

  /* Overrides normal SIGSEGV handler once the
   * _handleTerminate function is run. */
  void sigHandler(int sig) {_handleTerminate ();}
  struct sigaction hdl;
}

void
_registerStream (ostream& stream)
{
  s_streams.push_back (&stream);
}

void
_unregisterStream (ostream& stream)
{
  s_streams.remove (&stream);
}

void
_handleTerminate (void)
{
  /* Override default SIGSEGV handler - will flush subsequent
   * streams even if one of the stream pointers is bad. */
  hdl.sa_handler=sigHandler;
  sigaction (SIGSEGV, &hdl, 0);

  while (!s_streams.empty ())
    {
      ostream* s (s_streams.front ());
      s_streams.pop_front ();
      s->flush ();
    }

  std::fflush (0);

  std::cout.flush ();
  std::cerr.flush ();

  /* Restore default SIGSEGV handler (Not that it matters anyway) */
  hdl.sa_handler=SIG_DFL;
  sigaction (SIGSEGV, &hdl, 0);

  std::abort ();
}

}




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2010 NICTA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program 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
 *
 * Author: Quincy Tse <quincy.tse@nicta.com.au>
 */

#ifndef FATAL_IMPL_H
#define FATAL_IMPL_H

#include <ostream>

namespace ns3 {

void _registerStream (std::ostream& stream);

void _unregisterStream (std::ostream& stream);

void _handleTerminate (void);

}

#endif

(-)a/src/core/wscript (+1 lines)

Lines 80-85	Link Here

        'type-traits-test-suite.cc',

        'type-traits-test-suite.cc',

        'traced-callback-test-suite.cc',

        'traced-callback-test-suite.cc',

        'ptr-test-suite.cc',

        'ptr-test-suite.cc',

        'fatal-impl.cc',

    headers = bld.new_task_gen('ns3header')

    headers = bld.new_task_gen('ns3header')

Return to bug 933