MCLog.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ 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 Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MCLog.hpp"

#include "MCThreadLocalData.hpp"

#ifndef __AIBO_BUILD__
#include <qdebug.h>
#include <qregexp.h>
#endif

#include <boost/algorithm/string/find.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>

#include <boost/scoped_ptr.hpp>

#include <stdio.h>
#include <stdlib.h>

namespace
{
// Global message handler
static boost::scoped_ptr<MCLogMessageHandler> GlobalMessageHandler;
// Global debug status
static bool GlobalDebug = false;
// Enabled debug mode
MCThreadLocalData<bool> Debug(true);
// Debug filter
MCThreadLocalData<MC::StringList> DebugFilter(true);
// Debug color filter
MCThreadLocalData<MC::StringList> DebugColorFilters(true);
// Custom log message handler
MCThreadLocalData<MCLogMessageHandler> MessageHandler(true);

void CheckStaticDebugVariables()
{
  if (unlikely(!Debug.get()))
  {
    Debug.reset(new bool);
    *Debug = false;
    DebugFilter.reset(new MC::StringList);
    DebugColorFilters.reset(new MC::StringList);
  }
}
}

bool MCLog::GetDebugStatus(bool global)
{
  if (global)
  {
    return GlobalDebug;
  }
  CheckStaticDebugVariables();
  return *Debug;
}


void MCLog::SetDebugStatus(bool new_status, bool global)
{
  if (global)
  {
    GlobalDebug = new_status;
  } else {
    CheckStaticDebugVariables();
    *Debug = new_status;
  }
}


std::string MCLog::GetDebugFilter()
{
  CheckStaticDebugVariables();
  return boost::algorithm::join(*DebugFilter, ",");
}


void MCLog::SetDebugFilter(const std::string& new_filter)
{
  CheckStaticDebugVariables();
  boost::algorithm::split(*DebugFilter, new_filter, boost::is_any_of(","));
}


std::string MCLog::GetDebugColorFilters()
{
  CheckStaticDebugVariables();
  return boost::algorithm::join(*DebugColorFilters, ",");
}


void MCLog::SetDebugColorFilters(const std::string& new_color_filter)
{
  CheckStaticDebugVariables();
  boost::algorithm::split(*DebugColorFilters, new_color_filter, boost::is_any_of(","));
}


void MCLog::SetCustomHandler(MCLogMessageHandler* handler, bool global)
{
  if (global)
    GlobalMessageHandler.reset(handler);
  else
    MessageHandler.reset(handler);
}


bool MCLog::IsAnyFilterMatched(const MC::StringList& filters, const std::string& function_name)
{
  if (filters.empty() || function_name.empty())
    return false;

  std::string FunctionName = function_name;
  MC::StringList FunctionNameParts;

  MC_TRY_BEGIN
    // Cut down the non-interesting stuff after the function name
    iter_split(FunctionNameParts, FunctionName, boost::algorithm::first_finder("("));
    // Cut down the non-interesting stuff before the function name
    iter_split(FunctionNameParts, FunctionNameParts[0], boost::algorithm::first_finder(" "));
    // Remove the namespace
    iter_split(FunctionNameParts, FunctionNameParts[FunctionNameParts.size()-1], boost::algorithm::first_finder("::"));
    int CutNumber = (int)FunctionNameParts.size()-2;

    for (int i = 0; i < CutNumber; ++i)
    {
      FunctionNameParts.erase(FunctionNameParts.begin());
    }
    FunctionName = boost::algorithm::join(FunctionNameParts, "::");
    // Return true in the case of exact match
    if (std::find(filters.begin(), filters.end(), FunctionName) != filters.end())
      return true;

    // Search for the class name if exists
    iter_split(FunctionNameParts, FunctionName, boost::algorithm::first_finder("::"));
    if (FunctionNameParts.size() > 1)
      return std::find(filters.begin(), filters.end(), FunctionNameParts[0]) != filters.end();
  MC_CATCH_BEGIN
    printf("boost::algorithm::split in MCLog::IsAnyFilterMatched FAILED\n");
    exit(1);
  MC_CATCH_END
  return false;
}


