support.cpp

Go to the documentation of this file.

/*
  /\ ___ /\        Copyright (c) 1996-2020 ＦＲＥＥＣＩＶ ２１ and Freeciv
 (  o   o  )                 contributors. This file is part of Freeciv21.
  \  >#<  /           Freeciv21 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 3 of the License,
 \         /    //                  or (at your option) any later version.
                          GNU General Public License along with Freeciv21.
                                  If not, see https://www.gnu.org/licenses/.
 */
 
#include <fc_config.h>
 
#include <cmath> // ceil()
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/stat.h>
 
#ifdef FREECIV_MSWINDOWS
#include <process.h>
#include <windows.h>
#endif // FREECIV_MSWINDOWS
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
 
// Qt
#include <QFileInfo>
#include <QHostInfo>
#include <QString>
#include <QThread>
 
// utility
#include "fciconv.h"
#include "fcintl.h"
#include "log.h"
 
#include "support.h"
 
char *real_fc_strdup(const char *str, const char *called_as, int line,
                     const char *file)
{
  Q_UNUSED(file)
  char *dest = new char[strlen(str) + 1];
 
  // no need to check whether dest is non-nullptr (raises std::bad_alloc)
  qstrcpy(dest, str);
  return dest;
}
 
int fc_strcasecmp(const char *str0, const char *str1)
{
  auto left = QString::fromUtf8(str0);
  auto right = QString::fromUtf8(str1);
  return left.compare(right, Qt::CaseInsensitive);
}
 
int fc_strncasecmp(const char *str0, const char *str1, size_t n)
{
  auto left = QString::fromUtf8(str0);
  auto right = QString::fromUtf8(str1);
  return left.leftRef(n).compare(right.leftRef(n), Qt::CaseInsensitive);
}
 
void make_escapes(const char *str, char *buf, size_t buf_len)
{
  char *dest = buf;
  /* Sometimes we insert 2 characters at once ('\n' -> "\\n"), so keep
   * place for '\0' and an extra character. */
  const char *const max = buf + buf_len - 2;
 
  while (*str != '\0' && dest < max) {
    switch (*str) {
    case '\n':
      *dest++ = '\\';
      *dest++ = 'n';
      str++;
      break;
    case '\\':
    case '\"':
      *dest++ = '\\';
      // Fallthrough.
    default:
      *dest++ = *str++;
      break;
    }
  }
  *dest = 0;
}
 
QString remove_escapes(const QString &str, bool full_escapes)
{
  QString copy;
 
  if (full_escapes) {
    // Replace most everything
    copy.reserve(str.length());
 
    bool escape = false;
    for (const auto &c : str) {
      if (escape && full_escapes) {
        switch (c.unicode()) {
        case 'n':
          copy += '\n';
          break;
        case '\n':
          // Remove the newline
          break;
        default:
          copy += c;
        }
        escape = false;
      } else if (c == '\\') {
        escape = true;
      } else {
        copy += c;
      }
    }
  } else {
    // Replace only escaped newlines
    copy = str;
    copy.replace("\\\n", "\n");
  }
 
  return copy;
}
 
size_t effectivestrlenquote(const char *str)
{
  int len;
  if (!str) {
    return 0;
  }
 
  len = qstrlen(str);
 
  if (str[0] == '"' && str[len - 1] == '"') {
    return len - 2;
  }
 
  return len;
}
 
int fc_strncasequotecmp(const char *str0, const char *str1, size_t n)
{
  auto left = QString::fromUtf8(str0);
  auto right = QString::fromUtf8(str1);
  if (left.startsWith(QLatin1String("\""))
      && left.endsWith(QLatin1String("\""))) {
    left = left.mid(1, left.length() - 2);
  }
  if (right.startsWith(QLatin1String("\""))
      && right.endsWith(QLatin1String("\""))) {
    right = right.mid(1, right.length() - 2);
  }
  return left.leftRef(n).compare(right.leftRef(n), Qt::CaseInsensitive);
}
 
int fc_strcoll(const char *str0, const char *str1)
{
  return strcoll(str0, str1);
}
 
