RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 10:17:35 +00:00
Code Issues Activity Actions

AK+Everywhere: Rename String to DeprecatedString

Browse source 
We have a new, improved string type coming up in AK (OOM aware, no null
state), and while it's going to use UTF-8, the name UTF8String is a
mouthful - so let's free up the String name by renaming the existing
class.
Making the old one have an annoying name will hopefully also help with
quick adoption :^)
This commit is contained in:
Linus Groh 2022-12-04 18:02:33 +00:00 • committed by Andreas Kling
parent f74251606d
commit 6e19ab2bbc
2006 changed files with 11635 additions and 11636 deletions
Download patch file Download diff file Expand all files Collapse all files

160
Userland/Shell/AST.cpp
View file

@ -6,10 +6,10 @@
#include "AST.h"
#include "Shell.h"
#include <AK/DeprecatedString.h>
#include <AK/MemoryStream.h>
#include <AK/ScopeGuard.h>
#include <AK/ScopedValueRollback.h>
#include <AK/String.h>
#include <AK/StringBuilder.h>
#include <AK/URL.h>
#include <LibCore/EventLoop.h>
@ -108,7 +108,7 @@ namespace Shell::AST {
static inline void print_indented(StringView str, int indent)
{
dbgln("{}{}", String::repeated(' ', indent * 2), str);
dbgln("{}{}", DeprecatedString::repeated(' ', indent * 2), str);
}
static inline Optional<Position> merge_positions(Optional<Position> const& left, Optional<Position> const& right)
@ -154,7 +154,7 @@ static inline Vector<Command> join_commands(Vector<Command> left, Vector<Command
return commands;
}
static String resolve_slices(RefPtr<Shell> shell, String&& input_value, NonnullRefPtrVector<Slice> slices)
static DeprecatedString resolve_slices(RefPtr<Shell> shell, DeprecatedString&& input_value, NonnullRefPtrVector<Slice> slices)
{
if (slices.is_empty())
return move(input_value);
@ -177,7 +177,7 @@ static String resolve_slices(RefPtr<Shell> shell, String&& input_value, NonnullR
for (auto& value : index_values) {
auto maybe_index = value.to_int();
if (!maybe_index.has_value()) {
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, String::formatted("Invalid value in slice index {}: {} (expected a number)", i, value), slice.position());
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Invalid value in slice index {}: {} (expected a number)", i, value), slice.position());
return move(input_value);
}
++i;
@ -188,7 +188,7 @@ static String resolve_slices(RefPtr<Shell> shell, String&& input_value, NonnullR
index += input_value.length();
if (index < 0 || (size_t)index >= input_value.length()) {
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, String::formatted("Slice index {} (evaluated as {}) out of value bounds [0-{})", index, original_index, input_value.length()), slice.position());
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Slice index {} (evaluated as {}) out of value bounds [0-{})", index, original_index, input_value.length()), slice.position());
return move(input_value);
}
indices.unchecked_append(index);
@ -204,7 +204,7 @@ static String resolve_slices(RefPtr<Shell> shell, String&& input_value, NonnullR
return move(input_value);
}
static Vector<String> resolve_slices(RefPtr<Shell> shell, Vector<String>&& values, NonnullRefPtrVector<Slice> slices)
static Vector<DeprecatedString> resolve_slices(RefPtr<Shell> shell, Vector<DeprecatedString>&& values, NonnullRefPtrVector<Slice> slices)
{
if (slices.is_empty())
return move(values);
@ -227,7 +227,7 @@ static Vector<String> resolve_slices(RefPtr<Shell> shell, Vector<String>&& value
for (auto& value : index_values) {
auto maybe_index = value.to_int();
if (!maybe_index.has_value()) {
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, String::formatted("Invalid value in slice index {}: {} (expected a number)", i, value), slice.position());
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Invalid value in slice index {}: {} (expected a number)", i, value), slice.position());
return move(values);
}
++i;
@ -238,13 +238,13 @@ static Vector<String> resolve_slices(RefPtr<Shell> shell, Vector<String>&& value
index += values.size();
if (index < 0 || (size_t)index >= values.size()) {
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, String::formatted("Slice index {} (evaluated as {}) out of value bounds [0-{})", index, original_index, values.size()), slice.position());
shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Slice index {} (evaluated as {}) out of value bounds [0-{})", index, original_index, values.size()), slice.position());
return move(values);
}
indices.unchecked_append(index);
}
Vector<String> result;
Vector<DeprecatedString> result;
result.ensure_capacity(indices.size());
for (auto& index : indices)
result.unchecked_append(values[index]);
@ -315,7 +315,7 @@ Vector<Command> Node::to_lazy_evaluated_commands(RefPtr<Shell> shell)
void Node::dump(int level) const
{
print_indented(String::formatted("{} at {}:{} (from {}.{} to {}.{})",
print_indented(DeprecatedString::formatted("{} at {}:{} (from {}.{} to {}.{})",
class_name().characters(),
m_position.start_offset,
m_position.end_offset,
@ -380,7 +380,7 @@ Vector<Line::CompletionSuggestion> Node::complete_for_editor(Shell& shell, size_
if (!program_name_node)
return {};
String program_name;
DeprecatedString program_name;
if (program_name_node->is_bareword())
program_name = static_cast<BarewordLiteral*>(program_name_node.ptr())->text();
else
@ -666,7 +666,7 @@ void BarewordLiteral::highlight_in_editor(Line::Editor& editor, Shell& shell, Hi
}
}
BarewordLiteral::BarewordLiteral(Position position, String text)
BarewordLiteral::BarewordLiteral(Position position, DeprecatedString text)
: Node(move(position))
, m_text(move(text))
{
@ -857,7 +857,7 @@ CastToList::CastToList(Position position, RefPtr<Node> inner)
void CloseFdRedirection::dump(int level) const
{
Node::dump(level);
print_indented(String::formatted("{} -> Close", m_fd), level);
print_indented(DeprecatedString::formatted("{} -> Close", m_fd), level);
}
RefPtr<Value> CloseFdRedirection::run(RefPtr<Shell>)
@ -887,7 +887,7 @@ CloseFdRedirection::~CloseFdRedirection()
void CommandLiteral::dump(int level) const
{
Node::dump(level);
print_indented(String::formatted("(Generated command literal: {})", m_command), level + 1);
print_indented(DeprecatedString::formatted("(Generated command literal: {})", m_command), level + 1);
}
RefPtr<Value> CommandLiteral::run(RefPtr<Shell>)
@ -921,7 +921,7 @@ void Comment::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadat
editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(150, 150, 150) }); // Light gray
}
Comment::Comment(Position position, String text)
Comment::Comment(Position position, DeprecatedString text)
: Node(move(position))
, m_text(move(text))
{
@ -1048,7 +1048,7 @@ DynamicEvaluate::~DynamicEvaluate()
void Fd2FdRedirection::dump(int level) const
{
Node::dump(level);
print_indented(String::formatted("{} -> {}", m_old_fd, m_new_fd), level);
print_indented(DeprecatedString::formatted("{} -> {}", m_old_fd, m_new_fd), level);
}
RefPtr<Value> Fd2FdRedirection::run(RefPtr<Shell>)
@ -1078,10 +1078,10 @@ Fd2FdRedirection::~Fd2FdRedirection()
void FunctionDeclaration::dump(int level) const
{
Node::dump(level);
print_indented(String::formatted("(name: {})\n", m_name.name), level + 1);
print_indented(DeprecatedString::formatted("(name: {})\n", m_name.name), 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(DeprecatedString::formatted("(name: {})\n", arg.name), level + 2);
print_indented("(body)"sv, level + 1);
if (m_block)
@ -1092,7 +1092,7 @@ void FunctionDeclaration::dump(int level) const
RefPtr<Value> FunctionDeclaration::run(RefPtr<Shell> shell)
{
Vector<String> args;
Vector<DeprecatedString> args;
for (auto& arg : m_arguments)
args.append(arg.name);
@ -1167,9 +1167,9 @@ void ForLoop::dump(int level) const
{
Node::dump(level);
if (m_variable.has_value())
print_indented(String::formatted("iterating with {} in", m_variable->name), level + 1);
print_indented(DeprecatedString::formatted("iterating with {} in", m_variable->name), level + 1);
if (m_index_variable.has_value())
print_indented(String::formatted("with index name {} in", m_index_variable->name), level + 1);
print_indented(DeprecatedString::formatted("with index name {} in", m_index_variable->name), level + 1);
if (m_iterated_expression)
m_iterated_expression->dump(level + 2);
else
@ -1237,11 +1237,11 @@ RefPtr<Value> ForLoop::run(RefPtr<Shell> shell)
RefPtr<Value> block_value;
{
auto frame = shell->push_frame(String::formatted("for ({})", this));
auto frame = shell->push_frame(DeprecatedString::formatted("for ({})", this));
shell->set_local_variable(variable_name, value, true);
if (index_name.has_value())
shell->set_local_variable(index_name.value(), make_ref_counted<AST::StringValue>(String::number(i)), true);
shell->set_local_variable(index_name.value(), make_ref_counted<AST::StringValue>(DeprecatedString::number(i)), true);
++i;
@ -1349,7 +1349,7 @@ void Glob::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata m
editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style));
}
Glob::Glob(Position position, String text)
Glob::Glob(Position position, DeprecatedString text)
: Node(move(position))
, m_text(move(text))
{
@ -1365,7 +1365,7 @@ void Heredoc::dump(int level) const
print_indented("(End Key)"sv, level + 1);
print_indented(m_end, level + 2);
print_indented("(Allows Interpolation)"sv, level + 1);
print_indented(String::formatted("{}", m_allows_interpolation), level + 2);
print_indented(DeprecatedString::formatted("{}", m_allows_interpolation), level + 2);
print_indented("(Contents)"sv, level + 1);
if (m_contents)
m_contents->dump(level + 2);
@ -1422,7 +1422,7 @@ HitTestResult Heredoc::hit_test_position(size_t offset) const
return m_contents->hit_test_position(offset);
}
Heredoc::Heredoc(Position position, String end, bool allow_interpolation, bool deindent)
Heredoc::Heredoc(Position position, DeprecatedString end, bool allow_interpolation, bool deindent)
: Node(move(position))
, m_end(move(end))
, m_allows_interpolation(allow_interpolation)
@ -1452,16 +1452,16 @@ void HistoryEvent::dump(int level) const
print_indented("StartingStringLookup"sv, level + 2);
break;
}
print_indented(String::formatted("{}({})", m_selector.event.index, m_selector.event.text), level + 3);
print_indented(DeprecatedString::formatted("{}({})", m_selector.event.index, m_selector.event.text), level + 3);
print_indented("Word Selector"sv, level + 1);
auto print_word_selector = [&](HistorySelector::WordSelector const& selector) {
switch (selector.kind) {
case HistorySelector::WordSelectorKind::Index:
print_indented(String::formatted("Index {}", selector.selector), level + 3);
print_indented(DeprecatedString::formatted("Index {}", selector.selector), level + 3);
break;
case HistorySelector::WordSelectorKind::Last:
print_indented(String::formatted("Last"), level + 3);
print_indented(DeprecatedString::formatted("Last"), level + 3);
break;
}
};
@ -1500,7 +1500,7 @@ RefPtr<Value> HistoryEvent::run(RefPtr<Shell> shell)
return it_end;
};
// First, resolve the event itself.
String resolved_history;
DeprecatedString resolved_history;
switch (m_selector.event.kind) {
case HistorySelector::EventKind::IndexFromStart:
if (m_selector.event.index >= history.size()) {
@ -1764,7 +1764,7 @@ void Execute::for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(Non
auto entry = entry_result.release_value();
auto rc = stream.read_or_error(entry);
VERIFY(rc);
callback(make_ref_counted<StringValue>(String::copy(entry)));
callback(make_ref_counted<StringValue>(DeprecatedString::copy(entry)));
}
}
@ -2112,9 +2112,9 @@ Join::~Join()
void MatchExpr::dump(int level) const
{
Node::dump(level);
print_indented(String::formatted("(expression: {})", m_expr_name.characters()), level + 1);
print_indented(DeprecatedString::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(DeprecatedString::formatted("(named: {})", m_expr_name.characters()), level + 1);
print_indented("(entries)"sv, level + 1);
for (auto& entry : m_entries) {
StringBuilder builder;
@ -2141,7 +2141,7 @@ void MatchExpr::dump(int level) const
},
[&](Vector<Regex<ECMA262>> const& options) {
for (auto& option : options)
print_indented(String::formatted("(regex: {})", option.pattern_value), level + 3);
print_indented(DeprecatedString::formatted("(regex: {})", option.pattern_value), level + 3);
});
print_indented("(execute)"sv, level + 2);
if (entry.body)
@ -2194,7 +2194,7 @@ RefPtr<Value> MatchExpr::run(RefPtr<Shell> shell)
if constexpr (IsSame<RemoveCVReference<decltype(option)>, Regex<ECMA262>>) {
return option;
} else {
Vector<String> pattern;
Vector<DeprecatedString> pattern;
if (option.is_glob()) {
pattern.append(static_cast<const Glob*>(&option)->text());
} else if (option.is_bareword()) {
@ -2215,14 +2215,14 @@ RefPtr<Value> MatchExpr::run(RefPtr<Shell> shell)
}
};
auto frame = shell->push_frame(String::formatted("match ({})", this));
auto frame = shell->push_frame(DeprecatedString::formatted("match ({})", this));
if (!m_expr_name.is_empty())
shell->set_local_variable(m_expr_name, value, true);
for (auto& entry : m_entries) {
auto result = entry.options.visit([&](auto& options) -> Variant<IterationDecision, RefPtr<Value>> {
for (auto& option : options) {
Vector<String> spans;
Vector<DeprecatedString> spans;
if (list_matches(resolve_pattern(option), spans)) {
if (entry.body) {
if (entry.match_names.has_value()) {
@ -2298,7 +2298,7 @@ HitTestResult MatchExpr::hit_test_position(size_t offset) const
return {};
}
MatchExpr::MatchExpr(Position position, NonnullRefPtr<Node> expr, String name, Optional<Position> as_position, Vector<MatchEntry> entries)
MatchExpr::MatchExpr(Position position, NonnullRefPtr<Node> expr, DeprecatedString name, Optional<Position> as_position, Vector<MatchEntry> entries)
: Node(move(position))
, m_matched_expr(move(expr))
, m_expr_name(move(name))
@ -2495,7 +2495,7 @@ void PathRedirectionNode::highlight_in_editor(Line::Editor& editor, Shell& shell
auto& position = m_path->position();
auto& path = path_text[0];
if (!path.starts_with('/'))
path = String::formatted("{}/{}", shell.cwd, path);
path = DeprecatedString::formatted("{}/{}", shell.cwd, path);
auto url = URL::create_with_file_scheme(path);
url.set_host(shell.hostname);
editor.stylize({ position.start_offset, position.end_offset }, { Line::Style::Hyperlink(url.to_string()) });
@ -2573,16 +2573,16 @@ RefPtr<Value> Range::run(RefPtr<Shell> shell)
auto end = end_int.value();
auto step = start > end ? -1 : 1;
for (int value = start; value != end; value += step)
values.append(make_ref_counted<StringValue>(String::number(value)));
values.append(make_ref_counted<StringValue>(DeprecatedString::number(value)));
// Append the range end too, most shells treat this as inclusive.
values.append(make_ref_counted<StringValue>(String::number(end)));
values.append(make_ref_counted<StringValue>(DeprecatedString::number(end)));
} else {
goto yield_start_end;
}
}
} else {
yield_start_end:;
shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, String::formatted("Cannot interpolate between '{}' and '{}'!", start_str, end_str), position);
shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Cannot interpolate between '{}' and '{}'!", start_str, end_str), position);
// We can't really interpolate between the two, so just yield both.
values.append(make_ref_counted<StringValue>(move(start_str)));
values.append(make_ref_counted<StringValue>(move(end_str)));
@ -2654,7 +2654,7 @@ void ReadRedirection::dump(int level) const
{
Node::dump(level);
m_path->dump(level + 1);
print_indented(String::formatted("To {}", m_fd), level + 1);
print_indented(DeprecatedString::formatted("To {}", m_fd), level + 1);
}
RefPtr<Value> ReadRedirection::run(RefPtr<Shell> shell)
@ -2684,7 +2684,7 @@ void ReadWriteRedirection::dump(int level) const
{
Node::dump(level);
m_path->dump(level + 1);
print_indented(String::formatted("To/From {}", m_fd), level + 1);
print_indented(DeprecatedString::formatted("To/From {}", m_fd), level + 1);
}
RefPtr<Value> ReadWriteRedirection::run(RefPtr<Shell> shell)
@ -2927,7 +2927,7 @@ Vector<Line::CompletionSuggestion> SimpleVariable::complete_for_editor(Shell& sh
return shell.complete_variable(m_name, corrected_offset);
}
SimpleVariable::SimpleVariable(Position position, String name)
SimpleVariable::SimpleVariable(Position position, DeprecatedString name)
: VariableNode(move(position))
, m_name(move(name))
{
@ -2941,7 +2941,7 @@ void SpecialVariable::dump(int level) const
{
Node::dump(level);
print_indented("(Name)"sv, level + 1);
print_indented(String { &m_name, 1 }, level + 1);
print_indented(DeprecatedString { &m_name, 1 }, level + 1);
print_indented("(Slice)"sv, level + 1);
if (m_slice)
m_slice->dump(level + 2);
@ -3023,7 +3023,7 @@ RefPtr<Value> Juxtaposition::run(RefPtr<Shell> shell)
if (left.is_empty() || right.is_empty())
return make_ref_counted<ListValue>({});
Vector<String> result;
Vector<DeprecatedString> result;
result.ensure_capacity(left.size() * right.size());
StringBuilder builder;
@ -3154,7 +3154,7 @@ void StringLiteral::highlight_in_editor(Line::Editor& editor, Shell&, HighlightM
editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style));
}
StringLiteral::StringLiteral(Position position, String text, EnclosureType enclosure_type)
StringLiteral::StringLiteral(Position position, DeprecatedString text, EnclosureType enclosure_type)
: Node(move(position))
, m_text(move(text))
, m_enclosure_type(enclosure_type)
@ -3224,7 +3224,7 @@ void SyntaxError::dump(int level) const
print_indented("(Error text)"sv, level + 1);
print_indented(m_syntax_error_text, level + 2);
print_indented("(Can be recovered from)"sv, level + 1);
print_indented(String::formatted("{}", m_is_continuable), level + 2);
print_indented(DeprecatedString::formatted("{}", m_is_continuable), level + 2);
}
RefPtr<Value> SyntaxError::run(RefPtr<Shell> shell)
@ -3238,7 +3238,7 @@ void SyntaxError::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMet
editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Bold });
}
SyntaxError::SyntaxError(Position position, String error, bool is_continuable)
SyntaxError::SyntaxError(Position position, DeprecatedString error, bool is_continuable)
: Node(move(position))
, m_syntax_error_text(move(error))
, m_is_continuable(is_continuable)
@ -3314,7 +3314,7 @@ Vector<Line::CompletionSuggestion> Tilde::complete_for_editor(Shell& shell, size
return shell.complete_user(m_username, corrected_offset);
}
String Tilde::text() const
DeprecatedString Tilde::text() const
{
StringBuilder builder;
builder.append('~');
@ -3322,7 +3322,7 @@ String Tilde::text() const
return builder.to_string();
}
Tilde::Tilde(Position position, String username)
Tilde::Tilde(Position position, DeprecatedString username)
: Node(move(position))
, m_username(move(username))
{
@ -3336,7 +3336,7 @@ void WriteAppendRedirection::dump(int level) const
{
Node::dump(level);
m_path->dump(level + 1);
print_indented(String::formatted("From {}", m_fd), level + 1);
print_indented(DeprecatedString::formatted("From {}", m_fd), level + 1);
}
RefPtr<Value> WriteAppendRedirection::run(RefPtr<Shell> shell)
@ -3366,7 +3366,7 @@ void WriteRedirection::dump(int level) const
{
Node::dump(level);
m_path->dump(level + 1);
print_indented(String::formatted("From {}", m_fd), level + 1);
print_indented(DeprecatedString::formatted("From {}", m_fd), level + 1);
}
RefPtr<Value> WriteRedirection::run(RefPtr<Shell> shell)
@ -3468,7 +3468,7 @@ Value::~Value()
{
}
String Value::resolve_as_string(RefPtr<Shell> shell)
DeprecatedString Value::resolve_as_string(RefPtr<Shell> shell)
{
if (shell)
shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Conversion to string not allowed");
@ -3482,7 +3482,7 @@ Vector<AST::Command> Value::resolve_as_commands(RefPtr<Shell> shell)
return { command };
}
ListValue::ListValue(Vector<String> values)
ListValue::ListValue(Vector<DeprecatedString> values)
{
if (values.is_empty())
return;
@ -3509,9 +3509,9 @@ ListValue::~ListValue()
{
}
Vector<String> ListValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> ListValue::resolve_as_list(RefPtr<Shell> shell)
{
Vector<String> values;
Vector<DeprecatedString> values;
for (auto& value : m_contained_values)
values.extend(value.resolve_as_list(shell));
@ -3538,7 +3538,7 @@ CommandSequenceValue::~CommandSequenceValue()
{
}
Vector<String> CommandSequenceValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> CommandSequenceValue::resolve_as_list(RefPtr<Shell> shell)
{
shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Unexpected cast of a command sequence to a list");
return {};
@ -3549,7 +3549,7 @@ Vector<Command> CommandSequenceValue::resolve_as_commands(RefPtr<Shell>)
return m_contained_values;
}
Vector<String> CommandValue::resolve_as_list(RefPtr<Shell>)
Vector<DeprecatedString> CommandValue::resolve_as_list(RefPtr<Shell>)
{
return m_command.argv;
}
@ -3567,25 +3567,25 @@ StringValue::~StringValue()
{
}
String StringValue::resolve_as_string(RefPtr<Shell> shell)
DeprecatedString StringValue::resolve_as_string(RefPtr<Shell> shell)
{
if (m_split.is_null())
return m_string;
return Value::resolve_as_string(shell);
}
Vector<String> StringValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> StringValue::resolve_as_list(RefPtr<Shell> shell)
{
if (is_list()) {
auto parts = StringView(m_string).split_view(m_split, m_keep_empty ? SplitBehavior::KeepEmpty : SplitBehavior::Nothing);
Vector<String> result;
Vector<DeprecatedString> result;
result.ensure_capacity(parts.size());
for (auto& part : parts)
result.append(part);
return resolve_slices(shell, move(result), m_slices);
}
return { resolve_slices(shell, String { m_string }, m_slices) };
return { resolve_slices(shell, DeprecatedString { m_string }, m_slices) };
}
NonnullRefPtr<Value> StringValue::resolve_without_cast(RefPtr<Shell> shell)
@ -3599,10 +3599,10 @@ NonnullRefPtr<Value> StringValue::resolve_without_cast(RefPtr<Shell> shell)
GlobValue::~GlobValue()
{
}
Vector<String> GlobValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> GlobValue::resolve_as_list(RefPtr<Shell> shell)
{
if (!shell)
return { resolve_slices(shell, String { m_glob }, m_slices) };
return { resolve_slices(shell, DeprecatedString { m_glob }, m_slices) };
auto results = shell->expand_globs(m_glob, shell->cwd);
if (results.is_empty())
@ -3614,10 +3614,10 @@ SimpleVariableValue::~SimpleVariableValue()
{
}
String SimpleVariableValue::resolve_as_string(RefPtr<Shell> shell)
DeprecatedString SimpleVariableValue::resolve_as_string(RefPtr<Shell> shell)
{
if (!shell)
return resolve_slices(shell, String {}, m_slices);
return resolve_slices(shell, DeprecatedString {}, m_slices);
if (auto value = resolve_without_cast(shell); value != this)
return value->resolve_as_string(shell);
@ -3626,10 +3626,10 @@ String SimpleVariableValue::resolve_as_string(RefPtr<Shell> shell)
return resolve_slices(shell, env_value, m_slices);
}
Vector<String> SimpleVariableValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> SimpleVariableValue::resolve_as_list(RefPtr<Shell> shell)
{
if (!shell)
return resolve_slices(shell, Vector<String> {}, m_slices);
return resolve_slices(shell, Vector<DeprecatedString> {}, m_slices);
if (auto value = resolve_without_cast(shell); value != this)
return value->resolve_as_list(shell);
@ -3638,7 +3638,7 @@ Vector<String> SimpleVariableValue::resolve_as_list(RefPtr<Shell> shell)
if (env_value == nullptr)
return { resolve_slices(shell, "", m_slices) };
return { resolve_slices(shell, String { env_value }, m_slices) };
return { resolve_slices(shell, DeprecatedString { env_value }, m_slices) };
}
NonnullRefPtr<Value> SimpleVariableValue::resolve_without_cast(RefPtr<Shell> shell)
@ -3661,7 +3661,7 @@ SpecialVariableValue::~SpecialVariableValue()
{
}
String SpecialVariableValue::resolve_as_string(RefPtr<Shell> shell)
DeprecatedString SpecialVariableValue::resolve_as_string(RefPtr<Shell> shell)
{
if (!shell)
return {};
@ -3676,25 +3676,25 @@ String SpecialVariableValue::resolve_as_string(RefPtr<Shell> shell)
return Value::resolve_as_string(shell);
}
Vector<String> SpecialVariableValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> SpecialVariableValue::resolve_as_list(RefPtr<Shell> shell)
{
if (!shell)
return {};
switch (m_name) {
case '?':
return { resolve_slices(shell, String::number(shell->last_return_code.value_or(0)), m_slices) };
return { resolve_slices(shell, DeprecatedString::number(shell->last_return_code.value_or(0)), m_slices) };
case '$':
return { resolve_slices(shell, String::number(getpid()), m_slices) };
return { resolve_slices(shell, DeprecatedString::number(getpid()), m_slices) };
case '*':
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);
return resolve_slices(shell, Vector<DeprecatedString> {}, m_slices);
case '#':
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) };
return { resolve_slices(shell, DeprecatedString::number(list_argv->values().size()), m_slices) };
}
return { resolve_slices(shell, "1", m_slices) };
}
@ -3716,12 +3716,12 @@ TildeValue::~TildeValue()
{
}
String TildeValue::resolve_as_string(RefPtr<Shell> shell)
DeprecatedString TildeValue::resolve_as_string(RefPtr<Shell> shell)
{
return resolve_as_list(shell).first();
}
Vector<String> TildeValue::resolve_as_list(RefPtr<Shell> shell)
Vector<DeprecatedString> TildeValue::resolve_as_list(RefPtr<Shell> shell)
{
StringBuilder builder;
builder.append('~');
@ -3744,7 +3744,7 @@ CloseRedirection::~CloseRedirection()
ErrorOr<NonnullRefPtr<Rewiring>> PathRedirection::apply() const
{
auto check_fd_and_return = [my_fd = this->fd](int fd, String const& path) -> ErrorOr<NonnullRefPtr<Rewiring>> {
auto check_fd_and_return = [my_fd = this->fd](int fd, DeprecatedString const& path) -> ErrorOr<NonnullRefPtr<Rewiring>> {
if (fd < 0) {
auto error = Error::from_errno(errno);
dbgln("open() failed for '{}' with {}", path, error);

144
Userland/Shell/AST.h
View file

@ -9,11 +9,11 @@
#include "Forward.h"
#include "Job.h"
#include "NodeVisitor.h"
#include <AK/DeprecatedString.h>
#include <AK/Format.h>
#include <AK/NonnullRefPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <LibLine/Editor.h>
@ -50,7 +50,7 @@ struct Position {
};
struct NameWithPosition {
String name;
DeprecatedString name;
Position position;
};
@ -107,7 +107,7 @@ private:
};
struct PathRedirection : public Redirection {
String path;
DeprecatedString path;
int fd { -1 };
enum {
Read,
@ -116,7 +116,7 @@ struct PathRedirection : public Redirection {
ReadWrite,
} direction { Read };
static NonnullRefPtr<PathRedirection> create(String path, int fd, decltype(direction) direction)
static NonnullRefPtr<PathRedirection> create(DeprecatedString path, int fd, decltype(direction) direction)
{
return adopt_ref(*new PathRedirection(move(path), fd, direction));
}
@ -125,7 +125,7 @@ struct PathRedirection : public Redirection {
virtual ~PathRedirection();
private:
PathRedirection(String path, int fd, decltype(direction) direction)
PathRedirection(DeprecatedString path, int fd, decltype(direction) direction)
: path(move(path))
, fd(fd)
, direction(direction)
@ -197,7 +197,7 @@ struct NodeWithAction {
};
struct Command {
Vector<String> argv;
Vector<DeprecatedString> argv;
NonnullRefPtrVector<Redirection> redirections;
bool should_wait { true };
bool is_pipe_source { false };
@ -217,8 +217,8 @@ struct HitTestResult {
class Value : public RefCounted<Value> {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) = 0;
virtual String resolve_as_string(RefPtr<Shell> shell);
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) = 0;
virtual DeprecatedString resolve_as_string(RefPtr<Shell> shell);
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>);
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) { return *this; }
virtual NonnullRefPtr<Value> clone() const = 0;
@ -243,7 +243,7 @@ protected:
class CommandValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<CommandValue>(m_command)->set_slices(m_slices); }
virtual ~CommandValue();
@ -253,7 +253,7 @@ public:
{
}
CommandValue(Vector<String> argv, Position position)
CommandValue(Vector<DeprecatedString> argv, Position position)
: m_command({ move(argv), {}, true, false, true, false, nullptr, {}, move(position) })
{
}
@ -264,7 +264,7 @@ private:
class CommandSequenceValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<CommandSequenceValue>(m_contained_values)->set_slices(m_slices); }
virtual ~CommandSequenceValue();
@ -280,8 +280,8 @@ private:
class JobValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override { VERIFY_NOT_REACHED(); }
virtual String resolve_as_string(RefPtr<Shell>) override { return String::formatted("%{}", m_job->job_id()); }
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override { VERIFY_NOT_REACHED(); }
virtual DeprecatedString resolve_as_string(RefPtr<Shell>) override { return DeprecatedString::formatted("%{}", m_job->job_id()); }
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override { VERIFY_NOT_REACHED(); }
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<JobValue>(m_job)->set_slices(m_slices); }
virtual ~JobValue();
@ -299,13 +299,13 @@ private:
class ListValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<ListValue>(m_contained_values)->set_slices(m_slices); }
virtual ~ListValue();
virtual bool is_list() const override { return true; }
virtual bool is_list_without_resolution() const override { return true; }
ListValue(Vector<String> values);
ListValue(Vector<DeprecatedString> values);
ListValue(NonnullRefPtrVector<Value> values)
: m_contained_values(move(values))
{
@ -320,14 +320,14 @@ private:
class StringValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual String resolve_as_string(RefPtr<Shell> shell) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual DeprecatedString resolve_as_string(RefPtr<Shell> shell) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<StringValue>(m_string, m_split, m_keep_empty)->set_slices(m_slices); }
virtual ~StringValue();
virtual bool is_string() const override { return m_split.is_null(); }
virtual bool is_list() const override { return !m_split.is_null(); }
NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
StringValue(String string, String split_by = {}, bool keep_empty = false)
StringValue(DeprecatedString string, DeprecatedString split_by = {}, bool keep_empty = false)
: m_string(move(string))
, m_split(move(split_by))
, m_keep_empty(keep_empty)
@ -335,48 +335,48 @@ public:
}
private:
String m_string;
String m_split;
DeprecatedString m_string;
DeprecatedString m_split;
bool m_keep_empty { false };
};
class GlobValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<GlobValue>(m_glob, m_generation_position)->set_slices(m_slices); }
virtual ~GlobValue();
virtual bool is_glob() const override { return true; }
GlobValue(String glob, Position position)
GlobValue(DeprecatedString glob, Position position)
: m_glob(move(glob))
, m_generation_position(move(position))
{
}
private:
String m_glob;
DeprecatedString m_glob;
Position m_generation_position;
};
class SimpleVariableValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual String resolve_as_string(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual DeprecatedString resolve_as_string(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<SimpleVariableValue>(m_name)->set_slices(m_slices); }
virtual ~SimpleVariableValue();
SimpleVariableValue(String name)
SimpleVariableValue(DeprecatedString name)
: m_name(move(name))
{
}
private:
String m_name;
DeprecatedString m_name;
};
class SpecialVariableValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual String resolve_as_string(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual DeprecatedString resolve_as_string(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<SpecialVariableValue>(m_name)->set_slices(m_slices); }
virtual ~SpecialVariableValue();
@ -391,18 +391,18 @@ private:
class TildeValue final : public Value {
public:
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual String resolve_as_string(RefPtr<Shell>) override;
virtual Vector<DeprecatedString> resolve_as_list(RefPtr<Shell>) override;
virtual DeprecatedString resolve_as_string(RefPtr<Shell>) override;
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<TildeValue>(m_username)->set_slices(m_slices); }
virtual ~TildeValue();
virtual bool is_string() const override { return true; }
TildeValue(String name)
TildeValue(DeprecatedString name)
: m_username(move(name))
{
}
private:
String m_username;
DeprecatedString m_username;
};
class Node : public RefCounted<Node> {
@ -422,7 +422,7 @@ public:
return { this, nullptr, nullptr };
return { nullptr, nullptr, nullptr };
}
virtual String class_name() const { return "Node"; }
virtual DeprecatedString class_name() const { return "Node"; }
Node(Position);
virtual ~Node() = default;
@ -509,14 +509,14 @@ protected:
RefPtr<SyntaxError> m_syntax_error_node;
};
#define NODE(name) \
virtual String class_name() const override \
{ \
return #name; \
} \
virtual Kind kind() const override \
{ \
return Kind::name; \
#define NODE(name) \
virtual DeprecatedString class_name() const override \
{ \
return #name; \
} \
virtual Kind kind() const override \
{ \
return Kind::name; \
}
class PathRedirectionNode : public Node {
@ -600,11 +600,11 @@ private:
class BarewordLiteral final : public Node {
public:
BarewordLiteral(Position, String);
BarewordLiteral(Position, DeprecatedString);
virtual ~BarewordLiteral() = default;
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& text() const { return m_text; }
DeprecatedString const& text() const { return m_text; }
private:
NODE(BarewordLiteral);
@ -614,7 +614,7 @@ private:
virtual bool is_bareword() const override { return true; }
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; }
String m_text;
DeprecatedString m_text;
};
class BraceExpansion final : public Node {
@ -717,11 +717,11 @@ private:
class Comment : public Node {
public:
Comment(Position, String);
Comment(Position, DeprecatedString);
virtual ~Comment();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& text() const { return m_text; }
DeprecatedString const& text() const { return m_text; }
private:
NODE(Comment);
@ -729,7 +729,7 @@ private:
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
String m_text;
DeprecatedString m_text;
};
class ContinuationControl final : public Node {
@ -880,11 +880,11 @@ private:
class Glob final : public Node {
public:
Glob(Position, String);
Glob(Position, DeprecatedString);
virtual ~Glob();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& text() const { return m_text; }
DeprecatedString const& text() const { return m_text; }
private:
NODE(Glob);
@ -894,7 +894,7 @@ private:
virtual bool is_glob() const override { return true; }
virtual bool is_list() const override { return true; }
String m_text;
DeprecatedString m_text;
};
struct HistorySelector {
@ -913,7 +913,7 @@ struct HistorySelector {
EventKind kind { IndexFromStart };
size_t index { 0 };
Position text_position;
String text;
DeprecatedString text;
} event;
struct WordSelector {
@ -1014,7 +1014,7 @@ public:
NonnullRefPtrVector<Node> const& arguments() const { return m_arguments; }
auto const& function() const { return m_function; }
String const& function_name() const { return m_function.name; }
DeprecatedString const& function_name() const { return m_function.name; }
Position const& function_position() const { return m_function.position; }
bool has_closing_brace() const { return m_closing_brace_position.has_value(); }
@ -1056,7 +1056,7 @@ private:
struct MatchEntry {
Variant<NonnullRefPtrVector<Node>, Vector<Regex<ECMA262>>> options;
Optional<Vector<String>> match_names;
Optional<Vector<DeprecatedString>> match_names;
Optional<Position> match_as_position;
Vector<Position> pipe_positions;
RefPtr<Node> body;
@ -1064,12 +1064,12 @@ struct MatchEntry {
class MatchExpr final : public Node {
public:
MatchExpr(Position, NonnullRefPtr<Node> expr, String name, Optional<Position> as_position, Vector<MatchEntry> entries);
MatchExpr(Position, NonnullRefPtr<Node> expr, DeprecatedString name, Optional<Position> as_position, Vector<MatchEntry> entries);
virtual ~MatchExpr();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
NonnullRefPtr<Node> const& matched_expr() const { return m_matched_expr; }
String const& expr_name() const { return m_expr_name; }
DeprecatedString const& expr_name() const { return m_expr_name; }
Vector<MatchEntry> const& entries() const { return m_entries; }
Optional<Position> const& as_position() const { return m_as_position; }
@ -1083,7 +1083,7 @@ private:
virtual bool should_override_execution_in_current_process() const override { return true; }
NonnullRefPtr<Node> m_matched_expr;
String m_expr_name;
DeprecatedString m_expr_name;
Optional<Position> m_as_position;
Vector<MatchEntry> m_entries;
};
@ -1262,11 +1262,11 @@ protected:
class SimpleVariable final : public VariableNode {
public:
SimpleVariable(Position, String);
SimpleVariable(Position, DeprecatedString);
virtual ~SimpleVariable();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& name() const { return m_name; }
DeprecatedString const& name() const { return m_name; }
private:
NODE(SimpleVariable);
@ -1277,7 +1277,7 @@ private:
virtual HitTestResult hit_test_position(size_t) const override;
virtual bool is_simple_variable() const override { return true; }
String m_name;
DeprecatedString m_name;
};
class SpecialVariable final : public VariableNode {
@ -1322,11 +1322,11 @@ private:
class Heredoc final : public Node {
public:
Heredoc(Position, String end, bool allow_interpolation, bool deindent);
Heredoc(Position, DeprecatedString end, bool allow_interpolation, bool deindent);
virtual ~Heredoc();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& end() const { return m_end; }
DeprecatedString const& end() const { return m_end; }
bool allow_interpolation() const { return m_allows_interpolation; }
bool deindent() const { return m_deindent; }
RefPtr<AST::Node> const& contents() const { return m_contents; }
@ -1347,7 +1347,7 @@ private:
virtual HitTestResult hit_test_position(size_t) const override;
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; };
String m_end;
DeprecatedString m_end;
bool m_allows_interpolation { false };
bool m_deindent { false };
RefPtr<AST::Node> m_contents;
@ -1361,11 +1361,11 @@ public:
DoubleQuotes,
};
StringLiteral(Position, String, EnclosureType);
StringLiteral(Position, DeprecatedString, EnclosureType);
virtual ~StringLiteral();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& text() const { return m_text; }
DeprecatedString const& text() const { return m_text; }
EnclosureType enclosure_type() const { return m_enclosure_type; }
private:
@ -1375,7 +1375,7 @@ private:
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; };
String m_text;
DeprecatedString m_text;
EnclosureType m_enclosure_type;
};
@ -1401,11 +1401,11 @@ private:
class SyntaxError final : public Node {
public:
SyntaxError(Position, String, bool is_continuable = false);
SyntaxError(Position, DeprecatedString, bool is_continuable = false);
virtual ~SyntaxError();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String const& error_text() const { return m_syntax_error_text; }
DeprecatedString const& error_text() const { return m_syntax_error_text; }
bool is_continuable() const { return m_is_continuable; }
virtual void clear_syntax_error() override
@ -1430,7 +1430,7 @@ private:
virtual HitTestResult hit_test_position(size_t) const override { return { nullptr, nullptr, nullptr }; }
virtual SyntaxError const& syntax_error_node() const override;
String m_syntax_error_text;
DeprecatedString m_syntax_error_text;
bool m_is_continuable { false };
bool m_is_cleared { false };
};
@ -1454,11 +1454,11 @@ private:
class Tilde final : public Node {
public:
Tilde(Position, String);
Tilde(Position, DeprecatedString);
virtual ~Tilde();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
String text() const;
DeprecatedString text() const;
private:
NODE(Tilde);
@ -1469,7 +1469,7 @@ private:
virtual HitTestResult hit_test_position(size_t) const override;
virtual bool is_tilde() const override { return true; }
String m_username;
DeprecatedString m_username;
};
class VariableDeclarations final : public Node {

40
Userland/Shell/Builtin.cpp
View file

@ -7,10 +7,10 @@
#include "AST.h"
#include "Shell.h"
#include "Shell/Formatter.h"
#include <AK/DeprecatedString.h>
#include <AK/LexicalPath.h>
#include <AK/ScopeGuard.h>
#include <AK/Statistics.h>
#include <AK/String.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/EventLoop.h>
#include <LibCore/File.h>
@ -41,7 +41,7 @@ int Shell::builtin_dump(int argc, char const** argv)
int Shell::builtin_alias(int argc, char const** argv)
{
Vector<String> arguments;
Vector<DeprecatedString> arguments;
Core::ArgsParser parser;
parser.add_positional_argument(arguments, "List of name[=values]'s", "name[=value]", Core::ArgsParser::Required::No);
@ -77,7 +77,7 @@ int Shell::builtin_alias(int argc, char const** argv)
int Shell::builtin_unalias(int argc, char const** argv)
{
bool remove_all { false };
Vector<String> arguments;
Vector<DeprecatedString> arguments;
Core::ArgsParser parser;
parser.set_general_help("Remove alias from the list of aliases");
@ -180,7 +180,7 @@ int Shell::builtin_bg(int argc, char const** argv)
int Shell::builtin_type(int argc, char const** argv)
{
Vector<String> commands;
Vector<DeprecatedString> commands;
bool dont_show_function_source = false;
Core::ArgsParser parser;
@ -257,7 +257,7 @@ int Shell::builtin_cd(int argc, char const** argv)
if (!parser.parse(argc, const_cast<char**>(argv), Core::ArgsParser::FailureBehavior::PrintUsage))
return 1;
String new_path;
DeprecatedString new_path;
if (!arg_path) {
new_path = home;
@ -342,7 +342,7 @@ int Shell::builtin_dirs(int argc, char const** argv)
bool number_when_printing = false;
char separator = ' ';
Vector<String> paths;
Vector<DeprecatedString> paths;
Core::ArgsParser parser;
parser.add_option(clear, "Clear the directory stack", "clear", 'c');
@ -426,7 +426,7 @@ int Shell::builtin_exit(int argc, char const** argv)
int Shell::builtin_export(int argc, char const** argv)
{
Vector<String> vars;
Vector<DeprecatedString> vars;
Core::ArgsParser parser;
parser.add_positional_argument(vars, "List of variable[=value]'s", "values", Core::ArgsParser::Required::No);
@ -472,7 +472,7 @@ int Shell::builtin_export(int argc, char const** argv)
int Shell::builtin_glob(int argc, char const** argv)
{
Vector<String> globs;
Vector<DeprecatedString> globs;
Core::ArgsParser parser;
parser.add_positional_argument(globs, "Globs to resolve", "glob");
@ -704,8 +704,8 @@ int Shell::builtin_pushd(int argc, char const** argv)
return 1;
}
String dir1 = directory_stack.take_first();
String dir2 = directory_stack.take_first();
DeprecatedString dir1 = directory_stack.take_first();
DeprecatedString dir2 = directory_stack.take_first();
directory_stack.insert(0, dir2);
directory_stack.insert(1, dir1);
@ -855,7 +855,7 @@ int Shell::builtin_shift(int argc, char const** argv)
int Shell::builtin_source(int argc, char const** argv)
{
char const* file_to_source = nullptr;
Vector<String> args;
Vector<DeprecatedString> args;
Core::ArgsParser parser;
parser.add_positional_argument(file_to_source, "File to read commands from", "path");
@ -919,7 +919,7 @@ int Shell::builtin_time(int argc, char const** argv)
warnln("Timing report: {} ms", iteration_times.sum());
warnln("==============");
warnln("Command: {}", String::join(' ', Span<char const*>(argv, argc)));
warnln("Command: {}", DeprecatedString::join(' ', Span<char const*>(argv, argc)));
warnln("Average time: {:.2} ms (median: {}, stddev: {:.2}, min: {}, max:{})",
iteration_times.average(), iteration_times.median(),
iteration_times.standard_deviation(),
@ -1021,7 +1021,7 @@ int Shell::builtin_wait(int argc, char const** argv)
int Shell::builtin_unset(int argc, char const** argv)
{
Vector<String> vars;
Vector<DeprecatedString> vars;
Core::ArgsParser parser;
parser.add_positional_argument(vars, "List of variables", "variables", Core::ArgsParser::Required::Yes);
@ -1074,7 +1074,7 @@ int Shell::builtin_not(int argc, char const** argv)
int Shell::builtin_kill(int argc, char const** argv)
{
// Simply translate the arguments and pass them to `kill'
Vector<String> replaced_values;
Vector<DeprecatedString> replaced_values;
auto kill_path = Core::File::resolve_executable_from_environment("kill"sv);
if (!kill_path.has_value()) {
warnln("kill: `kill' not found in PATH");
@ -1085,7 +1085,7 @@ int Shell::builtin_kill(int argc, char const** argv)
if (auto job_id = resolve_job_spec({ argv[i], strlen(argv[1]) }); job_id.has_value()) {
auto job = find_job(job_id.value());
if (job) {
replaced_values.append(String::number(job->pid()));
replaced_values.append(DeprecatedString::number(job->pid()));
} else {
warnln("kill: Job with pid {} not found", job_id.value());
return 1;
@ -1177,7 +1177,7 @@ int Shell::builtin_argsparser_parse(int argc, char const** argv)
Vector<char const*> arguments;
Variant<Core::ArgsParser::Option, Core::ArgsParser::Arg, Empty> current;
String current_variable;
DeprecatedString current_variable;
// if max > 1 or min < 1, or explicit `--list`.
bool treat_arg_as_list = false;
enum class Type {
@ -1199,19 +1199,19 @@ int Shell::builtin_argsparser_parse(int argc, char const** argv)
return AST::make_ref_counted<AST::StringValue>(value);
case Type::I32:
if (auto number = value.to_int(); number.has_value())
return AST::make_ref_counted<AST::StringValue>(String::number(*number));
return AST::make_ref_counted<AST::StringValue>(DeprecatedString::number(*number));
warnln("Invalid value for type i32: {}", value);
return {};
case Type::U32:
case Type::Size:
if (auto number = value.to_uint(); number.has_value())
return AST::make_ref_counted<AST::StringValue>(String::number(*number));
return AST::make_ref_counted<AST::StringValue>(DeprecatedString::number(*number));
warnln("Invalid value for type u32|size: {}", value);
return {};
case Type::Double: {
String string = value;
DeprecatedString string = value;
char* endptr = nullptr;
auto number = strtod(string.characters(), &endptr);
if (endptr != string.characters() + string.length()) {
@ -1219,7 +1219,7 @@ int Shell::builtin_argsparser_parse(int argc, char const** argv)
return {};
}
return AST::make_ref_counted<AST::StringValue>(String::number(number));
return AST::make_ref_counted<AST::StringValue>(DeprecatedString::number(number));
}
default:
VERIFY_NOT_REACHED();

2
Userland/Shell/Execution.h
View file

@ -7,9 +7,9 @@
#pragma once
#include "Forward.h"
#include <AK/DeprecatedString.h>
#include <AK/Forward.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/String.h>
#include <AK/Vector.h>
#include <LibCore/ElapsedTimer.h>

6
Userland/Shell/Formatter.cpp
View file

@ -13,14 +13,14 @@
namespace Shell {
String Formatter::format()
DeprecatedString Formatter::format()
{
auto node = m_root_node ? m_root_node : Parser(m_source).parse();
if (m_cursor >= 0)
m_output_cursor = m_cursor;
if (!node)
return String();
return DeprecatedString();
if (node->is_syntax_error())
return m_source;
@ -66,7 +66,7 @@ void Formatter::in_new_block(Function<void()> callback)
current_builder().append('}');
}
String Formatter::in_new_builder(Function<void()> callback, StringBuilder new_builder)
DeprecatedString Formatter::in_new_builder(Function<void()> callback, StringBuilder new_builder)
{
m_builders.append(move(new_builder));
callback();

8
Userland/Shell/Formatter.h
View file

@ -7,8 +7,8 @@
#pragma once
#include "NodeVisitor.h"
#include <AK/DeprecatedString.h>
#include <AK/Forward.h>
#include <AK/String.h>
#include <AK/StringBuilder.h>
#include <AK/StringView.h>
#include <AK/Types.h>
@ -41,7 +41,7 @@ public:
{
}
String format();
DeprecatedString format();
size_t cursor() const { return m_output_cursor; }
private:
@ -97,7 +97,7 @@ private:
ALWAYS_INLINE void with_added_indent(int indent, Function<void()>);
ALWAYS_INLINE void in_new_block(Function<void()>);
ALWAYS_INLINE String in_new_builder(Function<void()>, StringBuilder new_builder = StringBuilder {});
ALWAYS_INLINE DeprecatedString in_new_builder(Function<void()>, StringBuilder new_builder = StringBuilder {});
StringBuilder& current_builder() { return m_builders.last(); }
@ -123,7 +123,7 @@ private:
const AST::Node* m_last_visited_node { nullptr };
StringView m_trivia;
Vector<String> m_heredocs_to_append_after_sequence;
Vector<DeprecatedString> m_heredocs_to_append_after_sequence;
};
}

18
Userland/Shell/ImmediateFunctions.cpp
View file

@ -14,7 +14,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
{
auto name = across ? "length_across" : "length";
if (arguments.size() < 1 || arguments.size() > 2) {
raise_error(ShellError::EvaluatedSyntaxError, String::formatted("Expected one or two arguments to `{}'", name), invoking_node.position());
raise_error(ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Expected one or two arguments to `{}'", name), invoking_node.position());
return nullptr;
}
@ -33,7 +33,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
auto& mode_arg = arguments.first();
if (!mode_arg.is_bareword()) {
raise_error(ShellError::EvaluatedSyntaxError, String::formatted("Expected a bareword (either 'string' or 'list') in the two-argument form of the `{}' immediate", name), mode_arg.position());
raise_error(ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Expected a bareword (either 'string' or 'list') in the two-argument form of the `{}' immediate", name), mode_arg.position());
return nullptr;
}
@ -45,7 +45,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
} else if (mode_name == "infer") {
mode = Infer;
} else {
raise_error(ShellError::EvaluatedSyntaxError, String::formatted("Expected either 'string' or 'list' (and not {}) in the two-argument form of the `{}' immediate", mode_name, name), mode_arg.position());
raise_error(ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Expected either 'string' or 'list' (and not {}) in the two-argument form of the `{}' immediate", mode_name, name), mode_arg.position());
return nullptr;
}
@ -67,7 +67,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
}
auto value_with_number = [&](auto number) -> NonnullRefPtr<AST::Node> {
return AST::make_ref_counted<AST::BarewordLiteral>(invoking_node.position(), String::number(number));
return AST::make_ref_counted<AST::BarewordLiteral>(invoking_node.position(), DeprecatedString::number(number));
};
auto do_across = [&](StringView mode_name, auto& values) {
@ -126,7 +126,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
if (is_inferred) {
raise_error(ShellError::EvaluatedSyntaxError,
String::formatted("Could not infer expression type, please explicitly use `{0} string' or `{0} list'", name),
DeprecatedString::formatted("Could not infer expression type, please explicitly use `{0} string' or `{0} list'", name),
invoking_node.position());
return nullptr;
}
@ -135,7 +135,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
raise_error(ShellError::EvaluatedSyntaxError,
source.is_empty()
? "Invalid application of `length' to a list"
: String::formatted("Invalid application of `length' to a list\nperhaps you meant `{1}length \"{0}\"{2}' or `{1}length_across {0}{2}'?", source, "\x1b[32m", "\x1b[0m"),
: DeprecatedString::formatted("Invalid application of `length' to a list\nperhaps you meant `{1}length \"{0}\"{2}' or `{1}length_across {0}{2}'?", source, "\x1b[32m", "\x1b[0m"),
expr_node->position());
return nullptr;
}
@ -159,7 +159,7 @@ RefPtr<AST::Node> Shell::immediate_length_impl(AST::ImmediateExpression& invokin
auto source = formatter.format();
raise_error(ShellError::EvaluatedSyntaxError,
String::formatted("Invalid application of `length_across' to a non-list\nperhaps you meant `{1}length {0}{2}'?", source, "\x1b[32m", "\x1b[0m"),
DeprecatedString::formatted("Invalid application of `length_across' to a non-list\nperhaps you meant `{1}length {0}{2}'?", source, "\x1b[32m", "\x1b[0m"),
expr_node->position());
return nullptr;
}
@ -340,7 +340,7 @@ RefPtr<AST::Node> Shell::immediate_split(AST::ImmediateExpression& invoking_node
return AST::make_ref_counted<AST::ListConcatenate>(invoking_node.position(), NonnullRefPtrVector<AST::Node> {});
auto& value = list.first();
Vector<String> split_strings;
Vector<DeprecatedString> split_strings;
if (delimiter_str.is_empty()) {
StringBuilder builder;
for (auto code_point : Utf8View { value }) {
@ -462,7 +462,7 @@ RefPtr<AST::Node> Shell::run_immediate_function(StringView str, AST::ImmediateEx
ENUMERATE_SHELL_IMMEDIATE_FUNCTIONS()
#undef __ENUMERATE_SHELL_IMMEDIATE_FUNCTION
raise_error(ShellError::EvaluatedSyntaxError, String::formatted("Unknown immediate function {}", str), invoking_node.position());
raise_error(ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Unknown immediate function {}", str), invoking_node.position());
return nullptr;
}

2
Userland/Shell/Job.cpp
View file

@ -63,7 +63,7 @@ bool Job::print_status(PrintStatusMode mode)
return true;
}
Job::Job(pid_t pid, unsigned pgid, String cmd, u64 job_id, AST::Command&& command)
Job::Job(pid_t pid, unsigned pgid, DeprecatedString cmd, u64 job_id, AST::Command&& command)
: m_pgid(pgid)
, m_pid(pid)
, m_job_id(job_id)

10
Userland/Shell/Job.h
View file

@ -9,11 +9,11 @@
#include "Execution.h"
#include "Forward.h"
#include <AK/Debug.h>
#include <AK/DeprecatedString.h>
#include <AK/Function.h>
#include <AK/JsonObject.h>
#include <AK/JsonValue.h>
#include <AK/OwnPtr.h>
#include <AK/String.h>
#include <LibCore/ElapsedTimer.h>
#include <LibCore/Object.h>
@ -23,7 +23,7 @@ struct LocalFrame;
class Job : public RefCounted<Job> {
public:
static NonnullRefPtr<Job> create(pid_t pid, pid_t pgid, String cmd, u64 job_id, AST::Command&& command) { return adopt_ref(*new Job(pid, pgid, move(cmd), job_id, move(command))); }
static NonnullRefPtr<Job> create(pid_t pid, pid_t pgid, DeprecatedString cmd, u64 job_id, AST::Command&& command) { return adopt_ref(*new Job(pid, pgid, move(cmd), job_id, move(command))); }
~Job()
{
@ -40,7 +40,7 @@ public:
pid_t pgid() const { return m_pgid; }
pid_t pid() const { return m_pid; }
String const& cmd() const { return m_cmd; }
DeprecatedString const& cmd() const { return m_cmd; }
const AST::Command& command() const { return *m_command; }
AST::Command* command_ptr() { return m_command; }
u64 job_id() const { return m_job_id; }
@ -92,12 +92,12 @@ public:
bool print_status(PrintStatusMode);
private:
Job(pid_t pid, unsigned pgid, String cmd, u64 job_id, AST::Command&& command);
Job(pid_t pid, unsigned pgid, DeprecatedString cmd, u64 job_id, AST::Command&& command);
pid_t m_pgid { 0 };
pid_t m_pid { 0 };
u64 m_job_id { 0 };
String m_cmd;
DeprecatedString m_cmd;
bool m_exited { false };
bool m_running_in_background { false };
bool m_should_announce_exit { false };

34
Userland/Shell/Parser.cpp
View file

@ -858,12 +858,12 @@ RefPtr<AST::Node> Parser::parse_match_expr()
if (!match_expression) {
return create<AST::MatchExpr>(
create<AST::SyntaxError>("Expected an expression after 'match'", true),
String {}, Optional<AST::Position> {}, Vector<AST::MatchEntry> {});
DeprecatedString {}, Optional<AST::Position> {}, Vector<AST::MatchEntry> {});
}
consume_while(is_any_of(" \t\n"sv));
String match_name;
DeprecatedString match_name;
Optional<AST::Position> as_position;
auto as_start = m_offset;
auto as_line = line();
@ -873,7 +873,7 @@ RefPtr<AST::Node> Parser::parse_match_expr()
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> {});
DeprecatedString {}, move(as_position), Vector<AST::MatchEntry> {});
node->set_is_syntax_error(create<AST::SyntaxError>("Expected whitespace after 'as' in 'match'", true));
return node;
}
@ -882,7 +882,7 @@ RefPtr<AST::Node> Parser::parse_match_expr()
if (match_name.is_empty()) {
auto node = create<AST::MatchExpr>(
match_expression.release_nonnull(),
String {}, move(as_position), Vector<AST::MatchEntry> {});
DeprecatedString {}, move(as_position), Vector<AST::MatchEntry> {});
node->set_is_syntax_error(create<AST::SyntaxError>("Expected an identifier after 'as' in 'match'", true));
return node;
}
@ -930,7 +930,7 @@ AST::MatchEntry Parser::parse_match_entry()
NonnullRefPtrVector<AST::Node> patterns;
Vector<Regex<ECMA262>> regexps;
Vector<AST::Position> pipe_positions;
Optional<Vector<String>> match_names;
Optional<Vector<DeprecatedString>> match_names;
Optional<AST::Position> match_as_position;
enum {
Regex,
@ -1001,7 +1001,7 @@ AST::MatchEntry Parser::parse_match_entry()
if (!error)
error = create<AST::SyntaxError>("Expected an explicit list of identifiers after a pattern 'as'");
} else {
match_names = Vector<String>();
match_names = Vector<DeprecatedString>();
for (;;) {
consume_while(is_whitespace);
auto name = consume_while(is_word_character);
@ -1019,7 +1019,7 @@ AST::MatchEntry Parser::parse_match_entry()
}
if (pattern_kind == Regex) {
Vector<String> names;
Vector<DeprecatedString> names;
for (auto& regex : regexps) {
if (names.is_empty()) {
for (auto& name : regex.parser_result.capture_groups)
@ -1226,7 +1226,7 @@ RefPtr<AST::Node> Parser::parse_expression()
{
auto rule_start = push_start();
if (m_rule_start_offsets.size() > max_allowed_nested_rule_depth)
return create<AST::SyntaxError>(String::formatted("Expression nested too deep (max allowed is {})", max_allowed_nested_rule_depth));
return create<AST::SyntaxError>(DeprecatedString::formatted("Expression nested too deep (max allowed is {})", max_allowed_nested_rule_depth));
auto starting_char = peek();
@ -1897,7 +1897,7 @@ RefPtr<AST::Node> Parser::parse_bareword()
auto current_line = line();
auto string = builder.to_string();
if (string.starts_with('~')) {
String username;
DeprecatedString username;
RefPtr<AST::Node> tilde, text;
auto first_slash_index = string.find('/');
@ -1963,7 +1963,7 @@ RefPtr<AST::Node> Parser::parse_glob()
} else {
// FIXME: Allow composition of tilde+bareword with globs: '~/foo/bar/baz*'
restore_to(saved_offset.offset, saved_offset.line);
bareword_part->set_is_syntax_error(*create<AST::SyntaxError>(String::formatted("Unexpected {} inside a glob", bareword_part->class_name())));
bareword_part->set_is_syntax_error(*create<AST::SyntaxError>(DeprecatedString::formatted("Unexpected {} inside a glob", bareword_part->class_name())));
return bareword_part;
}
textbuilder.append(text);
@ -1984,7 +1984,7 @@ RefPtr<AST::Node> Parser::parse_glob()
textbuilder.append('~');
textbuilder.append(bareword->text());
} else {
return create<AST::SyntaxError>(String::formatted("Invalid node '{}' in glob position, escape shell special characters", glob_after->class_name()));
return create<AST::SyntaxError>(DeprecatedString::formatted("Invalid node '{}' in glob position, escape shell special characters", glob_after->class_name()));
}
}
@ -2093,7 +2093,7 @@ RefPtr<AST::Node> Parser::parse_heredoc_initiation_record()
// StringLiteral | bareword
if (auto bareword = parse_bareword()) {
if (!bareword->is_bareword()) {
syntax_error_node = create<AST::SyntaxError>(String::formatted("Expected a bareword or a quoted string, not {}", bareword->class_name()));
syntax_error_node = create<AST::SyntaxError>(DeprecatedString::formatted("Expected a bareword or a quoted string, not {}", bareword->class_name()));
} else {
if (bareword->is_syntax_error())
syntax_error_node = bareword->syntax_error_node();
@ -2121,7 +2121,7 @@ RefPtr<AST::Node> Parser::parse_heredoc_initiation_record()
if (syntax_error_node)
node->set_is_syntax_error(*syntax_error_node);
else
node->set_is_syntax_error(*create<AST::SyntaxError>(String::formatted("Expected heredoc contents for heredoc with end key '{}'", node->end()), true));
node->set_is_syntax_error(*create<AST::SyntaxError>(DeprecatedString::formatted("Expected heredoc contents for heredoc with end key '{}'", node->end()), true));
record.node = node;
m_heredoc_initiations.append(move(record));
@ -2137,7 +2137,7 @@ bool Parser::parse_heredoc_entries()
for (auto& record : heredocs) {
auto rule_start = push_start();
if (m_rule_start_offsets.size() > max_allowed_nested_rule_depth) {
record.node->set_is_syntax_error(*create<AST::SyntaxError>(String::formatted("Expression nested too deep (max allowed is {})", max_allowed_nested_rule_depth)));
record.node->set_is_syntax_error(*create<AST::SyntaxError>(DeprecatedString::formatted("Expression nested too deep (max allowed is {})", max_allowed_nested_rule_depth)));
continue;
}
bool found_key = false;
@ -2164,7 +2164,7 @@ bool Parser::parse_heredoc_entries()
// Now just wrap it in a StringLiteral and set it as the node's contents
auto node = create<AST::StringLiteral>(m_input.substring_view(rule_start->offset, last_line_offset->offset - rule_start->offset), AST::StringLiteral::EnclosureType::None);
if (!found_key)
node->set_is_syntax_error(*create<AST::SyntaxError>(String::formatted("Expected to find the heredoc key '{}', but found Eof", record.end), true));
node->set_is_syntax_error(*create<AST::SyntaxError>(DeprecatedString::formatted("Expected to find the heredoc key '{}', but found Eof", record.end), true));
record.node->set_contents(move(node));
} else {
// Interpolation is allowed, so we're going to read doublequoted string innards
@ -2213,9 +2213,9 @@ bool Parser::parse_heredoc_entries()
if (!expr && found_key) {
expr = create<AST::StringLiteral>("", AST::StringLiteral::EnclosureType::None);
} else if (!expr) {
expr = create<AST::SyntaxError>(String::formatted("Expected to find a valid string inside a heredoc (with end key '{}')", record.end), true);
expr = create<AST::SyntaxError>(DeprecatedString::formatted("Expected to find a valid string inside a heredoc (with end key '{}')", record.end), true);
} else if (!found_key) {
expr->set_is_syntax_error(*create<AST::SyntaxError>(String::formatted("Expected to find the heredoc key '{}'", record.end), true));
expr->set_is_syntax_error(*create<AST::SyntaxError>(DeprecatedString::formatted("Expected to find the heredoc key '{}'", record.end), true));
}
record.node->set_contents(create<AST::DoubleQuotedString>(move(expr)));

4
Userland/Shell/Parser.h
View file

@ -7,9 +7,9 @@
#pragma once
#include "AST.h"
#include <AK/DeprecatedString.h>
#include <AK/Function.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/StringBuilder.h>
#include <AK/Vector.h>
@ -53,7 +53,7 @@ private:
};
struct HeredocInitiationRecord {
String end;
DeprecatedString end;
RefPtr<AST::Heredoc> node;
bool interpolate { false };
bool deindent { false };

104
Userland/Shell/Shell.cpp
View file

@ -76,9 +76,9 @@ void Shell::print_path(StringView path)
out("\033]8;;{}\033\\{}\033]8;;\033\\", url.serialize(), path);
}
String Shell::prompt() const
DeprecatedString Shell::prompt() const
{
auto build_prompt = [&]() -> String {
auto build_prompt = [&]() -> DeprecatedString {
auto* ps1 = getenv("PROMPT");
if (!ps1) {
if (uid == 0)
@ -113,7 +113,7 @@ String Shell::prompt() const
builder.append({ hostname, strlen(hostname) });
break;
case 'w': {
String home_path = getenv("HOME");
DeprecatedString home_path = getenv("HOME");
if (cwd.starts_with(home_path)) {
builder.append('~');
builder.append(cwd.substring_view(home_path.length(), cwd.length() - home_path.length()));
@ -136,7 +136,7 @@ String Shell::prompt() const
return build_prompt();
}
String Shell::expand_tilde(StringView expression)
DeprecatedString Shell::expand_tilde(StringView expression)
{
VERIFY(expression.starts_with('~'));
@ -159,9 +159,9 @@ String Shell::expand_tilde(StringView expression)
if (!home) {
auto passwd = getpwuid(getuid());
VERIFY(passwd && passwd->pw_dir);
return String::formatted("{}/{}", passwd->pw_dir, path.to_string());
return DeprecatedString::formatted("{}/{}", passwd->pw_dir, path.to_string());
}
return String::formatted("{}/{}", home, path.to_string());
return DeprecatedString::formatted("{}/{}", home, path.to_string());
}
auto passwd = getpwnam(login_name.to_string().characters());
@ -169,7 +169,7 @@ String Shell::expand_tilde(StringView expression)
return expression;
VERIFY(passwd->pw_dir);
return String::formatted("{}/{}", passwd->pw_dir, path.to_string());
return DeprecatedString::formatted("{}/{}", passwd->pw_dir, path.to_string());
}
bool Shell::is_glob(StringView s)
@ -204,7 +204,7 @@ Vector<StringView> Shell::split_path(StringView path)
return parts;
}
Vector<String> Shell::expand_globs(StringView path, StringView base)
Vector<DeprecatedString> Shell::expand_globs(StringView path, StringView base)
{
auto explicitly_set_base = false;
if (path.starts_with('/')) {
@ -212,7 +212,7 @@ Vector<String> Shell::expand_globs(StringView path, StringView base)
explicitly_set_base = true;
}
auto parts = split_path(path);
String base_string = base;
DeprecatedString base_string = base;
struct stat statbuf;
if (lstat(base_string.characters(), &statbuf) < 0) {
perror("lstat");
@ -242,10 +242,10 @@ Vector<String> Shell::expand_globs(StringView path, StringView base)
return results;
}
Vector<String> Shell::expand_globs(Vector<StringView> path_segments, StringView base)
Vector<DeprecatedString> Shell::expand_globs(Vector<StringView> path_segments, StringView base)
{
if (path_segments.is_empty()) {
String base_str = base;
DeprecatedString base_str = base;
struct stat statbuf;
if (lstat(base_str.characters(), &statbuf) < 0)
return {};
@ -254,14 +254,14 @@ Vector<String> Shell::expand_globs(Vector<StringView> path_segments, StringView
auto first_segment = path_segments.take_first();
if (is_glob(first_segment)) {
Vector<String> result;
Vector<DeprecatedString> result;
Core::DirIterator di(base, Core::DirIterator::SkipParentAndBaseDir);
if (di.has_error())
return {};
while (di.has_next()) {
String path = di.next_path();
DeprecatedString path = di.next_path();
// Dotfiles have to be explicitly requested
if (path[0] == '.' && first_segment[0] != '.')
@ -332,10 +332,10 @@ Vector<AST::Command> Shell::expand_aliases(Vector<AST::Command> initial_commands
return commands;
}
String Shell::resolve_path(String path) const
DeprecatedString Shell::resolve_path(DeprecatedString path) const
{
if (!path.starts_with('/'))
path = String::formatted("{}/{}", cwd, path);
path = DeprecatedString::formatted("{}/{}", cwd, path);
return Core::File::real_path_for(path);
}
@ -385,7 +385,7 @@ RefPtr<AST::Value> Shell::get_argument(size_t index) const
return nullptr;
}
String Shell::local_variable_or(StringView name, String const& replacement) const
DeprecatedString Shell::local_variable_or(StringView name, DeprecatedString const& replacement) const
{
auto value = lookup_local_variable(name);
if (value) {
@ -396,7 +396,7 @@ String Shell::local_variable_or(StringView name, String const& replacement) cons
return replacement;
}
void Shell::set_local_variable(String const& name, RefPtr<AST::Value> value, bool only_in_current_frame)
void Shell::set_local_variable(DeprecatedString const& name, RefPtr<AST::Value> value, bool only_in_current_frame)
{
if (!only_in_current_frame) {
if (auto* frame = find_frame_containing_local_variable(name)) {
@ -419,7 +419,7 @@ void Shell::unset_local_variable(StringView name, bool only_in_current_frame)
m_local_frames.last().local_variables.remove(name);
}
void Shell::define_function(String name, Vector<String> argnames, RefPtr<AST::Node> body)
void Shell::define_function(DeprecatedString name, Vector<DeprecatedString> argnames, RefPtr<AST::Node> body)
{
add_entry_to_cache({ RunnablePath::Kind::Function, name });
m_functions.set(name, { name, move(argnames), move(body) });
@ -437,7 +437,7 @@ bool Shell::invoke_function(const AST::Command& command, int& retval)
StringView name = command.argv.first();
TemporaryChange<String> script_change { current_script, name };
TemporaryChange<DeprecatedString> script_change { current_script, name };
auto function_option = m_functions.get(name);
if (!function_option.has_value())
@ -451,12 +451,12 @@ bool Shell::invoke_function(const AST::Command& command, int& retval)
}
if (command.argv.size() - 1 < function.arguments.size()) {
raise_error(ShellError::EvaluatedSyntaxError, String::formatted("Expected at least {} arguments to {}, but got {}", function.arguments.size(), function.name, command.argv.size() - 1), command.position);
raise_error(ShellError::EvaluatedSyntaxError, DeprecatedString::formatted("Expected at least {} arguments to {}, but got {}", function.arguments.size(), function.name, command.argv.size() - 1), command.position);
retval = 1;
return true;
}
auto frame = push_frame(String::formatted("function {}", function.name));
auto frame = push_frame(DeprecatedString::formatted("function {}", function.name));
size_t index = 0;
for (auto& arg : function.arguments) {
++index;
@ -476,7 +476,7 @@ bool Shell::invoke_function(const AST::Command& command, int& retval)
return true;
}
String Shell::format(StringView source, ssize_t& cursor) const
DeprecatedString Shell::format(StringView source, ssize_t& cursor) const
{
Formatter formatter(source, cursor);
auto result = formatter.format();
@ -485,7 +485,7 @@ String Shell::format(StringView source, ssize_t& cursor) const
return result;
}
Shell::Frame Shell::push_frame(String name)
Shell::Frame Shell::push_frame(DeprecatedString name)
{
m_local_frames.append(make<LocalFrame>(name, decltype(LocalFrame::local_variables) {}));
dbgln_if(SH_DEBUG, "New frame '{}' at {:p}", name, &m_local_frames.last());
@ -512,7 +512,7 @@ Shell::Frame::~Frame()
(void)frames.take_last();
}
String Shell::resolve_alias(StringView name) const
DeprecatedString Shell::resolve_alias(StringView name) const
{
return m_aliases.get(name).value_or({});
}
@ -534,7 +534,7 @@ Optional<Shell::RunnablePath> Shell::runnable_path_for(StringView name)
return *found;
}
Optional<String> Shell::help_path_for(Vector<RunnablePath> visited, Shell::RunnablePath const& runnable_path)
Optional<DeprecatedString> Shell::help_path_for(Vector<RunnablePath> visited, Shell::RunnablePath const& runnable_path)
{
switch (runnable_path.kind) {
case RunnablePath::Kind::Executable: {
@ -734,7 +734,7 @@ ErrorOr<RefPtr<Job>> Shell::run_command(const AST::Command& command)
}
Vector<char const*> argv;
Vector<String> copy_argv = command.argv;
Vector<DeprecatedString> copy_argv = command.argv;
argv.ensure_capacity(command.argv.size() + 1);
for (auto& arg : copy_argv)
@ -1012,7 +1012,7 @@ NonnullRefPtrVector<Job> Shell::run_commands(Vector<AST::Command>& commands)
}
auto job_result = run_command(command);
if (job_result.is_error()) {
raise_error(ShellError::LaunchError, String::formatted("{} while running '{}'", job_result.error(), command.argv.first()), command.position);
raise_error(ShellError::LaunchError, DeprecatedString::formatted("{} while running '{}'", job_result.error(), command.argv.first()), command.position);
break;
}
@ -1039,7 +1039,7 @@ NonnullRefPtrVector<Job> Shell::run_commands(Vector<AST::Command>& commands)
return spawned_jobs;
}
bool Shell::run_file(String const& filename, bool explicitly_invoked)
bool Shell::run_file(DeprecatedString const& filename, bool explicitly_invoked)
{
TemporaryChange script_change { current_script, filename };
TemporaryChange interactive_change { m_is_interactive, false };
@ -1047,7 +1047,7 @@ bool Shell::run_file(String const& filename, bool explicitly_invoked)
auto file_result = Core::File::open(filename, Core::OpenMode::ReadOnly);
if (file_result.is_error()) {
auto error = String::formatted("'{}': {}", escape_token_for_single_quotes(filename), file_result.error());
auto error = DeprecatedString::formatted("'{}': {}", escape_token_for_single_quotes(filename), file_result.error());
if (explicitly_invoked)
raise_error(ShellError::OpenFailure, error);
else
@ -1125,14 +1125,14 @@ void Shell::block_on_job(RefPtr<Job> job)
block_on_pipeline(command->pipeline);
}
String Shell::get_history_path()
DeprecatedString Shell::get_history_path()
{
if (auto histfile = getenv("HISTFILE"))
return { histfile };
return String::formatted("{}/.history", home);
return DeprecatedString::formatted("{}/.history", home);
}
String Shell::escape_token_for_single_quotes(StringView token)
DeprecatedString Shell::escape_token_for_single_quotes(StringView token)
{
// `foo bar \n '` -> `'foo bar \n '"'"`
@ -1162,7 +1162,7 @@ String Shell::escape_token_for_single_quotes(StringView token)
return builder.build();
}
String Shell::escape_token_for_double_quotes(StringView token)
DeprecatedString Shell::escape_token_for_double_quotes(StringView token)
{
// `foo bar \n $x 'blah "hello` -> `"foo bar \\n $x 'blah \"hello"`
@ -1228,7 +1228,7 @@ Shell::SpecialCharacterEscapeMode Shell::special_character_escape_mode(u32 code_
}
}
static String do_escape(Shell::EscapeMode escape_mode, auto& token)
static DeprecatedString do_escape(Shell::EscapeMode escape_mode, auto& token)
{
StringBuilder builder;
for (auto c : token) {
@ -1293,12 +1293,12 @@ static String do_escape(Shell::EscapeMode escape_mode, auto& token)
return builder.build();
}
String Shell::escape_token(Utf32View token, EscapeMode escape_mode)
DeprecatedString Shell::escape_token(Utf32View token, EscapeMode escape_mode)
{
return do_escape(escape_mode, token);
}
String Shell::escape_token(StringView token, EscapeMode escape_mode)
DeprecatedString Shell::escape_token(StringView token, EscapeMode escape_mode)
{
Utf8View view { token };
if (view.validate())
@ -1306,7 +1306,7 @@ String Shell::escape_token(StringView token, EscapeMode escape_mode)
return do_escape(escape_mode, token);
}
String Shell::unescape_token(StringView token)
DeprecatedString Shell::unescape_token(StringView token)
{
StringBuilder builder;
@ -1365,14 +1365,14 @@ void Shell::cache_path()
}
// TODO: Can we make this rely on Core::File::resolve_executable_from_environment()?
String path = getenv("PATH");
DeprecatedString path = getenv("PATH");
if (!path.is_empty()) {
auto directories = path.split(':');
for (auto const& directory : directories) {
Core::DirIterator programs(directory.characters(), Core::DirIterator::SkipDots);
while (programs.has_next()) {
auto program = programs.next_path();
auto program_path = String::formatted("{}/{}", directory, program);
auto program_path = DeprecatedString::formatted("{}/{}", directory, program);
auto escaped_name = escape_token(program);
if (cached_path.contains_slow(escaped_name))
continue;
@ -1439,7 +1439,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) : ""sv;
String path;
DeprecatedString path;
ssize_t last_slash = token.length() - 1;
while (last_slash >= 0 && token[last_slash] != '/')
@ -1500,7 +1500,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_path(StringView base, StringV
auto file = files.next_path();
if (file.starts_with(token)) {
struct stat program_status;
auto file_path = String::formatted("{}/{}", path, file);
auto file_path = DeprecatedString::formatted("{}/{}", path, file);
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)) {
@ -1540,7 +1540,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_program_name(StringView name,
if (!match)
return complete_path(""sv, name, offset, ExecutableOnly::Yes, nullptr, nullptr, escape_mode);
String completion = match->path;
DeprecatedString completion = match->path;
auto token_length = escape_token(name, escape_mode).length();
auto invariant_offset = token_length;
size_t static_offset = 0;
@ -1594,7 +1594,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_variable(StringView name, siz
auto parts = entry.split_view('=');
if (parts.is_empty() || parts.first().is_empty())
continue;
String name = parts.first();
DeprecatedString name = parts.first();
if (suggestions.contains_slow(name))
continue;
suggestions.append(move(name));
@ -1626,7 +1626,7 @@ Vector<Line::CompletionSuggestion> Shell::complete_user(StringView name, size_t
return suggestions;
while (di.has_next()) {
String name = di.next_path();
DeprecatedString name = di.next_path();
if (name.starts_with(pattern)) {
suggestions.append(name);
auto& suggestion = suggestions.last();
@ -1668,7 +1668,7 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
if (command_node->would_execute())
return Error::from_string_literal("Refusing to complete nodes that would execute");
String program_name_storage;
DeprecatedString program_name_storage;
if (known_program_name.is_null()) {
auto node = command_node->leftmost_trivial_literal();
if (!node)
@ -1684,7 +1684,7 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
completion_command.argv.append(program_name);
completion_command = expand_aliases({ completion_command }).last();
auto completion_utility_name = String::formatted("_complete_{}", completion_command.argv[0]);
auto completion_utility_name = DeprecatedString::formatted("_complete_{}", completion_command.argv[0]);
if (binary_search(cached_path.span(), completion_utility_name, nullptr, RunnablePathComparator {}) != nullptr)
completion_command.argv[0] = completion_utility_name;
else if (!options.invoke_program_for_autocomplete)
@ -1702,12 +1702,12 @@ ErrorOr<Vector<Line::CompletionSuggestion>> Shell::complete_via_program_itself(s
Shell& shell;
AST::Position completion_position;
Vector<Vector<String>> lists;
Vector<Vector<DeprecatedString>> lists;
bool fail { false };
void push_list() { lists.empend(); }
Vector<String> pop_list() { return lists.take_last(); }
Vector<String>& list() { return lists.last(); }
Vector<DeprecatedString> pop_list() { return lists.take_last(); }
Vector<DeprecatedString>& list() { return lists.last(); }
bool should_include(AST::Node const* node) const { return node->position().end_offset <= completion_position.end_offset; }
@ -1969,7 +1969,7 @@ void Shell::bring_cursor_to_beginning_of_a_line() const
// Black with Cyan background.
constexpr auto default_mark = "\e[30;46m%\e[0m";
String eol_mark = getenv("PROMPT_EOL_MARK");
DeprecatedString eol_mark = getenv("PROMPT_EOL_MARK");
if (eol_mark.is_null())
eol_mark = default_mark;
size_t eol_mark_length = Line::Editor::actual_rendered_string_metrics(eol_mark).line_metrics.last().total_length();
@ -1983,7 +1983,7 @@ void Shell::bring_cursor_to_beginning_of_a_line() const
// We write a line's worth of whitespace to the terminal. This way, we ensure that
// the prompt ends up on a new line even if there is dangling output on the current line.
size_t fill_count = ws.ws_col - eol_mark_length;
auto fill_buffer = String::repeated(' ', fill_count);
auto fill_buffer = DeprecatedString::repeated(' ', fill_count);
fwrite(fill_buffer.characters(), 1, fill_count, stderr);
putc('\r', stderr);
@ -2387,7 +2387,7 @@ void Shell::possibly_print_error() const
}
};
int line = -1;
String current_line;
DeprecatedString current_line;
i64 line_to_skip_to = max(source_position.position->start_line.line_number, 2ul) - 2;
if (!source_position.source_file.is_null()) {

86
Userland/Shell/Shell.h
View file

@ -10,10 +10,10 @@
#include "Parser.h"
#include <AK/Array.h>
#include <AK/CircularQueue.h>
#include <AK/DeprecatedString.h>
#include <AK/HashMap.h>
#include <AK/NonnullOwnPtrVector.h>
#include <AK/StackInfo.h>
#include <AK/String.h>
#include <AK/StringBuilder.h>
#include <AK/StringView.h>
#include <AK/Types.h>
@ -88,8 +88,8 @@ public:
void setup_signals();
struct SourcePosition {
String source_file;
String literal_source_text;
DeprecatedString source_file;
DeprecatedString literal_source_text;
Optional<AST::Position> position;
};
@ -102,7 +102,7 @@ public:
};
Kind kind;
String path;
DeprecatedString path;
bool operator<(RunnablePath const& other) const
{
@ -138,50 +138,50 @@ public:
int run_command(StringView, Optional<SourcePosition> = {});
Optional<RunnablePath> runnable_path_for(StringView);
Optional<String> help_path_for(Vector<RunnablePath> visited, RunnablePath const& runnable_path);
Optional<DeprecatedString> help_path_for(Vector<RunnablePath> visited, RunnablePath const& runnable_path);
ErrorOr<RefPtr<Job>> run_command(const AST::Command&);
NonnullRefPtrVector<Job> run_commands(Vector<AST::Command>&);
bool run_file(String const&, bool explicitly_invoked = true);
bool run_file(DeprecatedString const&, bool explicitly_invoked = true);
bool run_builtin(const AST::Command&, NonnullRefPtrVector<AST::Rewiring> const&, int& retval);
bool has_builtin(StringView) const;
RefPtr<AST::Node> run_immediate_function(StringView name, AST::ImmediateExpression& invoking_node, NonnullRefPtrVector<AST::Node> const&);
static bool has_immediate_function(StringView);
void block_on_job(RefPtr<Job>);
void block_on_pipeline(RefPtr<AST::Pipeline>);
String prompt() const;
DeprecatedString prompt() const;
static String expand_tilde(StringView expression);
static Vector<String> expand_globs(StringView path, StringView base);
static Vector<String> expand_globs(Vector<StringView> path_segments, StringView base);
static DeprecatedString expand_tilde(StringView expression);
static Vector<DeprecatedString> expand_globs(StringView path, StringView base);
static Vector<DeprecatedString> expand_globs(Vector<StringView> path_segments, StringView base);
Vector<AST::Command> expand_aliases(Vector<AST::Command>);
String resolve_path(String) const;
String resolve_alias(StringView) const;
DeprecatedString resolve_path(DeprecatedString) const;
DeprecatedString resolve_alias(StringView) const;
static bool has_history_event(StringView);
RefPtr<AST::Value> get_argument(size_t) const;
RefPtr<AST::Value> lookup_local_variable(StringView) const;
String local_variable_or(StringView, String const&) const;
void set_local_variable(String const&, RefPtr<AST::Value>, bool only_in_current_frame = false);
DeprecatedString local_variable_or(StringView, DeprecatedString const&) const;
void set_local_variable(DeprecatedString const&, RefPtr<AST::Value>, bool only_in_current_frame = false);
void unset_local_variable(StringView, bool only_in_current_frame = false);
void define_function(String name, Vector<String> argnames, RefPtr<AST::Node> body);
void define_function(DeprecatedString name, Vector<DeprecatedString> argnames, RefPtr<AST::Node> body);
bool has_function(StringView);
bool invoke_function(const AST::Command&, int& retval);
String format(StringView, ssize_t& cursor) const;
DeprecatedString format(StringView, ssize_t& cursor) const;
RefPtr<Line::Editor> editor() const { return m_editor; }
struct LocalFrame {
LocalFrame(String name, HashMap<String, RefPtr<AST::Value>> variables)
LocalFrame(DeprecatedString name, HashMap<DeprecatedString, RefPtr<AST::Value>> variables)
: name(move(name))
, local_variables(move(variables))
{
}
String name;
HashMap<String, RefPtr<AST::Value>> local_variables;
DeprecatedString name;
HashMap<DeprecatedString, RefPtr<AST::Value>> local_variables;
};
struct Frame {
@ -200,16 +200,16 @@ public:
bool should_destroy_frame { true };
};
[[nodiscard]] Frame push_frame(String name);
[[nodiscard]] Frame push_frame(DeprecatedString name);
void pop_frame();
struct Promise {
struct Data {
struct Unveil {
String path;
String access;
DeprecatedString path;
DeprecatedString access;
};
String exec_promises;
DeprecatedString exec_promises;
Vector<Unveil> unveils;
} data;
@ -243,11 +243,11 @@ public:
SingleQuotedString,
DoubleQuotedString,
};
static String escape_token_for_double_quotes(StringView token);
static String escape_token_for_single_quotes(StringView token);
static String escape_token(StringView token, EscapeMode = EscapeMode::Bareword);
static String escape_token(Utf32View token, EscapeMode = EscapeMode::Bareword);
static String unescape_token(StringView token);
static DeprecatedString escape_token_for_double_quotes(StringView token);
static DeprecatedString escape_token_for_single_quotes(StringView token);
static DeprecatedString escape_token(StringView token, EscapeMode = EscapeMode::Bareword);
static DeprecatedString escape_token(Utf32View token, EscapeMode = EscapeMode::Bareword);
static DeprecatedString unescape_token(StringView token);
enum class SpecialCharacterEscapeMode {
Untouched,
Escaped,
@ -283,7 +283,7 @@ public:
Job const* current_job() const { return m_current_job; }
void kill_job(Job const*, int sig);
String get_history_path();
DeprecatedString get_history_path();
void print_path(StringView path);
void cache_path();
@ -296,9 +296,9 @@ public:
bool was_interrupted { false };
bool was_resized { false };
String cwd;
String username;
String home;
DeprecatedString cwd;
DeprecatedString username;
DeprecatedString home;
constexpr static auto TTYNameSize = 32;
constexpr static auto HostNameSize = 64;
@ -308,12 +308,12 @@ public:
uid_t uid;
Optional<int> last_return_code;
Vector<String> directory_stack;
CircularQueue<String, 8> cd_history; // FIXME: have a configurable cd history length
Vector<DeprecatedString> directory_stack;
CircularQueue<DeprecatedString, 8> cd_history; // FIXME: have a configurable cd history length
HashMap<u64, NonnullRefPtr<Job>> jobs;
Vector<RunnablePath, 256> cached_path;
String current_script;
DeprecatedString current_script;
enum ShellEventType {
ReadLine,
@ -334,7 +334,7 @@ public:
LaunchError,
};
void raise_error(ShellError kind, String description, Optional<AST::Position> position = {})
void raise_error(ShellError kind, DeprecatedString description, Optional<AST::Position> position = {})
{
m_error = kind;
m_error_description = move(description);
@ -343,7 +343,7 @@ public:
}
bool has_error(ShellError err) const { return m_error == err; }
bool has_any_error() const { return !has_error(ShellError::None); }
String const& error_description() const { return m_error_description; }
DeprecatedString const& error_description() const { return m_error_description; }
ShellError take_error()
{
auto err = m_error;
@ -435,23 +435,23 @@ private:
pid_t m_pid { 0 };
struct ShellFunction {
String name;
Vector<String> arguments;
DeprecatedString name;
Vector<DeprecatedString> arguments;
RefPtr<AST::Node> body;
};
HashMap<String, ShellFunction> m_functions;
HashMap<DeprecatedString, ShellFunction> m_functions;
NonnullOwnPtrVector<LocalFrame> m_local_frames;
Promise::List m_active_promises;
NonnullRefPtrVector<AST::Redirection> m_global_redirections;
HashMap<String, String> m_aliases;
HashMap<DeprecatedString, DeprecatedString> m_aliases;
bool m_is_interactive { true };
bool m_is_subshell { false };
bool m_should_reinstall_signal_handlers { true };
ShellError m_error { ShellError::None };
String m_error_description;
DeprecatedString m_error_description;
Optional<SourcePosition> m_source_position;
bool m_should_format_live { false };
@ -548,7 +548,7 @@ struct Traits<Shell::Shell::RunnablePath> : public GenericTraits<Shell::Shell::R
return self.path == other;
}
static bool equals(Shell::Shell::RunnablePath const& self, String const& other)
static bool equals(Shell::Shell::RunnablePath const& self, DeprecatedString const& other)
{
return self.path == other;
}

6
Userland/Shell/main.cpp
View file

@ -104,7 +104,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
}
if (should_escape) {
String escaped_string;
DeprecatedString escaped_string;
Optional<char> trivia {};
bool starting_trivia_already_provided = false;
auto escape_mode = Shell::Shell::EscapeMode::Bareword;
@ -156,7 +156,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
StringView command_to_run = {};
StringView file_to_read_from = {};
Vector<String> script_args;
Vector<DeprecatedString> script_args;
bool skip_rc_files = false;
char const* format = nullptr;
bool should_format_live = false;
@ -213,7 +213,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
if (!skip_rc_files) {
auto run_rc_file = [&](auto& name) {
String file_path = name;
DeprecatedString file_path = name;
if (file_path.starts_with('~'))
file_path = shell->expand_tilde(file_path);
if (Core::File::exists(file_path)) {