RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-14 08:54:58 +00:00
Code Issues Activity Actions

AK: Remove ByteString from GenericLexer

Browse source 
A bunch of users used consume_specific with a constant ByteString
literal, which can be replaced by an allocation-free StringView literal.

The generic consume_while overload gains a requires clause so that
consume_specific("abc") causes a more understandable and actionable
error.
This commit is contained in:
kleines Filmröllchen 2023-10-10 12:42:20 +02:00 • committed by Andrew Kaster
parent 7c88ab2836
commit eada4f2ee8
16 changed files with 89 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

6
AK/Format.cpp
View file

@ -125,10 +125,10 @@ StringView FormatParser::consume_literal()
auto const begin = tell();
while (!is_eof()) {
if (consume_specific("{{"))
if (consume_specific("{{"sv))
continue;
if (consume_specific("}}"))
if (consume_specific("}}"sv))
continue;
if (next_is(is_any_of("{}"sv)))
@ -858,7 +858,7 @@ void StandardFormatter::parse(TypeErasedFormatParams& params, FormatParser& pars
m_mode = Mode::Hexfloat;
else if (parser.consume_specific('A'))
m_mode = Mode::HexfloatUppercase;
else if (parser.consume_specific("hex-dump"))
else if (parser.consume_specific("hex-dump"sv))
m_mode = Mode::HexDump;
if (!parser.is_eof())

7
AK/GenericLexer.h
View file

@ -7,6 +7,7 @@
#pragma once
#include <AK/Result.h>
#include <AK/String.h>
#include <AK/StringView.h>
namespace AK {
@ -92,9 +93,11 @@ public:
}
#ifndef KERNEL
bool consume_specific(ByteString const& next)
bool consume_specific(ByteString next) = delete;
bool consume_specific(String const& next)
{
return consume_specific(StringView { next });
return consume_specific(next.bytes_as_string_view());
}
#endif

6
AK/JsonParser.cpp
View file

@ -298,21 +298,21 @@ ErrorOr<JsonValue> JsonParser::parse_number()
ErrorOr<JsonValue> JsonParser::parse_true()
{
if (!consume_specific("true"))
if (!consume_specific("true"sv))
return Error::from_string_literal("JsonParser: Expected 'true'");
return JsonValue(true);
}
ErrorOr<JsonValue> JsonParser::parse_false()
{
if (!consume_specific("false"))
if (!consume_specific("false"sv))
return Error::from_string_literal("JsonParser: Expected 'false'");
return JsonValue(false);
}
ErrorOr<JsonValue> JsonParser::parse_null()
{
if (!consume_specific("null"))
if (!consume_specific("null"sv))
return Error::from_string_literal("JsonParser: Expected 'null'");
return JsonValue {};
}

2
Meta/Lagom/Tools/CodeGenerators/IPCCompiler/main.cpp
View file

@ -231,7 +231,7 @@ Vector<Endpoint> parse(ByteBuffer const& file_contents)
consume_whitespace();
parse_includes();
consume_whitespace();
lexer.consume_specific("endpoint");
lexer.consume_specific("endpoint"sv);
consume_whitespace();
endpoints.last().name = lexer.consume_while([](char ch) { return !isspace(ch); });
endpoints.last().magic = Traits<ByteString>::hash(endpoints.last().name);

2
Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSEasingFunctions.cpp
View file

@ -166,7 +166,7 @@ EasingFunctionMetadata easing_function_metadata(EasingFunction easing_function)
auto parameter_type_name = lexer.consume_until([](char ch) { return ch == ' ' || ch == '>'; });
auto has_bounds = false;
auto is_optional = false;
if (lexer.consume_specific(" [")) {
if (lexer.consume_specific(" ["sv)) {
has_bounds = true;
auto contents = lexer.consume_until(']');
VERIFY(contents == "0, 1"sv);

2
Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp
View file

@ -28,7 +28,7 @@ static void consume_whitespace(GenericLexer& lexer)
while (consumed) {
consumed = lexer.consume_while(is_ascii_space).length() > 0;
if (lexer.consume_specific("//")) {
if (lexer.consume_specific("//"sv)) {
lexer.consume_until('\n');
lexer.ignore();
consumed = true;

22
Meta/Lagom/Tools/CodeGenerators/StateMachineGenerator/main.cpp
View file

@ -56,7 +56,7 @@ parse_state_machine(StringView input)
bool consumed = true;
while (consumed) {
consumed = lexer.consume_while(isspace).length() > 0;
if (lexer.consume_specific("//")) {
if (lexer.consume_specific("//"sv)) {
lexer.consume_line();
consumed = true;
}
@ -78,7 +78,7 @@ parse_state_machine(StringView input)
auto consume_number = [&] {
int num = 0;
consume_whitespace();
if (lexer.consume_specific("0x")) {
if (lexer.consume_specific("0x"sv)) {
auto hex_digits = lexer.consume_while([](char c) {
if (isdigit(c)) return true;
else {
@ -107,7 +107,7 @@ parse_state_machine(StringView input)
consume_whitespace();
condition.begin = consume_number();
consume_whitespace();
lexer.consume_specific("..");
lexer.consume_specific(".."sv);
consume_whitespace();
condition.end = consume_number();
consume_whitespace();
@ -123,16 +123,16 @@ parse_state_machine(StringView input)
auto consume_action = [&]() {
StateTransition action;
consume_whitespace();
lexer.consume_specific("=>");
lexer.consume_specific("=>"sv);
consume_whitespace();
lexer.consume_specific('(');
consume_whitespace();
if (!lexer.consume_specific("_"))
if (!lexer.consume_specific("_"sv))
action.new_state = consume_identifier();
consume_whitespace();
lexer.consume_specific(',');
consume_whitespace();
if (!lexer.consume_specific("_"))
if (!lexer.consume_specific("_"sv))
action.action = consume_identifier();
consume_whitespace();
lexer.consume_specific(')');
@ -152,10 +152,10 @@ parse_state_machine(StringView input)
if (lexer.consume_specific('}')) {
break;
}
if (lexer.consume_specific("@entry")) {
if (lexer.consume_specific("@entry"sv)) {
consume_whitespace();
state.entry_action = consume_identifier();
} else if (lexer.consume_specific("@exit")) {
} else if (lexer.consume_specific("@exit"sv)) {
consume_whitespace();
state.exit_action = consume_identifier();
} else if (lexer.next_is('@')) {
@ -176,13 +176,13 @@ parse_state_machine(StringView input)
consume_whitespace();
if (lexer.is_eof())
break;
if (lexer.consume_specific("@namespace")) {
if (lexer.consume_specific("@namespace"sv)) {
consume_whitespace();
state_machine->namespaces = lexer.consume_while([](char c) { return isalpha(c) || c == ':'; });
} else if (lexer.consume_specific("@begin")) {
} else if (lexer.consume_specific("@begin"sv)) {
consume_whitespace();
state_machine->initial_state = consume_identifier();
} else if (lexer.consume_specific("@name")) {
} else if (lexer.consume_specific("@name"sv)) {
consume_whitespace();
state_machine->name = consume_identifier();
} else if (lexer.next_is("@anywhere")) {

2
Tests/AK/TestGenericLexer.cpp
View file

@ -94,7 +94,7 @@ TEST_CASE(should_constexpr_consume_specific_cstring)
{
constexpr auto sut = [] {
GenericLexer sut("abcdef"sv);
sut.consume_specific("abcd");
sut.consume_specific("abcd"sv);
return sut;
}();
static_assert(sut.peek() == 'e');

18
Userland/Applications/Spreadsheet/Readers/XSV.cpp
View file

@ -67,7 +67,7 @@ void XSV::parse()
// Read and drop any extra lines at the end.
while (!m_lexer.is_eof()) {
if (!m_lexer.consume_specific("\r\n") && !m_lexer.consume_specific('\n'))
if (!m_lexer.consume_specific("\r\n"sv) && !m_lexer.consume_specific('\n'))
break;
}
@ -89,13 +89,13 @@ Vector<XSV::Field> XSV::read_row(bool header_row)
{
Vector<Field> row;
bool first = true;
while (!(m_lexer.is_eof() || m_lexer.next_is('\n') || m_lexer.next_is("\r\n")) && (first || m_lexer.consume_specific(m_traits.separator))) {
while (!(m_lexer.is_eof() || m_lexer.next_is('\n') || m_lexer.next_is("\r\n")) && (first || m_lexer.consume_specific(m_traits.separator.view()))) {
first = false;
row.append(read_one_field());
}
if (!m_lexer.is_eof()) {
auto crlf_ok = m_lexer.consume_specific("\r\n");
auto crlf_ok = m_lexer.consume_specific("\r\n"sv);
if (!crlf_ok) {
auto lf_ok = m_lexer.consume_specific('\n');
if (!lf_ok)
@ -176,7 +176,7 @@ XSV::Field XSV::read_one_field()
XSV::Field XSV::read_one_quoted_field()
{
if (!m_lexer.consume_specific(m_traits.quote))
if (!m_lexer.consume_specific(m_traits.quote.view()))
set_error(ReadError::InternalError);
size_t start = m_lexer.tell(), end = start;
@ -188,7 +188,7 @@ XSV::Field XSV::read_one_quoted_field()
char ch;
switch (m_traits.quote_escape) {
case ParserTraits::Backslash:
if (m_lexer.consume_specific('\\') && m_lexer.consume_specific(m_traits.quote)) {
if (m_lexer.consume_specific('\\') && m_lexer.consume_specific(m_traits.quote.view())) {
// If there is an escaped quote, we have no choice but to make a copy.
if (!is_copy) {
is_copy = true;
@ -200,8 +200,8 @@ XSV::Field XSV::read_one_quoted_field()
}
break;
case ParserTraits::Repeat:
if (m_lexer.consume_specific(m_traits.quote)) {
if (m_lexer.consume_specific(m_traits.quote)) {
if (m_lexer.consume_specific(m_traits.quote.view())) {
if (m_lexer.consume_specific(m_traits.quote.view())) {
// If there is an escaped quote, we have no choice but to make a copy.
if (!is_copy) {
is_copy = true;
@ -236,7 +236,7 @@ XSV::Field XSV::read_one_quoted_field()
break;
}
if (!m_lexer.consume_specific(m_traits.quote))
if (!m_lexer.consume_specific(m_traits.quote.view()))
set_error(ReadError::QuoteFailure);
if (is_copy)
@ -257,7 +257,7 @@ XSV::Field XSV::read_one_unquoted_field()
if (m_lexer.next_is("\r\n") || m_lexer.next_is("\n"))
break;
if (m_lexer.consume_specific(m_traits.quote)) {
if (m_lexer.consume_specific(m_traits.quote.view())) {
if (!allow_quote_in_field)
set_error(ReadError::QuoteFailure);
end = m_lexer.tell();

2
Userland/Applications/Spreadsheet/Writers/XSV.h
View file

@ -144,7 +144,7 @@ private:
GenericLexer lexer(string);
while (!lexer.is_eof()) {
if (lexer.consume_specific(m_traits.quote)) {
if (lexer.consume_specific(m_traits.quote.view())) {
switch (m_traits.quote_escape) {
case WriterTraits::Repeat:
TRY(m_output.write_until_depleted(m_traits.quote.bytes()));

8
Userland/Libraries/LibCrypto/ASN1/PEM.cpp
View file

@ -24,12 +24,12 @@ ByteBuffer decode_pem(ReadonlyBytes data)
while (!lexer.is_eof()) {
switch (state) {
case PreStartData:
if (lexer.consume_specific("-----BEGIN"))
if (lexer.consume_specific("-----BEGIN"sv))
state = Started;
lexer.consume_line();
break;
case Started: {
if (lexer.consume_specific("-----END")) {
if (lexer.consume_specific("-----END"sv)) {
state = Ended;
lexer.consume_line();
break;
@ -69,12 +69,12 @@ ErrorOr<Vector<ByteBuffer>> decode_pems(ReadonlyBytes data)
while (!lexer.is_eof()) {
switch (state) {
case Junk:
if (lexer.consume_specific("-----BEGIN"))
if (lexer.consume_specific("-----BEGIN"sv))
state = Parsing;
lexer.consume_line();
break;
case Parsing: {
if (lexer.consume_specific("-----END")) {
if (lexer.consume_specific("-----END"sv)) {
state = Junk;
lexer.consume_line();
TRY(pems.try_append(decoded));

10
Userland/Libraries/LibDiff/Hunks.cpp
View file

@ -26,7 +26,7 @@ Optional<HunkLocation> Parser::consume_unified_location()
return true;
};
if (!consume_specific("@@ -"))
if (!consume_specific("@@ -"sv))
return {};
HunkLocation location;
@ -34,13 +34,13 @@ Optional<HunkLocation> Parser::consume_unified_location()
if (!consume_range(location.old_range))
return {};
if (!consume_specific(" +"))
if (!consume_specific(" +"sv))
return {};
if (!consume_range(location.new_range))
return {};
if (!consume_specific(" @@"))
if (!consume_specific(" @@"sv))
return {};
return location;
@ -101,12 +101,12 @@ ErrorOr<Header> Parser::parse_header(Optional<size_t> const& strip_count)
while (!is_eof()) {
if (consume_specific("+++ ")) {
if (consume_specific("+++ "sv)) {
header.new_file_path = TRY(parse_file_line(strip_count));
continue;
}
if (consume_specific("--- ")) {
if (consume_specific("--- "sv)) {
header.old_file_path = TRY(parse_file_line(strip_count));
continue;
}

30
Userland/Libraries/LibIDL/IDLParser.cpp
View file

@ -90,7 +90,7 @@ void Parser::consume_whitespace()
while (consumed) {
consumed = lexer.consume_while(is_ascii_space).length() > 0;
if (lexer.consume_specific("//")) {
if (lexer.consume_specific("//"sv)) {
lexer.consume_until('\n');
lexer.ignore();
consumed = true;
@ -178,7 +178,7 @@ NonnullRefPtr<Type const> Parser::parse_type()
union_member_types.append(parse_type());
consume_whitespace();
while (lexer.consume_specific("or")) {
while (lexer.consume_specific("or"sv)) {
consume_whitespace();
union_member_types.append(parse_type());
consume_whitespace();
@ -199,12 +199,12 @@ NonnullRefPtr<Type const> Parser::parse_type()
return type;
}
bool unsigned_ = lexer.consume_specific("unsigned");
bool unsigned_ = lexer.consume_specific("unsigned"sv);
if (unsigned_)
consume_whitespace();
// FIXME: Actually treat "unrestricted" and normal floats/doubles differently.
if (lexer.consume_specific("unrestricted"))
if (lexer.consume_specific("unrestricted"sv))
consume_whitespace();
auto name = lexer.consume_until([](auto ch) { return !is_ascii_alphanumeric(ch) && ch != '_'; });
@ -262,15 +262,15 @@ NonnullRefPtr<Type const> Parser::parse_type()
void Parser::parse_attribute(HashMap<ByteString, ByteString>& extended_attributes, Interface& interface)
{
bool inherit = lexer.consume_specific("inherit");
bool inherit = lexer.consume_specific("inherit"sv);
if (inherit)
consume_whitespace();
bool readonly = lexer.consume_specific("readonly");
bool readonly = lexer.consume_specific("readonly"sv);
if (readonly)
consume_whitespace();
if (lexer.consume_specific("attribute"))
if (lexer.consume_specific("attribute"sv))
consume_whitespace();
else
report_parsing_error("expected 'attribute'"sv, filename, input, lexer.tell());
@ -300,7 +300,7 @@ void Parser::parse_attribute(HashMap<ByteString, ByteString>& extended_attribute
void Parser::parse_constant(Interface& interface)
{
lexer.consume_specific("const");
lexer.consume_specific("const"sv);
consume_whitespace();
auto type = parse_type();
@ -331,7 +331,7 @@ Vector<Parameter> Parser::parse_parameters()
HashMap<ByteString, ByteString> extended_attributes;
if (lexer.consume_specific('['))
extended_attributes = parse_extended_attributes();
bool optional = lexer.consume_specific("optional");
bool optional = lexer.consume_specific("optional"sv);
if (optional)
consume_whitespace();
if (lexer.consume_specific('[')) {
@ -373,7 +373,7 @@ Vector<Parameter> Parser::parse_parameters()
Function Parser::parse_function(HashMap<ByteString, ByteString>& extended_attributes, Interface& interface, IsSpecialOperation is_special_operation)
{
bool static_ = false;
if (lexer.consume_specific("static")) {
if (lexer.consume_specific("static"sv)) {
static_ = true;
consume_whitespace();
}
@ -766,7 +766,7 @@ void Parser::parse_dictionary(Interface& interface)
bool required = false;
HashMap<ByteString, ByteString> extended_attributes;
if (lexer.consume_specific("required")) {
if (lexer.consume_specific("required"sv)) {
required = true;
consume_whitespace();
}
@ -876,7 +876,7 @@ void Parser::parse_non_interface_entities(bool allow_interface, Interface& inter
auto current_offset = lexer.tell();
auto name = lexer.consume_until([](auto ch) { return is_ascii_space(ch); });
consume_whitespace();
if (lexer.consume_specific("includes")) {
if (lexer.consume_specific("includes"sv)) {
consume_whitespace();
auto mixin_name = lexer.consume_until([](auto ch) { return is_ascii_space(ch) || ch == ';'; });
interface.included_mixins.ensure(name).set(mixin_name);
@ -977,7 +977,7 @@ Interface& Parser::parse()
Vector<Interface&> imports;
{
HashTable<ByteString> required_imported_paths;
while (lexer.consume_specific("#import")) {
while (lexer.consume_specific("#import"sv)) {
consume_whitespace();
assert_specific('<');
auto path = lexer.consume_until('>');
@ -995,9 +995,9 @@ Interface& Parser::parse()
parse_non_interface_entities(true, interface);
if (lexer.consume_specific("interface"))
if (lexer.consume_specific("interface"sv))
parse_interface(interface);
else if (lexer.consume_specific("namespace"))
else if (lexer.consume_specific("namespace"sv))
parse_namespace(interface);
parse_non_interface_entities(false, interface);

8
Userland/Libraries/LibLine/Editor.cpp
View file

@ -89,19 +89,19 @@ Configuration Configuration::from_config(StringView libname)
escape = false;
} else {
if (key_lexer.next_is("alt+")) {
alt = key_lexer.consume_specific("alt+");
alt = key_lexer.consume_specific("alt+"sv);
continue;
}
if (key_lexer.next_is("^[")) {
alt = key_lexer.consume_specific("^[");
alt = key_lexer.consume_specific("^["sv);
continue;
}
if (key_lexer.next_is("^")) {
has_ctrl = key_lexer.consume_specific("^");
has_ctrl = key_lexer.consume_specific("^"sv);
continue;
}
if (key_lexer.next_is("ctrl+")) {
has_ctrl = key_lexer.consume_specific("ctrl+");
has_ctrl = key_lexer.consume_specific("ctrl+"sv);
continue;
}
if (key_lexer.next_is("\\")) {

34
Userland/Libraries/LibXML/Parser/Parser.cpp
View file

@ -1145,23 +1145,23 @@ ErrorOr<AttributeListDeclaration::Definition, ParseError> Parser::parse_attribut
// EnumeratedType ::= NotationType | Enumeration
// NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
// Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
if (m_lexer.consume_specific("CDATA")) {
if (m_lexer.consume_specific("CDATA"sv)) {
type = AttributeListDeclaration::StringType::CData;
} else if (m_lexer.consume_specific("IDREFS")) {
} else if (m_lexer.consume_specific("IDREFS"sv)) {
type = AttributeListDeclaration::TokenizedType::IDRefs;
} else if (m_lexer.consume_specific("IDREF")) {
} else if (m_lexer.consume_specific("IDREF"sv)) {
type = AttributeListDeclaration::TokenizedType::IDRef;
} else if (m_lexer.consume_specific("ID")) {
} else if (m_lexer.consume_specific("ID"sv)) {
type = AttributeListDeclaration::TokenizedType::ID;
} else if (m_lexer.consume_specific("ENTITIES")) {
} else if (m_lexer.consume_specific("ENTITIES"sv)) {
type = AttributeListDeclaration::TokenizedType::Entities;
} else if (m_lexer.consume_specific("ENTITY")) {
} else if (m_lexer.consume_specific("ENTITY"sv)) {
type = AttributeListDeclaration::TokenizedType::Entity;
} else if (m_lexer.consume_specific("NMTOKENS")) {
} else if (m_lexer.consume_specific("NMTOKENS"sv)) {
type = AttributeListDeclaration::TokenizedType::NMTokens;
} else if (m_lexer.consume_specific("NMTOKEN")) {
} else if (m_lexer.consume_specific("NMTOKEN"sv)) {
type = AttributeListDeclaration::TokenizedType::NMToken;
} else if (m_lexer.consume_specific("NOTATION")) {
} else if (m_lexer.consume_specific("NOTATION"sv)) {
HashTable<Name> names;
TRY(skip_whitespace(Required::Yes));
TRY(expect("("sv));
@ -1198,13 +1198,13 @@ ErrorOr<AttributeListDeclaration::Definition, ParseError> Parser::parse_attribut
// DefaultDecl ::= '#REQUIRED' | '#IMPLIED'
// | (('#FIXED' S)? AttValue)
if (m_lexer.consume_specific("#REQUIRED")) {
if (m_lexer.consume_specific("#REQUIRED"sv)) {
default_ = AttributeListDeclaration::Required {};
} else if (m_lexer.consume_specific("#IMPLIED")) {
} else if (m_lexer.consume_specific("#IMPLIED"sv)) {
default_ = AttributeListDeclaration::Implied {};
} else {
bool fixed = false;
if (m_lexer.consume_specific("#FIXED")) {
if (m_lexer.consume_specific("#FIXED"sv)) {
TRY(skip_whitespace(Required::Yes));
fixed = true;
}
@ -1273,19 +1273,19 @@ ErrorOr<ElementDeclaration::ContentSpec, ParseError> Parser::parse_content_spec(
Optional<ElementDeclaration::ContentSpec> content_spec;
// contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
if (m_lexer.consume_specific("EMPTY")) {
if (m_lexer.consume_specific("EMPTY"sv)) {
content_spec = ElementDeclaration::Empty {};
} else if (m_lexer.consume_specific("ANY")) {
} else if (m_lexer.consume_specific("ANY"sv)) {
content_spec = ElementDeclaration::Any {};
} else {
TRY(expect("("sv));
TRY(skip_whitespace());
if (m_lexer.consume_specific("#PCDATA")) {
if (m_lexer.consume_specific("#PCDATA"sv)) {
HashTable<Name> names;
// Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*'
// | '(' S? '#PCDATA' S? ')'
TRY(skip_whitespace());
if (m_lexer.consume_specific(")*")) {
if (m_lexer.consume_specific(")*"sv)) {
content_spec = ElementDeclaration::Mixed { .types = {}, .many = true };
} else if (m_lexer.consume_specific(')')) {
content_spec = ElementDeclaration::Mixed { .types = {}, .many = false };
@ -1599,7 +1599,7 @@ ErrorOr<ExternalID, ParseError> Parser::parse_external_id()
Optional<PublicID> public_id;
SystemID system_id;
if (m_lexer.consume_specific("SYSTEM")) {
if (m_lexer.consume_specific("SYSTEM"sv)) {
auto accept = accept_rule();
TRY(skip_whitespace(Required::Yes));
system_id = SystemID { TRY(parse_system_id_literal()) };

16
Userland/Utilities/pro.cpp
View file

@ -33,18 +33,18 @@ public:
lexer.ignore_while(is_ascii_space);
if (lexer.consume_specific("inline")) {
if (lexer.consume_specific("inline"sv)) {
m_kind = Kind::Inline;
if (!lexer.is_eof())
m_might_be_wrong = true;
return;
}
if (lexer.consume_specific("attachment")) {
if (lexer.consume_specific("attachment"sv)) {
m_kind = Kind::Attachment;
if (lexer.consume_specific(";")) {
if (lexer.consume_specific(";"sv)) {
lexer.ignore_while(is_ascii_space);
if (lexer.consume_specific("filename=")) {
if (lexer.consume_specific("filename="sv)) {
// RFC 2183: "A short (length <= 78 characters)
// parameter value containing only non-`tspecials' characters SHOULD be
// represented as a single `token'."
@ -62,13 +62,13 @@ public:
return;
}
if (lexer.consume_specific("form-data")) {
if (lexer.consume_specific("form-data"sv)) {
m_kind = Kind::FormData;
while (lexer.consume_specific(";")) {
while (lexer.consume_specific(";"sv)) {
lexer.ignore_while(is_ascii_space);
if (lexer.consume_specific("name=")) {
if (lexer.consume_specific("name="sv)) {
m_name = lexer.consume_quoted_string();
} else if (lexer.consume_specific("filename=")) {
} else if (lexer.consume_specific("filename="sv)) {
if (lexer.next_is('"'))
m_filename = lexer.consume_quoted_string();
else