utf8.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2024) Licensed under MIT License.
  This is part of UTF8 project. See LICENSE file for full license terms.
*/
 
#pragma once
 
#include <string>
#include <vector>
#include <fstream>
 
//#define USE_WINDOWS_API 0
 
#if defined (_WIN32) && !defined (USE_WINDOWS_API)
#define USE_WINDOWS_API 1
#elif !defined (USE_WINDOWS_API)
#define USE_WINDOWS_API 0
#endif
 
#if !USE_WINDOWS_API
#include <filesystem>
 
#if (defined(_MSVC_LANG) && _MSVC_LANG < 201703L)                                                  \
  || (!defined(_MSVC_LANG) && (__cplusplus < 201703L))
#error "UTF8 requires c++17 or newer if not using Windows API functions"
#endif
 
#endif
 
namespace utf8 {
 
struct exception : public std::exception
{
  enum cause { invalid_utf8=1, invalid_wchar, invalid_char32 };
 
  explicit exception (cause c)
    : code (c)
  {}
 
  const char* what() const noexcept
  {
    return (code == cause::invalid_utf8)   ? "Invalid UTF-8 encoding"
         : (code == cause::invalid_wchar)  ? "Invalid UTF-16 encoding"
         : (code == cause::invalid_char32) ? "Invalid code-point value"
         : "Other UTF-8 exception";
  }
  cause code;
};
 
enum action {
  replace, 
  except   
};
 
action error_mode (action mode);
 
const char32_t REPLACEMENT_CHARACTER = 0xfffd;
 
 
std::string narrow (const wchar_t* s, size_t nch=0);
std::string narrow (const std::wstring& s);
std::string narrow (const char32_t* s, size_t nch = 0);
std::string narrow (const std::u32string& s);
std::string narrow (char32_t r);
 
std::wstring widen (const char* s, size_t nch = 0);
std::wstring widen (const std::string& s);
std::u32string runes (const char* s, size_t nch = 0);
std::u32string runes (const std::string& s);
 
char32_t rune (const char* p);
char32_t rune (const std::string::const_iterator& p);
 
bool is_valid (const char* p);
bool is_valid (std::string::const_iterator p, const std::string::const_iterator last);
bool valid_str (const char* s, size_t nch = 0);
bool valid_str (const std::string& s);
 
char32_t next (std::string::const_iterator& ptr, const std::string::const_iterator last);
char32_t next (std::string::iterator& ptr, const std::string::const_iterator last);
char32_t next (const char*& ptr);
char32_t next (char*& p);
 
char32_t prev (const char*& ptr);
char32_t prev (char*& ptr);
char32_t prev (std::string::const_iterator& ptr, const std::string::const_iterator first);
char32_t prev (std::string::iterator& ptr, const std::string::const_iterator first);
 
size_t length (const std::string& s);
size_t length (const char* s);
 
void make_lower (std::string& str);
void make_upper (std::string& str);
std::string tolower (const std::string& str);
std::string toupper (const std::string& str);
int icompare (const std::string& s1, const std::string& s2);
 
bool isspace (char32_t r);
bool isspace (const char* p);
bool isspace (std::string::const_iterator p);
 
bool isblank (char32_t r);
bool isblank (const char* p);
bool isblank (std::string::const_iterator p);
 
bool isdigit (char32_t r);
bool isdigit (const char* p);
bool isdigit (std::string::const_iterator p);
 
bool isalnum (char32_t r);
bool isalnum (const char* p);
bool isalnum (std::string::const_iterator p);
 
bool isalpha (char32_t r);
bool isalpha (const char* p);
bool isalpha (std::string::const_iterator p);
 
bool isxdigit (char32_t r);
bool isxdigit (const char* p);
bool isxdigit (std::string::const_iterator p);
 
bool isupper (char32_t r);
bool isupper (const char* p);
bool isupper (std::string::const_iterator p);
 
bool islower (char32_t r);
bool islower (const char* p);
bool islower (std::string::const_iterator p);
 
#ifdef _WIN32
class ifstream : public std::ifstream
{
public:
  ifstream () : std::ifstream () {};
  explicit ifstream (const char* filename, std::ios_base::openmode mode = ios_base::in)
    : std::ifstream (utf8::widen (filename), mode) {};
  explicit ifstream (const std::string& filename, std::ios_base::openmode mode = ios_base::in)
    : std::ifstream (utf8::widen (filename), mode) {};
  ifstream (ifstream&& other) noexcept : std::ifstream ((std::ifstream&&)other) {};
  ifstream (const ifstream& rhs) = delete;
 