int fc_stricoll(const char *str0, const char *str1)
{
  /* We prefer _stricoll() over stricoll() since
   * latter is not declared in MinGW headers causing compiler
   * warning, preventing -Werror builds. */
#if defined(ENABLE_NLS) && defined(HAVE__STRICOLL)
  return _stricoll(str0, str1);
#elif defined(ENABLE_NLS) && defined(HAVE_STRICOLL)
  return stricoll(str0, str1);
#elif defined(ENABLE_NLS) && defined(HAVE_STRCASECOLL)
  return strcasecoll(str0, str1);
#else
  return fc_strcasecmp(str0, str1);
#endif
}
 
FILE *fc_fopen(const char *filename, const char *opentype)
{
#ifdef FREECIV_MSWINDOWS
  FILE *result;
  char *filename_in_local_encoding =
      internal_to_local_string_malloc(filename);
 
  result = fopen(filename_in_local_encoding, opentype);
  free(filename_in_local_encoding);
  return result;
#else  // FREECIV_MSWINDOWS
  return fopen(filename, opentype);
#endif // FREECIV_MSWINDOWS
}
 
int fc_remove(const char *filename)
{
#ifdef FREECIV_MSWINDOWS
  int result;
  char *filename_in_local_encoding =
      internal_to_local_string_malloc(filename);
 
  result = remove(filename_in_local_encoding);
  free(filename_in_local_encoding);
  return result;
#else  // FREECIV_MSWINDOWS
  return remove(filename);
#endif // FREECIV_MSWINDOWS
}
 
int fc_stat(const char *filename, struct stat *buf)
{
#ifdef FREECIV_MSWINDOWS
  int result;
  char *filename_in_local_encoding =
      internal_to_local_string_malloc(filename);
 
  result = stat(filename_in_local_encoding, buf);
  free(filename_in_local_encoding);
  return result;
#else  // FREECIV_MSWINDOWS
  return stat(filename, buf);
#endif // FREECIV_MSWINDOWS
}
 
fc_errno fc_get_errno()
{
#ifdef FREECIV_MSWINDOWS
  return GetLastError();
#else  // FREECIV_MSWINDOWS
  return errno;
#endif // FREECIV_MSWINDOWS
}
 
const char *fc_strerror(fc_errno err)
{
#ifdef FREECIV_MSWINDOWS
  static char buf[256];
 
  if (!FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
                         | FORMAT_MESSAGE_IGNORE_INSERTS,
                     nullptr, err, 0, buf, sizeof(buf), nullptr)) {
    fc_snprintf(buf, sizeof(buf), _("error %ld (failed FormatMessage)"),
                err);
  }
  return buf;
#else  // FREECIV_MSWINDOWS
  static char buf[256];
  return local_to_internal_string_buffer(strerror(err), buf, sizeof(buf));
#endif // FREECIV_MSWINDOWS
}
 
void fc_usleep(unsigned long usec) { QThread::usleep(usec); }
 
bool fc_strrep(char *str, size_t len, const char *search,
               const char *replace)
{
  size_t len_search, len_replace;
  char *s, *p;
 
  fc_assert_ret_val(str != nullptr, false);
  if (search == nullptr || replace == nullptr) {
    return true;
  }
 
  len_search = qstrlen(search);
  len_replace = qstrlen(replace);
 
  s = str;
  while (s != nullptr) {
    p = strstr(s, search);
    if (p == nullptr) {
      // nothing found
      break;
    }
 
    if (len < (strlen(str) + len_replace - len_search + 1)) {
      // sizeof(str) not large enough to do the replacement
      return false;
    }
 
    memmove(p + len_replace, p + len_search, qstrlen(p + len_search) + 1);
    memcpy(p, replace, len_replace);
    s = p + len_replace;
  }
 
  return true;
}
 
