vpDebug.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
 *
 * This software 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.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Debug and trace macro.
 *
 *   - TRACING:    vpTRACE and vpERROR_TRACE work like printf with carreer
 *return at the end of the string. vpCERROR et vpCTRACE work like the C++
 *output streams std::cout and std::cerr.
 *   - DEBUGING:   vpDEBUG_TRACE(niv) and vpDERROR_TRACE(niv), work like
 *printf, but print only if the tracing level niv is greater than the debug
 *level VP_DEBUG_MODE. vpCDEBUG(niv) work like the C++ output
 *stream std::cout. vpDEBUG_ENABLE(niv) is equal to 1 if the
 *debug level niv is greater than the debug mode
 *                 VP_DEBUG_MODE, 0 else.
 *   - PROG DEFENSIVE: DEFENSIF(a) is equal to a if defensive mode is active,
 *0 else.
 *
 * Authors:
 * Nicolas Mansard, Bruno Renier
 *
 *****************************************************************************/
 
#ifndef _vpDebug_h_
#define _vpDebug_h_
 
#include <iostream>
#include <stdarg.h>
#include <stdio.h>
#include <visp3/core/vpConfig.h>
 
#if defined(_WIN32)
#ifndef __FUNCTION__
#define __FUNCTION__ " "
#endif
#endif
 
#ifndef VP_DEBUG_MODE
#define VP_DEBUG_MODE 0
#endif
 
class vpTraceOutput
{
private:
  const char *currentFile; // Name of the file to use in the displays
  const char *currentFunc; // Name of the function to use in the displays
  int currentLine;         // Line to use in the displays
 
  // if true, output to std::cerr/stderr else std::cout/stdout
  bool err;
  // string to display before anything else
  const char *header;
 
public:
  vpTraceOutput(const char *file, int line, const char *func, bool error = false, const char *s = NULL)
    : currentFile(file), currentFunc(func), currentLine(line), err(error), header(s)
  {
  }
 
  void operator()(int level, const char *format, ...)
  {
    // if the level is inferior to VP_DEBUG_MODE
    if (VP_DEBUG_MODE >= level) {
      // gets the variable list of arguments
      va_list args;
      va_start(args, format);
 
      if (err)
        std::cerr << "(L" << level << ") ";
      else
        std::cout << "(L" << level << ") ";
 
      // calls display with it
      display(format, args);
 
      va_end(args);
    }
  }
 
  void operator()(const char *format, ...)
  {
    // gets the variable list of arguments
    va_list args;
    va_start(args, format);
 
#ifdef VP_DEBUG
    std::cout << "(L0) ";
#endif
 
    // calls display with it
    display(format, args);
 
    va_end(args);
  }
 
  void display(const char *format, va_list args)
  {
    // if we want to write to std::cerr/stderr
    if (err) {
      // first writes the header if there is one
      if (header != NULL)
        std::cerr << header;
      // then writes the recorded namefile, function and line
      std::cerr << "!!\t" << currentFile << ": " << currentFunc << "(#" << currentLine << ") : ";
      // and finally writes the message passed to () operator.
      vfprintf(stderr, format, args);
      fprintf(stderr, "\n");
      // flushes the buffer
      fflush(stderr);
    } else {
      // first writes the header if there is one
      if (header != NULL)
        std::cout << header;
      // then writes the recorded namefile, function and line
      std::cout << currentFile << ": " << currentFunc << "(#" << currentLine << ") : ";
      // and finally writes the message passed to () operator.
      vprintf(format, args);
      printf("\n");
      // flushes the buffer
      fflush(stdout);
    }
  }
};
 
/* -------------------------------------------------------------------------
 */
/* --- vpTRACE IN/OUT FONCTION ---------------------------------------------
 */
/* -------------------------------------------------------------------------
 */
 
#ifdef VP_TRACE // Activate the trace mode
 
#define vpIN_FCT (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, false, "begin "))
 
#define vpOUT_FCT (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, false, "end "))
 
#else // #ifdef VP_TRACE
 
inline void vpIN_FCT(const char * /* a */, ...) {}
inline void vpOUT_FCT(const char * /* a */, ...) {}
 
#endif // #ifdef VP_TRACE
 
/* --------------------------------------------------------------------------
 */
/* --- vpTRACE --------------------------------------------------------------
 */
/* --------------------------------------------------------------------------
 */
 
#ifdef VP_TRACE
 
#define vpCTRACE std::cout << "(L0) " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "
 
#define vpCERROR                                                                                                       \
  std::cerr << "(L0) "                                                                                                 \
            << "!!\t" << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "
 
#define vpERROR_TRACE (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, true))
 
#define vpTRACE (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, false))
 
#else // #ifdef VP_TRACE
 
#define vpCTRACE                                                                                                       \
  if (false)                                                                                                           \
  std::cout // Warning C4127
#define vpCERROR                                                                                                       \
  if (false)                                                                                                           \
  std::cerr // Warning C4127
 
inline void vpERROR_TRACE(const char * /* a */, ...) {}
inline void vpERROR_TRACE(int /* level */, const char * /* a */, ...) {}
inline void vpTRACE(const char * /* a */, ...) {}
inline void vpTRACE(int /* level */, const char * /* a */, ...) {}
 
#endif // #ifdef VP_TRACE
 
/* -------------------------------------------------------------------------
 */
/* --- VP_DEBUG ------------------------------------------------------------
 */
/* -------------------------------------------------------------------------
 */
 
#ifdef VP_DEBUG
 
#define vpDERROR_TRACE (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, true))
 
#define vpDEBUG_TRACE (vpTraceOutput(__FILE__, __LINE__, __FUNCTION__, false))
 
#define vpCDEBUG(level)                                                                                                \
  if (VP_DEBUG_MODE < level)                                                                                           \
    ;                                                                                                                  \
  else                                                                                                                 \
    std::cout << "(L" << level << ") " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "
 
#define vpDEBUG_ENABLE(level) (VP_DEBUG_MODE >= level)
 
#else // #ifdef VP_DEBUG
 
inline void vpDERROR_TRACE(const char * /* a */, ...) {}
inline void vpDEBUG_TRACE(const char * /* a */, ...) {}
inline void vpDERROR_TRACE(int /* level */, const char * /* a */, ...) {}
inline void vpDEBUG_TRACE(int /* level */, const char * /* a */, ...) {}
 
#define vpCDEBUG(level)                                                                                                \
  if (false)                                                                                                           \
  std::cout                           // Warning C4127
#define vpDEBUG_ENABLE(level) (false) // Warning C4127
 
#endif // #ifdef VP_DEBUG
 
/* --------------------------------------------------------------------------
 */
/* --- DEFENSIF -------------------------------------------------------------
 */
/* --------------------------------------------------------------------------
 */
#ifdef VP_DEFENSIF
#define DEFENSIF(a) (a)
#else
#define DEFENSIF(a) (0)
#endif /*#ifdef DEFENSIF*/
 
#endif /* #ifdef __DEBUG_HH */