MCDefs.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 "MCDefs.hpp"

#include "MCLog.hpp"

#ifndef __AIBO_BUILD__
#include <qdir.h>
#include <QtGlobal>
#endif

#include <fstream>

#if defined(__unix__) && !defined(__ANDROID__) && !defined(__AIBO_BUILD__)
#include <execinfo.h>
#endif
#include <unistd.h>
#ifdef __AIBO_BUILD__
#include <math.h>
#else
#include <cmath>
#endif

#ifdef __AIBO_BUILD__
#include <MCOOP.h>
#endif

#if defined(__AIBO_BUILD__)
extern "C"
{
jmp_buf JumpPoint;
int JumpPointValid = 0;

void RaiseCppException()
{
  if (JumpPointValid == 1)
    longjmp(JumpPoint, 1);
  else
    abort();
}
}
#endif

#ifndef __AIBO_BUILD__
namespace
{
static QStringList SearchPaths;
}
#endif

boost::mt19937 MCRandomSeed::Algorithm;

void MCRandomSeed::SetNewSeed(int seed)
{
  srand(seed);
  Algorithm.seed(seed);
}


int MCRandSign()
{
  if (MCRand(0, 1) == 0)
  {
    return -1;
  }
  return 1;
}


void MCSleep(unsigned int msecs)
{
#ifdef __AIBO_BUILD__
  Wait(msecs*1000*1000);
#else
  usleep(msecs*1000);
#endif
}


#if !defined(__AIBO_BUILD__) && defined(__unix__)
int MCGetSystemMemorySize()
{
  long pages = sysconf(_SC_PHYS_PAGES);
  long page_size = sysconf(_SC_PAGE_SIZE);

  return (int)((float)pages / 1024*page_size / 1024);
}
#endif


float MCFloatInfinity()
{
  return std::numeric_limits<float>::infinity();
}


double MCDoubleInfinity()
{
  return std::numeric_limits<double>::infinity();
}


bool MCIsFloatInfinity(const float value)
{
#ifdef __AIBO_BUILD__
  return __isinff(value);
#else
  return std::isinf(value);
#endif
}


bool MCIsDoubleInfinity(const double value)
{
#ifdef __AIBO_BUILD__
  return __isinfd(value);
#else
  return std::isinf(value);
#endif
}


float MCRound(float number)
{
  double IntPart = 0.0;
  float FracPart = (float)modf((double)number, &IntPart);

  if (number >= 0)
    return (float)(FracPart >= 0.5 ? IntPart+1 : IntPart);

  return (float)(FracPart <= -0.5 ? IntPart-1 : IntPart);
}


float MCScaleValue(float value, float min, float max, float new_max)
{
  if (MCIsFloatInfinity(value) || MCIsFloatInfinity(min) || MCIsFloatInfinity(max) ||
      MCIsFloatInfinity(new_max) || min > max || min > new_max || value < min || value > max)
  {
    return value;
  }
  float CurrentValueRate = (value-min) / (max-min);

  return min+CurrentValueRate*(new_max-min);
}


int MCCompare(const std::string& item, const std::string& a, const std::string& b)
{
  std::string Item = item;
  std::string A = a;
  std::string B = b;

  boost::algorithm::to_lower(Item);
  boost::algorithm::to_lower(A);
  boost::algorithm::to_lower(B);
  int Result = 0;

  while (true)
  {
    if (Item.size() == 0 || (A.size() == 0 && B.size() == 0))
      return Result;
    if (A.size() == 0)
      return -1;
    if (B.size() == 0)
      return 1;

    if (Result == 0)
      Result = MCCompare(A[0], B[0]);

    Item.erase(0, 1);
    A.erase(0, 1);
    B.erase(0, 1);
  }
  return 0;
}


int MCCompare(const std::string& a, const std::string& b)
{
  std::string A = a;
  std::string B = b;

  boost::algorithm::to_lower(A);
  boost::algorithm::to_lower(B);
  int Result = 0;

  while (true)
  {
    if (A.size() == 0 && B.size() == 0)
      return Result;
    if (A.size() == 0)
      return 1;
    if (B.size() == 0)
      return -1;

    if (Result == 0)
      Result = MCCompare(A[0], B[0]);

    A.erase(0, 1);
    B.erase(0, 1);
  }
  return 0;
}


bool MCFileExists(const std::string& file_name)
{
  std::ifstream InputFile(file_name.c_str(), std::ios::in | std::ios::binary);

  if (!InputFile.is_open())
  {
    return false;
  }
  InputFile.close();
  return true;
}


int MCGetFileSize(const std::string& file_name)
{
  std::ifstream InputFile(file_name.c_str(), std::ios::in | std::ios::binary);

  if (!InputFile.is_open())
  {
    return -1;
  }
  InputFile.seekg(0, std::ifstream::end);
  return (int)InputFile.tellg();
}


#ifndef __AIBO_BUILD__
#if defined(__unix__) && !defined(__ANDROID__)
namespace {
bool MCRealBacktraceEntry(const std::string& str)
{
  if (str.length() < 5)
    return false;

  if (str.c_str()[0] != '[' || str.c_str()[1] != '0' || str.c_str()[2] != 'x' ||
      str.c_str()[str.length()-1] != ']')
  {
    return false;
  }
  return true;
}
}