void MCLog::LogMessage(const char* function, const char* format, ...)
{
  if (!function || !format)
    return;

  // We must avoid to create static members in tls here for performance reasons.
  // Since the default value of Debug is false, we don't need to output anything if the tls is empty.
  if (!GlobalDebug &&
      (!Debug.get() || !*Debug || (DebugFilter.get() && !DebugFilter->empty() &&
       !IsAnyFilterMatched(*DebugFilter, function))))
  {
    return;
  }

  va_list ap;
  va_start(ap, format);

  if (GlobalMessageHandler.get())
  {
    GlobalMessageHandler->Message(MCLog::Normal, function, format, ap);
    va_end(ap);
    return;
  } else
  if (MessageHandler.get())
  {
    MessageHandler->Message(MCLog::Normal, function, format, ap);
    va_end(ap);
    return;
  }
  std::string TempStr(function);
#if defined(__ANDROID__)
  char OtherTempStr[512];

  vsnprintf(OtherTempStr, sizeof(OtherTempStr), format, ap);
  qCritical("%s", OtherTempStr);
  va_end(ap);
  return;
#endif

  if (TempStr.find('(') != std::string::npos)
  {
    MC::StringList FunctionNameSplitParts;

    MC_TRY_BEGIN
      boost::algorithm::split(FunctionNameSplitParts, TempStr, boost::is_any_of("("));
    MC_CATCH_BEGIN
      printf("boost::algorithm::split FAILED\n");
      exit(1);
    MC_CATCH_END
    TempStr = FunctionNameSplitParts[0];
  }
  const char* color_str = MC_ANSI_BLACK;

  if (!DebugColorFilters->empty() && IsAnyFilterMatched(*DebugColorFilters, function))
    color_str = MC_ANSI_GREEN;

  fprintf(stdout, "%s%45s%s - ", color_str, TempStr.c_str(), MC_ANSI_COLOR_END);
  vfprintf(stdout, format, ap);
  fprintf(stdout, "\n");
  va_end(ap);
}


void MCLog::ErrorMessage(const char* function, const char* format, ...)
{
  if (!function || !format)
    return;

  va_list ap;

  va_start(ap, format);
  if (MessageHandler.get())
  {
    MessageHandler->Message(MCLog::Error, function, format, ap);
    va_end(ap);
#ifdef __AIBO_BUILD__
    ::abort();
#else
    exit(1);
#endif
  }
  std::string TempStr(function);
#if defined(__ANDROID__)
  char OtherTempStr[512];

  // cppcheck-suppress va_list_usedBeforeStarted
  vsnprintf(OtherTempStr, sizeof(OtherTempStr), format, ap);
  qCritical("%s", OtherTempStr);
  // cppcheck-suppress va_list_usedBeforeStarted
  va_end(ap);
  exit(1);
#endif
  if (TempStr.find('(') != std::string::npos)
  {
    MC::StringList FunctionNameSplitParts;

    MC_TRY_BEGIN
      boost::algorithm::split(FunctionNameSplitParts, TempStr, boost::is_any_of("("));
    MC_CATCH_BEGIN
      printf("boost::algorithm::split FAILED\n");
      exit(1);
    MC_CATCH_END
    TempStr = FunctionNameSplitParts[0];
  }

  fprintf(stdout, "%s%45s%s - ", MC_ANSI_RED, TempStr.c_str(), MC_ANSI_COLOR_END);
  vfprintf(stdout, format, ap);
  fprintf(stdout, "\n");
  va_end(ap);
  exit(1);
}


void MCLog::WarningMessage(const char* function, const char* format, ...)
{
  if (!function || !format)
    return;

  va_list ap;
  va_start(ap, format);

  if (MessageHandler.get())
  {
    MessageHandler->Message(MCLog::Warning, function, format, ap);
    va_end(ap);
    return;
  }
  std::string TempStr(function);
#if defined(__ANDROID__)
  char OtherTempStr[512];

  vsnprintf(OtherTempStr, sizeof(OtherTempStr), format, ap);
  qCritical("%s", OtherTempStr);
  va_end(ap);
  return;
#endif
  if (TempStr.find('(') != std::string::npos)
  {
    MC::StringList FunctionNameSplitParts;

    MC_TRY_BEGIN
      boost::algorithm::split(FunctionNameSplitParts, TempStr, boost::is_any_of("("));
    MC_CATCH_BEGIN
      printf("boost::algorithm::split FAILED\n");
      exit(1);
    MC_CATCH_END
    TempStr = FunctionNameSplitParts[0];
  }
  fprintf(stdout, "%s%45s%s - ", MC_ANSI_PURPLE, TempStr.c_str(), MC_ANSI_COLOR_END);
  vfprintf(stdout, format, ap);
  fprintf(stdout, "\n");
  va_end(ap);
}


