utf8.h

Go to the documentation of this file.

/*
  (c) Mircea Neacsu 2014-2023. Licensed under MIT License.
  See README file for full license terms.
*/
 
#pragma once
 
#include <string>
#include <vector>
 
// If USE_WINDOWS_API is not zero, the library issues direct Windows API
// calls. Otherwise it relies only on standard C++17 functions.
// If not defined, USE_WINDOWS_API defaults to 1 on Windows platform.
 
#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
#pragma message ("Using Windows API")
#endif
 
namespace utf8 {
 
struct exception : public std::exception
{
  enum reason { invalid_utf8, invalid_wchar, invalid_char32 };
 
  explicit exception (reason c)
    : why (c)
  {}
  const char* what() const noexcept
  {
    return (why == reason::invalid_utf8)   ? "Invalid UTF-8 encoding"
         : (why == reason::invalid_wchar)  ? "Invalid UTF-16 encoding"
         : (why == reason::invalid_char32) ? "Invalid code-point value"
         : "Other UTF-8 exception";
  }
 
  reason why;
};
 
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 (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);
 
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);
 
 
// INLINES --------------------------------------------------------------------
 
inline
bool is_valid (const char* p)
{
  return next (p) != REPLACEMENT_CHARACTER;
}
 
inline
bool is_valid (std::string::const_iterator p, const std::string::const_iterator last)
{
  return next (p, last) != REPLACEMENT_CHARACTER;
}
 
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));
}
 
 
}; //namespace utf8
 
#ifdef _WIN32
#include <utf8/winutf8.h>
#endif
#include <utf8/ini.h>
 
#ifdef _MSC_VER
#pragma comment (lib, "utf8")
#endif