srctree

copts = HASTUR_COPTS,

visibility = ["//visibility:public"],

deps = [

"//util:string",

],

)

 

 

 

#include "css2/token.h"

 

#include "util/string.h"

 

#include <cassert>

#include <charconv>

auto c = consume_next_input_character();

if (!c) {

emit(ParseError::EofInEscapeSequence);

}

 

if (util::is_hex_digit(*c)) {

 

// https://www.w3.org/TR/css-syntax-3/#maximum-allowed-code-point

static constexpr std::uint32_t kMaximumAllowedCodePoint = 0x10FFFF;

code_point = kReplacementCharacter;

}

 

}

 

return std::string{*c};

 

copts = HASTUR_COPTS,

visibility = ["//visibility:public"],

deps = [

"//util:string",

"@fmt",

],

)

 

#include "html2/character_reference.h"

#include "html2/token.h"

 

#include "util/string.h"

 

#include <algorithm>

#include <cassert>

}

 

temporary_buffer_.clear();

if (maybe_reference->second_codepoint) {

}

 

flush_code_points_consumed_as_a_character_reference();

character_reference_code_ = 0xFFFD;

}

 

emit(ParseError::SurrogateCharacterReference);

character_reference_code_ = 0xFFFD;

}

 

emit(ParseError::NoncharacterCharacterReference);

}

 

character_reference_code_ = it->second;

}

 

flush_code_points_consumed_as_a_character_reference();

state_ = return_state_;

continue;

 

],

copts = HASTUR_COPTS,

visibility = ["//visibility:public"],

)

 

[cc_test(

deps = [

":idna",

"//etest",

],

) for src in glob(["*_test.cpp"])]

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

#ifndef IDNA_PUNYCODE_H_

#define IDNA_PUNYCODE_H_

 

 

#include <algorithm>

#include <functional>

static constexpr std::string unicode_to_utf8(std::u32string const &code_points) {

std::string result{};

for (auto const code_point : code_points) {

}

 

return result;

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

#include "idna/punycode.h"

 

#include "etest/etest2.h"

 

#include <string>

#include <vector>

std::string unicode_as_utf8_string(std::vector<int> const &code_points) {

std::string result{};

for (auto const code_point : code_points) {

}

 

return result;

 

 

#include "idna/idna_data.h"

 

 

// NOLINTNEXTLINE(misc-include-cleaner): This is used for std::ranges::lower_bound.

#include <algorithm>

// input.size is just an estimate, but probably good enough for now.

result.reserve(input.size());

 

// * clang-tidy thinks std::ranges::lower_bound is provided by

// <bits/ranges_algo.h> when it's actually provided by <algorithm>.

// * clang-tidy says this is pointer-ish, but msvc disagrees.

 

// These would be mapped in transitional processing, but we don't support that.

if (std::holds_alternative<uts46::Deviation>(entry)) {

continue;

}

 

if (std::holds_alternative<uts46::Valid>(entry) //

|| std::holds_alternative<uts46::ValidNv8>(entry) //

|| std::holds_alternative<uts46::ValidXv8>(entry)) {

continue;

}

}

 

)

 

cc_library(

copts = HASTUR_COPTS,

visibility = ["//visibility:public"],

)

 

[cc_test(

srcs = [src],

copts = HASTUR_COPTS,

deps = [

"//etest",

],

) for src in glob(["*_test.cpp"])]

 

#include "unicode/normalization.h"

 

#include "unicode/unicode_data.h"

 

// NOLINTNEXTLINE(misc-include-cleaner): This is used for std::ranges::lower_bound.

#include <algorithm>

 

// This code point does not decompose.

if (maybe_decomposition->code_point != code_point) {

return;

}

 

// Recursively decompose the decomposition. This is needed as some code

// points decompose into code points that also decompose.

decompose_to(os, decomposed);

}

}

std::string Normalization::decompose(std::string_view input) {

std::stringstream ss{};

 

decompose_to(ss, code_point);

}

 

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

 

#include <cstddef>

#include <cstdint>

#include <string_view>

#include <utility>

 

 

return code_point <= 0x7f;

}

 

return std::uint8_t{1};

}

 

return std::nullopt;

}

 

case 1:

return {static_cast<char>(code_point & 0x7F)};

case 2:

}

 

// https://infra.spec.whatwg.org/#surrogate

return code_point >= 0xD800 && code_point <= 0xDFFF;

}

 

// https://infra.spec.whatwg.org/#noncharacter

if (code_point >= 0xFDD0 && code_point <= 0xFDEF) {

return true;

}

};

};

 

 

#endif

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

 

#include "etest/etest.h"

 

#include <vector>

 

using namespace std::literals;

 

using etest::expect;

using etest::expect_eq;

 

int main() {

 

 

 

 

});

 

 

 

 

 

// Invalid code points return "".

});

 

});

 

 

for (std::uint32_t i = 0xFDD0; i <= 0xFDEF; ++i) {

}

 

 

// Every 0x10000 pair of values ending in FFFE and FFFF are noncharacters.

for (std::uint32_t i = 0xFFFE; i <= 0x10FFFE; i += 0x10000) {

}

});

 

 

visibility = ["//visibility:public"],

deps = [

":rtti_hack",

"//util:string",

"//util:uuid",

"@icu//:common",

"@icu//:icudata",

 

 

#include "url/rtti_hack.h" // IWYU pragma: keep

 

#include "util/string.h"

#include "util/uuid.h"

 

// unicode/uclean is for u_cleanup, but icu does a lot of macro magic renaming

state_ = ParserState::Fragment;

}

} else {

validation_error(ValidationError::InvalidUrlUnit);

}

 

 

state_ = ParserState::Fragment;

} else {

validation_error(ValidationError::InvalidUrlUnit);

}

 

state_ = ParserState::Fragment;

}

} else if (!is_eof()) {

validation_error(ValidationError::InvalidUrlUnit);

}

 

// https://url.spec.whatwg.org/#fragment-state

void UrlParser::state_fragment() {

if (auto c = peek(); !is_eof()) {

validation_error(ValidationError::InvalidUrlUnit);

}

 

std::string_view tmp = input;

 

while (!tmp.empty()) {

 

if (!is_url_codepoint(cp)) {

validation_error(ValidationError::InvalidUrlUnit);

// unicode_utf8_byte_count fails if the codepoint is larger than the

// maximum valid code point, 0x10ffff, meaning it'll have to take up at

// least 4 bytes.

tmp.remove_prefix(len);

}

 

return cp == '!' || cp == '$' || cp == '&' || cp == '\'' || cp == '(' || cp == ')' || cp == '*' || cp == '+'

|| cp == ',' || cp == '-' || cp == '.' || cp == '/' || cp == ':' || cp == ';' || cp == '=' || cp == '?'

|| cp == '@' || cp == '_' || cp == '~'

}

 

// NOLINTEND(bugprone-unchecked-optional-access)