  void open (const char* filename, std::ios_base::openmode mode = ios_base::in)
  {
    std::ifstream::open (utf8::widen (filename), mode);
  }
  void open (const std::string& filename, ios_base::openmode mode = ios_base::in)
  {
    std::ifstream::open (utf8::widen (filename), mode);
  }
};
class ofstream : public std::ofstream
{
public:
  ofstream () : std::ofstream () {};
  explicit ofstream (const char* filename, std::ios_base::openmode mode = ios_base::out)
    : std::ofstream (utf8::widen (filename), mode) {};
  explicit ofstream (const std::string& filename, std::ios_base::openmode mode = ios_base::out)
    : std::ofstream (utf8::widen (filename), mode) {};
  ofstream (ofstream&& other) noexcept : std::ofstream ((std::ofstream&&)other) {};
  ofstream (const ofstream& rhs) = delete;
 
  void open (const char* filename, ios_base::openmode mode = ios_base::out)
  {
    std::ofstream::open (utf8::widen (filename), mode);
  }
  void open (const std::string& filename, ios_base::openmode mode = ios_base::out)
  {
    std::ofstream::open (utf8::widen (filename), mode);
  }
};
 
class fstream : public std::fstream
{
public:
  fstream () : std::fstream () {};
  explicit fstream (const char* filename, std::ios_base::openmode mode = ios_base::in | ios_base::out)
    : std::fstream (utf8::widen (filename), mode) {};
  explicit fstream (const std::string& filename, std::ios_base::openmode mode = ios_base::in | ios_base::out)
    : std::fstream (utf8::widen (filename), mode) {};
  fstream (fstream&& other) noexcept : std::fstream ((std::fstream&&)other) {};
  fstream (const fstream& rhs) = delete;
 
