ouch/inspircd
2
0
Fork 0
mirror of https://github.com/inspircd/inspircd.git synced 2025-03-09 10:39:02 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update the vendored libraries.

Browse Source
This commit is contained in:
Sadie Powell 2023-11-16 13:42:43 +00:00
parent a3e0c33f37
commit 03f2211f1d
3 changed files with 218 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
vendor/README.md vendored
View File

@ -18,7 +18,7 @@ This directory contains vendored dependencies that are shipped with InspIRCd to
**License** — MIT License
**Version** — debian/2.9.4-5
**Version** — debian/2.9.4-6
**Website** — [https://git.in-ulm.de/cbiedl/http-parser](https://git.in-ulm.de/cbiedl/http-parser)
@ -38,7 +38,7 @@ This directory contains vendored dependencies that are shipped with InspIRCd to
**License** — Boost Software License
**Version** — v3.2.3
**Version** — v4.0.2
**Website** — [https://github.com/nemtrif/utfcpp](https://github.com/nemtrif/utfcpp)

207
vendor/utfcpp/core.h vendored
View File

@ -29,6 +29,8 @@ DEALINGS IN THE SOFTWARE.
#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
#include <iterator>
#include <cstring>
#include <string>
// Determine the C++ standard version.
// If the user defines UTF_CPP_CPLUSPLUS, use that.
@ -49,12 +51,20 @@ DEALINGS IN THE SOFTWARE.
namespace utf8
{
// The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
// You may need to change them to match your system.
// These typedefs have the same names as ones from cstdint, or boost/cstdint
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
// The typedefs for 8-bit, 16-bit and 32-bit code units
#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
#if UTF_CPP_CPLUSPLUS >= 202002L // C++ 20 or later
typedef char8_t utfchar8_t;
#else // C++ 11/14/17
typedef unsigned char utfchar8_t;
#endif
typedef char16_t utfchar16_t;
typedef char32_t utfchar32_t;
#else // C++ 98/03
typedef unsigned char utfchar8_t;
typedef unsigned short utfchar16_t;
typedef unsigned int utfchar32_t;
#endif // C++ 11 or later
// Helper code - not intended to be directly called by the library users. May be changed at any time
namespace internal
@ -62,61 +72,62 @@ namespace internal
// Unicode constants
// Leading (high) surrogates: 0xd800 - 0xdbff
// Trailing (low) surrogates: 0xdc00 - 0xdfff
const uint16_t LEAD_SURROGATE_MIN = 0xd800u;
const uint16_t LEAD_SURROGATE_MAX = 0xdbffu;
const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
const uint16_t LEAD_OFFSET = 0xd7c0u; // LEAD_SURROGATE_MIN - (0x10000 >> 10)
const uint32_t SURROGATE_OFFSET = 0xfca02400u; // 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN
const utfchar16_t LEAD_SURROGATE_MIN = 0xd800u;
const utfchar16_t LEAD_SURROGATE_MAX = 0xdbffu;
const utfchar16_t TRAIL_SURROGATE_MIN = 0xdc00u;
const utfchar16_t TRAIL_SURROGATE_MAX = 0xdfffu;
const utfchar16_t LEAD_OFFSET = 0xd7c0u; // LEAD_SURROGATE_MIN - (0x10000 >> 10)
const utfchar32_t SURROGATE_OFFSET = 0xfca02400u; // 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN
// Maximum valid value for a Unicode code point
const uint32_t CODE_POINT_MAX = 0x0010ffffu;
const utfchar32_t CODE_POINT_MAX = 0x0010ffffu;
template<typename octet_type>
inline uint8_t mask8(octet_type oc)
inline utfchar8_t mask8(octet_type oc)
{
return static_cast<uint8_t>(0xff & oc);
return static_cast<utfchar8_t>(0xff & oc);
}
template<typename u16_type>
inline uint16_t mask16(u16_type oc)
inline utfchar16_t mask16(u16_type oc)
{
return static_cast<uint16_t>(0xffff & oc);
return static_cast<utfchar16_t>(0xffff & oc);
}
template<typename octet_type>
inline bool is_trail(octet_type oc)
{
return ((utf8::internal::mask8(oc) >> 6) == 0x2);
}
template <typename u16>
inline bool is_lead_surrogate(u16 cp)
inline bool is_lead_surrogate(utfchar32_t cp)
{
return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
}
template <typename u16>
inline bool is_trail_surrogate(u16 cp)
inline bool is_trail_surrogate(utfchar32_t cp)
{
return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
}
template <typename u16>
inline bool is_surrogate(u16 cp)
inline bool is_surrogate(utfchar32_t cp)
{
return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
}
template <typename u32>
inline bool is_code_point_valid(u32 cp)
inline bool is_code_point_valid(utfchar32_t cp)
{
return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
}
template <typename octet_iterator>
inline typename std::iterator_traits<octet_iterator>::difference_type
sequence_length(octet_iterator lead_it)
inline bool is_in_bmp(utfchar32_t cp)
{
uint8_t lead = utf8::internal::mask8(*lead_it);
return cp < utfchar32_t(0x10000);
}
template <typename octet_iterator>
int sequence_length(octet_iterator lead_it)
{
const utfchar8_t lead = utf8::internal::mask8(*lead_it);
if (lead < 0x80)
return 1;
else if ((lead >> 5) == 0x6)
@ -129,8 +140,7 @@ namespace internal
return 0;
}
template <typename octet_difference_type>
inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
inline bool is_overlong_sequence(utfchar32_t cp, int length)
{
if (cp < 0x80) {
if (length != 1)
@ -144,7 +154,6 @@ namespace internal
if (length != 3)
return true;
}
return false;
}
@ -152,7 +161,7 @@ namespace internal
/// Helper for get_sequence_x
template <typename octet_iterator>
utf_error increase_safely(octet_iterator& it, octet_iterator end)
utf_error increase_safely(octet_iterator& it, const octet_iterator end)
{
if (++it == end)
return NOT_ENOUGH_ROOM;
@ -163,11 +172,11 @@ namespace internal
return UTF8_OK;
}
#define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}
#define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}
/// get_sequence_x functions decode utf-8 sequences of the length x
template <typename octet_iterator>
utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
utf_error get_sequence_1(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
@ -178,7 +187,7 @@ namespace internal
}
template <typename octet_iterator>
utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
utf_error get_sequence_2(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
@ -193,7 +202,7 @@ namespace internal
}
template <typename octet_iterator>
utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
utf_error get_sequence_3(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
@ -212,7 +221,7 @@ namespace internal
}
template <typename octet_iterator>
utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
utf_error get_sequence_4(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
@ -237,7 +246,7 @@ namespace internal
#undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
template <typename octet_iterator>
utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
utf_error validate_next(octet_iterator& it, octet_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
@ -246,10 +255,9 @@ namespace internal
// Of course, it does not make much sense with i.e. stream iterators
octet_iterator original_it = it;
uint32_t cp = 0;
utfchar32_t cp = 0;
// Determine the sequence length based on the lead octet
typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
const octet_difference_type length = utf8::internal::sequence_length(it);
const int length = utf8::internal::sequence_length(it);
// Get trail octets and calculate the code point
utf_error err = UTF8_OK;
@ -293,15 +301,51 @@ namespace internal
template <typename octet_iterator>
inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
uint32_t ignored;
utfchar32_t ignored;
return utf8::internal::validate_next(it, end, ignored);
}
template <typename word_iterator>
utf_error validate_next16(word_iterator& it, word_iterator end, utfchar32_t& code_point)
{
if (it == end)
return NOT_ENOUGH_ROOM;
// Save the original value of it so we can go back in case of failure
// Of course, it does not make much sense with i.e. stream iterators
word_iterator original_it = it;
utf_error err = UTF8_OK;
const utfchar16_t first_word = *it++;
if (!is_surrogate(first_word)) {
code_point = first_word;
return UTF8_OK;
}
else {
if (it == end)
err = NOT_ENOUGH_ROOM;
else if (is_lead_surrogate(first_word)) {
const utfchar16_t second_word = *it++;
if (is_trail_surrogate(second_word)) {
code_point = (first_word << 10) + second_word + SURROGATE_OFFSET;
return UTF8_OK;
} else
err = INCOMPLETE_SEQUENCE;
} else {
err = INVALID_LEAD;
}
}
// error branch
it = original_it;
return err;
}
// Internal implementation of both checked and unchecked append() function
// This function will be invoked by the overloads below, as they will know
// the octet_type.
template <typename octet_iterator, typename octet_type>
octet_iterator append(uint32_t cp, octet_iterator result) {
octet_iterator append(utfchar32_t cp, octet_iterator result) {
if (cp < 0x80) // one octet
*(result++) = static_cast<octet_type>(cp);
else if (cp < 0x800) { // two octets
@ -325,7 +369,7 @@ namespace internal
// One of the following overloads will be invoked from the API calls
// A simple (but dangerous) case: the caller appends byte(s) to a char array
inline char* append(uint32_t cp, char* result) {
inline char* append(utfchar32_t cp, char* result) {
return append<char*, char>(cp, result);
}
@ -333,17 +377,49 @@ namespace internal
// i.e. append(cp, std::back_inserter(str));
template<typename container_type>
std::back_insert_iterator<container_type> append
(uint32_t cp, std::back_insert_iterator<container_type> result) {
(utfchar32_t cp, std::back_insert_iterator<container_type> result) {
return append<std::back_insert_iterator<container_type>,
typename container_type::value_type>(cp, result);
}
// The caller uses some other kind of output operator - not covered above
// Note that in this case we are not able to determine octet_type
// so we assume it's uint_8; that can cause a conversion warning if we are wrong.
// so we assume it's utfchar8_t; that can cause a conversion warning if we are wrong.
template <typename octet_iterator>
octet_iterator append(uint32_t cp, octet_iterator result) {
return append<octet_iterator, uint8_t>(cp, result);
octet_iterator append(utfchar32_t cp, octet_iterator result) {
return append<octet_iterator, utfchar8_t>(cp, result);
}
// Internal implementation of both checked and unchecked append16() function
// This function will be invoked by the overloads below, as they will know
// the word_type.
template <typename word_iterator, typename word_type>
word_iterator append16(utfchar32_t cp, word_iterator result) {
if (is_in_bmp(cp))
*(result++) = static_cast<word_type>(cp);
else {
// Code points from the supplementary planes are encoded via surrogate pairs
*(result++) = static_cast<word_type>(LEAD_OFFSET + (cp >> 10));
*(result++) = static_cast<word_type>(TRAIL_SURROGATE_MIN + (cp & 0x3FF));
}
return result;
}
// Hopefully, most common case: the caller uses back_inserter
// i.e. append16(cp, std::back_inserter(str));
template<typename container_type>
std::back_insert_iterator<container_type> append16
(utfchar32_t cp, std::back_insert_iterator<container_type> result) {
return append16<std::back_insert_iterator<container_type>,
typename container_type::value_type>(cp, result);
}
// The caller uses some other kind of output operator - not covered above
// Note that in this case we are not able to determine word_type
// so we assume it's utfchar16_t; that can cause a conversion warning if we are wrong.
template <typename word_iterator>
word_iterator append16(utfchar32_t cp, word_iterator result) {
return append16<word_iterator, utfchar16_t>(cp, result);
}
} // namespace internal
@ -351,7 +427,7 @@ namespace internal
/// The library API - functions intended to be called by the users
// Byte order mark
const uint8_t bom[] = {0xef, 0xbb, 0xbf};
const utfchar8_t bom[] = {0xef, 0xbb, 0xbf};
template <typename octet_iterator>
octet_iterator find_invalid(octet_iterator start, octet_iterator end)
@ -365,12 +441,36 @@ namespace internal
return result;
}
inline const char* find_invalid(const char* str)
{
const char* end = str + std::strlen(str);
return find_invalid(str, end);
}
inline std::size_t find_invalid(const std::string& s)
{
std::string::const_iterator invalid = find_invalid(s.begin(), s.end());
return (invalid == s.end()) ? std::string::npos : static_cast<std::size_t>(invalid - s.begin());
}
template <typename octet_iterator>
inline bool is_valid(octet_iterator start, octet_iterator end)
{
return (utf8::find_invalid(start, end) == end);
}
inline bool is_valid(const char* str)
{
return (*(utf8::find_invalid(str)) == '\0');
}
inline bool is_valid(const std::string& s)
{
return is_valid(s.begin(), s.end());
}
template <typename octet_iterator>
inline bool starts_with_bom (octet_iterator it, octet_iterator end)
{
@ -379,7 +479,12 @@ namespace internal
((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
((it != end) && (utf8::internal::mask8(*it)) == bom[2])
);
}
}
inline bool starts_with_bom(const std::string& s)
{
return starts_with_bom(s.begin(), s.end());
}
} // namespace utf8
#endif // header guard

90
vendor/utfcpp/unchecked.h vendored
View File

@ -35,13 +35,19 @@ namespace utf8
namespace unchecked
{
template <typename octet_iterator>
octet_iterator append(uint32_t cp, octet_iterator result)
octet_iterator append(utfchar32_t cp, octet_iterator result)
{
return internal::append(cp, result);
}
template <typename word_iterator>
word_iterator append16(utfchar32_t cp, word_iterator result)
{
return internal::append16(cp, result);
}
template <typename octet_iterator, typename output_iterator>
output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, utfchar32_t replacement)
{
while (start != end) {
octet_iterator sequence_start = start;
@ -52,17 +58,17 @@ namespace utf8
*out++ = *it;
break;
case internal::NOT_ENOUGH_ROOM:
out = utf8::unchecked::append (replacement, out);
out = utf8::unchecked::append(replacement, out);
start = end;
break;
case internal::INVALID_LEAD:
out = utf8::unchecked::append (replacement, out);
out = utf8::unchecked::append(replacement, out);
++start;
break;
case internal::INCOMPLETE_SEQUENCE:
case internal::OVERLONG_SEQUENCE:
case internal::INVALID_CODE_POINT:
out = utf8::unchecked::append (replacement, out);
out = utf8::unchecked::append(replacement, out);
++start;
// just one replacement mark for the sequence
while (start != end && utf8::internal::is_trail(*start))
@ -76,16 +82,29 @@ namespace utf8
template <typename octet_iterator, typename output_iterator>
inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
{
static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
static const utfchar32_t replacement_marker = utf8::internal::mask16(0xfffd);
return utf8::unchecked::replace_invalid(start, end, out, replacement_marker);
}
template <typename octet_iterator>
uint32_t next(octet_iterator& it)
inline std::string replace_invalid(const std::string& s, utfchar32_t replacement)
{
uint32_t cp = utf8::internal::mask8(*it);
typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it);
switch (length) {
std::string result;
replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
return result;
}
inline std::string replace_invalid(const std::string& s)
{
std::string result;
replace_invalid(s.begin(), s.end(), std::back_inserter(result));
return result;
}
template <typename octet_iterator>
utfchar32_t next(octet_iterator& it)
{
utfchar32_t cp = utf8::internal::mask8(*it);
switch (utf8::internal::sequence_length(it)) {
case 1:
break;
case 2:
@ -112,13 +131,22 @@ namespace utf8
}
template <typename octet_iterator>
uint32_t peek_next(octet_iterator it)
utfchar32_t peek_next(octet_iterator it)
{
return utf8::unchecked::next(it);
}
template <typename word_iterator>
utfchar32_t next16(word_iterator& it)
{
utfchar32_t cp = utf8::internal::mask16(*it++);
if (utf8::internal::is_lead_surrogate(cp))
return (cp << 10) + *it++ + utf8::internal::SURROGATE_OFFSET;
return cp;
}
template <typename octet_iterator>
uint32_t prior(octet_iterator& it)
utfchar32_t prior(octet_iterator& it)
{
while (utf8::internal::is_trail(*(--it))) ;
octet_iterator temp = it;
@ -126,7 +154,7 @@ namespace utf8
}
template <typename octet_iterator, typename distance_type>
void advance (octet_iterator& it, distance_type n)
void advance(octet_iterator& it, distance_type n)
{
const distance_type zero(0);
if (n < zero) {
@ -142,7 +170,7 @@ namespace utf8
template <typename octet_iterator>
typename std::iterator_traits<octet_iterator>::difference_type
distance (octet_iterator first, octet_iterator last)
distance(octet_iterator first, octet_iterator last)
{
typename std::iterator_traits<octet_iterator>::difference_type dist;
for (dist = 0; first < last; ++dist)
@ -151,13 +179,15 @@ namespace utf8
}
template <typename u16bit_iterator, typename octet_iterator>
octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result)
{
while (start != end) {
uint32_t cp = utf8::internal::mask16(*start++);
// Take care of surrogate pairs first
utfchar32_t cp = utf8::internal::mask16(*start++);
// Take care of surrogate pairs first
if (utf8::internal::is_lead_surrogate(cp)) {
uint32_t trail_surrogate = utf8::internal::mask16(*start++);
if (start == end)
return result;
utfchar32_t trail_surrogate = utf8::internal::mask16(*start++);
cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
}
result = utf8::unchecked::append(cp, result);
@ -166,22 +196,22 @@ namespace utf8
}
template <typename u16bit_iterator, typename octet_iterator>
u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result)
{
while (start < end) {
uint32_t cp = utf8::unchecked::next(start);
utfchar32_t cp = utf8::unchecked::next(start);
if (cp > 0xffff) { //make a surrogate pair
*result++ = static_cast<uint16_t>((cp >> 10) + internal::LEAD_OFFSET);
*result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
*result++ = static_cast<utfchar16_t>((cp >> 10) + internal::LEAD_OFFSET);
*result++ = static_cast<utfchar16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
}
else
*result++ = static_cast<uint16_t>(cp);
*result++ = static_cast<utfchar16_t>(cp);
}
return result;
}
template <typename octet_iterator, typename u32bit_iterator>
octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result)
{
while (start != end)
result = utf8::unchecked::append(*(start++), result);
@ -190,7 +220,7 @@ namespace utf8
}
template <typename octet_iterator, typename u32bit_iterator>
u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result)
{
while (start < end)
(*result++) = utf8::unchecked::next(start);
@ -203,16 +233,16 @@ namespace utf8
class iterator {
octet_iterator it;
public:
typedef uint32_t value_type;
typedef uint32_t* pointer;
typedef uint32_t& reference;
typedef utfchar32_t value_type;
typedef utfchar32_t* pointer;
typedef utfchar32_t& reference;
typedef std::ptrdiff_t difference_type;
typedef std::bidirectional_iterator_tag iterator_category;
iterator () {}
explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
// the default "big three" are OK
octet_iterator base () const { return it; }
uint32_t operator * () const
utfchar32_t operator * () const
{
octet_iterator temp = it;
return utf8::unchecked::next(temp);