void MCLog::FormattedMessage(MCLog::ColorType color, bool bold, const char* format, ...)
{
  if (!format)
    return;

  va_list ap;
  va_start(ap, format);
#if defined(__ANDROID__)
  char OtherTempStr[4096];

  vsnprintf(OtherTempStr, sizeof(OtherTempStr), format, ap);
  qCritical("%s", OtherTempStr);
  va_end(ap);
  return;
#endif
#ifdef WIN32
  vfprintf(stdout, format, ap);
  va_end(ap);
  return;
#endif
  // Workaround to avoid the new-line code among the ANSI codes
  std::string TempStr(format);
  bool NewLine = false;

  if (TempStr.c_str()[TempStr.size()-1] == '\n')
  {
    NewLine = true;
    TempStr.erase(TempStr.size()-1, 1);
  }

  if (color != NoColor)
  {
    char OtherTempStr[256];

    if (bold)
    {
      snprintf(OtherTempStr, sizeof(OtherTempStr), "\033[1;%dm%s\033[0;39m", (int)color, TempStr.c_str());
    } else {
      snprintf(OtherTempStr, sizeof(OtherTempStr), "\033[;%dm%s\033[0;39m", (int)color, TempStr.c_str());
    }
    TempStr = OtherTempStr;
  }
  vfprintf(stdout, TempStr.c_str(), ap);

  if (NewLine)
  {
    fprintf(stdout, "\n");
  }
  va_end(ap);
}


#ifndef __AIBO_BUILD__
QString MCLog::ConvertFromAnsiToQtMarkup(const QString& orig_str)
{
  if (!orig_str.contains('\033')) // -V536 (PVS Studio suppression)
    return orig_str;

  QString NewStr(orig_str);

  for (int i = MinColor; i <= MaxColor; ++i)
  {
    QString NormalCodeStr = QString("\033[;%1m").arg(QString::number(i));
    QString BoldCodeStr = QString("\033[1;%1m").arg(QString::number(i));

    if (i == Black)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:black\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:black;font-weight:bold\">");
    }
    if (i == Red)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:#ff363c\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:#ff363c;font-weight:bold\">");
    }
    if (i == Green)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:#389e0b\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:#389e0b;font-weight:bold\">");
    }
    if (i == Yellow)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:yellow\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:yellow;font-weight:bold\">");
    }
    if (i == Blue)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:blue\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:blue;font-weight:bold\">");
    }
    if (i == Purple)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:purple\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:purple;font-weight:bold\">");
    }
    if (i == Cyan)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:cyan\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:cyan;font-weight:bold\">");
    }
    if (i == White)
    {
      NewStr.replace(NormalCodeStr, "<span style=\"color:white\">");
      NewStr.replace(BoldCodeStr, "<span style=\"color:white;font-weight:bold\">");
    }
  }
  NewStr.replace("\033[0;39m", "</span>");
  return NewStr;
}


QString MCLog::RemoveMarkup(const QString& orig_str)
{
  QString NewStr(orig_str);

  // Note: Kinda hack, not really good
  NewStr.remove("<b>");
  NewStr.remove("</b>");
  NewStr.remove("</span>");
  NewStr.remove(QRegExp("<*>", Qt::CaseInsensitive, QRegExp::Wildcard));
  return NewStr;
}
#endif


void MCLogEcho::Message(MCLog::MessageType message_type, const char* function, const char* format, va_list arg_list)
{
  MC_UNUSED(function);
  int Position = 0;
  const int BufferSize = 1024;
  char Buffer[BufferSize];

  Position += vsnprintf(&Buffer[Position], BufferSize-Position, format, arg_list);
  snprintf(&Buffer[Position], BufferSize-Position, "\n");
  printf("%s", Buffer);
  if (message_type == MCLog::Error)
  {
#ifdef __AIBO_BUILD__
    ::abort();
#else
    exit(1);
#endif
  }
}


#ifndef __AIBO_BUILD__
void MCQtLogEcho::Message(MCLog::MessageType message_type, const char* function, const char* format, va_list arg_list)
{
  MC_UNUSED(function);
  const int BufferSize = 1024;
  char Buffer[BufferSize];

  vsnprintf(&Buffer[0], BufferSize, format, arg_list);
  if (message_type == MCLog::Normal)
  {
    qDebug() << Buffer;
  } else
  if (message_type == MCLog::Warning)
  {
    qWarning() << Buffer;
  } else
  if (message_type == MCLog::Error)
  {
    exit(1);
  }
}
#endif