GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — deps: update ada to 2.9.0 · nodejs/node@a19b283

File tree

Expand file treeCollapse file tree
Open diff view settings
Filter options
  • deps/ada
    • ada.cpp
    • ada.h
    • ada_c.h
  • src
    • node_url.cc
Expand file treeCollapse file tree
Open diff view settings
Collapse file

‎deps/ada/ada.cpp‎

Copy file name to clipboardExpand all lines: deps/ada/ada.cpp
+111-81Lines changed: 111 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
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

78
namespace ada::checkers {
@@ -9794,6 +9795,10 @@ ADA_POP_DISABLE_WARNINGS
97949795

97959796
namespace ada::unicode {
97969797

9798+
constexpr bool is_tabs_or_newline(char c) noexcept {
9799+
return c == '\r' || c == '\n' || c == '\t';
9800+
}
9801+
97979802
constexpr 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 {
1035910350
template <class result_type>
1036010351
ada_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

1039710389
bool 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

1041010408
ada_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+
1214212141
namespace 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+
1304013062
template url parse_url<url>(std::string_view user_input,
1304113063
const url* base_url = nullptr);
1304213064
template 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+
1540015430
void 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

Comments
0 (0)
You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.