  void open (const char* filename, ios_base::openmode mode = ios_base::in | ios_base::out)
  {
    std::fstream::open (utf8::widen (filename), mode);
  }
  void open (const std::string& filename, ios_base::openmode mode = ios_base::in | ios_base::out)
  {
    std::fstream::open (utf8::widen (filename), mode);
  }
};
 
#else
//Under Linux file streams already use UTF-8 filenames
typedef std::ifstream ifstream;
typedef std::ofstream ofstream;
typedef std::fstream fstream;
#endif
 
 
// INLINES --------------------------------------------------------------------
 
inline
bool is_valid (const char* p)
{
  auto prev_mode = error_mode (action::replace);
  bool valid =  (next (p) != REPLACEMENT_CHARACTER);
  error_mode (prev_mode);
  return valid;
}
 
inline
bool is_valid (std::string::const_iterator p, const std::string::const_iterator last)
{
  auto len = last - p;
  auto prev_mode = error_mode (action::replace);
  bool valid = (next (p, last) != REPLACEMENT_CHARACTER);
  error_mode (prev_mode);
  return valid;
}
 
inline
char32_t next (std::string::iterator& ptr, const std::string::const_iterator last)
{
  return next (*(std::string::const_iterator*)(&ptr), last);
}
 
inline
char32_t prev (std::string::iterator& ptr, const std::string::const_iterator first)
{
  return prev (*(std::string::const_iterator*)(&ptr), first);
}
 
inline
char32_t rune (const char* p)
{
  return next (p);
}
 
 
inline
char32_t next (char*& ptr)
{
  return next (const_cast<const char*&>(ptr));
}
 
inline
char32_t prev (char*& ptr)
{
  return prev (const_cast<const char*&>(ptr));
}
 
 
inline
bool valid_str (const std::string& s)
{
  return valid_str (s.c_str (), s.size());
}
 
inline
char32_t rune (const std::string::const_iterator& p)
{
  return rune (&(*p));
}
 
 
inline
bool isspace (const char* p)
{
  return isspace (rune (p));
}
 
inline
bool isspace (std::string::const_iterator p)
{
  return isspace (rune(p));
}
 
 
inline
bool isblank (const char *p)
{
  return isblank(rune(p));
}
 
inline
bool isblank (std::string::const_iterator p)
{
  return isblank (rune (p));
}
 
inline
bool isdigit (char32_t r)
{
  return '0' <= r && r <= '9';
}
 
inline
bool isdigit (const char *p)
{
  return isdigit (rune (p));
}
 
inline
bool isdigit (std::string::const_iterator p)
{
  return isdigit (rune (p));
}
 
inline
bool isalnum (char32_t r)
{
  return ('0' <= r && r <= '9') || ('A' <= r && r <= 'Z') || ('a' <= r && r <= 'z');
}
 
inline
bool isalnum (const char *p)
{
  return isalnum (rune (p));
}
 
inline
bool isalnum (std::string::const_iterator p)
{
  return isalnum (rune (p));
}
 
inline
bool isalpha (char32_t r)
{
  return ('A' <= r && r <= 'Z') || ('a' <= r && r <= 'z');
}
 
inline
bool isalpha (const char *p)
{
  return isalpha (rune (p));
}
 
inline
bool isalpha (std::string::const_iterator p)
{
  return isalpha (&*p);
}
 
 
inline
bool isxdigit (char32_t r)
{
  return ('0' <= r && r <= '9') || ('A' <= r && r <= 'F') || ('a' <= r && r <= 'f');
}
 
inline
bool isxdigit (const char *p)
{
  return isxdigit(rune(p));
}
 
inline
bool isxdigit (std::string::const_iterator p)
{
  return isxdigit (rune(p));
}
 
inline
bool isupper (std::string::const_iterator p)
{
  return isupper (rune(p));
}
 
inline
bool islower (std::string::const_iterator p)
{
  return islower (rune(p));
}
 
// File System functions -----------------------------------------------------
 
inline
FILE* fopen (const std::string& filename, const std::string& mode)
{
  FILE* h = nullptr;
#ifdef _WIN32
  _wfopen_s (&h, widen (filename).c_str (), widen (mode).c_str ());
#else
  h = ::fopen (filename.c_str(), mode.c_str());
#endif
  return h;
}
 
inline
FILE* fopen (const char* filename, const char* mode)
{
  FILE* h = nullptr;
#ifdef _WIN32
  _wfopen_s (&h, widen (filename).c_str (), widen (mode).c_str ());
#else
  h = ::fopen (filename, mode);
#endif
  return h;
}
 
inline
std::string getcwd ()
{
#if USE_WINDOWS_API
  wchar_t tmp[_MAX_PATH];
  if (_wgetcwd (tmp, _countof (tmp)))
    return narrow (tmp);
  else
    return std::string ();
#else
  std::error_code ec;
  std::filesystem::path wd = std::filesystem::current_path (ec);
  if (ec)
    return std::string ();
# ifdef _WIN32
  return narrow (wd.native());
# else
  return wd;
# endif
#endif
}
 
inline
bool chdir (const std::string& dirname)
{
#if USE_WINDOWS_API
  return (_wchdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::current_path (dir, ec);
  return !ec;
#endif
}
 
inline
bool chdir (const char* dirname)
{
#if USE_WINDOWS_API
  return (_wchdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::current_path (dir, ec);
  return !ec;
#endif
}
 
 
inline
bool mkdir (const std::string& dirname)
{
#if USE_WINDOWS_API
  return (_wmkdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::create_directory (dir, ec);
  return !ec;
#endif
}
 
 
inline
bool mkdir (const char* dirname)
{
#if USE_WINDOWS_API
  return (_wmkdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::create_directory (dir, ec);
  return !ec;
#endif
}
 
inline
bool rmdir (const std::string& dirname)
{
#if USE_WINDOWS_API
  return (_wrmdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::remove (dir, ec);
  return !ec;
#endif
}
 
inline
bool rmdir (const char* dirname)
{
#if USE_WINDOWS_API
  return (_wrmdir (widen (dirname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path dir (widen (dirname));
# else
  std::filesystem::path dir (dirname);
# endif
  std::error_code ec;
  std::filesystem::remove (dir, ec);
  return !ec;
#endif
}
 
inline
bool rename (const std::string& oldname, const std::string& newname)
{
#if USE_WINDOWS_API
  return (_wrename (widen (oldname).c_str (), widen (newname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path fn (widen (newname));
  std::filesystem::path fo (widen (oldname));
# else
  std::filesystem::path fn (newname);
  std::filesystem::path fo (oldname);
# endif
  std::error_code ec;
  std::filesystem::rename (fo, fn, ec);
  return !ec;
#endif
}
 
inline 
bool rename (const char* oldname, const char* newname)
{
#if USE_WINDOWS_API
  return (_wrename (widen (oldname).c_str (), widen (newname).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path fn (widen (newname));
  std::filesystem::path fo (widen (oldname));
# else
  std::filesystem::path fn (newname);
  std::filesystem::path fo (oldname);
# endif
  std::error_code ec;
  std::filesystem::rename (fo, fn, ec);
  return !ec;
#endif
}
 
inline
bool remove (const std::string& filename)
{
#if USE_WINDOWS_API
  return (_wremove (widen (filename).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path f (widen(filename));
# else
  std::filesystem::path f (filename);
# endif
  std::error_code ec;
  std::filesystem::remove (f, ec);
  return !ec;
#endif
}
 
 
inline
bool remove (const char* filename)
{
#if USE_WINDOWS_API
  return (_wremove (widen (filename).c_str ()) == 0);
#else
# ifdef _WIN32
  std::filesystem::path f (widen (filename));
# else
  std::filesystem::path f (filename);
# endif
  std::error_code ec;
  std::filesystem::remove (f, ec);
  return !ec;
#endif
}
 
inline
std::ostream& operator<<(std::ostream& os, const exception& x)
{
  os << x.what ();
  return os;
}
 
inline
bool operator ==(const exception& lhs, const exception rhs)
{
  return (lhs.code == rhs.code);
}
 
inline
bool operator !=(const exception& lhs, const exception& rhs)
{
  return !operator ==(lhs, rhs);
}
 
}; //namespace utf8
 
#if defined(_WIN32) && !defined(UTF8_KEEP_WIN32_API)
#include <utf8/winutf8.h>
#endif
#include <utf8/ini.h>
 
#ifdef _MSC_VER
#pragma comment (lib, "utf8")
#endif