1- /* auto-generated on 2024-05-30 22:24:57 -0400. Do not edit! */
1+ /* auto-generated on 2024-07-06 17:38:56 -0400. Do not edit! */
22/* begin file src/ada.cpp */
33#include "ada.h"
44/* begin file src/checkers.cpp */
5+
56#include <algorithm>
67
78namespace ada::checkers {
@@ -9794,6 +9795,10 @@ ADA_POP_DISABLE_WARNINGS
97949795
97959796namespace ada::unicode {
97969797
9798+ constexpr bool is_tabs_or_newline(char c) noexcept {
9799+ return c == '\r' || c == '\n' || c == '\t';
9800+ }
9801+
97979802constexpr uint64_t broadcast(uint8_t v) noexcept {
97989803 return 0x101010101010101ull * v;
97999804}
@@ -9828,13 +9833,8 @@ ada_really_inline bool has_tabs_or_newline(
98289833 std::string_view user_input) noexcept {
98299834 // first check for short strings in which case we do it naively.
98309835 if (user_input.size() < 16) { // slow path
9831- for (size_t i = 0; i < user_input.size(); i++) {
9832- if (user_input[i] == '\r' || user_input[i] == '\n' ||
9833- user_input[i] == '\t') {
9834- return true;
9835- }
9836- }
9837- return false;
9836+ return std::any_of(user_input.begin(), user_input.end(),
9837+ is_tabs_or_newline);
98389838 }
98399839 // fast path for long strings (expected to be common)
98409840 size_t i = 0;
@@ -9872,13 +9872,8 @@ ada_really_inline bool has_tabs_or_newline(
98729872 std::string_view user_input) noexcept {
98739873 // first check for short strings in which case we do it naively.
98749874 if (user_input.size() < 16) { // slow path
9875- for (size_t i = 0; i < user_input.size(); i++) {
9876- if (user_input[i] == '\r' || user_input[i] == '\n' ||
9877- user_input[i] == '\t') {
9878- return true;
9879- }
9880- }
9881- return false;
9875+ return std::any_of(user_input.begin(), user_input.end(),
9876+ is_tabs_or_newline);
98829877 }
98839878 // fast path for long strings (expected to be common)
98849879 size_t i = 0;
@@ -10263,10 +10258,6 @@ std::string percent_encode(const std::string_view input,
1026310258 return out;
1026410259}
1026510260
10266- std::string to_unicode(std::string_view input) {
10267- return ada::idna::to_unicode(input);
10268- }
10269-
1027010261} // namespace ada::unicode
1027110262/* end file src/unicode.cpp */
1027210263/* begin file src/serializers.cpp */
@@ -10359,7 +10350,8 @@ namespace ada {
1035910350template <class result_type>
1036010351ada_warn_unused tl::expected<result_type, ada::errors> parse(
1036110352 std::string_view input, const result_type* base_url) {
10362- result_type u = ada::parser::parse_url<result_type>(input, base_url);
10353+ result_type u =
10354+ ada::parser::parse_url_impl<result_type, true>(input, base_url);
1036310355 if (!u.is_valid) {
1036410356 return tl::unexpected(errors::generic_error);
1036510357 }
@@ -10395,16 +10387,22 @@ std::string href_from_file(std::string_view input) {
1039510387}
1039610388
1039710389bool can_parse(std::string_view input, const std::string_view* base_input) {
10398- ada::result<ada:: url_aggregator> base ;
10390+ ada::url_aggregator base_aggregator ;
1039910391 ada::url_aggregator* base_pointer = nullptr;
10392+
1040010393 if (base_input != nullptr) {
10401- base = ada::parse<url_aggregator>(*base_input);
10402- if (!base) {
10394+ base_aggregator = ada::parser::parse_url_impl<ada::url_aggregator, false>(
10395+ *base_input, nullptr);
10396+ if (!base_aggregator.is_valid) {
1040310397 return false;
1040410398 }
10405- base_pointer = &base.value() ;
10399+ base_pointer = &base_aggregator ;
1040610400 }
10407- return ada::parse<url_aggregator>(input, base_pointer).has_value();
10401+
10402+ ada::url_aggregator result =
10403+ ada::parser::parse_url_impl<ada::url_aggregator, false>(input,
10404+ base_pointer);
10405+ return result.is_valid;
1040810406}
1040910407
1041010408ada_warn_unused std::string to_string(ada::encoding_type type) {
@@ -12139,11 +12137,12 @@ bool url::set_href(const std::string_view input) {
1213912137
1214012138#include <limits>
1214112139
12140+
1214212141namespace ada::parser {
1214312142
12144- template <class result_type>
12145- result_type parse_url (std::string_view user_input,
12146- const result_type* base_url) {
12143+ template <class result_type, bool store_values >
12144+ result_type parse_url_impl (std::string_view user_input,
12145+ const result_type* base_url) {
1214712146 // We can specialize the implementation per type.
1214812147 // Important: result_type_is_ada_url is evaluated at *compile time*. This
1214912148 // means that doing if constexpr(result_type_is_ada_url) { something } else {
@@ -12178,7 +12177,7 @@ result_type parse_url(std::string_view user_input,
1217812177 if (!url.is_valid) {
1217912178 return url;
1218012179 }
12181- if constexpr (result_type_is_ada_url_aggregator) {
12180+ if constexpr (result_type_is_ada_url_aggregator && store_values ) {
1218212181 // Most of the time, we just need user_input.size().
1218312182 // In some instances, we may need a bit more.
1218412183 ///////////////////////////
@@ -12195,9 +12194,6 @@ result_type parse_url(std::string_view user_input,
1219512194 helpers::leading_zeroes(uint32_t(1 | user_input.size()))) +
1219612195 1;
1219712196 url.reserve(reserve_capacity);
12198- //
12199- //
12200- //
1220112197 }
1220212198 std::string tmp_buffer;
1220312199 std::string_view internal_input;
@@ -12420,32 +12416,36 @@ result_type parse_url(std::string_view user_input,
1242012416 password_token_seen =
1242112417 password_token_location != std::string_view::npos;
1242212418
12423- if (!password_token_seen) {
12424- if constexpr (result_type_is_ada_url) {
12425- url.username += unicode::percent_encode(
12426- authority_view, character_sets::USERINFO_PERCENT_ENCODE);
12427- } else {
12428- url.append_base_username(unicode::percent_encode(
12429- authority_view, character_sets::USERINFO_PERCENT_ENCODE));
12430- }
12431- } else {
12432- if constexpr (result_type_is_ada_url) {
12433- url.username += unicode::percent_encode(
12434- authority_view.substr(0, password_token_location),
12435- character_sets::USERINFO_PERCENT_ENCODE);
12436- url.password += unicode::percent_encode(
12437- authority_view.substr(password_token_location + 1),
12438- character_sets::USERINFO_PERCENT_ENCODE);
12419+ if constexpr (store_values) {
12420+ if (!password_token_seen) {
12421+ if constexpr (result_type_is_ada_url) {
12422+ url.username += unicode::percent_encode(
12423+ authority_view,
12424+ character_sets::USERINFO_PERCENT_ENCODE);
12425+ } else {
12426+ url.append_base_username(unicode::percent_encode(
12427+ authority_view,
12428+ character_sets::USERINFO_PERCENT_ENCODE));
12429+ }
1243912430 } else {
12440- url.append_base_username(unicode::percent_encode(
12441- authority_view.substr(0, password_token_location),
12442- character_sets::USERINFO_PERCENT_ENCODE));
12443- url.append_base_password(unicode::percent_encode(
12444- authority_view.substr(password_token_location + 1),
12445- character_sets::USERINFO_PERCENT_ENCODE));
12431+ if constexpr (result_type_is_ada_url) {
12432+ url.username += unicode::percent_encode(
12433+ authority_view.substr(0, password_token_location),
12434+ character_sets::USERINFO_PERCENT_ENCODE);
12435+ url.password += unicode::percent_encode(
12436+ authority_view.substr(password_token_location + 1),
12437+ character_sets::USERINFO_PERCENT_ENCODE);
12438+ } else {
12439+ url.append_base_username(unicode::percent_encode(
12440+ authority_view.substr(0, password_token_location),
12441+ character_sets::USERINFO_PERCENT_ENCODE));
12442+ url.append_base_password(unicode::percent_encode(
12443+ authority_view.substr(password_token_location + 1),
12444+ character_sets::USERINFO_PERCENT_ENCODE));
12445+ }
1244612446 }
1244712447 }
12448- } else {
12448+ } else if constexpr (store_values) {
1244912449 if constexpr (result_type_is_ada_url) {
1245012450 url.password += unicode::percent_encode(
1245112451 authority_view, character_sets::USERINFO_PERCENT_ENCODE);
@@ -12472,8 +12472,10 @@ result_type parse_url(std::string_view user_input,
1247212472 break;
1247312473 }
1247412474 if (end_of_authority == input_size) {
12475- if (fragment.has_value()) {
12476- url.update_unencoded_base_hash(*fragment);
12475+ if constexpr (store_values) {
12476+ if (fragment.has_value()) {
12477+ url.update_unencoded_base_hash(*fragment);
12478+ }
1247712479 }
1247812480 return url;
1247912481 }
@@ -12670,19 +12672,22 @@ result_type parse_url(std::string_view user_input,
1267012672 }
1267112673 case ada::state::QUERY: {
1267212674 ada_log("QUERY ", helpers::substring(url_data, input_position));
12673- // Let queryPercentEncodeSet be the special-query percent-encode set if
12674- // url is special; otherwise the query percent-encode set.
12675- const uint8_t* query_percent_encode_set =
12676- url.is_special() ? ada::character_sets::SPECIAL_QUERY_PERCENT_ENCODE
12677- : ada::character_sets::QUERY_PERCENT_ENCODE;
12678-
12679- // Percent-encode after encoding, with encoding, buffer, and
12680- // queryPercentEncodeSet, and append the result to url's query.
12681- url.update_base_search(helpers::substring(url_data, input_position),
12682- query_percent_encode_set);
12683- ada_log("QUERY update_base_search completed ");
12684- if (fragment.has_value()) {
12685- url.update_unencoded_base_hash(*fragment);
12675+ if constexpr (store_values) {
12676+ // Let queryPercentEncodeSet be the special-query percent-encode set
12677+ // if url is special; otherwise the query percent-encode set.
12678+ const uint8_t* query_percent_encode_set =
12679+ url.is_special()
12680+ ? ada::character_sets::SPECIAL_QUERY_PERCENT_ENCODE
12681+ : ada::character_sets::QUERY_PERCENT_ENCODE;
12682+
12683+ // Percent-encode after encoding, with encoding, buffer, and
12684+ // queryPercentEncodeSet, and append the result to url's query.
12685+ url.update_base_search(helpers::substring(url_data, input_position),
12686+ query_percent_encode_set);
12687+ ada_log("QUERY update_base_search completed ");
12688+ if (fragment.has_value()) {
12689+ url.update_unencoded_base_hash(*fragment);
12690+ }
1268612691 }
1268712692 return url;
1268812693 }
@@ -12785,9 +12790,11 @@ result_type parse_url(std::string_view user_input,
1278512790 // Optimization: Avoiding going into PATH state improves the
1278612791 // performance of urls ending with /.
1278712792 if (input_position == input_size) {
12788- url.update_base_pathname("/");
12789- if (fragment.has_value()) {
12790- url.update_unencoded_base_hash(*fragment);
12793+ if constexpr (store_values) {
12794+ url.update_base_pathname("/");
12795+ if (fragment.has_value()) {
12796+ url.update_unencoded_base_hash(*fragment);
12797+ }
1279112798 }
1279212799 return url;
1279312800 }
@@ -12833,11 +12840,13 @@ result_type parse_url(std::string_view user_input,
1283312840 } else {
1283412841 input_position = input_size + 1;
1283512842 }
12836- if constexpr (result_type_is_ada_url) {
12837- helpers::parse_prepared_path(view, url.type, url.path);
12838- } else {
12839- url.consume_prepared_path(view);
12840- ADA_ASSERT_TRUE(url.validate());
12843+ if constexpr (store_values) {
12844+ if constexpr (result_type_is_ada_url) {
12845+ helpers::parse_prepared_path(view, url.type, url.path);
12846+ } else {
12847+ url.consume_prepared_path(view);
12848+ ADA_ASSERT_TRUE(url.validate());
12849+ }
1284112850 }
1284212851 break;
1284312852 }
@@ -13031,17 +13040,29 @@ result_type parse_url(std::string_view user_input,
1303113040 ada::unreachable();
1303213041 }
1303313042 }
13034- if (fragment.has_value()) {
13035- url.update_unencoded_base_hash(*fragment);
13043+ if constexpr (store_values) {
13044+ if (fragment.has_value()) {
13045+ url.update_unencoded_base_hash(*fragment);
13046+ }
1303613047 }
1303713048 return url;
1303813049}
1303913050
13051+ template url parse_url_impl(std::string_view user_input,
13052+ const url* base_url = nullptr);
13053+ template url_aggregator parse_url_impl(
13054+ std::string_view user_input, const url_aggregator* base_url = nullptr);
13055+
13056+ template <class result_type>
13057+ result_type parse_url(std::string_view user_input,
13058+ const result_type* base_url) {
13059+ return parse_url_impl<result_type, true>(user_input, base_url);
13060+ }
13061+
1304013062template url parse_url<url>(std::string_view user_input,
1304113063 const url* base_url = nullptr);
1304213064template url_aggregator parse_url<url_aggregator>(
1304313065 std::string_view user_input, const url_aggregator* base_url = nullptr);
13044-
1304513066} // namespace ada::parser
1304613067/* end file src/parser.cpp */
1304713068/* begin file src/url_components.cpp */
@@ -15397,6 +15418,15 @@ void ada_search_params_sort(ada_url_search_params result) {
1539715418 }
1539815419}
1539915420
15421+ void ada_search_params_reset(ada_url_search_params result, const char* input,
15422+ size_t length) {
15423+ ada::result<ada::url_search_params>& r =
15424+ *(ada::result<ada::url_search_params>*)result;
15425+ if (r) {
15426+ r->reset(std::string_view(input, length));
15427+ }
15428+ }
15429+
1540015430void ada_search_params_append(ada_url_search_params result, const char* key,
1540115431 size_t key_length, const char* value,
1540215432 size_t value_length) {
0 commit comments