size_t fc_strlcpy(char *dest, const char *src, size_t n)
{
  fc_assert_ret_val(nullptr != dest, -1);
  fc_assert_ret_val(nullptr != src, -1);
  fc_assert_ret_val(0 < n, -1);
 
  auto source = QString::fromUtf8(src);
 
  // Strategy: cut the string after n-1 code points, and encode. If the
  // encoded version is too long to copy to the output buffer, remove the
  // last character and repeat.
  size_t cut_at = n - 1;
  QByteArray encoded;
  do {
    encoded = source.leftRef(cut_at--).toUtf8();
  } while (cut_at > 0 && encoded.size() + 1 > n);
 
  if (cut_at == 0) {
    // Can't put anything in the buffer except the \0
    // Perhaps there's a character with diacritics taking many bytes at the
    // beginning, or the size of the buffer is just 1.
    *dest = '\0';
    return 1;
  } else {
    // Can put something
    memcpy(dest, encoded.data(), encoded.size() + 1);
    return encoded.size() + 1;
  }
}
 
size_t fc_strlcat(char *dest, const char *src, size_t n)
{
  size_t start;
 
  start = qstrlen(dest);
 
  fc_assert(start < n);
 
  return fc_strlcpy(dest + start, src, n - start) + start;
}
 
// "64k should be big enough for anyone" ;-)
#define VSNP_BUF_SIZE (64 * 1024)
int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap)
{
  int r;
 
  /* This may be overzealous, but I suspect any triggering of these to
   * be bugs.  */
 
  fc_assert_ret_val(nullptr != str, -1);
  fc_assert_ret_val(0 < n, -1);
  fc_assert_ret_val(nullptr != format, -1);
 
  r = vsnprintf(str, n, format, ap);
  str[n - 1] = 0;
 
  // Convert C99 return value to C89.
  if (r >= n) {
    return -1;
  }
 
  return r;
}
 
int fc_snprintf(char *str, size_t n, const char *format, ...)
{
  int ret;
  va_list ap;
 
  fc_assert_ret_val(nullptr != format, -1);
 
  va_start(ap, format);
  ret = fc_vsnprintf(str, n, format, ap);
  va_end(ap);
  return ret;
}
 
int cat_snprintf(char *str, size_t n, const char *format, ...)
{
  size_t len;
  int ret;
  va_list ap;
 
  fc_assert_ret_val(nullptr != format, -1);
  fc_assert_ret_val(nullptr != str, -1);
  fc_assert_ret_val(0 < n, -1);
 
  len = qstrlen(str);
  fc_assert_ret_val(len < n, -1);
 
  va_start(ap, format);
  ret = fc_vsnprintf(str + len, n - len, format, ap);
  va_end(ap);
  return (-1 == ret ? -1 : ret + len);
}
 
int fc_gethostname(char *buf, size_t len)
{
  auto name = QHostInfo::localHostName();
  fc_strlcpy(buf, name.toUtf8().data(), len);
  return 0;
}
 
int fc_break_lines(char *str, size_t desired_len)
{
  size_t slen = static_cast<size_t>(qstrlen(str));
  int num_lines = 0;
  bool not_end = true;
  /* At top of this loop, s points to the rest of string,
   * either at start or after inserted newline: */
  do {
    bool double_break = false;
    if (str && *str != '\0' && slen > desired_len) {
      char *c;
 
      num_lines++;
 
      // check if there is already a newline:
      for (c = str; c < str + desired_len; c++) {
        if (*c == '\n') {
          slen -= c + 1 - str;
          str = c + 1;
          double_break = true;
          break;
        }
      }
      if (double_break) {
        continue;
      }
 
      // find space and break:
      for (c = str + desired_len; c > str; c--) {
        if (QChar::isSpace(*c)) {
          *c = '\n';
          slen -= c + 1 - str;
          str = c + 1;
          double_break = true;
          break;
        }
      }
      if (double_break) {
        continue;
      }
 
      // couldn't find a good break; settle for a bad one...
      for (c = str + desired_len + 1; *c != '\0'; c++) {
        if (QChar::isSpace(*c)) {
          *c = '\n';
          slen -= c + 1 - str;
          str = c + 1;
          break;
        }
      }
    }
    not_end = false;
  } while (not_end);
 
  return num_lines;
}
 
int fc_at_quick_exit(void (*func)())
{
#ifdef HAVE_AT_QUICK_EXIT
  return at_quick_exit(func);
#else  // HAVE_AT_QUICK_EXIT
  return -1;
#endif // HAVE_AT_QUICK_EXIT
}