// Nice backtrace implementation taken from: http://stackoverflow.com/questions/77005
void MCGenerateBacktrace()
{
  void* Array[100];
  int Size = backtrace(Array, 100);

  char **Messages = backtrace_symbols(Array, Size);

  // Skip first stack frame (points here)
  for (int i = 1; i < Size && Messages != nullptr; ++i)
  {
    char* MangledName = nullptr;
    char* OffsetBegin = nullptr;
    char* OffsetEnd = nullptr;

    // Find parentheses and +address offset surrounding mangled name
    for (char *Chr = Messages[i]; *Chr; ++Chr)
    {
      if (*Chr == '(')
      {
        MangledName = Chr;
      }
      else if (*Chr == '+')
      {
        OffsetBegin = Chr;
      }
      else if (*Chr == ')')
      {
        OffsetEnd = Chr;
        break;
      }
    }

    // If the line could be processed, attempt to demangle the symbol
    if (MangledName && OffsetBegin && OffsetEnd && MangledName < OffsetBegin)
    {
      *MangledName++ = '\0';
      *OffsetBegin++ = '\0';
      *OffsetEnd++ = '\0';

      int Status;
      char *RealName = abi::__cxa_demangle(MangledName, 0, 0, &Status);

      if (Status == 0)
      {
        // If demangling is successful, output the demangled function name
        MC_PRINT(MCLog::White, "[bt]: %s+%s (%s)\n", RealName, OffsetBegin, Messages[i]);
      } else {
        // Otherwise, output the mangled function name
        if (strcmp("", MangledName) != 0)
          MC_PRINT(MCLog::White, "[bt]: %s+%s (%s)\n", MangledName, OffsetBegin, Messages[i]);
        // Return if the main() function is reached
        if (strcmp("main", MangledName) == 0)
        {
          printf("\n");
          free(Messages);
          return;
        }
      }
      free(RealName);
    } else {
      // Otherwise, print the whole line unless it is empty or it is just a memory address
      if (!Messages[i] && strcmp("", Messages[i]) != 0 && MCRealBacktraceEntry(Messages[0]))
      {
        MC_PRINT(MCLog::White, "[bt]: %s\n", Messages[i]);
      }
    }
  }
  printf("\n");
  free(Messages);
}
#endif


bool MCCreatePath(const QString& path)
{
  if (path.isEmpty())
  {
    MC_WARNING("Empty path is not valid.");
    return false;
  }
  // Create a directory if it does not exist.
  QDir Path(path);

  if (!Path.exists())
  {
    if (!Path.mkpath(Path.absolutePath()))
    {
      MC_WARNING("Cannot create the directory: %s\n", qPrintable(path));
      return false;
    } else {
      MC_LOG("Create directory: %s", qPrintable(path));
      return true;
    }
  }
  // Silently returns without any real work done
  return true;
}


bool MCRemoveDirectory(const QString& dir_str)
{
  bool Result = true;
  QDir Dir(dir_str);

  if (Dir.exists())
  {
    QFileInfoList InfoList = Dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden |
                                               QDir::AllDirs | QDir::Files, QDir::DirsFirst);

    for (int i = 0; i < InfoList.size(); ++i)
    {
      if (InfoList[i].isDir())
      {
        Result = MCRemoveDirectory(InfoList[i].absoluteFilePath());
      } else {
        Result = QFile::remove(InfoList[i].absoluteFilePath());
      }
      if (!Result)
      {
        return Result;
      }
    }
    Result = Dir.rmdir(Dir.absolutePath());
  }
  return Result;
}


QString MCFixPath(const QString& path)
{
  if (path.isEmpty())
  {
    MC_WARNING("Empty path is not valid.");
    return QString();
  }
#if defined(__MINGW32__) || defined(__MINGW64__)
  return QString(path).replace('/', '\\');
#else
  return QString(path).replace('\\', '/');
#endif
}


void MCAddSearchPath(const QString& path)
{
  if (path.isEmpty())
  {
    MC_WARNING("Empty path is not valid as a search path.");
    return;
  }
  SearchPaths += path;
}


QString MCGetDataFile(const QString& file_name)
{
  if (file_name.isEmpty())
  {
    MC_WARNING("Empty file name is not valid.");
    return QString();
  }
  QStringList Paths = SearchPaths;

  Paths += QString('.');
  for (int i = 0; i < Paths.size(); ++i)
  {
    QString location;

    location = MCFixPath(Paths[i]+QDir::separator())+file_name;
    if (QFile::exists(location))
    {
//      MC_LOG("Found: %s", qPrintable(location));
      return location;
    } else {
//      MC_LOG("Missing: %s", qPrintable(location));
    }
  }
  MC_LOG("Not found (%s)", qPrintable(file_name));
  return QString();
}


QString MCGetDataSubdirectory(const QString& subdirectory)
{
  if (subdirectory.isEmpty())
  {
    MC_WARNING("Empty directory is not valid.");
    return QString();
  }
  QStringList Paths = SearchPaths;

  Paths += QString('.');
  for (int i = 0; i < Paths.size(); ++i)
  {
    QString location;

    location = MCFixPath(Paths[i]+QDir::separator())+subdirectory;
    if (QDir(location).exists())
    {
      MC_LOG("Found: %s", qPrintable(location));
      return location;
    } else {
      MC_LOG("Missing: %s", qPrintable(location));
    }
  }
  MC_LOG("Not found (%s)", qPrintable(subdirectory));
  return QString();
}
#endif