23template <
typename out_iter>
24void encode_json(std::string_view view, out_iter out) {
26 const char* hexvalues =
27 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
28 for (uint8_t c : view) {
32 }
else if (c ==
'"') {
35 }
else if (c <= 0x1f) {
40 *out++ = hexvalues[2 * c];
41 *out++ = hexvalues[2 * c + 1];
53 return "Scheme Start";
63 return "Relative Scheme";
65 return "Relative Slash";
73 return "Path or Authority";
75 return "Special Authority Ignore Slashes";
77 return "Special Authority Slashes";
79 return "Special Relative or Authority";
91 return "unknown state";
96 std::string_view& input)
noexcept {
99 size_t location_of_first = input.find(
'#');
100 if (location_of_first == std::string_view::npos) {
103 std::string_view hash = input;
104 hash.remove_prefix(location_of_first + 1);
105 input.remove_suffix(input.size() - location_of_first);
114 path.find(
'/', 1) == std::string_view::npos && !path.empty()) {
116 helpers::substring(path, 1))) {
122 size_t last_delimiter = path.rfind(
'/');
123 if (last_delimiter != std::string::npos) {
124 path.erase(last_delimiter);
137 path.find(
'/', 1) == std::string_view::npos && !path.empty()) {
139 helpers::substring(path, 1))) {
146 size_t slash_loc = path.rfind(
'/');
147 if (slash_loc != std::string_view::npos) {
148 path.remove_suffix(path.size() - slash_loc);
161 if (!ada::unicode::has_tabs_or_newline(input)) {
164 std::erase_if(input, ada::unicode::is_ascii_tab_or_newline);
172 return input.substr(pos);
177 input.remove_suffix(input.size() - pos);
183#ifdef ADA_REGULAR_VISUAL_STUDIO
187 _BitScanForward(&ret, input_num);
190 return __builtin_ctzl(input_num);
198#ifdef ADA_REGULAR_VISUAL_STUDIO
200 _BitScanForward64(&ret, input_num);
203 return __builtin_ctzll(input_num);
219 return vshrn_n_u16(vreinterpretq_u16_u8(comparison), 4);
223#if ADA_NEON_SAFE_ZERO_CHECK
224 return vget_lane_u64(vreinterpret_u64_u8(nibble_mask), 0) != 0;
226 return vdupd_lane_f64(vreinterpret_f64_u8(nibble_mask), 0) != 0.0;
233 vget_lane_u64(vreinterpret_u64_u8(nibble_mask), 0))) >>
243 std::string_view view,
size_t location)
noexcept {
245 if (view.size() - location < 16) {
246 for (
size_t i = location; i < view.size(); i++) {
247 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'\\' ||
248 view[i] ==
'?' || view[i] ==
'[') {
252 return size_t(view.size());
257 const __m128i low_mask =
258 _mm_setr_epi8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
259 0x01, 0x04, 0x04, 0x00, 0x00, 0x03);
260 const __m128i high_mask =
261 _mm_setr_epi8(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
263 const __m128i fmask = _mm_set1_epi8(0xf);
264 const __m128i zero = _mm_setzero_si128();
265 for (; i + 15 < view.size(); i += 16) {
266 __m128i word = _mm_loadu_si128((
const __m128i*)(view.data() + i));
267 __m128i lowpart = _mm_shuffle_epi8(low_mask, _mm_and_si128(word, fmask));
268 __m128i highpart = _mm_shuffle_epi8(
269 high_mask, _mm_and_si128(_mm_srli_epi16(word, 4), fmask));
270 __m128i classify = _mm_and_si128(lowpart, highpart);
271 __m128i is_zero = _mm_cmpeq_epi8(classify, zero);
275 int mask = ~_mm_movemask_epi8(is_zero) & 0xFFFF;
280 if (i < view.size()) {
282 _mm_loadu_si128((
const __m128i*)(view.data() + view.length() - 16));
283 __m128i lowpart = _mm_shuffle_epi8(low_mask, _mm_and_si128(word, fmask));
284 __m128i highpart = _mm_shuffle_epi8(
285 high_mask, _mm_and_si128(_mm_srli_epi16(word, 4), fmask));
286 __m128i classify = _mm_and_si128(lowpart, highpart);
287 __m128i is_zero = _mm_cmpeq_epi8(classify, zero);
291 int mask = ~_mm_movemask_epi8(is_zero) & 0xFFFF;
293 return view.length() - 16 +
trailing_zeroes(
static_cast<uint32_t
>(mask));
296 return size_t(view.size());
302#ifndef ada_make_uint8x16_t
303#define ada_make_uint8x16_t(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, \
304 x13, x14, x15, x16) \
306 static uint8_t array[16] = {x1, x2, x3, x4, x5, x6, x7, x8, \
307 x9, x10, x11, x12, x13, x14, x15, x16}; \
308 return vld1q_u8(array); \
313 std::string_view view,
size_t location)
noexcept {
315 if (view.size() - location < 16) {
316 for (
size_t i = location; i < view.size(); i++) {
317 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'\\' ||
318 view[i] ==
'?' || view[i] ==
'[') {
322 return size_t(view.size());
326 uint8x16_t low_mask =
327 ada_make_uint8x16_t(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x03);
329 uint8x16_t high_mask =
330 ada_make_uint8x16_t(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
332 uint8x16_t fmask = vmovq_n_u8(0xf);
333 for (; i + 15 < view.size(); i += 16) {
334 uint8x16_t word = vld1q_u8((
const uint8_t*)view.data() + i);
335 uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
336 uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
340 uint8x8_t matches = to_nibble_mask(vtstq_u8(lowpart, highpart));
341 if (any_set(matches)) {
342 return i + first_set(matches);
346 if (i < view.size()) {
348 vld1q_u8((
const uint8_t*)view.data() + view.length() - 16);
349 uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
350 uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
351 uint8x8_t matches = to_nibble_mask(vtstq_u8(lowpart, highpart));
352 if (any_set(matches)) {
353 return view.length() - 16 + first_set(matches);
356 return size_t(view.size());
360 std::string_view view,
size_t location)
noexcept {
362 if (view.size() - location < 16) {
363 for (
size_t i = location; i < view.size(); i++) {
364 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'\\' ||
365 view[i] ==
'?' || view[i] ==
'[') {
369 return size_t(view.size());
373 const __m128i mask1 = _mm_set1_epi8(
':');
374 const __m128i mask2 = _mm_set1_epi8(
'/');
375 const __m128i mask3 = _mm_set1_epi8(
'\\');
376 const __m128i mask4 = _mm_set1_epi8(
'?');
377 const __m128i mask5 = _mm_set1_epi8(
'[');
379 for (; i + 15 < view.size(); i += 16) {
380 __m128i word = _mm_loadu_si128((
const __m128i*)(view.data() + i));
381 __m128i m1 = _mm_cmpeq_epi8(word, mask1);
382 __m128i m2 = _mm_cmpeq_epi8(word, mask2);
383 __m128i m3 = _mm_cmpeq_epi8(word, mask3);
384 __m128i m4 = _mm_cmpeq_epi8(word, mask4);
385 __m128i m5 = _mm_cmpeq_epi8(word, mask5);
386 __m128i m = _mm_or_si128(
387 _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m3, m4)), m5);
388 int mask = _mm_movemask_epi8(m);
393 if (i < view.size()) {
395 _mm_loadu_si128((
const __m128i*)(view.data() + view.length() - 16));
396 __m128i m1 = _mm_cmpeq_epi8(word, mask1);
397 __m128i m2 = _mm_cmpeq_epi8(word, mask2);
398 __m128i m3 = _mm_cmpeq_epi8(word, mask3);
399 __m128i m4 = _mm_cmpeq_epi8(word, mask4);
400 __m128i m5 = _mm_cmpeq_epi8(word, mask5);
401 __m128i m = _mm_or_si128(
402 _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m3, m4)), m5);
403 int mask = _mm_movemask_epi8(m);
408 return size_t(view.length());
412 std::string_view view,
size_t location)
noexcept {
414 if (view.size() - location < 16) {
415 for (
size_t i = location; i < view.size(); i++) {
416 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'\\' ||
417 view[i] ==
'?' || view[i] ==
'[') {
421 return size_t(view.size());
425 const __m128i mask1 = __lsx_vrepli_b(
':');
426 const __m128i mask2 = __lsx_vrepli_b(
'/');
427 const __m128i mask3 = __lsx_vrepli_b(
'\\');
428 const __m128i mask4 = __lsx_vrepli_b(
'?');
429 const __m128i mask5 = __lsx_vrepli_b(
'[');
431 for (; i + 15 < view.size(); i += 16) {
432 __m128i word = __lsx_vld((
const __m128i*)(view.data() + i), 0);
433 __m128i m1 = __lsx_vseq_b(word, mask1);
434 __m128i m2 = __lsx_vseq_b(word, mask2);
435 __m128i m3 = __lsx_vseq_b(word, mask3);
436 __m128i m4 = __lsx_vseq_b(word, mask4);
437 __m128i m5 = __lsx_vseq_b(word, mask5);
439 __lsx_vor_v(__lsx_vor_v(__lsx_vor_v(m1, m2), __lsx_vor_v(m3, m4)), m5);
440 int mask = __lsx_vpickve2gr_hu(__lsx_vmsknz_b(m), 0);
445 if (i < view.size()) {
447 __lsx_vld((
const __m128i*)(view.data() + view.length() - 16), 0);
448 __m128i m1 = __lsx_vseq_b(word, mask1);
449 __m128i m2 = __lsx_vseq_b(word, mask2);
450 __m128i m3 = __lsx_vseq_b(word, mask3);
451 __m128i m4 = __lsx_vseq_b(word, mask4);
452 __m128i m5 = __lsx_vseq_b(word, mask5);
454 __lsx_vor_v(__lsx_vor_v(__lsx_vor_v(m1, m2), __lsx_vor_v(m3, m4)), m5);
455 int mask = __lsx_vpickve2gr_hu(__lsx_vmsknz_b(m), 0);
460 return size_t(view.length());
464 std::string_view view,
size_t location)
noexcept {
469 static const uint8_t tbl[16] = {
470 0xF, 0, 0, 0, 0, 0,
'[',
'\\', 0, 0, 0,
'/', 0, 0,
':',
'?'
472 vuint8m1_t vtbl = __riscv_vle8_v_u8m1(tbl, 16);
474 uint8_t* src = (uint8_t*)view.data() + location;
475 for (
size_t vl, n = view.size() - location; n > 0;
476 n -= vl, src += vl, location += vl) {
477 vl = __riscv_vsetvl_e8m1(n);
478 vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
480 vuint8m1_t vidx = __riscv_vand(__riscv_vsrl(v, 2, vl), 0xF, vl);
481 vuint8m1_t vlut = __riscv_vrgather(vtbl, vidx, vl);
482 vbool8_t m = __riscv_vmseq(v, vlut, vl);
484 vbool8_t m1 = __riscv_vmseq(v,
':', vl);
485 vbool8_t m2 = __riscv_vmseq(v,
'/', vl);
486 vbool8_t m3 = __riscv_vmseq(v,
'?', vl);
487 vbool8_t m4 = __riscv_vmseq(v,
'[', vl);
488 vbool8_t m5 = __riscv_vmseq(v,
'\\', vl);
489 vbool8_t m = __riscv_vmor(
490 __riscv_vmor(__riscv_vmor(m1, m2, vl), __riscv_vmor(m3, m4, vl), vl),
493 long idx = __riscv_vfirst(m, vl);
494 if (idx >= 0)
return location + idx;
496 return size_t(view.size());
502 std::array<uint8_t, 256>
result{};
503 for (
int i : {
':',
'/',
'[',
'\\',
'?'}) {
510 std::string_view view,
size_t location)
noexcept {
511 auto const str = view.substr(location);
512 for (
auto pos = str.begin(); pos != str.end(); ++pos) {
514 return pos - str.begin() + location;
517 return size_t(view.size());
526 size_t location)
noexcept {
528 if (view.size() - location < 16) {
529 for (
size_t i = location; i < view.size(); i++) {
530 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'?' ||
535 return size_t(view.size());
544 const __m128i low_mask =
545 _mm_setr_epi8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
546 0x01, 0x04, 0x00, 0x00, 0x00, 0x03);
547 const __m128i high_mask =
548 _mm_setr_epi8(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
549 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
550 const __m128i fmask = _mm_set1_epi8(0xf);
551 const __m128i zero = _mm_setzero_si128();
553 for (; i + 15 < view.size(); i += 16) {
554 __m128i word = _mm_loadu_si128((
const __m128i*)(view.data() + i));
555 __m128i lowpart = _mm_shuffle_epi8(low_mask, _mm_and_si128(word, fmask));
556 __m128i highpart = _mm_shuffle_epi8(
557 high_mask, _mm_and_si128(_mm_srli_epi16(word, 4), fmask));
558 __m128i classify = _mm_and_si128(lowpart, highpart);
559 __m128i is_zero = _mm_cmpeq_epi8(classify, zero);
563 int mask = ~_mm_movemask_epi8(is_zero) & 0xFFFF;
569 if (i < view.size()) {
571 _mm_loadu_si128((
const __m128i*)(view.data() + view.length() - 16));
572 __m128i lowpart = _mm_shuffle_epi8(low_mask, _mm_and_si128(word, fmask));
573 __m128i highpart = _mm_shuffle_epi8(
574 high_mask, _mm_and_si128(_mm_srli_epi16(word, 4), fmask));
575 __m128i classify = _mm_and_si128(lowpart, highpart);
576 __m128i is_zero = _mm_cmpeq_epi8(classify, zero);
580 int mask = ~_mm_movemask_epi8(is_zero) & 0xFFFF;
582 return view.length() - 16 +
trailing_zeroes(
static_cast<uint32_t
>(mask));
585 return size_t(view.size());
589 size_t location)
noexcept {
591 if (view.size() - location < 16) {
592 for (
size_t i = location; i < view.size(); i++) {
593 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'?' ||
598 return size_t(view.size());
602 uint8x16_t low_mask =
603 ada_make_uint8x16_t(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
604 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x03);
605 uint8x16_t high_mask =
606 ada_make_uint8x16_t(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
607 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
608 uint8x16_t fmask = vmovq_n_u8(0xf);
609 for (; i + 15 < view.size(); i += 16) {
610 uint8x16_t word = vld1q_u8((
const uint8_t*)view.data() + i);
611 uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
612 uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
616 uint8x8_t matches = to_nibble_mask(vtstq_u8(lowpart, highpart));
617 if (any_set(matches)) {
618 return i + first_set(matches);
622 if (i < view.size()) {
624 vld1q_u8((
const uint8_t*)view.data() + view.length() - 16);
625 uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
626 uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
627 uint8x8_t matches = to_nibble_mask(vtstq_u8(lowpart, highpart));
628 if (any_set(matches)) {
629 return view.length() - 16 + first_set(matches);
632 return size_t(view.size());
636 size_t location)
noexcept {
638 if (view.size() - location < 16) {
639 for (
size_t i = location; i < view.size(); i++) {
640 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'?' ||
645 return size_t(view.size());
649 const __m128i mask1 = _mm_set1_epi8(
':');
650 const __m128i mask2 = _mm_set1_epi8(
'/');
651 const __m128i mask4 = _mm_set1_epi8(
'?');
652 const __m128i mask5 = _mm_set1_epi8(
'[');
654 for (; i + 15 < view.size(); i += 16) {
655 __m128i word = _mm_loadu_si128((
const __m128i*)(view.data() + i));
656 __m128i m1 = _mm_cmpeq_epi8(word, mask1);
657 __m128i m2 = _mm_cmpeq_epi8(word, mask2);
658 __m128i m4 = _mm_cmpeq_epi8(word, mask4);
659 __m128i m5 = _mm_cmpeq_epi8(word, mask5);
660 __m128i m = _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m4, m5));
661 int mask = _mm_movemask_epi8(m);
666 if (i < view.size()) {
668 _mm_loadu_si128((
const __m128i*)(view.data() + view.length() - 16));
669 __m128i m1 = _mm_cmpeq_epi8(word, mask1);
670 __m128i m2 = _mm_cmpeq_epi8(word, mask2);
671 __m128i m4 = _mm_cmpeq_epi8(word, mask4);
672 __m128i m5 = _mm_cmpeq_epi8(word, mask5);
673 __m128i m = _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m4, m5));
674 int mask = _mm_movemask_epi8(m);
679 return size_t(view.length());
683 size_t location)
noexcept {
685 if (view.size() - location < 16) {
686 for (
size_t i = location; i < view.size(); i++) {
687 if (view[i] ==
':' || view[i] ==
'/' || view[i] ==
'?' ||
692 return size_t(view.size());
696 const __m128i mask1 = __lsx_vrepli_b(
':');
697 const __m128i mask2 = __lsx_vrepli_b(
'/');
698 const __m128i mask4 = __lsx_vrepli_b(
'?');
699 const __m128i mask5 = __lsx_vrepli_b(
'[');
701 for (; i + 15 < view.size(); i += 16) {
702 __m128i word = __lsx_vld((
const __m128i*)(view.data() + i), 0);
703 __m128i m1 = __lsx_vseq_b(word, mask1);
704 __m128i m2 = __lsx_vseq_b(word, mask2);
705 __m128i m4 = __lsx_vseq_b(word, mask4);
706 __m128i m5 = __lsx_vseq_b(word, mask5);
707 __m128i m = __lsx_vor_v(__lsx_vor_v(m1, m2), __lsx_vor_v(m4, m5));
708 int mask = __lsx_vpickve2gr_hu(__lsx_vmsknz_b(m), 0);
713 if (i < view.size()) {
715 __lsx_vld((
const __m128i*)(view.data() + view.length() - 16), 0);
716 __m128i m1 = __lsx_vseq_b(word, mask1);
717 __m128i m2 = __lsx_vseq_b(word, mask2);
718 __m128i m4 = __lsx_vseq_b(word, mask4);
719 __m128i m5 = __lsx_vseq_b(word, mask5);
720 __m128i m = __lsx_vor_v(__lsx_vor_v(m1, m2), __lsx_vor_v(m4, m5));
721 int mask = __lsx_vpickve2gr_hu(__lsx_vmsknz_b(m), 0);
726 return size_t(view.length());
730 size_t location)
noexcept {
731 uint8_t* src = (uint8_t*)view.data() + location;
732 for (
size_t vl, n = view.size() - location; n > 0;
733 n -= vl, src += vl, location += vl) {
734 vl = __riscv_vsetvl_e8m1(n);
735 vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
736 vbool8_t m1 = __riscv_vmseq(v,
':', vl);
737 vbool8_t m2 = __riscv_vmseq(v,
'/', vl);
738 vbool8_t m3 = __riscv_vmseq(v,
'?', vl);
739 vbool8_t m4 = __riscv_vmseq(v,
'[', vl);
741 __riscv_vmor(__riscv_vmor(m1, m2, vl), __riscv_vmor(m3, m4, vl), vl);
742 long idx = __riscv_vfirst(m, vl);
743 if (idx >= 0)
return location + idx;
745 return size_t(view.size());
750 std::array<uint8_t, 256>
result{};
751 for (
int i : {
':',
'/',
'?',
'['}) {
758 size_t location)
noexcept {
759 auto const str = view.substr(location);
760 for (
auto pos = str.begin(); pos != str.end(); ++pos) {
762 return pos - str.begin() + location;
765 return size_t(view.size());
770 const bool is_special, std::string_view& view)
noexcept {
779 const size_t view_size = view.size();
781 bool found_colon =
false;
806 for (; location < view_size;
808 if (view[location] ==
'[') {
809 location = view.find(
']', location);
810 if (location == std::string_view::npos) {
814 location = view_size;
818 found_colon = view[location] ==
':';
827 for (; location < view_size;
829 if (view[location] ==
'[') {
830 location = view.find(
']', location);
831 if (location == std::string_view::npos) {
835 location = view_size;
839 found_colon = view[location] ==
':';
845 view.remove_suffix(view_size - location);
846 return {location, found_colon};
849void trim_c0_whitespace(std::string_view& input)
noexcept {
850 while (!input.empty() &&
851 ada::unicode::is_c0_control_or_space(input.front())) {
852 input.remove_prefix(1);
854 while (!input.empty() && ada::unicode::is_c0_control_or_space(input.back())) {
855 input.remove_suffix(1);
862 ada_log(
"parse_prepared_path ", input);
863 uint8_t accumulator = checkers::path_signature(input);
868 constexpr uint8_t need_encoding = 1;
869 constexpr uint8_t backslash_char = 2;
870 constexpr uint8_t dot_char = 4;
871 constexpr uint8_t percent_char = 8;
876 (special ? (accumulator == 0)
877 : ((accumulator & (need_encoding | dot_char | percent_char)) ==
879 (!may_need_slow_file_handling);
880 if (accumulator == dot_char && !may_need_slow_file_handling) {
888 if (input[0] !=
'.') {
890 bool dot_is_file =
true;
892 slashdot = input.find(
"/.", slashdot);
893 if (slashdot == std::string_view::npos) {
898 dot_is_file &= !(slashdot == input.size() || input[slashdot] ==
'.' ||
899 input[slashdot] ==
'/');
902 trivial_path = dot_is_file;
906 ada_log(
"parse_path trivial");
917 (accumulator & (need_encoding | backslash_char | percent_char)) == 0) &&
920 ada_log(
"parse_prepared_path fast");
925 size_t previous_location = 0;
927 size_t new_location = input.find(
'/', previous_location);
930 if (new_location == std::string_view::npos) {
931 std::string_view path_view = input.substr(previous_location);
932 if (path_view ==
"..") {
939 if (path.back() ==
'/') {
944 path.resize(path.rfind(
'/') + 1);
948 if (path_view !=
".") {
949 path.append(path_view);
954 std::string_view path_view =
955 input.substr(previous_location, new_location - previous_location);
956 previous_location = new_location + 1;
957 if (path_view ==
"..") {
958 size_t last_delimiter = path.rfind(
'/');
959 if (last_delimiter != std::string::npos) {
960 path.erase(last_delimiter);
962 }
else if (path_view !=
".") {
964 path.append(path_view);
969 ada_log(
"parse_path slow");
971 bool needs_percent_encoding = (accumulator & 1);
973 size_t location = (special && (accumulator & 2))
974 ? input.find_first_of(
"/\\")
976 std::string_view path_view = input;
977 if (location != std::string_view::npos) {
978 path_view.remove_suffix(path_view.size() - location);
979 input.remove_prefix(location + 1);
982 if (unicode::is_double_dot_path_segment(path_view)) {
983 helpers::shorten_path(path, type);
984 if (location == std::string_view::npos) {
987 }
else if (unicode::is_single_dot_path_segment(path_view) &&
988 (location == std::string_view::npos)) {
992 else if (!unicode::is_single_dot_path_segment(path_view)) {
997 path_view.size() == 2 &&
1000 path += path_view[0];
1002 path_view.remove_prefix(2);
1003 path.append(path_view);
1007 if (!needs_percent_encoding ||
1010 path.append(path_view);
1014 if (location == std::string_view::npos) {
1021bool overlaps(std::string_view input1,
const std::string& input2)
noexcept {
1022 ada_log(
"helpers::overlaps check if string_view '", input1,
"' [",
1023 input1.size(),
" bytes] is part of string '", input2,
"' [",
1024 input2.size(),
" bytes]");
1025 return !input1.empty() && !input2.empty() && input1.data() >= input2.data() &&
1026 input1.data() < input2.data() + input2.size();
1029template <
class url_type>
1031 ada_log(
"helpers::strip_trailing_spaces_from_opaque_path");
1032 if (!
url.has_opaque_path)
return;
1033 if (
url.has_hash())
return;
1034 if (
url.has_search())
return;
1036 auto path = std::string(
url.get_pathname());
1037 while (!path.empty() && path.back() ==
' ') {
1038 path.resize(path.size() - 1);
1040 url.update_base_pathname(path);
1046 std::array<uint8_t, 256>
result{};
1047 for (uint8_t i : {
'@',
'/',
'\\',
'?'}) {
1054find_authority_delimiter_special(std::string_view view)
noexcept {
1057 for (
auto pos = view.begin(); pos != view.end(); ++pos) {
1059 return pos - view.begin();
1062 return size_t(view.size());
1067 std::array<uint8_t, 256>
result{};
1068 for (uint8_t i : {
'@',
'/',
'?'}) {
1075find_authority_delimiter(std::string_view view)
noexcept {
1078 for (
auto pos = view.begin(); pos != view.end(); ++pos) {
1080 return pos - view.begin();
1083 return size_t(view.size());
1092#undef ada_make_uint8x16_t
Definitions for URL specific checkers used within Ada.
Cross-platform compiler macros and common definitions.
#define ADA_ASSERT_TRUE(COND)
#define ada_really_inline
Definitions for helper functions used within Ada.
constexpr uint8_t PATH_PERCENT_ENCODE[32]
constexpr bool is_normalized_windows_drive_letter(std::string_view input) noexcept
constexpr bool is_windows_drive_letter(std::string_view input) noexcept
Includes the definitions for helper functions.
ada_really_inline size_t find_next_host_delimiter(std::string_view view, size_t location) noexcept
static constexpr std::array< uint8_t, 256 > authority_delimiter_special
static constexpr std::array< uint8_t, 256 > host_delimiters
ada_really_inline size_t find_next_host_delimiter_special(std::string_view view, size_t location) noexcept
ada_unused std::string get_state(ada::state s)
static constexpr std::array< uint8_t, 256 > authority_delimiter
static constexpr std::array< uint8_t, 256 > special_host_delimiters
ada_really_inline int trailing_zeroes(uint32_t input_num) noexcept
ada_really_inline int trailing_zeroes64(uint64_t input_num) noexcept
type
Enumeration of URL scheme types.
template bool percent_encode< true >(std::string_view input, const uint8_t character_set[], std::string &out)
state
States in the URL parsing state machine.
@ SPECIAL_RELATIVE_OR_AUTHORITY
@ SPECIAL_AUTHORITY_SLASHES
@ SPECIAL_AUTHORITY_IGNORE_SLASHES
ada_warn_unused std::string_view to_string(encoding_type type)
tl::expected< result_type, ada::errors > result
URL scheme type definitions and utilities.
URL parser state machine states.
Definitions for all unicode specific functions.