mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 19:47:34 +00:00
Everywhere: Add sv suffix to strings relying on StringView(char const*)
Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
This commit is contained in:
sin-ack
Andreas Kling
parent
e5f09ea170
commit
3f3f45580a
762 changed files with 8315 additions and 8316 deletions
|
|
@ -35,12 +35,12 @@ ErrorOr<void> AK::Formatter<Shell::AST::Command>::format(FormatBuilder& builder,
|
|||
VERIFY_NOT_REACHED();
|
||||
|
||||
if (value.argv.is_empty()) {
|
||||
TRY(builder.put_literal("(ShellInternal)"));
|
||||
TRY(builder.put_literal("(ShellInternal)"sv));
|
||||
} else {
|
||||
bool first = true;
|
||||
for (auto& arg : value.argv) {
|
||||
if (!first)
|
||||
TRY(builder.put_literal(" "));
|
||||
TRY(builder.put_literal(" "sv));
|
||||
first = false;
|
||||
TRY(builder.put_literal(arg));
|
||||
}
|
||||
|
|
@ -53,28 +53,28 @@ ErrorOr<void> AK::Formatter<Shell::AST::Command>::format(FormatBuilder& builder,
|
|||
TRY(builder.put_i64(path_redir->fd));
|
||||
switch (path_redir->direction) {
|
||||
case Shell::AST::PathRedirection::Read:
|
||||
TRY(builder.put_literal("<"));
|
||||
TRY(builder.put_literal("<"sv));
|
||||
break;
|
||||
case Shell::AST::PathRedirection::Write:
|
||||
TRY(builder.put_literal(">"));
|
||||
TRY(builder.put_literal(">"sv));
|
||||
break;
|
||||
case Shell::AST::PathRedirection::WriteAppend:
|
||||
TRY(builder.put_literal(">>"));
|
||||
TRY(builder.put_literal(">>"sv));
|
||||
break;
|
||||
case Shell::AST::PathRedirection::ReadWrite:
|
||||
TRY(builder.put_literal("<>"));
|
||||
TRY(builder.put_literal("<>"sv));
|
||||
break;
|
||||
}
|
||||
TRY(builder.put_literal(path_redir->path));
|
||||
} else if (redir.is_fd_redirection()) {
|
||||
auto* fdredir = (Shell::AST::FdRedirection const*)&redir;
|
||||
TRY(builder.put_i64(fdredir->new_fd));
|
||||
TRY(builder.put_literal(">"));
|
||||
TRY(builder.put_literal(">"sv));
|
||||
TRY(builder.put_i64(fdredir->old_fd));
|
||||
} else if (redir.is_close_redirection()) {
|
||||
auto close_redir = (Shell::AST::CloseRedirection const*)&redir;
|
||||
TRY(builder.put_i64(close_redir->fd));
|
||||
TRY(builder.put_literal(">&-"));
|
||||
TRY(builder.put_literal(">&-"sv));
|
||||
} else {
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
|
@ -84,23 +84,23 @@ ErrorOr<void> AK::Formatter<Shell::AST::Command>::format(FormatBuilder& builder,
|
|||
for (auto& command : value.next_chain) {
|
||||
switch (command.action) {
|
||||
case Shell::AST::NodeWithAction::And:
|
||||
TRY(builder.put_literal(" && "));
|
||||
TRY(builder.put_literal(" && "sv));
|
||||
break;
|
||||
case Shell::AST::NodeWithAction::Or:
|
||||
TRY(builder.put_literal(" || "));
|
||||
TRY(builder.put_literal(" || "sv));
|
||||
break;
|
||||
case Shell::AST::NodeWithAction::Sequence:
|
||||
TRY(builder.put_literal("; "));
|
||||
TRY(builder.put_literal("; "sv));
|
||||
break;
|
||||
}
|
||||
|
||||
TRY(builder.put_literal("("));
|
||||
TRY(builder.put_literal("("sv));
|
||||
TRY(builder.put_literal(command.node->class_name()));
|
||||
TRY(builder.put_literal("...)"));
|
||||
TRY(builder.put_literal("...)"sv));
|
||||
}
|
||||
}
|
||||
if (!value.should_wait)
|
||||
TRY(builder.put_literal("&"));
|
||||
TRY(builder.put_literal("&"sv));
|
||||
return {};
|
||||
}
|
||||
|
||||
|
|
@ -367,8 +367,8 @@ Vector<Line::CompletionSuggestion> Node::complete_for_editor(Shell& shell, size_
|
|||
return {};
|
||||
|
||||
// If the literal isn't an option, treat it as a path.
|
||||
if (!(text.starts_with("-") || text == "--" || text == "-"))
|
||||
return set_results_trivia(shell.complete_path("", text, corrected_offset, Shell::ExecutableOnly::No, hit_test_result.closest_command_node.ptr(), hit_test_result.matching_node, escape_mode));
|
||||
if (!(text.starts_with('-') || text == "--" || text == "-"))
|
||||
return set_results_trivia(shell.complete_path(""sv, text, corrected_offset, Shell::ExecutableOnly::No, hit_test_result.closest_command_node.ptr(), hit_test_result.matching_node, escape_mode));
|
||||
|
||||
// If the literal is an option, we have to know the program name
|
||||
// should we have no way to get that, bail early.
|
||||
|
|
@ -392,7 +392,7 @@ Vector<Line::CompletionSuggestion> Node::complete_for_editor(Shell& shell, size_
|
|||
}
|
||||
auto result = hit_test_position(offset);
|
||||
if (!result.matching_node)
|
||||
return shell.complete_path("", "", 0, Shell::ExecutableOnly::No, result.closest_command_node.ptr(), nullptr, Shell::EscapeMode::Bareword);
|
||||
return shell.complete_path(""sv, ""sv, 0, Shell::ExecutableOnly::No, result.closest_command_node.ptr(), nullptr, Shell::EscapeMode::Bareword);
|
||||
|
||||
auto node = result.matching_node;
|
||||
if (node->is_bareword() || node != result.closest_node_with_semantic_meaning)
|
||||
|
|
@ -651,7 +651,7 @@ void BarewordLiteral::highlight_in_editor(Line::Editor& editor, Shell& shell, Hi
|
|||
if (m_text == "-")
|
||||
return;
|
||||
|
||||
if (m_text.starts_with("--")) {
|
||||
if (m_text.starts_with("--"sv)) {
|
||||
auto index = m_text.find('=').value_or(m_text.length() - 1) + 1;
|
||||
editor.stylize({ m_position.start_offset, m_position.start_offset + index }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan) });
|
||||
} else {
|
||||
|
|
@ -798,7 +798,7 @@ void CastToList::dump(int level) const
|
|||
if (m_inner)
|
||||
m_inner->dump(level + 1);
|
||||
else
|
||||
print_indented("(empty)", level + 1);
|
||||
print_indented("(empty)"sv, level + 1);
|
||||
}
|
||||
|
||||
RefPtr<Value> CastToList::run(RefPtr<Shell> shell)
|
||||
|
|
@ -934,7 +934,7 @@ Comment::~Comment()
|
|||
void ContinuationControl::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented(m_kind == Continue ? "(Continue)" : "(Break)", level + 1);
|
||||
print_indented(m_kind == Continue ? "(Continue)"sv : "(Break)"sv, level + 1);
|
||||
}
|
||||
|
||||
RefPtr<Value> ContinuationControl::run(RefPtr<Shell> shell)
|
||||
|
|
@ -964,7 +964,7 @@ RefPtr<Value> DoubleQuotedString::run(RefPtr<Shell> shell)
|
|||
StringBuilder builder;
|
||||
auto values = m_inner->run(shell)->resolve_as_list(shell);
|
||||
|
||||
builder.join("", values);
|
||||
builder.join(""sv, values);
|
||||
|
||||
return make_ref_counted<StringValue>(builder.to_string());
|
||||
}
|
||||
|
|
@ -1079,15 +1079,15 @@ void FunctionDeclaration::dump(int level) const
|
|||
{
|
||||
Node::dump(level);
|
||||
print_indented(String::formatted("(name: {})\n", m_name.name), level + 1);
|
||||
print_indented("(argument names)", level + 1);
|
||||
print_indented("(argument names)"sv, level + 1);
|
||||
for (auto& arg : m_arguments)
|
||||
print_indented(String::formatted("(name: {})\n", arg.name), level + 2);
|
||||
|
||||
print_indented("(body)", level + 1);
|
||||
print_indented("(body)"sv, level + 1);
|
||||
if (m_block)
|
||||
m_block->dump(level + 2);
|
||||
else
|
||||
print_indented("(null)", level + 2);
|
||||
print_indented("(null)"sv, level + 2);
|
||||
}
|
||||
|
||||
RefPtr<Value> FunctionDeclaration::run(RefPtr<Shell> shell)
|
||||
|
|
@ -1173,12 +1173,12 @@ void ForLoop::dump(int level) const
|
|||
if (m_iterated_expression)
|
||||
m_iterated_expression->dump(level + 2);
|
||||
else
|
||||
print_indented("(ever)", level + 2);
|
||||
print_indented("Running", level + 1);
|
||||
print_indented("(ever)"sv, level + 2);
|
||||
print_indented("Running"sv, level + 1);
|
||||
if (m_block)
|
||||
m_block->dump(level + 2);
|
||||
else
|
||||
print_indented("(null)", level + 2);
|
||||
print_indented("(null)"sv, level + 2);
|
||||
}
|
||||
|
||||
RefPtr<Value> ForLoop::run(RefPtr<Shell> shell)
|
||||
|
|
@ -1362,15 +1362,15 @@ Glob::~Glob()
|
|||
void Heredoc::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(End Key)", level + 1);
|
||||
print_indented("(End Key)"sv, level + 1);
|
||||
print_indented(m_end, level + 2);
|
||||
print_indented("(Allows Interpolation)", level + 1);
|
||||
print_indented("(Allows Interpolation)"sv, level + 1);
|
||||
print_indented(String::formatted("{}", m_allows_interpolation), level + 2);
|
||||
print_indented("(Contents)", level + 1);
|
||||
print_indented("(Contents)"sv, level + 1);
|
||||
if (m_contents)
|
||||
m_contents->dump(level + 2);
|
||||
else
|
||||
print_indented("(null)", level + 2);
|
||||
print_indented("(null)"sv, level + 2);
|
||||
}
|
||||
|
||||
RefPtr<Value> Heredoc::run(RefPtr<Shell> shell)
|
||||
|
|
@ -1437,24 +1437,24 @@ Heredoc::~Heredoc()
|
|||
void HistoryEvent::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("Event Selector", level + 1);
|
||||
print_indented("Event Selector"sv, level + 1);
|
||||
switch (m_selector.event.kind) {
|
||||
case HistorySelector::EventKind::IndexFromStart:
|
||||
print_indented("IndexFromStart", level + 2);
|
||||
print_indented("IndexFromStart"sv, level + 2);
|
||||
break;
|
||||
case HistorySelector::EventKind::IndexFromEnd:
|
||||
print_indented("IndexFromEnd", level + 2);
|
||||
print_indented("IndexFromEnd"sv, level + 2);
|
||||
break;
|
||||
case HistorySelector::EventKind::ContainingStringLookup:
|
||||
print_indented("ContainingStringLookup", level + 2);
|
||||
print_indented("ContainingStringLookup"sv, level + 2);
|
||||
break;
|
||||
case HistorySelector::EventKind::StartingStringLookup:
|
||||
print_indented("StartingStringLookup", level + 2);
|
||||
print_indented("StartingStringLookup"sv, level + 2);
|
||||
break;
|
||||
}
|
||||
print_indented(String::formatted("{}({})", m_selector.event.index, m_selector.event.text), level + 3);
|
||||
|
||||
print_indented("Word Selector", level + 1);
|
||||
print_indented("Word Selector"sv, level + 1);
|
||||
auto print_word_selector = [&](HistorySelector::WordSelector const& selector) {
|
||||
switch (selector.kind) {
|
||||
case HistorySelector::WordSelectorKind::Index:
|
||||
|
|
@ -1467,12 +1467,12 @@ void HistoryEvent::dump(int level) const
|
|||
};
|
||||
|
||||
if (m_selector.word_selector_range.end.has_value()) {
|
||||
print_indented("Range Start", level + 2);
|
||||
print_indented("Range Start"sv, level + 2);
|
||||
print_word_selector(m_selector.word_selector_range.start);
|
||||
print_indented("Range End", level + 2);
|
||||
print_indented("Range End"sv, level + 2);
|
||||
print_word_selector(m_selector.word_selector_range.end.value());
|
||||
} else {
|
||||
print_indented("Direct Address", level + 2);
|
||||
print_indented("Direct Address"sv, level + 2);
|
||||
print_word_selector(m_selector.word_selector_range.start);
|
||||
}
|
||||
}
|
||||
|
|
@ -1593,7 +1593,7 @@ void Execute::dump(int level) const
|
|||
{
|
||||
Node::dump(level);
|
||||
if (m_capture_stdout)
|
||||
print_indented("(Capturing stdout)", level + 1);
|
||||
print_indented("(Capturing stdout)"sv, level + 1);
|
||||
m_command->dump(level + 1);
|
||||
}
|
||||
|
||||
|
|
@ -1649,7 +1649,7 @@ void Execute::for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(Non
|
|||
NothingLeft,
|
||||
};
|
||||
auto check_and_call = [&] {
|
||||
auto ifs = shell->local_variable_or("IFS", "\n");
|
||||
auto ifs = shell->local_variable_or("IFS"sv, "\n"sv);
|
||||
|
||||
if (auto offset = stream.offset_of(ifs.bytes()); offset.has_value()) {
|
||||
auto line_end = offset.value();
|
||||
|
|
@ -1846,18 +1846,18 @@ Execute::~Execute()
|
|||
void IfCond::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("Condition", ++level);
|
||||
print_indented("Condition"sv, ++level);
|
||||
m_condition->dump(level + 1);
|
||||
print_indented("True Branch", level);
|
||||
print_indented("True Branch"sv, level);
|
||||
if (m_true_branch)
|
||||
m_true_branch->dump(level + 1);
|
||||
else
|
||||
print_indented("(empty)", level + 1);
|
||||
print_indented("False Branch", level);
|
||||
print_indented("(empty)"sv, level + 1);
|
||||
print_indented("False Branch"sv, level);
|
||||
if (m_false_branch)
|
||||
m_false_branch->dump(level + 1);
|
||||
else
|
||||
print_indented("(empty)", level + 1);
|
||||
print_indented("(empty)"sv, level + 1);
|
||||
}
|
||||
|
||||
RefPtr<Value> IfCond::run(RefPtr<Shell> shell)
|
||||
|
|
@ -1957,9 +1957,9 @@ IfCond::~IfCond()
|
|||
void ImmediateExpression::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(function)", level + 1);
|
||||
print_indented("(function)"sv, level + 1);
|
||||
print_indented(m_function.name, level + 2);
|
||||
print_indented("(arguments)", level + 1);
|
||||
print_indented("(arguments)"sv, level + 1);
|
||||
for (auto& argument : arguments())
|
||||
argument.dump(level + 2);
|
||||
}
|
||||
|
|
@ -2115,12 +2115,12 @@ void MatchExpr::dump(int level) const
|
|||
print_indented(String::formatted("(expression: {})", m_expr_name.characters()), level + 1);
|
||||
m_matched_expr->dump(level + 2);
|
||||
print_indented(String::formatted("(named: {})", m_expr_name.characters()), level + 1);
|
||||
print_indented("(entries)", level + 1);
|
||||
print_indented("(entries)"sv, level + 1);
|
||||
for (auto& entry : m_entries) {
|
||||
StringBuilder builder;
|
||||
builder.append("(match");
|
||||
builder.append("(match"sv);
|
||||
if (entry.match_names.has_value()) {
|
||||
builder.append(" to names (");
|
||||
builder.append(" to names ("sv);
|
||||
bool first = true;
|
||||
for (auto& name : entry.match_names.value()) {
|
||||
if (!first)
|
||||
|
|
@ -2128,7 +2128,7 @@ void MatchExpr::dump(int level) const
|
|||
first = false;
|
||||
builder.append(name);
|
||||
}
|
||||
builder.append("))");
|
||||
builder.append("))"sv);
|
||||
|
||||
} else {
|
||||
builder.append(')');
|
||||
|
|
@ -2143,11 +2143,11 @@ void MatchExpr::dump(int level) const
|
|||
for (auto& option : options)
|
||||
print_indented(String::formatted("(regex: {})", option.pattern_value), level + 3);
|
||||
});
|
||||
print_indented("(execute)", level + 2);
|
||||
print_indented("(execute)"sv, level + 2);
|
||||
if (entry.body)
|
||||
entry.body->dump(level + 3);
|
||||
else
|
||||
print_indented("(nothing)", level + 3);
|
||||
print_indented("(nothing)"sv, level + 3);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2522,7 +2522,7 @@ Vector<Line::CompletionSuggestion> PathRedirectionNode::complete_for_editor(Shel
|
|||
if (corrected_offset > node->text().length())
|
||||
return {};
|
||||
|
||||
return shell.complete_path("", node->text(), corrected_offset, Shell::ExecutableOnly::No, nullptr, nullptr);
|
||||
return shell.complete_path(""sv, node->text(), corrected_offset, Shell::ExecutableOnly::No, nullptr, nullptr);
|
||||
}
|
||||
|
||||
PathRedirectionNode::~PathRedirectionNode()
|
||||
|
|
@ -2532,9 +2532,9 @@ PathRedirectionNode::~PathRedirectionNode()
|
|||
void Range::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(From)", level + 1);
|
||||
print_indented("(From)"sv, level + 1);
|
||||
m_start->dump(level + 2);
|
||||
print_indented("(To)", level + 1);
|
||||
print_indented("(To)"sv, level + 1);
|
||||
m_end->dump(level + 2);
|
||||
}
|
||||
|
||||
|
|
@ -2872,13 +2872,13 @@ Slice::~Slice()
|
|||
void SimpleVariable::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(Name)", level + 1);
|
||||
print_indented("(Name)"sv, level + 1);
|
||||
print_indented(m_name, level + 2);
|
||||
print_indented("(Slice)", level + 1);
|
||||
print_indented("(Slice)"sv, level + 1);
|
||||
if (m_slice)
|
||||
m_slice->dump(level + 2);
|
||||
else
|
||||
print_indented("(None)", level + 2);
|
||||
print_indented("(None)"sv, level + 2);
|
||||
}
|
||||
|
||||
RefPtr<Value> SimpleVariable::run(RefPtr<Shell>)
|
||||
|
|
@ -2940,13 +2940,13 @@ SimpleVariable::~SimpleVariable()
|
|||
void SpecialVariable::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(Name)", level + 1);
|
||||
print_indented("(Name)"sv, level + 1);
|
||||
print_indented(String { &m_name, 1 }, level + 1);
|
||||
print_indented("(Slice)", level + 1);
|
||||
print_indented("(Slice)"sv, level + 1);
|
||||
if (m_slice)
|
||||
m_slice->dump(level + 2);
|
||||
else
|
||||
print_indented("(None)", level + 2);
|
||||
print_indented("(None)"sv, level + 2);
|
||||
}
|
||||
|
||||
RefPtr<Value> SpecialVariable::run(RefPtr<Shell>)
|
||||
|
|
@ -3221,9 +3221,9 @@ StringPartCompose::~StringPartCompose()
|
|||
void SyntaxError::dump(int level) const
|
||||
{
|
||||
Node::dump(level);
|
||||
print_indented("(Error text)", level + 1);
|
||||
print_indented("(Error text)"sv, level + 1);
|
||||
print_indented(m_syntax_error_text, level + 2);
|
||||
print_indented("(Can be recovered from)", level + 1);
|
||||
print_indented("(Can be recovered from)"sv, level + 1);
|
||||
print_indented(String::formatted("{}", m_is_continuable), level + 2);
|
||||
}
|
||||
|
||||
|
|
@ -3396,7 +3396,7 @@ void VariableDeclarations::dump(int level) const
|
|||
{
|
||||
Node::dump(level);
|
||||
for (auto& var : m_variables) {
|
||||
print_indented("Set", level + 1);
|
||||
print_indented("Set"sv, level + 1);
|
||||
var.name->dump(level + 2);
|
||||
var.value->dump(level + 2);
|
||||
}
|
||||
|
|
@ -3687,11 +3687,11 @@ Vector<String> SpecialVariableValue::resolve_as_list(RefPtr<Shell> shell)
|
|||
case '$':
|
||||
return { resolve_slices(shell, String::number(getpid()), m_slices) };
|
||||
case '*':
|
||||
if (auto argv = shell->lookup_local_variable("ARGV"))
|
||||
if (auto argv = shell->lookup_local_variable("ARGV"sv))
|
||||
return resolve_slices(shell, argv->resolve_as_list(shell), m_slices);
|
||||
return resolve_slices(shell, Vector<String> {}, m_slices);
|
||||
case '#':
|
||||
if (auto argv = shell->lookup_local_variable("ARGV")) {
|
||||
if (auto argv = shell->lookup_local_variable("ARGV"sv)) {
|
||||
if (argv->is_list()) {
|
||||
auto list_argv = static_cast<AST::ListValue*>(argv.ptr());
|
||||
return { resolve_slices(shell, String::number(list_argv->values().size()), m_slices) };
|
||||
|
|
|
|||
|
|
@ -213,7 +213,7 @@ int Shell::builtin_type(int argc, char const** argv)
|
|||
if (!(i == fn.arguments.size() - 1))
|
||||
builder.append(" ");
|
||||
}
|
||||
builder.append(") {\n");
|
||||
builder.append(") {\n"sv);
|
||||
if (fn.body) {
|
||||
auto formatter = Formatter(*fn.body);
|
||||
builder.append(formatter.format());
|
||||
|
|
@ -831,7 +831,7 @@ int Shell::builtin_shift(int argc, char const** argv)
|
|||
if (count < 1)
|
||||
return 0;
|
||||
|
||||
auto argv_ = lookup_local_variable("ARGV");
|
||||
auto argv_ = lookup_local_variable("ARGV"sv);
|
||||
if (!argv_) {
|
||||
warnln("shift: ARGV is unset");
|
||||
return 1;
|
||||
|
|
@ -864,7 +864,7 @@ int Shell::builtin_source(int argc, char const** argv)
|
|||
if (!parser.parse(argc, const_cast<char**>(argv)))
|
||||
return 1;
|
||||
|
||||
auto previous_argv = lookup_local_variable("ARGV");
|
||||
auto previous_argv = lookup_local_variable("ARGV"sv);
|
||||
ScopeGuard guard { [&] {
|
||||
if (!args.is_empty())
|
||||
set_local_variable("ARGV", move(previous_argv));
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ void Formatter::insert_separator(bool escaped)
|
|||
void Formatter::insert_indent()
|
||||
{
|
||||
for (size_t i = 0; i < m_current_indent; ++i)
|
||||
current_builder().append(" ");
|
||||
current_builder().append(" "sv);
|
||||
}
|
||||
|
||||
void Formatter::visit(const AST::PathRedirectionNode* node)
|
||||
|
|
@ -147,7 +147,7 @@ void Formatter::visit(const AST::And* node)
|
|||
|
||||
current_builder().append(' ');
|
||||
insert_separator(true);
|
||||
current_builder().append("&& ");
|
||||
current_builder().append("&& "sv);
|
||||
|
||||
node->right()->visit(*this);
|
||||
});
|
||||
|
|
@ -177,7 +177,7 @@ void Formatter::visit(const AST::Background* node)
|
|||
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
NodeVisitor::visit(node);
|
||||
current_builder().append(" &");
|
||||
current_builder().append(" &"sv);
|
||||
visited(node);
|
||||
}
|
||||
|
||||
|
|
@ -255,7 +255,7 @@ void Formatter::visit(const AST::Comment* node)
|
|||
{
|
||||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
current_builder().append("#");
|
||||
current_builder().append("#"sv);
|
||||
current_builder().append(node->text());
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -265,9 +265,9 @@ void Formatter::visit(const AST::ContinuationControl* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
if (node->continuation_kind() == AST::ContinuationControl::Break)
|
||||
current_builder().append("break");
|
||||
current_builder().append("break"sv);
|
||||
else if (node->continuation_kind() == AST::ContinuationControl::Continue)
|
||||
current_builder().append("continue");
|
||||
current_builder().append("continue"sv);
|
||||
else
|
||||
VERIFY_NOT_REACHED();
|
||||
visited(node);
|
||||
|
|
@ -289,7 +289,7 @@ void Formatter::visit(const AST::DoubleQuotedString* node)
|
|||
test_and_update_output_cursor(node);
|
||||
auto not_in_heredoc = m_parent_node->kind() != AST::Node::Kind::Heredoc;
|
||||
if (not_in_heredoc)
|
||||
current_builder().append("\"");
|
||||
current_builder().append("\""sv);
|
||||
|
||||
TemporaryChange quotes { m_options.in_double_quotes, true };
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
|
@ -297,7 +297,7 @@ void Formatter::visit(const AST::DoubleQuotedString* node)
|
|||
NodeVisitor::visit(node);
|
||||
|
||||
if (not_in_heredoc)
|
||||
current_builder().append("\"");
|
||||
current_builder().append("\""sv);
|
||||
visited(node);
|
||||
}
|
||||
|
||||
|
|
@ -329,7 +329,7 @@ void Formatter::visit(const AST::FunctionDeclaration* node)
|
|||
current_builder().append(arg.name);
|
||||
}
|
||||
|
||||
current_builder().append(") ");
|
||||
current_builder().append(") "sv);
|
||||
|
||||
in_new_block([&] {
|
||||
if (node->block())
|
||||
|
|
@ -343,18 +343,18 @@ void Formatter::visit(const AST::ForLoop* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
auto is_loop = node->iterated_expression().is_null();
|
||||
current_builder().append(is_loop ? "loop" : "for ");
|
||||
current_builder().append(is_loop ? "loop"sv : "for "sv);
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
||||
if (!is_loop) {
|
||||
if (node->index_variable().has_value()) {
|
||||
current_builder().append("index ");
|
||||
current_builder().append("index "sv);
|
||||
current_builder().append(node->index_variable()->name);
|
||||
current_builder().append(" ");
|
||||
current_builder().append(" "sv);
|
||||
}
|
||||
if (node->variable().has_value() && node->variable()->name != "it") {
|
||||
current_builder().append(node->variable()->name);
|
||||
current_builder().append(" in ");
|
||||
current_builder().append(" in "sv);
|
||||
}
|
||||
|
||||
node->iterated_expression()->visit(*this);
|
||||
|
|
@ -381,7 +381,7 @@ void Formatter::visit(const AST::Heredoc* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
|
||||
current_builder().append("<<");
|
||||
current_builder().append("<<"sv);
|
||||
if (node->deindent())
|
||||
current_builder().append('~');
|
||||
else
|
||||
|
|
@ -474,12 +474,12 @@ void Formatter::visit(const AST::Execute* node)
|
|||
ScopedValueRollback options_rollback { m_options };
|
||||
|
||||
if (node->does_capture_stdout())
|
||||
builder.append("$(");
|
||||
builder.append("$("sv);
|
||||
|
||||
NodeVisitor::visit(node);
|
||||
|
||||
if (node->does_capture_stdout())
|
||||
builder.append(")");
|
||||
builder.append(")"sv);
|
||||
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -489,7 +489,7 @@ void Formatter::visit(const AST::IfCond* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
|
||||
current_builder().append("if ");
|
||||
current_builder().append("if "sv);
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
||||
node->condition()->visit(*this);
|
||||
|
|
@ -502,7 +502,7 @@ void Formatter::visit(const AST::IfCond* node)
|
|||
});
|
||||
|
||||
if (node->false_branch()) {
|
||||
current_builder().append(" else ");
|
||||
current_builder().append(" else "sv);
|
||||
if (node->false_branch()->kind() != AST::Node::Kind::IfCond) {
|
||||
in_new_block([&] {
|
||||
node->false_branch()->visit(*this);
|
||||
|
|
@ -511,7 +511,7 @@ void Formatter::visit(const AST::IfCond* node)
|
|||
node->false_branch()->visit(*this);
|
||||
}
|
||||
} else if (node->else_position().has_value()) {
|
||||
current_builder().append(" else ");
|
||||
current_builder().append(" else "sv);
|
||||
}
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -521,7 +521,7 @@ void Formatter::visit(const AST::ImmediateExpression* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
|
||||
current_builder().append("${");
|
||||
current_builder().append("${"sv);
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
||||
current_builder().append(node->function_name());
|
||||
|
|
@ -564,14 +564,14 @@ void Formatter::visit(const AST::MatchExpr* node)
|
|||
{
|
||||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
current_builder().append("match ");
|
||||
current_builder().append("match "sv);
|
||||
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
||||
node->matched_expr()->visit(*this);
|
||||
|
||||
if (!node->expr_name().is_empty()) {
|
||||
current_builder().append(" as ");
|
||||
current_builder().append(" as "sv);
|
||||
current_builder().append(node->expr_name());
|
||||
}
|
||||
|
||||
|
|
@ -587,7 +587,7 @@ void Formatter::visit(const AST::MatchExpr* node)
|
|||
[&](NonnullRefPtrVector<AST::Node> const& patterns) {
|
||||
for (auto& option : patterns) {
|
||||
if (!first)
|
||||
current_builder().append(" | ");
|
||||
current_builder().append(" | "sv);
|
||||
first = false;
|
||||
option.visit(*this);
|
||||
}
|
||||
|
|
@ -595,7 +595,7 @@ void Formatter::visit(const AST::MatchExpr* node)
|
|||
[&](Vector<Regex<ECMA262>> const& patterns) {
|
||||
for (auto& option : patterns) {
|
||||
if (!first)
|
||||
current_builder().append(" | ");
|
||||
current_builder().append(" | "sv);
|
||||
first = false;
|
||||
auto node = make_ref_counted<AST::BarewordLiteral>(AST::Position {}, option.pattern_value);
|
||||
node->visit(*this);
|
||||
|
|
@ -604,7 +604,7 @@ void Formatter::visit(const AST::MatchExpr* node)
|
|||
|
||||
current_builder().append(' ');
|
||||
if (entry.match_names.has_value() && !entry.match_names.value().is_empty()) {
|
||||
current_builder().append("as (");
|
||||
current_builder().append("as ("sv);
|
||||
auto first = true;
|
||||
for (auto& name : entry.match_names.value()) {
|
||||
if (!first)
|
||||
|
|
@ -612,7 +612,7 @@ void Formatter::visit(const AST::MatchExpr* node)
|
|||
first = false;
|
||||
current_builder().append(name);
|
||||
}
|
||||
current_builder().append(") ");
|
||||
current_builder().append(") "sv);
|
||||
}
|
||||
in_new_block([&] {
|
||||
if (entry.body)
|
||||
|
|
@ -633,9 +633,9 @@ void Formatter::visit(const AST::Or* node)
|
|||
with_added_indent(should_indent ? 1 : 0, [&] {
|
||||
node->left()->visit(*this);
|
||||
|
||||
current_builder().append(" ");
|
||||
current_builder().append(" "sv);
|
||||
insert_separator(true);
|
||||
current_builder().append("|| ");
|
||||
current_builder().append("|| "sv);
|
||||
|
||||
node->right()->visit(*this);
|
||||
});
|
||||
|
|
@ -650,11 +650,11 @@ void Formatter::visit(const AST::Pipe* node)
|
|||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
|
||||
node->left()->visit(*this);
|
||||
current_builder().append(" ");
|
||||
current_builder().append(" "sv);
|
||||
|
||||
with_added_indent(should_indent ? 1 : 0, [&] {
|
||||
insert_separator(true);
|
||||
current_builder().append("| ");
|
||||
current_builder().append("| "sv);
|
||||
|
||||
node->right()->visit(*this);
|
||||
});
|
||||
|
|
@ -670,7 +670,7 @@ void Formatter::visit(const AST::Range* node)
|
|||
|
||||
TemporaryChange<const AST::Node*> parent { m_parent_node, node };
|
||||
node->start()->visit(*this);
|
||||
current_builder().append("..");
|
||||
current_builder().append(".."sv);
|
||||
node->end()->visit(*this);
|
||||
|
||||
if (!m_parent_node || m_parent_node->kind() != AST::Node::Kind::Slice)
|
||||
|
|
@ -687,7 +687,7 @@ void Formatter::visit(const AST::ReadRedirection* node)
|
|||
if (node->fd() != 0)
|
||||
current_builder().appendff(" {}<", node->fd());
|
||||
else
|
||||
current_builder().append(" <");
|
||||
current_builder().append(" <"sv);
|
||||
NodeVisitor::visit(node);
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -701,7 +701,7 @@ void Formatter::visit(const AST::ReadWriteRedirection* node)
|
|||
if (node->fd() != 0)
|
||||
current_builder().appendff(" {}<>", node->fd());
|
||||
else
|
||||
current_builder().append(" <>");
|
||||
current_builder().append(" <>"sv);
|
||||
NodeVisitor::visit(node);
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -787,7 +787,7 @@ void Formatter::visit(const AST::StringLiteral* node)
|
|||
will_visit(node);
|
||||
test_and_update_output_cursor(node);
|
||||
if (!m_options.in_double_quotes && !m_options.in_heredoc)
|
||||
current_builder().append("'");
|
||||
current_builder().append("'"sv);
|
||||
|
||||
if (m_options.in_double_quotes && !m_options.in_heredoc) {
|
||||
for (auto ch : node->text()) {
|
||||
|
|
@ -798,25 +798,25 @@ void Formatter::visit(const AST::StringLiteral* node)
|
|||
current_builder().append('\\');
|
||||
break;
|
||||
case '\n':
|
||||
current_builder().append("\\n");
|
||||
current_builder().append("\\n"sv);
|
||||
continue;
|
||||
case '\r':
|
||||
current_builder().append("\\r");
|
||||
current_builder().append("\\r"sv);
|
||||
continue;
|
||||
case '\t':
|
||||
current_builder().append("\\t");
|
||||
current_builder().append("\\t"sv);
|
||||
continue;
|
||||
case '\v':
|
||||
current_builder().append("\\v");
|
||||
current_builder().append("\\v"sv);
|
||||
continue;
|
||||
case '\f':
|
||||
current_builder().append("\\f");
|
||||
current_builder().append("\\f"sv);
|
||||
continue;
|
||||
case '\a':
|
||||
current_builder().append("\\a");
|
||||
current_builder().append("\\a"sv);
|
||||
continue;
|
||||
case '\e':
|
||||
current_builder().append("\\e");
|
||||
current_builder().append("\\e"sv);
|
||||
continue;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -828,7 +828,7 @@ void Formatter::visit(const AST::StringLiteral* node)
|
|||
}
|
||||
|
||||
if (!m_options.in_double_quotes && !m_options.in_heredoc)
|
||||
current_builder().append("'");
|
||||
current_builder().append("'"sv);
|
||||
visited(node);
|
||||
}
|
||||
|
||||
|
|
@ -892,7 +892,7 @@ void Formatter::visit(const AST::WriteAppendRedirection* node)
|
|||
if (node->fd() != 1)
|
||||
current_builder().appendff(" {}>>", node->fd());
|
||||
else
|
||||
current_builder().append(" >>");
|
||||
current_builder().append(" >>"sv);
|
||||
NodeVisitor::visit(node);
|
||||
visited(node);
|
||||
}
|
||||
|
|
@ -906,7 +906,7 @@ void Formatter::visit(const AST::WriteRedirection* node)
|
|||
if (node->fd() != 1)
|
||||
current_builder().appendff(" {}>", node->fd());
|
||||
else
|
||||
current_builder().append(" >");
|
||||
current_builder().append(" >"sv);
|
||||
NodeVisitor::visit(node);
|
||||
visited(node);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
|
|||
|
||||
auto do_across = [&](StringView mode_name, auto& values) {
|
||||
if (is_inferred)
|
||||
mode_name = "infer";
|
||||
mode_name = "infer"sv;
|
||||
// Translate to a list of applications of `length <mode_name>`
|
||||
Vector<NonnullRefPtr<AST::Node>> resulting_nodes;
|
||||
resulting_nodes.ensure_capacity(values.size());
|
||||
|
|
@ -104,7 +104,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
|
|||
|
||||
if (auto list = dynamic_cast<AST::ListValue*>(value.ptr())) {
|
||||
if (across)
|
||||
return do_across("list", list->values());
|
||||
return do_across("list"sv, list->values());
|
||||
|
||||
return value_with_number(list->values().size());
|
||||
}
|
||||
|
|
@ -115,7 +115,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
|
|||
|
||||
dbgln("List has {} entries", list.size());
|
||||
auto values = AST::make_ref_counted<AST::ListValue>(move(list));
|
||||
return do_across("list", values->values());
|
||||
return do_across("list"sv, values->values());
|
||||
}
|
||||
case String: {
|
||||
// 'across' will only accept lists, and '!across' will only accept non-lists here.
|
||||
|
|
@ -151,7 +151,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
|
|||
if (!across)
|
||||
goto raise_no_list_allowed;
|
||||
|
||||
return do_across("string", list->values());
|
||||
return do_across("string"sv, list->values());
|
||||
}
|
||||
|
||||
if (across && !value->is_list()) {
|
||||
|
|
@ -184,7 +184,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
|
|||
}
|
||||
|
||||
auto values = AST::make_ref_counted<AST::ListValue>(move(list));
|
||||
return do_across("string", values->values());
|
||||
return do_across("string"sv, values->values());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -192,7 +192,7 @@ Parser::SequenceParseResult Parser::parse_sequence()
|
|||
auto read_terminators = [&](bool consider_tabs_and_spaces) {
|
||||
if (m_heredoc_initiations.is_empty()) {
|
||||
discard_terminators:;
|
||||
consume_while(is_any_of(consider_tabs_and_spaces ? " \t\n;" : "\n;"));
|
||||
consume_while(is_any_of(consider_tabs_and_spaces ? " \t\n;"sv : "\n;"sv));
|
||||
} else {
|
||||
for (;;) {
|
||||
if (consider_tabs_and_spaces && (peek() == '\t' || peek() == ' ')) {
|
||||
|
|
@ -208,7 +208,7 @@ Parser::SequenceParseResult Parser::parse_sequence()
|
|||
consume();
|
||||
if (!parse_heredoc_entries()) {
|
||||
StringBuilder error_builder;
|
||||
error_builder.append("Expected to find heredoc entries for ");
|
||||
error_builder.append("Expected to find heredoc entries for "sv);
|
||||
bool first = true;
|
||||
for (auto& entry : m_heredoc_initiations) {
|
||||
if (first)
|
||||
|
|
@ -249,7 +249,7 @@ Parser::SequenceParseResult Parser::parse_sequence()
|
|||
if (left.is_empty())
|
||||
break;
|
||||
|
||||
consume_while(is_any_of("\n;"));
|
||||
consume_while(is_any_of("\n;"sv));
|
||||
auto pos_after_seps = save_offset();
|
||||
AST::Position separator_position { pos_before_seps.offset, pos_after_seps.offset, pos_before_seps.line, pos_after_seps.line };
|
||||
|
||||
|
|
@ -280,7 +280,7 @@ Parser::SequenceParseResult Parser::parse_sequence()
|
|||
read_terminators(false);
|
||||
[[fallthrough]];
|
||||
case ';': {
|
||||
consume_while(is_any_of("\n;"));
|
||||
consume_while(is_any_of("\n;"sv));
|
||||
auto pos_after_seps = save_offset();
|
||||
separator_positions.empend(pos_before_seps.offset, pos_after_seps.offset, pos_before_seps.line, pos_after_seps.line);
|
||||
return { move(left), move(separator_positions), ShouldReadMoreSequences::Yes };
|
||||
|
|
@ -394,7 +394,7 @@ RefPtr<AST::Node> Parser::parse_function_decl()
|
|||
arguments.append({ arg_name, { name_offset, m_offset, start_line, line() } });
|
||||
}
|
||||
|
||||
consume_while(is_any_of("\n\t "));
|
||||
consume_while(is_any_of("\n\t "sv));
|
||||
|
||||
{
|
||||
RefPtr<AST::Node> syntax_error;
|
||||
|
|
@ -454,7 +454,7 @@ RefPtr<AST::Node> Parser::parse_or_logical_sequence()
|
|||
|
||||
consume_while(is_whitespace);
|
||||
auto pos_before_or = save_offset();
|
||||
if (!expect("||"))
|
||||
if (!expect("||"sv))
|
||||
return and_sequence;
|
||||
auto pos_after_or = save_offset();
|
||||
|
||||
|
|
@ -478,7 +478,7 @@ RefPtr<AST::Node> Parser::parse_and_logical_sequence()
|
|||
|
||||
consume_while(is_whitespace);
|
||||
auto pos_before_and = save_offset();
|
||||
if (!expect("&&"))
|
||||
if (!expect("&&"sv))
|
||||
return pipe_sequence;
|
||||
auto pos_after_end = save_offset();
|
||||
|
||||
|
|
@ -578,10 +578,10 @@ RefPtr<AST::Node> Parser::parse_continuation_control()
|
|||
|
||||
auto rule_start = push_start();
|
||||
|
||||
if (expect("break")) {
|
||||
if (expect("break"sv)) {
|
||||
{
|
||||
auto break_end = push_start();
|
||||
if (consume_while(is_any_of(" \t\n;")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n;"sv)).is_empty()) {
|
||||
restore_to(*rule_start);
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -590,10 +590,10 @@ RefPtr<AST::Node> Parser::parse_continuation_control()
|
|||
return create<AST::ContinuationControl>(AST::ContinuationControl::Break);
|
||||
}
|
||||
|
||||
if (expect("continue")) {
|
||||
if (expect("continue"sv)) {
|
||||
{
|
||||
auto continue_end = push_start();
|
||||
if (consume_while(is_any_of(" \t\n;")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n;"sv)).is_empty()) {
|
||||
restore_to(*rule_start);
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -608,10 +608,10 @@ RefPtr<AST::Node> Parser::parse_continuation_control()
|
|||
RefPtr<AST::Node> Parser::parse_for_loop()
|
||||
{
|
||||
auto rule_start = push_start();
|
||||
if (!expect("for"))
|
||||
if (!expect("for"sv))
|
||||
return nullptr;
|
||||
|
||||
if (consume_while(is_any_of(" \t\n")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n"sv)).is_empty()) {
|
||||
restore_to(*rule_start);
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -620,7 +620,7 @@ RefPtr<AST::Node> Parser::parse_for_loop()
|
|||
Optional<AST::Position> in_start_position, index_start_position;
|
||||
|
||||
auto offset_before_index = current_position();
|
||||
if (expect("index")) {
|
||||
if (expect("index"sv)) {
|
||||
auto offset = current_position();
|
||||
if (!consume_while(is_whitespace).is_empty()) {
|
||||
auto offset_before_variable = current_position();
|
||||
|
|
@ -653,7 +653,7 @@ RefPtr<AST::Node> Parser::parse_for_loop()
|
|||
};
|
||||
consume_while(is_whitespace);
|
||||
auto in_error_start = push_start();
|
||||
if (!expect("in")) {
|
||||
if (!expect("in"sv)) {
|
||||
auto syntax_error = create<AST::SyntaxError>("Expected 'in' after a variable name in a 'for' loop", true);
|
||||
return create<AST::ForLoop>(move(variable_name), move(index_variable_name), move(syntax_error), nullptr); // ForLoop Var Iterated Block
|
||||
}
|
||||
|
|
@ -669,7 +669,7 @@ RefPtr<AST::Node> Parser::parse_for_loop()
|
|||
iterated_expression = create<AST::SyntaxError>("Expected an expression in 'for' loop", true);
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
{
|
||||
auto obrace_error_start = push_start();
|
||||
if (!expect('{')) {
|
||||
|
|
@ -699,10 +699,10 @@ RefPtr<AST::Node> Parser::parse_for_loop()
|
|||
RefPtr<AST::Node> Parser::parse_loop_loop()
|
||||
{
|
||||
auto rule_start = push_start();
|
||||
if (!expect("loop"))
|
||||
if (!expect("loop"sv))
|
||||
return nullptr;
|
||||
|
||||
if (consume_while(is_any_of(" \t\n")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n"sv)).is_empty()) {
|
||||
restore_to(*rule_start);
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -736,10 +736,10 @@ RefPtr<AST::Node> Parser::parse_loop_loop()
|
|||
RefPtr<AST::Node> Parser::parse_if_expr()
|
||||
{
|
||||
auto rule_start = push_start();
|
||||
if (!expect("if"))
|
||||
if (!expect("if"sv))
|
||||
return nullptr;
|
||||
|
||||
if (consume_while(is_any_of(" \t\n")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n"sv)).is_empty()) {
|
||||
restore_to(*rule_start);
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -779,23 +779,23 @@ RefPtr<AST::Node> Parser::parse_if_expr()
|
|||
return body;
|
||||
};
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
auto true_branch = parse_braced_toplevel();
|
||||
|
||||
auto end_before_else = m_offset;
|
||||
auto line_before_else = line();
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
Optional<AST::Position> else_position;
|
||||
{
|
||||
auto else_start = push_start();
|
||||
if (expect("else"))
|
||||
if (expect("else"sv))
|
||||
else_position = AST::Position { else_start->offset, m_offset, else_start->line, line() };
|
||||
else
|
||||
restore_to(end_before_else, line_before_else);
|
||||
}
|
||||
|
||||
if (else_position.has_value()) {
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
if (peek() == '{') {
|
||||
auto false_branch = parse_braced_toplevel();
|
||||
return create<AST::IfCond>(else_position, condition.release_nonnull(), move(true_branch), move(false_branch)); // If expr true_branch Else false_branch
|
||||
|
|
@ -834,7 +834,7 @@ RefPtr<AST::Node> Parser::parse_subshell()
|
|||
RefPtr<AST::Node> Parser::parse_match_expr()
|
||||
{
|
||||
auto rule_start = push_start();
|
||||
if (!expect("match"))
|
||||
if (!expect("match"sv))
|
||||
return nullptr;
|
||||
|
||||
if (consume_while(is_whitespace).is_empty()) {
|
||||
|
|
@ -849,16 +849,16 @@ RefPtr<AST::Node> Parser::parse_match_expr()
|
|||
String {}, Optional<AST::Position> {}, Vector<AST::MatchEntry> {});
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
String match_name;
|
||||
Optional<AST::Position> as_position;
|
||||
auto as_start = m_offset;
|
||||
auto as_line = line();
|
||||
if (expect("as")) {
|
||||
if (expect("as"sv)) {
|
||||
as_position = AST::Position { as_start, m_offset, as_line, line() };
|
||||
|
||||
if (consume_while(is_any_of(" \t\n")).is_empty()) {
|
||||
if (consume_while(is_any_of(" \t\n"sv)).is_empty()) {
|
||||
auto node = create<AST::MatchExpr>(
|
||||
match_expression.release_nonnull(),
|
||||
String {}, move(as_position), Vector<AST::MatchEntry> {});
|
||||
|
|
@ -876,7 +876,7 @@ RefPtr<AST::Node> Parser::parse_match_expr()
|
|||
}
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
if (!expect('{')) {
|
||||
auto node = create<AST::MatchExpr>(
|
||||
|
|
@ -886,19 +886,19 @@ RefPtr<AST::Node> Parser::parse_match_expr()
|
|||
return node;
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
Vector<AST::MatchEntry> entries;
|
||||
for (;;) {
|
||||
auto entry = parse_match_entry();
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
if (entry.options.visit([](auto& x) { return x.is_empty(); }))
|
||||
break;
|
||||
|
||||
entries.append(move(entry));
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
if (!expect('}')) {
|
||||
auto node = create<AST::MatchExpr>(
|
||||
|
|
@ -925,7 +925,7 @@ AST::MatchEntry Parser::parse_match_entry()
|
|||
Glob,
|
||||
} pattern_kind;
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
auto regex_pattern = parse_regex_pattern();
|
||||
if (regex_pattern.has_value()) {
|
||||
|
|
@ -943,14 +943,14 @@ AST::MatchEntry Parser::parse_match_entry()
|
|||
patterns.append(glob_pattern.release_nonnull());
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
auto previous_pipe_start_position = m_offset;
|
||||
auto previous_pipe_start_line = line();
|
||||
RefPtr<AST::SyntaxError> error;
|
||||
while (expect('|')) {
|
||||
pipe_positions.append({ previous_pipe_start_position, m_offset, previous_pipe_start_line, line() });
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
switch (pattern_kind) {
|
||||
case Regex: {
|
||||
auto pattern = parse_regex_pattern();
|
||||
|
|
@ -972,19 +972,19 @@ AST::MatchEntry Parser::parse_match_entry()
|
|||
}
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
previous_pipe_start_line = line();
|
||||
previous_pipe_start_position = m_offset;
|
||||
}
|
||||
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
|
||||
auto as_start_position = m_offset;
|
||||
auto as_start_line = line();
|
||||
if (pattern_kind == Glob && expect("as")) {
|
||||
if (pattern_kind == Glob && expect("as"sv)) {
|
||||
match_as_position = AST::Position { as_start_position, m_offset, as_start_line, line() };
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
if (!expect('(')) {
|
||||
if (!error)
|
||||
error = create<AST::SyntaxError>("Expected an explicit list of identifiers after a pattern 'as'");
|
||||
|
|
@ -1003,7 +1003,7 @@ AST::MatchEntry Parser::parse_match_entry()
|
|||
error = create<AST::SyntaxError>("Expected a close paren ')' to end the identifier list of pattern 'as'", true);
|
||||
}
|
||||
}
|
||||
consume_while(is_any_of(" \t\n"));
|
||||
consume_while(is_any_of(" \t\n"sv));
|
||||
}
|
||||
|
||||
if (pattern_kind == Regex) {
|
||||
|
|
@ -1064,7 +1064,7 @@ Optional<Regex<ECMA262>> Parser::parse_regex_pattern()
|
|||
auto rule_start = push_start();
|
||||
|
||||
auto start = m_offset;
|
||||
if (!expect("(?:") && !expect("(?<"))
|
||||
if (!expect("(?:"sv) && !expect("(?<"sv))
|
||||
return {};
|
||||
|
||||
size_t open_parens = 1;
|
||||
|
|
@ -1072,9 +1072,9 @@ Optional<Regex<ECMA262>> Parser::parse_regex_pattern()
|
|||
if (at_end())
|
||||
break;
|
||||
|
||||
if (next_is("("))
|
||||
if (next_is("("sv))
|
||||
++open_parens;
|
||||
else if (next_is(")"))
|
||||
else if (next_is(")"sv))
|
||||
--open_parens;
|
||||
consume();
|
||||
}
|
||||
|
|
@ -1094,7 +1094,7 @@ RefPtr<AST::Node> Parser::parse_redirection()
|
|||
auto rule_start = push_start();
|
||||
|
||||
// heredoc entry
|
||||
if (next_is("<<-") || next_is("<<~"))
|
||||
if (next_is("<<-"sv) || next_is("<<~"sv))
|
||||
return nullptr;
|
||||
|
||||
auto pipe_fd = 0;
|
||||
|
|
@ -1229,7 +1229,7 @@ RefPtr<AST::Node> Parser::parse_expression()
|
|||
};
|
||||
|
||||
// Heredocs are expressions, so allow them
|
||||
if (!(next_is("<<-") || next_is("<<~"))) {
|
||||
if (!(next_is("<<-"sv) || next_is("<<~"sv))) {
|
||||
if (strchr("&|)} ;<>\n", starting_char) != nullptr)
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -1237,7 +1237,7 @@ RefPtr<AST::Node> Parser::parse_expression()
|
|||
if (m_extra_chars_not_allowed_in_barewords.contains_slow(starting_char))
|
||||
return nullptr;
|
||||
|
||||
if (m_is_in_brace_expansion_spec && next_is(".."))
|
||||
if (m_is_in_brace_expansion_spec && next_is(".."sv))
|
||||
return nullptr;
|
||||
|
||||
if (isdigit(starting_char)) {
|
||||
|
|
@ -1524,7 +1524,7 @@ RefPtr<AST::Node> Parser::parse_variable_ref()
|
|||
RefPtr<AST::Slice> Parser::parse_slice()
|
||||
{
|
||||
auto rule_start = push_start();
|
||||
if (!next_is("["))
|
||||
if (!next_is("["sv))
|
||||
return nullptr;
|
||||
|
||||
consume(); // [
|
||||
|
|
@ -1865,7 +1865,7 @@ RefPtr<AST::Node> Parser::parse_bareword()
|
|||
continue;
|
||||
}
|
||||
|
||||
if (m_is_in_brace_expansion_spec && next_is("..")) {
|
||||
if (m_is_in_brace_expansion_spec && next_is(".."sv)) {
|
||||
// Don't eat '..' in a brace expansion spec.
|
||||
break;
|
||||
}
|
||||
|
|
@ -1922,7 +1922,7 @@ RefPtr<AST::Node> Parser::parse_bareword()
|
|||
return create<AST::Juxtaposition>(tilde.release_nonnull(), text.release_nonnull()); // Juxtaposition Variable Bareword
|
||||
}
|
||||
|
||||
if (string.starts_with("\\~")) {
|
||||
if (string.starts_with("\\~"sv)) {
|
||||
// Un-escape the tilde, but only at the start (where it would be an expansion)
|
||||
string = string.substring(1, string.length() - 1);
|
||||
}
|
||||
|
|
@ -2010,13 +2010,13 @@ RefPtr<AST::Node> Parser::parse_brace_expansion_spec()
|
|||
auto rule_start = push_start();
|
||||
NonnullRefPtrVector<AST::Node> subexpressions;
|
||||
|
||||
if (next_is(",")) {
|
||||
if (next_is(","sv)) {
|
||||
// Note that we don't consume the ',' here.
|
||||
subexpressions.append(create<AST::StringLiteral>("", AST::StringLiteral::EnclosureType::None));
|
||||
} else {
|
||||
auto start_expr = parse_expression();
|
||||
if (start_expr) {
|
||||
if (expect("..")) {
|
||||
if (expect(".."sv)) {
|
||||
if (auto end_expr = parse_expression()) {
|
||||
if (end_expr->position().start_offset != start_expr->position().end_offset + 2)
|
||||
end_expr->set_is_syntax_error(create<AST::SyntaxError>("Expected no whitespace between '..' and the following expression in brace expansion"));
|
||||
|
|
@ -2049,7 +2049,7 @@ RefPtr<AST::Node> Parser::parse_brace_expansion_spec()
|
|||
|
||||
RefPtr<AST::Node> Parser::parse_heredoc_initiation_record()
|
||||
{
|
||||
if (!next_is("<<"))
|
||||
if (!next_is("<<"sv))
|
||||
return nullptr;
|
||||
|
||||
auto rule_start = push_start();
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ String Shell::prompt() const
|
|||
break;
|
||||
switch (*ptr) {
|
||||
case 'X':
|
||||
builder.append("\033]0;");
|
||||
builder.append("\033]0;"sv);
|
||||
break;
|
||||
case 'a':
|
||||
builder.append(0x07);
|
||||
|
|
@ -208,7 +208,7 @@ Vector<String> Shell::expand_globs(StringView path, StringView base)
|
|||
{
|
||||
auto explicitly_set_base = false;
|
||||
if (path.starts_with('/')) {
|
||||
base = "/";
|
||||
base = "/"sv;
|
||||
explicitly_set_base = true;
|
||||
}
|
||||
auto parts = split_path(path);
|
||||
|
|
@ -367,7 +367,7 @@ RefPtr<AST::Value> Shell::get_argument(size_t index) const
|
|||
return adopt_ref(*new AST::StringValue(current_script));
|
||||
|
||||
--index;
|
||||
if (auto argv = lookup_local_variable("ARGV")) {
|
||||
if (auto argv = lookup_local_variable("ARGV"sv)) {
|
||||
if (argv->is_list_without_resolution()) {
|
||||
AST::ListValue* list = static_cast<AST::ListValue*>(argv.ptr());
|
||||
if (list->values().size() <= index)
|
||||
|
|
@ -887,7 +887,7 @@ void Shell::execute_process(Vector<char const*>&& argv)
|
|||
|
||||
int rc = execvp(argv[0], const_cast<char* const*>(argv.data()));
|
||||
if (rc < 0) {
|
||||
auto parts = StringView { argv[0] }.split_view('/');
|
||||
auto parts = StringView { argv[0], strlen(argv[0]) }.split_view('/');
|
||||
if (parts.size() == 1) {
|
||||
// If this is a path in the current directory and it caused execvp() to fail,
|
||||
// simply don't attempt to execute it, see #6774.
|
||||
|
|
@ -913,10 +913,10 @@ void Shell::execute_process(Vector<char const*>&& argv)
|
|||
break;
|
||||
auto& file = file_result.value();
|
||||
auto line = file->read_line();
|
||||
if (!line.starts_with("#!"))
|
||||
if (!line.starts_with("#!"sv))
|
||||
break;
|
||||
GenericLexer shebang_lexer { line.substring_view(2) };
|
||||
auto shebang = shebang_lexer.consume_until(is_any_of("\n\r")).to_string();
|
||||
auto shebang = shebang_lexer.consume_until(is_any_of("\n\r"sv)).to_string();
|
||||
argv.prepend(shebang.characters());
|
||||
int rc = execvp(argv[0], const_cast<char* const*>(argv.data()));
|
||||
if (rc < 0) {
|
||||
|
|
@ -1139,27 +1139,27 @@ String Shell::escape_token_for_single_quotes(StringView token)
|
|||
// `foo bar \n '` -> `'foo bar \n '"'"`
|
||||
|
||||
StringBuilder builder;
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
auto started_single_quote = true;
|
||||
|
||||
for (auto c : token) {
|
||||
switch (c) {
|
||||
case '\'':
|
||||
builder.append("\"'\"");
|
||||
builder.append("\"'\""sv);
|
||||
started_single_quote = false;
|
||||
continue;
|
||||
default:
|
||||
builder.append(c);
|
||||
if (!started_single_quote) {
|
||||
started_single_quote = true;
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (started_single_quote)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
|
||||
return builder.build();
|
||||
}
|
||||
|
|
@ -1174,10 +1174,10 @@ String Shell::escape_token_for_double_quotes(StringView token)
|
|||
for (auto c : token) {
|
||||
switch (c) {
|
||||
case '\"':
|
||||
builder.append("\\\"");
|
||||
builder.append("\\\""sv);
|
||||
continue;
|
||||
case '\\':
|
||||
builder.append("\\\\");
|
||||
builder.append("\\\\"sv);
|
||||
continue;
|
||||
default:
|
||||
builder.append(c);
|
||||
|
|
@ -1244,40 +1244,40 @@ static String do_escape(Shell::EscapeMode escape_mode, auto& token)
|
|||
break;
|
||||
case Shell::SpecialCharacterEscapeMode::Escaped:
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
builder.append('\\');
|
||||
builder.append(c);
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
break;
|
||||
case Shell::SpecialCharacterEscapeMode::QuotedAsEscape:
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
if (escape_mode != Shell::EscapeMode::DoubleQuotedString)
|
||||
builder.append("\"");
|
||||
builder.append("\""sv);
|
||||
switch (c) {
|
||||
case '\n':
|
||||
builder.append(R"(\n)");
|
||||
builder.append(R"(\n)"sv);
|
||||
break;
|
||||
case '\t':
|
||||
builder.append(R"(\t)");
|
||||
builder.append(R"(\t)"sv);
|
||||
break;
|
||||
case '\r':
|
||||
builder.append(R"(\r)");
|
||||
builder.append(R"(\r)"sv);
|
||||
break;
|
||||
default:
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
if (escape_mode != Shell::EscapeMode::DoubleQuotedString)
|
||||
builder.append("\"");
|
||||
builder.append("\""sv);
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
break;
|
||||
case Shell::SpecialCharacterEscapeMode::QuotedAsHex:
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
if (escape_mode != Shell::EscapeMode::DoubleQuotedString)
|
||||
builder.append("\"");
|
||||
builder.append("\""sv);
|
||||
|
||||
if (c <= NumericLimits<u8>::max())
|
||||
builder.appendff(R"(\x{:0>2x})", static_cast<u8>(c));
|
||||
|
|
@ -1285,9 +1285,9 @@ static String do_escape(Shell::EscapeMode escape_mode, auto& token)
|
|||
builder.appendff(R"(\u{:0>8x})", static_cast<u32>(c));
|
||||
|
||||
if (escape_mode != Shell::EscapeMode::DoubleQuotedString)
|
||||
builder.append("\"");
|
||||
builder.append("\""sv);
|
||||
if (escape_mode == Shell::EscapeMode::SingleQuotedString)
|
||||
builder.append("'");
|
||||
builder.append("'"sv);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1460,7 +1460,7 @@ Vector<Line::CompletionSuggestion> Shell::complete(StringView line)
|
|||
|
||||
Vector<Line::CompletionSuggestion> Shell::complete_path(StringView base, StringView part, size_t offset, ExecutableOnly executable_only, AST::Node const* command_node, AST::Node const* node, EscapeMode escape_mode)
|
||||
{
|
||||
auto token = offset ? part.substring_view(0, offset) : "";
|
||||
auto token = offset ? part.substring_view(0, offset) : ""sv;
|
||||
String path;
|
||||
|
||||
ssize_t last_slash = token.length() - 1;
|
||||
|
|
@ -1526,11 +1526,11 @@ Vector<Line::CompletionSuggestion> Shell::complete_path(StringView base, StringV
|
|||
int stat_error = stat(file_path.characters(), &program_status);
|
||||
if (!stat_error && (executable_only == ExecutableOnly::No || access(file_path.characters(), X_OK) == 0)) {
|
||||
if (S_ISDIR(program_status.st_mode)) {
|
||||
suggestions.append({ escape_token(file, escape_mode), "/" });
|
||||
suggestions.append({ escape_token(file, escape_mode), "/"sv });
|
||||
} else {
|
||||
if (!allow_direct_children && !file.contains("/"))
|
||||
if (!allow_direct_children && !file.contains('/'))
|
||||
continue;
|
||||
suggestions.append({ escape_token(file, escape_mode), " " });
|
||||
suggestions.append({ escape_token(file, escape_mode), " "sv });
|
||||
}
|
||||
suggestions.last().input_offset = token_length;
|
||||
suggestions.last().invariant_offset = invariant_offset;
|
||||
|
|
@ -1556,7 +1556,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_program_name(StringView name,
|
|||
});
|
||||
|
||||
if (!match)
|
||||
return complete_path("", name, offset, ExecutableOnly::Yes, nullptr, nullptr, escape_mode);
|
||||
return complete_path(""sv, name, offset, ExecutableOnly::Yes, nullptr, nullptr, escape_mode);
|
||||
|
||||
String completion = match->path;
|
||||
auto token_length = escape_token(name, escape_mode).length();
|
||||
|
|
@ -1573,10 +1573,10 @@ Vector<Line::CompletionSuggestion> Shell::complete_program_name(StringView name,
|
|||
|
||||
int index = match - cached_path.data();
|
||||
for (int i = index - 1; i >= 0 && cached_path[i].path.starts_with(name); --i)
|
||||
suggestions.append({ cached_path[i].path, " " });
|
||||
suggestions.append({ cached_path[i].path, " "sv });
|
||||
for (size_t i = index + 1; i < cached_path.size() && cached_path[i].path.starts_with(name); ++i)
|
||||
suggestions.append({ cached_path[i].path, " " });
|
||||
suggestions.append({ cached_path[index].path, " " });
|
||||
suggestions.append({ cached_path[i].path, " "sv });
|
||||
suggestions.append({ cached_path[index].path, " "sv });
|
||||
|
||||
for (auto& entry : suggestions) {
|
||||
entry.input_offset = token_length;
|
||||
|
|
@ -1590,7 +1590,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_program_name(StringView name,
|
|||
Vector<Line::CompletionSuggestion> Shell::complete_variable(StringView name, size_t offset)
|
||||
{
|
||||
Vector<Line::CompletionSuggestion> suggestions;
|
||||
auto pattern = offset ? name.substring_view(0, offset) : "";
|
||||
auto pattern = offset ? name.substring_view(0, offset) : ""sv;
|
||||
|
||||
auto invariant_offset = offset;
|
||||
size_t static_offset = 0;
|
||||
|
|
@ -1631,7 +1631,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_variable(StringView name, siz
|
|||
Vector<Line::CompletionSuggestion> Shell::complete_user(StringView name, size_t offset)
|
||||
{
|
||||
Vector<Line::CompletionSuggestion> suggestions;
|
||||
auto pattern = offset ? name.substring_view(0, offset) : "";
|
||||
auto pattern = offset ? name.substring_view(0, offset) : ""sv;
|
||||
|
||||
auto invariant_offset = offset;
|
||||
size_t static_offset = 0;
|
||||
|
|
@ -1668,7 +1668,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_option(StringView program_nam
|
|||
size_t start = 0;
|
||||
while (start < option.length() && option[start] == '-' && start < 2)
|
||||
++start;
|
||||
auto option_pattern = offset > start ? option.substring_view(start, offset - start) : "";
|
||||
auto option_pattern = offset > start ? option.substring_view(start, offset - start) : ""sv;
|
||||
auto invariant_offset = offset;
|
||||
size_t static_offset = 0;
|
||||
if (m_editor)
|
||||
|
|
@ -1762,7 +1762,7 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
|
|||
AST::NodeVisitor::visit(node);
|
||||
auto list = pop_list();
|
||||
StringBuilder builder;
|
||||
builder.join("", list);
|
||||
builder.join(""sv, list);
|
||||
this->list().append(builder.build());
|
||||
}
|
||||
|
||||
|
|
@ -1781,7 +1781,7 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
|
|||
AST::NodeVisitor::visit(node);
|
||||
auto list = pop_list();
|
||||
StringBuilder builder;
|
||||
builder.join("", list);
|
||||
builder.join(""sv, list);
|
||||
this->list().append(builder.build());
|
||||
}
|
||||
|
||||
|
|
@ -1898,32 +1898,32 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
|
|||
auto parsed = parsed_result.release_value();
|
||||
if (parsed.is_object()) {
|
||||
auto& object = parsed.as_object();
|
||||
auto kind = object.get("kind").as_string_or("plain");
|
||||
auto kind = object.get("kind"sv).as_string_or("plain");
|
||||
if (kind == "path") {
|
||||
auto base = object.get("base").as_string_or("");
|
||||
auto part = object.get("part").as_string_or("");
|
||||
auto executable_only = object.get("executable_only").to_bool(false) ? ExecutableOnly::Yes : ExecutableOnly::No;
|
||||
auto base = object.get("base"sv).as_string_or("");
|
||||
auto part = object.get("part"sv).as_string_or("");
|
||||
auto executable_only = object.get("executable_only"sv).to_bool(false) ? ExecutableOnly::Yes : ExecutableOnly::No;
|
||||
suggestions.extend(complete_path(base, part, part.length(), executable_only, nullptr, nullptr));
|
||||
} else if (kind == "program") {
|
||||
auto name = object.get("name").as_string_or("");
|
||||
auto name = object.get("name"sv).as_string_or("");
|
||||
suggestions.extend(complete_program_name(name, name.length()));
|
||||
} else if (kind == "proxy") {
|
||||
if (m_completion_stack_info.size_free() < 4 * KiB) {
|
||||
dbgln("Not enough stack space, recursion?");
|
||||
return IterationDecision::Continue;
|
||||
}
|
||||
auto argv = object.get("argv").as_string_or("");
|
||||
auto argv = object.get("argv"sv).as_string_or("");
|
||||
dbgln("Proxy completion for {}", argv);
|
||||
suggestions.extend(complete(argv));
|
||||
} else if (kind == "plain") {
|
||||
Line::CompletionSuggestion suggestion {
|
||||
object.get("completion").as_string_or(""),
|
||||
object.get("trailing_trivia").as_string_or(""),
|
||||
object.get("display_trivia").as_string_or(""),
|
||||
object.get("completion"sv).as_string_or(""),
|
||||
object.get("trailing_trivia"sv).as_string_or(""),
|
||||
object.get("display_trivia"sv).as_string_or(""),
|
||||
};
|
||||
suggestion.static_offset = object.get("static_offset").to_u64(0);
|
||||
suggestion.invariant_offset = object.get("invariant_offset").to_u64(0);
|
||||
suggestion.allow_commit_without_listing = object.get("allow_commit_without_listing").to_bool(true);
|
||||
suggestion.static_offset = object.get("static_offset"sv).to_u64(0);
|
||||
suggestion.invariant_offset = object.get("invariant_offset"sv).to_u64(0);
|
||||
suggestion.allow_commit_without_listing = object.get("allow_commit_without_listing"sv).to_bool(true);
|
||||
suggestions.append(move(suggestion));
|
||||
} else {
|
||||
dbgln("LibLine: Unhandled completion kind: {}", kind);
|
||||
|
|
@ -1957,7 +1957,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_immediate_function_name(Strin
|
|||
|
||||
#define __ENUMERATE_SHELL_IMMEDIATE_FUNCTION(fn_name) \
|
||||
if (auto name_view = #fn_name##sv; name_view.starts_with(name)) \
|
||||
suggestions.append({ name_view, " " });
|
||||
suggestions.append({ name_view, " "sv });
|
||||
|
||||
ENUMERATE_SHELL_IMMEDIATE_FUNCTIONS();
|
||||
|
||||
|
|
@ -2040,7 +2040,7 @@ bool Shell::read_single_line()
|
|||
|
||||
if (is_eof || is_empty) {
|
||||
// Pretend the user tried to execute builtin_exit()
|
||||
auto exit_code = run_command("exit");
|
||||
auto exit_code = run_command("exit"sv);
|
||||
if (exit_code != 0) {
|
||||
// If we didn't end up actually calling exit(), and the command didn't succeed, just pretend it's all okay
|
||||
// unless we can't, then just quit anyway.
|
||||
|
|
@ -2188,8 +2188,8 @@ Shell::Shell()
|
|||
if (path_env_ptr != NULL)
|
||||
path.append({ path_env_ptr, strlen(path_env_ptr) });
|
||||
if (path.length())
|
||||
path.append(":");
|
||||
path.append("/usr/local/sbin:/usr/local/bin:/usr/bin:/bin");
|
||||
path.append(":"sv);
|
||||
path.append("/usr/local/sbin:/usr/local/bin:/usr/bin:/bin"sv);
|
||||
setenv("PATH", path.to_string().characters(), true);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue