30#include <riscv_vector.h>
38 return c ==
'\r' || c ==
'\n' || c ==
'\t';
42 return 0x101010101010101ull * v;
45constexpr bool to_lower_ascii(
char* input,
size_t length)
noexcept {
47 uint64_t broadcast_Ap =
broadcast(128 -
'A');
48 uint64_t broadcast_Zp =
broadcast(128 -
'Z' - 1);
49 uint64_t non_ascii = 0;
52 for (; i + 7 < length; i += 8) {
54 memcpy(&word, input + i,
sizeof(word));
55 non_ascii |= (word & broadcast_80);
57 (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
58 memcpy(input + i, &word,
sizeof(word));
62 memcpy(&word, input + i, length - i);
63 non_ascii |= (word & broadcast_80);
65 (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
66 memcpy(input + i, &word, length - i);
68 return non_ascii == 0;
72 std::string_view user_input)
noexcept {
74 if (user_input.size() < 16) {
83 _mm_setr_epi8(1, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 0, 0, 13, 0, 0);
84 __m128i running = _mm_setzero_si128();
85 for (; i + 15 < user_input.size(); i += 16) {
86 __m128i word = _mm_loadu_si128((
const __m128i*)(user_input.data() + i));
88 __m128i shuffled = _mm_shuffle_epi8(rnt, word);
90 __m128i matches = _mm_cmpeq_epi8(shuffled, word);
91 running = _mm_or_si128(running, matches);
93 if (i < user_input.size()) {
94 __m128i word = _mm_loadu_si128(
95 (
const __m128i*)(user_input.data() + user_input.length() - 16));
96 __m128i shuffled = _mm_shuffle_epi8(rnt, word);
97 __m128i matches = _mm_cmpeq_epi8(shuffled, word);
98 running = _mm_or_si128(running, matches);
100 return _mm_movemask_epi8(running) != 0;
104 std::string_view user_input)
noexcept {
106 if (user_input.size() < 16) {
123 static uint8_t rnt_array[16] = {1, 0, 0, 0, 0, 0, 0, 0,
124 0, 9, 10, 0, 0, 13, 0, 0};
125 const uint8x16_t rnt = vld1q_u8(rnt_array);
127 uint8x16_t running{0};
128 for (; i + 15 < user_input.size(); i += 16) {
129 uint8x16_t word = vld1q_u8((
const uint8_t*)user_input.data() + i);
131 running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
133 if (i < user_input.size()) {
135 vld1q_u8((
const uint8_t*)user_input.data() + user_input.length() - 16);
136 running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
142 uint8x8_t narrowed = vshrn_n_u16(vreinterpretq_u16_u8(running), 4);
143#if ADA_NEON_SAFE_ZERO_CHECK
144 return vget_lane_u64(vreinterpret_u64_u8(narrowed), 0) != 0;
146 return vdupd_lane_f64(vreinterpret_f64_u8(narrowed), 0) != 0.0;
151 std::string_view user_input)
noexcept {
153 if (user_input.size() < 16) {
158 const __m128i mask1 = _mm_set1_epi8(
'\r');
159 const __m128i mask2 = _mm_set1_epi8(
'\n');
160 const __m128i mask3 = _mm_set1_epi8(
'\t');
163 for (; i + 15 < user_input.size(); i += 16) {
164 __m128i word = _mm_loadu_si128((
const __m128i*)(user_input.data() + i));
165 running = _mm_or_si128(
166 _mm_or_si128(running, _mm_or_si128(_mm_cmpeq_epi8(word, mask1),
167 _mm_cmpeq_epi8(word, mask2))),
168 _mm_cmpeq_epi8(word, mask3));
170 if (i < user_input.size()) {
171 __m128i word = _mm_loadu_si128(
172 (
const __m128i*)(user_input.data() + user_input.length() - 16));
173 running = _mm_or_si128(
174 _mm_or_si128(running, _mm_or_si128(_mm_cmpeq_epi8(word, mask1),
175 _mm_cmpeq_epi8(word, mask2))),
176 _mm_cmpeq_epi8(word, mask3));
178 return _mm_movemask_epi8(running) != 0;
182 std::string_view user_input)
noexcept {
184 if (user_input.size() < 16) {
189 const __m128i mask1 = __lsx_vrepli_b(
'\r');
190 const __m128i mask2 = __lsx_vrepli_b(
'\n');
191 const __m128i mask3 = __lsx_vrepli_b(
'\t');
194 for (; i + 15 < user_input.size(); i += 16) {
195 __m128i word = __lsx_vld((
const __m128i*)(user_input.data() + i), 0);
196 running = __lsx_vor_v(
197 __lsx_vor_v(running, __lsx_vor_v(__lsx_vseq_b(word, mask1),
198 __lsx_vseq_b(word, mask2))),
199 __lsx_vseq_b(word, mask3));
201 if (i < user_input.size()) {
202 __m128i word = __lsx_vld(
203 (
const __m128i*)(user_input.data() + user_input.length() - 16), 0);
204 running = __lsx_vor_v(
205 __lsx_vor_v(running, __lsx_vor_v(__lsx_vseq_b(word, mask1),
206 __lsx_vseq_b(word, mask2))),
207 __lsx_vseq_b(word, mask3));
209 if (__lsx_bz_v(running))
return false;
214 std::string_view user_input)
noexcept {
215 uint8_t* src = (uint8_t*)user_input.data();
216 for (
size_t vl, n = user_input.size(); n > 0; n -= vl, src += vl) {
217 vl = __riscv_vsetvl_e8m1(n);
218 vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
219 vbool8_t m1 = __riscv_vmseq(v,
'\r', vl);
220 vbool8_t m2 = __riscv_vmseq(v,
'\n', vl);
221 vbool8_t m3 = __riscv_vmseq(v,
'\t', vl);
222 vbool8_t m = __riscv_vmor(__riscv_vmor(m1, m2, vl), m3, vl);
223 long idx = __riscv_vfirst(m, vl);
224 if (idx >= 0)
return true;
230 std::string_view user_input)
noexcept {
231 auto has_zero_byte = [](uint64_t v) {
232 return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080);
239 for (; i + 7 < user_input.size(); i += 8) {
241 memcpy(&word, user_input.data() + i,
sizeof(word));
242 uint64_t xor1 = word ^ mask1;
243 uint64_t xor2 = word ^ mask2;
244 uint64_t xor3 = word ^ mask3;
245 running |= has_zero_byte(xor1) | has_zero_byte(xor2) | has_zero_byte(xor3);
247 if (i < user_input.size()) {
249 memcpy(&word, user_input.data() + i, user_input.size() - i);
250 uint64_t xor1 = word ^ mask1;
251 uint64_t xor2 = word ^ mask2;
252 uint64_t xor3 = word ^ mask3;
253 running |= has_zero_byte(xor1) | has_zero_byte(xor2) | has_zero_byte(xor3);
265 std::array<uint8_t, 256>
result{};
266 for (uint8_t c : {
'\0',
'\x09',
'\x0a',
'\x0d',
' ',
'#',
'/',
':',
'<',
267 '>',
'?',
'@',
'[',
'\\',
']',
'^',
'|'}) {
274 const char c)
noexcept {
280 std::array<uint8_t, 256>
result{};
281 for (uint8_t c : {
'\0',
'\x09',
'\x0a',
'\x0d',
' ',
'#',
'/',
':',
'<',
282 '>',
'?',
'@',
'[',
'\\',
']',
'^',
'|',
'%'}) {
285 for (uint8_t c = 0; c <= 32; c++) {
288 for (
size_t c = 127; c < 256; c++) {
297 const char c)
noexcept {
302 const char* input,
size_t length)
noexcept {
304 uint8_t accumulator{};
305 for (; i + 4 <= length; i += 4) {
311 for (; i < length; i++) {
317constexpr static std::array<uint8_t, 256>
319 std::array<uint8_t, 256>
result{};
320 for (uint8_t c : {
'\0',
'\x09',
'\x0a',
'\x0d',
' ',
'#',
'/',
':',
'<',
321 '>',
'?',
'@',
'[',
'\\',
']',
'^',
'|',
'%'}) {
324 for (uint8_t c =
'A'; c <=
'Z'; c++) {
327 for (uint8_t c = 0; c <= 32; c++) {
330 for (
size_t c = 127; c < 256; c++) {
337contains_forbidden_domain_code_point_or_upper(
const char* input,
338 size_t length)
noexcept {
340 uint8_t accumulator{};
341 for (; i + 4 <= length; i += 4) {
351 for (; i < length; i++) {
360 std::array<bool, 256>
result{};
361 for (
size_t c = 0; c < 256; c++) {
362 result[c] = (c >=
'0' && c <=
'9') || (c >=
'a' && c <=
'z') ||
363 (c >=
'A' && c <=
'Z') || c ==
'+' || c ==
'-' || c ==
'.';
376 return (c >=
'0' && c <=
'9') || (c >=
'A' && c <=
'F') ||
377 (c >=
'a' && c <=
'f');
383 return (c >=
'0' && c <=
'9');
392 return (
unsigned char)c <=
' ';
396 const char c)
noexcept {
397 return c ==
'\t' || c ==
'\n' || c ==
'\r';
401 "..",
"%2e.",
".%2e",
"%2e%2e"};
404 std::string_view input)
noexcept {
409 uint64_t half_length = uint64_t(input.size()) / 2;
410 if (half_length - 1 > 2) {
415 if ((input[0] !=
'.') && (input[0] !=
'%')) {
419 int hash_value = (input.size() + (
unsigned)(input[0])) & 3;
421 if (target.size() != input.size()) {
426 auto prefix_equal_unsafe = [](std::string_view a, std::string_view b) {
428 memcpy(&A, a.data(),
sizeof(A));
429 memcpy(&B, b.data(),
sizeof(B));
432 if (!prefix_equal_unsafe(input, target)) {
435 for (
size_t i = 2; i < input.size(); i++) {
437 if ((uint8_t((c | 0x20) - 0x61) <= 25 ? (c | 0x20) : c) != target[i]) {
453 std::string_view input)
noexcept {
454 return input ==
"." || input ==
"%2e" || input ==
"%2E";
458 return (c >=
'0' && c <=
'9') || (c >=
'a' && c <=
'f');
462 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 10, 11,
463 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
464 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15};
465unsigned constexpr convert_hex_to_binary(
const char c)
noexcept {
469std::string percent_decode(
const std::string_view input,
size_t first_percent) {
472 if (first_percent == std::string_view::npos) {
473 return std::string(input);
477 const char*
const src = input.data();
478 const char*
const end = src + input.size();
483 std::string out(input.size(),
'\0');
484 char* d = out.data();
487 std::memcpy(d, src, first_percent);
490 const char* p = src + first_percent;
494 while (p + 2 < end && *p ==
'%') {
495 if (!is_ascii_hex_digit(p[1]) || !is_ascii_hex_digit(p[2])) {
498 *d++ =
static_cast<char>(convert_hex_to_binary(p[1]) * 16 +
499 convert_hex_to_binary(p[2]));
502 if (p < end && *p ==
'%') {
508 const char* q =
static_cast<const char*
>(
509 std::memchr(p,
'%',
static_cast<size_t>(end - p)));
510 const char* run_end = q ? q : end;
511 const size_t n =
static_cast<size_t>(run_end - p);
512 std::memcpy(d, p, n);
518 out.resize(
static_cast<size_t>(d - d0));
523constexpr static std::array<uint8_t, 256>
unhex_table = []()
consteval {
524 std::array<uint8_t, 256> t{};
525 for (
size_t i = 0; i < 256; ++i) {
528 for (uint8_t i = 0; i < 10; ++i) {
529 t[
static_cast<size_t>(
'0') + i] = i;
531 for (uint8_t i = 0; i < 6; ++i) {
532 t[
static_cast<size_t>(
'A') + i] =
static_cast<uint8_t
>(10 + i);
533 t[
static_cast<size_t>(
'a') + i] =
static_cast<uint8_t
>(10 + i);
539 const size_t len = input.size();
540 if (len == 0) [[unlikely]] {
545 const char*
const src = input.data();
546 const char*
const end = src + len;
550 while (p < end && *p !=
'+' && *p !=
'%') {
554 return std::string(input);
559 std::string out(len,
'\0');
560 char* d = out.data();
563 const size_t prefix =
static_cast<size_t>(p - src);
564 std::memcpy(d, src, prefix);
572 }
else if (c ==
'%') {
574 while (p + 2 < end && *p ==
'%') {
575 const uint8_t hi =
unhex_table[
static_cast<uint8_t
>(p[1])];
576 const uint8_t lo =
unhex_table[
static_cast<uint8_t
>(p[2])];
577 if ((hi | lo) >= 16) {
580 *d++ =
static_cast<char>((hi << 4) | lo);
583 if (p < end && *p ==
'%') {
589 const char* start = p;
591 while (p < end && *p !=
'+' && *p !=
'%') {
594 const size_t n =
static_cast<size_t>(p - start);
595 std::memcpy(d, start, n);
600 out.resize(
static_cast<size_t>(d - d0));
605 const uint8_t character_set[], std::string& out);
607std::string percent_encode(
const std::string_view input,
608 const uint8_t character_set[]) {
609 auto pointer = std::ranges::find_if(input, [character_set](
const char c) {
613 if (pointer == input.end()) {
614 return std::string(input);
618 result.reserve(input.length());
620 result.append(input.substr(0, std::distance(input.begin(), pointer)));
621 if (
static_cast<size_t>(input.end() - pointer) >= 48) {
625 for (; pointer != input.end(); pointer++) {
636template <
bool append>
637bool percent_encode(
const std::string_view input,
const uint8_t character_set[],
639 ada_log(
"percent_encode ", input,
" to output string while ",
640 append ?
"appending" :
"overwriting");
641 auto pointer = std::ranges::find_if(input, [character_set](
const char c) {
644 ada_log(
"percent_encode done checking, moved to ",
645 std::distance(input.begin(), pointer));
648 if (pointer == input.end()) {
649 ada_log(
"percent_encode encoding not needed.");
652 if constexpr (!append) {
655 ada_log(
"percent_encode appending ", std::distance(input.begin(), pointer),
658 out.append(input.data(), std::distance(input.begin(), pointer));
659 ada_log(
"percent_encode processing ", std::distance(pointer, input.end()),
661 for (; pointer != input.end(); pointer++) {
672 const uint8_t character_set[],
675 const uint8_t character_set[],
678bool to_ascii(std::optional<std::string>& out,
const std::string_view plain,
679 size_t first_percent) {
680 std::string percent_decoded_buffer;
681 std::string_view input = plain;
682 if (first_percent != std::string_view::npos) {
683 percent_decoded_buffer = unicode::percent_decode(plain, first_percent);
684 input = percent_decoded_buffer;
688 if (idna_ascii.empty() || contains_forbidden_domain_code_point(
689 idna_ascii.data(), idna_ascii.size())) {
692 out = std::move(idna_ascii);
696std::string percent_encode(
const std::string_view input,
697 const uint8_t character_set[],
size_t index) {
700 out.append(input.data(), index);
701 auto pointer = input.begin() + index;
702 if (
static_cast<size_t>(input.end() - pointer) >= 48) {
706 for (; pointer != input.end(); pointer++) {
Definitions of the character sets used by unicode functions.
Declaration of the character sets used by unicode functions.
Cross-platform compiler macros and common definitions.
#define ADA_PUSH_DISABLE_ALL_WARNINGS
#define ADA_POP_DISABLE_WARNINGS
#define ada_really_inline
ada_really_inline constexpr bool bit_at(const uint8_t a[], const uint8_t i)
std::string to_ascii(std::string_view ut8_string)
Includes the declarations for unicode operations.
static constexpr std::array< uint8_t, 256 > is_forbidden_domain_code_point_table
static constexpr std::array< uint8_t, 256 > is_forbidden_domain_code_point_table_or_upper
std::string form_urlencoded_decode(std::string_view input)
static constexpr char hex_to_binary_table[]
template bool percent_encode< true >(std::string_view input, const uint8_t character_set[], std::string &out)
constexpr uint64_t broadcast(uint8_t v) noexcept
constexpr std::string_view table_is_double_dot_path_segment[]
static constexpr std::array< uint8_t, 256 > unhex_table
constexpr bool is_tabs_or_newline(char c) noexcept
static constexpr std::array< uint8_t, 256 > is_forbidden_host_code_point_table
static constexpr std::array< bool, 256 > is_alnum_plus_table
void percent_encode_suffix(const char *p, const char *end, const uint8_t character_set[], std::string &out)
template bool percent_encode< false >(std::string_view input, const uint8_t character_set[], std::string &out)
tl::expected< result_type, ada::errors > result
Definitions for all unicode specific functions.