dbg.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007 SCHUNK GmbH & Co. KG
 * Copyright (c) 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//======================================================================
//======================================================================

#ifndef DBG_h_
#define DBG_h_

#include "sdhlibrary_settings.h"

#if SDH_USE_VCC
# pragma warning(disable : 4996)
#endif

//----------------------------------------------------------------------
// System Includes - include with <>
//----------------------------------------------------------------------

#include <iostream>
#include <iomanip>
#include <string>
#include <stdarg.h>
#include <cstring>    // needed in gcc-4.3 for prototypes like strcmp according to http://gcc.gnu.org/gcc-4.3/porting_to.html
#include <stdlib.h>   // needed in gcc-4.3 for prototypes like getenv
#include <cstdio>     // needed in gcc-4.4 (as reported by Hannes Saal)

//----------------------------------------------------------------------
// Project Includes - include with ""
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Defines, enums, unions, structs
//----------------------------------------------------------------------

NAMESPACE_SDH_START


//----------------------------------------------------------------------
// Global variables (declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// External functions and classes (declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Function prototypes (function declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Class declarations
//----------------------------------------------------------------------


class VCC_EXPORT cDBG
{
protected:
  char const*   debug_color;
  char const*   normal_color;
  std::ostream *output;
  bool          debug_flag;
  std::streamsize mywidth;
public:

  cDBG(bool flag = false, char const* color = "red", std::ostream *fd = &std::cerr)
  {
    debug_flag     = flag;
    SetColor(color);
    output         = fd;
    mywidth = output->width();
  }
  //---------------------

  ~cDBG()
  {
    output->flush();
  }

  void SetFlag(bool flag)
  {
    debug_flag  = flag;
  }


  bool GetFlag(void) const
  {
    return debug_flag;
  }

  void SetColor(char const* color)
  {
    debug_color = GetColor(color);
    if (!strcmp(debug_color, ""))
      // no debug color hence no normal color needed
      normal_color = debug_color;
    else
      // the code to set color back to normal
      normal_color = GetColor("normal");
  }
  //---------------------

  void SetOutput(std::ostream *fd)
  {
    output = fd;
  }
  //---------------------

  void PDM(char const* fmt, ...) SDH__attribute__((format(printf, 2, 3)))
  /*
  * Remark:
  *   Since non-static C++ methods have an implicit `this' argument,
  *   the arguments of such methods should be counted from two, not
  *   one, when giving values for STRING-INDEX and FIRST-TO-CHECK
  *   parameter of the format __attribute__.)
  */
  {
    if (!debug_flag) return;

    char buffer[ 256 ];

    va_list arglist;
    va_start(arglist, fmt);
#if SDH_USE_VCC
    vsnprintf_s(buffer, 256, 256, fmt, arglist);
#else
    vsnprintf(buffer, 256, fmt, arglist);
#endif
    va_end(arglist);

    *output << debug_color << buffer << normal_color << std::flush;
  }
  //---------------------

  char const* GetColor(char const* c)
  {
    char* sdh_no_color = getenv("SDH_NO_COLOR");
    if (sdh_no_color != NULL)
      return "";

    char* os = getenv("OS");
    char* ostype = getenv("OSTYPE");
    if (os && (!strncmp(os, "WIN", 3) || !strncmp(os, "Win", 3)) && (! ostype || (ostype && strcmp(ostype, "cygwin"))))
      return "";

    if (!strcmp(c, "normal"))       return "\x1b[0m";
    if (!strcmp(c, "bold"))         return "\x1b[1m";
    if (!strcmp(c, "red"))          return "\x1b[31m";
    if (!strcmp(c, "green"))        return "\x1b[32m";
    if (!strcmp(c, "yellow"))       return "\x1b[33m";
    if (!strcmp(c, "blue"))         return "\x1b[34m";
    if (!strcmp(c, "magenta"))      return "\x1b[35m";
    if (!strcmp(c, "cyan"))         return "\x1b[36m";
    if (!strcmp(c, "white"))        return "\x1b[37m";
    if (!strcmp(c, "black"))        return "\x1b[39m";
    if (!strcmp(c, "black_back"))   return "\x1b[40m";
    if (!strcmp(c, "red_back"))     return "\x1b[41m";
    if (!strcmp(c, "green_back"))   return "\x1b[42m";
    if (!strcmp(c, "yellow_back"))  return "\x1b[43m";
    if (!strcmp(c, "blue_back"))    return "\x1b[44m";
    if (!strcmp(c, "cyan_back"))    return "\x1b[45m";
    if (!strcmp(c, "magenta_back")) return "\x1b[46m";
    if (!strcmp(c, "white_back"))   return "\x1b[47m";

    // no coloring possible or unknown color: return ""
    return "";
  }

  template <typename T>
  cDBG& operator<<(T const& v)
  {
    if (!debug_flag) return *this;

    output->width(0);
    *output << debug_color;
    output->width(mywidth);
    *output << v;
    mywidth = output->width();
    output->width(0);
    *output << normal_color << std::flush;
    return *this;
  }
  //---------------------

  std::ostream& flush()
  {
    return output->flush();
  }
  //---------------------


# define VAR( _d, _var )                        \
    (_d) << #_var << "='" << _var << "'\n"

# define VAL( _var )                      \
    #_var << "='" << _var << "' "
};

class VCC_EXPORT cHexByteString
{
  char const* bytes;
  int         len;
public:
  cHexByteString(char const* _bytes, int _len) :
    bytes(_bytes),
    len(_len)
  {};

  friend VCC_EXPORT std::ostream &operator<<(std::ostream &stream, cHexByteString const &s);
};

inline VCC_EXPORT std::ostream &operator<<(std::ostream &stream, cHexByteString const &s)
{
  //-----
  // print all bytes as hex bytes:
  bool is_all_printable_ascii = true;
  for (int i = 0; i < s.len; i++)
  {
    stream << std::hex << std::setw(2) << std::setfill('0') << int(((unsigned char const*)s.bytes)[i]) << " ";
    if (s.bytes[i] < 0x20 || ((unsigned char) s.bytes[i]) >= 0x80)
      is_all_printable_ascii = false;
  }
  //-----

  //-----
  // if the bytes were all printable ascii codes then print them as string as well:
  if (is_all_printable_ascii)
    stream << "= \"" << std::string(s.bytes, s.len) << "\"";
  //-----

  return stream << std::dec;
};

NAMESPACE_SDH_END

#endif


//======================================================================
/*
  Here are some settings for the emacs/xemacs editor (and can be safely ignored):
  (e.g. to explicitely set C++ mode for *.h header files)

  Local Variables:
  mode:C++
  mode:ELSE
  End:
 */
//======================================================================