/* * Copyright (c) 2020, the SerenityOS developers. * * SPDX-License-Identifier: BSD-2-Clause */ #include "AST.h" #include "Shell.h" #include #include #include #include #include #include #include #include #include #include #include #include ErrorOr AK::Formatter::format(FormatBuilder& builder, Shell::AST::Command const& value) { if (m_sign_mode != FormatBuilder::SignMode::Default) VERIFY_NOT_REACHED(); if (m_alternative_form) VERIFY_NOT_REACHED(); if (m_zero_pad) VERIFY_NOT_REACHED(); if (m_mode != Mode::Default && m_mode != Mode::String) VERIFY_NOT_REACHED(); if (m_width.has_value()) VERIFY_NOT_REACHED(); if (m_precision.has_value()) VERIFY_NOT_REACHED(); if (value.argv.is_empty()) { TRY(builder.put_literal("(ShellInternal)"sv)); } else { bool first = true; for (auto& arg : value.argv) { if (!first) TRY(builder.put_literal(" "sv)); first = false; TRY(builder.put_literal(arg)); } } for (auto& redir : value.redirections) { TRY(builder.put_padding(' ', 1)); if (redir->is_path_redirection()) { auto path_redir = static_cast(redir.ptr()); TRY(builder.put_i64(path_redir->fd)); switch (path_redir->direction) { case Shell::AST::PathRedirection::Read: TRY(builder.put_literal("<"sv)); break; case Shell::AST::PathRedirection::Write: TRY(builder.put_literal(">"sv)); break; case Shell::AST::PathRedirection::WriteAppend: TRY(builder.put_literal(">>"sv)); break; case Shell::AST::PathRedirection::ReadWrite: TRY(builder.put_literal("<>"sv)); break; } TRY(builder.put_literal(path_redir->path)); } else if (redir->is_fd_redirection()) { auto* fdredir = static_cast(redir.ptr()); TRY(builder.put_i64(fdredir->new_fd)); TRY(builder.put_literal(">"sv)); TRY(builder.put_i64(fdredir->old_fd)); } else if (redir->is_close_redirection()) { auto close_redir = static_cast(redir.ptr()); TRY(builder.put_i64(close_redir->fd)); TRY(builder.put_literal(">&-"sv)); } else { VERIFY_NOT_REACHED(); } } if (!value.next_chain.is_empty()) { for (auto& command : value.next_chain) { switch (command.action) { case Shell::AST::NodeWithAction::And: TRY(builder.put_literal(" && "sv)); break; case Shell::AST::NodeWithAction::Or: TRY(builder.put_literal(" || "sv)); break; case Shell::AST::NodeWithAction::Sequence: TRY(builder.put_literal("; "sv)); break; } TRY(builder.put_literal("("sv)); TRY(builder.put_literal(command.node->class_name())); TRY(builder.put_literal("...)"sv)); } } if (!value.should_wait) TRY(builder.put_literal("&"sv)); return {}; } namespace Shell::AST { template static inline void print_indented(int indent, CheckedFormatString format, Args&&... args) { auto str = DeprecatedString::formatted(format.view(), forward(args)...); dbgln("{: >{}}", str, str.length() + indent * 2); } static inline Optional merge_positions(Optional const& left, Optional const& right) { if (!left.has_value()) return right; if (!right.has_value()) return left; return Position { .start_offset = left->start_offset, .end_offset = right->end_offset, .start_line = left->start_line, .end_line = right->end_line, }; } static inline Vector join_commands(Vector left, Vector right) { Command command; auto last_in_left = left.take_last(); auto first_in_right = right.take_first(); command.argv.extend(last_in_left.argv); command.argv.extend(first_in_right.argv); command.redirections.extend(last_in_left.redirections); command.redirections.extend(first_in_right.redirections); command.should_wait = first_in_right.should_wait && last_in_left.should_wait; command.is_pipe_source = first_in_right.is_pipe_source; command.should_notify_if_in_background = first_in_right.should_notify_if_in_background || last_in_left.should_notify_if_in_background; command.position = merge_positions(last_in_left.position, first_in_right.position); Vector commands; commands.extend(left); commands.append(command); commands.extend(right); return commands; } static ErrorOr resolve_slices(RefPtr shell, String&& input_value, Vector> slices) { if (slices.is_empty()) return move(input_value); for (auto& slice : slices) { auto value = TRY(slice->run(shell)); if (shell && shell->has_any_error()) break; if (!value) { shell->raise_error(Shell::ShellError::InvalidSliceContentsError, "Invalid slice contents", slice->position()); return move(input_value); } auto index_values = value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); Vector indices; indices.ensure_capacity(index_values.size()); size_t i = 0; for (auto& value : index_values) { auto maybe_index = value.bytes_as_string_view().to_int(); if (!maybe_index.has_value()) { 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; auto index = maybe_index.value(); auto original_index = index; if (index < 0) index += input_value.bytes_as_string_view().length(); if (index < 0 || (size_t)index >= input_value.bytes_as_string_view().length()) { shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Slice index {} (evaluated as {}) out of value bounds [0-{})", index, original_index, input_value.bytes_as_string_view().length()), slice->position()); return move(input_value); } indices.unchecked_append(index); } StringBuilder builder { indices.size() }; for (auto& index : indices) builder.append(input_value.bytes_as_string_view()[index]); input_value = builder.to_string().release_value_but_fixme_should_propagate_errors(); } return move(input_value); } static ErrorOr> resolve_slices(RefPtr shell, Vector&& values, Vector> slices) { if (slices.is_empty()) return move(values); for (auto& slice : slices) { auto value = TRY(slice->run(shell)); if (shell && shell->has_any_error()) break; if (!value) { shell->raise_error(Shell::ShellError::InvalidSliceContentsError, "Invalid slice contents", slice->position()); return move(values); } auto index_values = value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); Vector indices; indices.ensure_capacity(index_values.size()); size_t i = 0; for (auto& value : index_values) { auto maybe_index = value.bytes_as_string_view().to_int(); if (!maybe_index.has_value()) { shell->raise_error(Shell::ShellError::InvalidSliceContentsError, DeprecatedString::formatted("Invalid value in slice index {}: {} (expected a number)", i, value), slice->position()); return move(values); } ++i; auto index = maybe_index.value(); auto original_index = index; if (index < 0) index += values.size(); if (index < 0 || (size_t)index >= values.size()) { 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 result; result.ensure_capacity(indices.size()); for (auto& index : indices) result.unchecked_append(values[index]); values = move(result); } return move(values); } void Node::clear_syntax_error() { m_syntax_error_node->clear_syntax_error(); } void Node::set_is_syntax_error(SyntaxError& error_node) { if (!m_syntax_error_node) { m_syntax_error_node = error_node; } else { m_syntax_error_node->set_is_syntax_error(error_node); } } bool Node::is_syntax_error() const { return m_syntax_error_node && m_syntax_error_node->is_syntax_error(); } ErrorOr Node::for_each_entry(RefPtr shell, Function(NonnullRefPtr)> callback) { auto value = TRY(TRY(run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return {}; if (value->is_job()) { TRY(callback(value)); return {}; } if (value->is_list_without_resolution()) { auto list = value->resolve_without_cast(shell).release_value_but_fixme_should_propagate_errors(); for (auto& element : static_cast(list.ptr())->values()) { if (TRY(callback(element)) == IterationDecision::Break) break; } return {}; } auto list = value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); for (auto& element : list) { if (TRY(callback(make_ref_counted(move(element)))) == IterationDecision::Break) break; } return {}; } ErrorOr> Node::to_lazy_evaluated_commands(RefPtr shell) { if (would_execute()) { // Wrap the node in a "should immediately execute next" command. return Vector { Command { {}, {}, true, false, true, true, {}, { NodeWithAction(*this, NodeWithAction::Sequence) }, position() } }; } return TRY(TRY(run(shell))->resolve_as_commands(shell)); } ErrorOr Node::dump(int level) const { print_indented(level, "{} at {}:{} (from {}.{} to {}.{})", class_name(), m_position.start_offset, m_position.end_offset, m_position.start_line.line_number, m_position.start_line.line_column, m_position.end_line.line_number, m_position.end_line.line_column); return {}; } Node::Node(Position position) : m_position(position) { } ErrorOr> Node::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (matching_node) { auto kind = matching_node->kind(); StringLiteral::EnclosureType enclosure_type = StringLiteral::EnclosureType::None; if (kind == Kind::StringLiteral) enclosure_type = static_cast(matching_node.ptr())->enclosure_type(); auto set_results_trivia = [enclosure_type](Vector&& suggestions) { if (enclosure_type != StringLiteral::EnclosureType::None) { for (auto& entry : suggestions) entry.trailing_trivia = { static_cast(enclosure_type == StringLiteral::EnclosureType::SingleQuotes ? '\'' : '"') }; } return suggestions; }; if (kind == Kind::BarewordLiteral || kind == Kind::StringLiteral) { Shell::EscapeMode escape_mode; StringView text; size_t corrected_offset; if (kind == Kind::BarewordLiteral) { auto* node = static_cast(matching_node.ptr()); text = node->text(); escape_mode = Shell::EscapeMode::Bareword; corrected_offset = find_offset_into_node(text, offset - matching_node->position().start_offset, escape_mode); } else { auto* node = static_cast(matching_node.ptr()); text = node->text(); escape_mode = enclosure_type == StringLiteral::EnclosureType::SingleQuotes ? Shell::EscapeMode::SingleQuotedString : Shell::EscapeMode::DoubleQuotedString; corrected_offset = find_offset_into_node(text, offset - matching_node->position().start_offset + 1, escape_mode); } if (corrected_offset > text.length()) return Vector {}; // 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(""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. if (!hit_test_result.closest_command_node) return Vector {}; auto program_name_node = hit_test_result.closest_command_node->leftmost_trivial_literal(); if (!program_name_node) return Vector {}; String program_name; if (program_name_node->is_bareword()) program_name = static_cast(program_name_node.ptr())->text(); else program_name = static_cast(program_name_node.ptr())->text(); return set_results_trivia(shell.complete_option(program_name, text, corrected_offset, hit_test_result.closest_command_node.ptr(), hit_test_result.matching_node)); } return Vector {}; } auto result = hit_test_position(offset); if (!result.matching_node) 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) node = result.closest_node_with_semantic_meaning; if (!node) return Vector {}; return node->complete_for_editor(shell, offset, result); } ErrorOr> Node::complete_for_editor(Shell& shell, size_t offset) { return Node::complete_for_editor(shell, offset, { nullptr, nullptr, nullptr }); } ErrorOr And::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> And::run(RefPtr shell) { auto commands = TRY(m_left->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); commands.last().next_chain.append(NodeWithAction { *m_right, NodeWithAction::And }); return make_ref_counted(move(commands)); } ErrorOr And::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { metadata.is_first_in_list = true; TRY(m_left->highlight_in_editor(editor, shell, metadata)); TRY(m_right->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult And::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = m_right; return result; } result = m_right->hit_test_position(offset); if (!result.closest_command_node) result.closest_command_node = m_right; return result; } And::And(Position position, NonnullRefPtr left, NonnullRefPtr right, Position and_position) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) , m_and_position(and_position) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } ErrorOr ListConcatenate::dump(int level) const { TRY(Node::dump(level)); for (auto& element : m_list) TRY(element->dump(level + 1)); return {}; } ErrorOr> ListConcatenate::run(RefPtr shell) { RefPtr result = nullptr; for (auto& element : m_list) { if (shell && shell->has_any_error()) break; if (!result) { result = make_ref_counted({ TRY(TRY(element->run(shell))->resolve_without_cast(shell)) }); continue; } auto element_value = TRY(TRY(element->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) break; if (result->is_command() || element_value->is_command()) { auto joined_commands = join_commands( result->resolve_as_commands(shell).release_value_but_fixme_should_propagate_errors(), element_value->resolve_as_commands(shell).release_value_but_fixme_should_propagate_errors()); if (joined_commands.size() == 1) { auto& command = joined_commands[0]; command.position = position(); result = make_ref_counted(command); } else { result = make_ref_counted(move(joined_commands)); } } else { Vector> values; if (result->is_list_without_resolution()) { values.extend(static_cast(result.ptr())->values()); } else { for (auto& result : TRY(result->resolve_as_list(shell))) values.append(make_ref_counted(result)); } values.append(element_value); result = make_ref_counted(move(values)); } } if (!result) return make_ref_counted({}); return result; } ErrorOr ListConcatenate::for_each_entry(RefPtr shell, Function(NonnullRefPtr)> callback) { for (auto& entry : m_list) { auto value = TRY(entry->run(shell)); if (shell && shell->has_any_error()) break; if (!value) continue; if (TRY(callback(value.release_nonnull())) == IterationDecision::Break) break; } return {}; } ErrorOr ListConcatenate::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { auto first = metadata.is_first_in_list; metadata.is_first_in_list = false; metadata.is_first_in_list = first; for (auto& element : m_list) { TRY(element->highlight_in_editor(editor, shell, metadata)); metadata.is_first_in_list = false; } return {}; } HitTestResult ListConcatenate::hit_test_position(size_t offset) const { bool first = true; for (auto& element : m_list) { auto result = element->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning && !first) result.closest_node_with_semantic_meaning = this; if (result.matching_node) return result; first = false; } return {}; } RefPtr ListConcatenate::leftmost_trivial_literal() const { if (m_list.is_empty()) return nullptr; return m_list.first()->leftmost_trivial_literal(); } ListConcatenate::ListConcatenate(Position position, Vector> list) : Node(move(position)) , m_list(move(list)) { for (auto& element : m_list) { if (element->is_syntax_error()) { set_is_syntax_error(element->syntax_error_node()); break; } } } ErrorOr Background::dump(int level) const { TRY(Node::dump(level)); TRY(m_command->dump(level + 1)); return {}; } ErrorOr> Background::run(RefPtr shell) { auto commands = TRY(m_command->to_lazy_evaluated_commands(shell)); for (auto& command : commands) command.should_wait = false; return make_ref_counted(move(commands)); } ErrorOr Background::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { return m_command->highlight_in_editor(editor, shell, metadata); } HitTestResult Background::hit_test_position(size_t offset) const { return m_command->hit_test_position(offset); } Background::Background(Position position, NonnullRefPtr command) : Node(move(position)) , m_command(move(command)) { if (m_command->is_syntax_error()) set_is_syntax_error(m_command->syntax_error_node()); } ErrorOr BarewordLiteral::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_text); return {}; } ErrorOr> BarewordLiteral::run(RefPtr) { return make_ref_counted(m_text); } ErrorOr BarewordLiteral::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { if (metadata.is_first_in_list) { auto runnable = shell.runnable_path_for(m_text); if (runnable.has_value()) { Line::Style bold = { Line::Style::Bold }; Line::Style style = bold; #ifdef AK_OS_SERENITY if (runnable->kind == Shell::RunnablePath::Kind::Executable || runnable->kind == Shell::RunnablePath::Kind::Alias) { auto name = shell.help_path_for({}, *runnable); if (name.has_value()) { auto url = URL::create_with_help_scheme(name.release_value(), shell.hostname); style = bold.unified_with(Line::Style::Hyperlink(url.to_deprecated_string())); } } #endif editor.stylize({ m_position.start_offset, m_position.end_offset }, style); } else { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Red) }); } return {}; } if (m_text.starts_with('-')) { if (m_text == "--"sv) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Green) }); return {}; } if (m_text == "-"sv) return {}; if (m_text.starts_with_bytes("--"sv)) { auto index = m_text.find_byte_offset('=').value_or(m_text.bytes_as_string_view().length() - 1) + 1; editor.stylize({ m_position.start_offset, m_position.start_offset + index }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan) }); } else { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan) }); } } if (FileSystem::exists(m_text)) { auto realpath = shell.resolve_path(m_text.bytes_as_string_view()); auto url = URL::create_with_file_scheme(realpath); url.set_host(TRY(String::from_deprecated_string(shell.hostname))); editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Hyperlink(url.to_deprecated_string()) }); } return {}; } BarewordLiteral::BarewordLiteral(Position position, String text) : Node(move(position)) , m_text(move(text)) { } ErrorOr BraceExpansion::dump(int level) const { TRY(Node::dump(level)); for (auto& entry : m_entries) TRY(entry->dump(level + 1)); return {}; } ErrorOr> BraceExpansion::run(RefPtr shell) { Vector> values; for (auto& entry : m_entries) { if (shell && shell->has_any_error()) break; auto value = TRY(entry->run(shell)); if (value) values.append(value.release_nonnull()); } return make_ref_counted(move(values)); } HitTestResult BraceExpansion::hit_test_position(size_t offset) const { for (auto& entry : m_entries) { auto result = entry->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = entry; return result; } } return {}; } ErrorOr BraceExpansion::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { for (auto& entry : m_entries) { TRY(entry->highlight_in_editor(editor, shell, metadata)); metadata.is_first_in_list = false; } return {}; } BraceExpansion::BraceExpansion(Position position, Vector> entries) : Node(move(position)) , m_entries(move(entries)) { for (auto& entry : m_entries) { if (entry->is_syntax_error()) { set_is_syntax_error(entry->syntax_error_node()); break; } } } ErrorOr CastToCommand::dump(int level) const { TRY(Node::dump(level)); TRY(m_inner->dump(level + 1)); return {}; } ErrorOr> CastToCommand::run(RefPtr shell) { if (m_inner->is_command()) return m_inner->run(shell); auto value = TRY(TRY(m_inner->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); if (value->is_command()) return value; auto argv = TRY(value->resolve_as_list(shell)); return make_ref_counted(move(argv), position()); } ErrorOr CastToCommand::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { return m_inner->highlight_in_editor(editor, shell, metadata); } HitTestResult CastToCommand::hit_test_position(size_t offset) const { auto result = m_inner->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning) result.closest_node_with_semantic_meaning = this; if (!result.closest_command_node && position().contains(offset)) result.closest_command_node = this; return result; } ErrorOr> CastToCommand::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node || !matching_node->is_bareword()) return Vector {}; auto corrected_offset = offset - matching_node->position().start_offset; auto* node = static_cast(matching_node.ptr()); if (corrected_offset > node->text().bytes_as_string_view().length()) return Vector {}; return shell.complete_program_name(node->text(), corrected_offset); } RefPtr CastToCommand::leftmost_trivial_literal() const { return m_inner->leftmost_trivial_literal(); } CastToCommand::CastToCommand(Position position, NonnullRefPtr inner) : Node(move(position)) , m_inner(move(inner)) { if (m_inner->is_syntax_error()) set_is_syntax_error(m_inner->syntax_error_node()); } ErrorOr CastToList::dump(int level) const { TRY(Node::dump(level)); if (m_inner) TRY(m_inner->dump(level + 1)); else print_indented(level + 1, "(empty)"); return {}; } ErrorOr> CastToList::run(RefPtr shell) { if (!m_inner) return make_ref_counted({}); auto inner_value = TRY(TRY(m_inner->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); if (inner_value->is_command() || inner_value->is_list()) return inner_value; auto values = TRY(inner_value->resolve_as_list(shell)); Vector> cast_values; for (auto& value : values) cast_values.append(make_ref_counted(value)); return make_ref_counted(cast_values); } ErrorOr CastToList::for_each_entry(RefPtr shell, Function(NonnullRefPtr)> callback) { if (m_inner) TRY(m_inner->for_each_entry(shell, move(callback))); return {}; } ErrorOr CastToList::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { if (m_inner) TRY(m_inner->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult CastToList::hit_test_position(size_t offset) const { if (!m_inner) return {}; return m_inner->hit_test_position(offset); } RefPtr CastToList::leftmost_trivial_literal() const { return m_inner->leftmost_trivial_literal(); } CastToList::CastToList(Position position, RefPtr inner) : Node(move(position)) , m_inner(move(inner)) { if (m_inner && m_inner->is_syntax_error()) set_is_syntax_error(m_inner->syntax_error_node()); } ErrorOr CloseFdRedirection::dump(int level) const { TRY(Node::dump(level)); print_indented(level, "{} -> Close", m_fd); return {}; } ErrorOr> CloseFdRedirection::run(RefPtr) { Command command; command.position = position(); command.redirections.append(adopt_ref(*new CloseRedirection(m_fd))); return make_ref_counted(move(command)); } ErrorOr CloseFdRedirection::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata) { editor.stylize({ m_position.start_offset, m_position.end_offset - 1 }, { Line::Style::Foreground(0x87, 0x9b, 0xcd) }); // 25% Darkened Periwinkle editor.stylize({ m_position.end_offset - 1, m_position.end_offset }, { Line::Style::Foreground(0xff, 0x7e, 0x00) }); // Amber return {}; } CloseFdRedirection::CloseFdRedirection(Position position, int fd) : Node(move(position)) , m_fd(fd) { } CloseFdRedirection::~CloseFdRedirection() { } ErrorOr CommandLiteral::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(Generated command literal: {})", m_command); return {}; } ErrorOr> CommandLiteral::run(RefPtr) { return make_ref_counted(m_command); } CommandLiteral::CommandLiteral(Position position, Command command) : Node(move(position)) , m_command(move(command)) { } CommandLiteral::~CommandLiteral() { } ErrorOr Comment::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_text); return {}; } ErrorOr> Comment::run(RefPtr) { return make_ref_counted({}); } ErrorOr Comment::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(150, 150, 150) }); // Light gray return {}; } Comment::Comment(Position position, String text) : Node(move(position)) , m_text(move(text)) { } Comment::~Comment() { } ErrorOr ContinuationControl::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_kind == Continue ? "(Continue)"sv : "(Break)"sv); return {}; } ErrorOr> ContinuationControl::run(RefPtr shell) { if (m_kind == Break) shell->raise_error(Shell::ShellError::InternalControlFlowBreak, {}, position()); else if (m_kind == Continue) shell->raise_error(Shell::ShellError::InternalControlFlowContinue, {}, position()); else VERIFY_NOT_REACHED(); return make_ref_counted({}); } ErrorOr ContinuationControl::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); return {}; } ErrorOr DoubleQuotedString::dump(int level) const { TRY(Node::dump(level)); TRY(m_inner->dump(level + 1)); return {}; } ErrorOr> DoubleQuotedString::run(RefPtr shell) { StringBuilder builder; auto values = TRY(TRY(m_inner->run(shell))->resolve_as_list(shell)); builder.join(""sv, values); return make_ref_counted(TRY(builder.to_string())); } ErrorOr DoubleQuotedString::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { Line::Style style { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }; if (metadata.is_first_in_list) style.unify_with({ Line::Style::Bold }); editor.stylize({ m_position.start_offset, m_position.end_offset }, style); metadata.is_first_in_list = false; return m_inner->highlight_in_editor(editor, shell, metadata); } HitTestResult DoubleQuotedString::hit_test_position(size_t offset) const { return m_inner->hit_test_position(offset); } DoubleQuotedString::DoubleQuotedString(Position position, RefPtr inner) : Node(move(position)) , m_inner(move(inner)) { if (m_inner->is_syntax_error()) set_is_syntax_error(m_inner->syntax_error_node()); } DoubleQuotedString::~DoubleQuotedString() { } ErrorOr DynamicEvaluate::dump(int level) const { TRY(Node::dump(level)); TRY(m_inner->dump(level + 1)); return {}; } ErrorOr> DynamicEvaluate::run(RefPtr shell) { auto result = TRY(TRY(m_inner->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); // Dynamic Evaluation behaves differently between strings and lists. // Strings are treated as variables, and Lists are treated as commands. if (result->is_string()) { auto name_part = result->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); VERIFY(name_part.size() == 1); return make_ref_counted(name_part[0]); } // If it's anything else, we're just gonna cast it to a list. auto list = TRY(result->resolve_as_list(shell)); return make_ref_counted(move(list), position()); } ErrorOr DynamicEvaluate::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); return m_inner->highlight_in_editor(editor, shell, metadata); } HitTestResult DynamicEvaluate::hit_test_position(size_t offset) const { return m_inner->hit_test_position(offset); } DynamicEvaluate::DynamicEvaluate(Position position, NonnullRefPtr inner) : Node(move(position)) , m_inner(move(inner)) { if (m_inner->is_syntax_error()) set_is_syntax_error(m_inner->syntax_error_node()); } DynamicEvaluate::~DynamicEvaluate() { } ErrorOr Fd2FdRedirection::dump(int level) const { TRY(Node::dump(level)); print_indented(level, "{} -> {}", m_old_fd, m_new_fd); return {}; } ErrorOr> Fd2FdRedirection::run(RefPtr) { Command command; command.position = position(); command.redirections.append(FdRedirection::create(m_new_fd, m_old_fd, Rewiring::Close::None)); return make_ref_counted(move(command)); } ErrorOr Fd2FdRedirection::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(0x87, 0x9b, 0xcd) }); // 25% Darkened Periwinkle return {}; } Fd2FdRedirection::Fd2FdRedirection(Position position, int src, int dst) : Node(move(position)) , m_old_fd(src) , m_new_fd(dst) { } Fd2FdRedirection::~Fd2FdRedirection() { } ErrorOr FunctionDeclaration::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(name: {})\n", m_name.name); print_indented(level + 1, "(argument names)"); for (auto& arg : m_arguments) print_indented(level + 2, "(name: {})\n", arg.name); print_indented(level + 1, "(body)"); if (m_block) TRY(m_block->dump(level + 2)); else print_indented(level + 2, "(null)"); return {}; } ErrorOr> FunctionDeclaration::run(RefPtr shell) { Vector args; for (auto& arg : m_arguments) args.append(arg.name.to_deprecated_string()); shell->define_function(m_name.name.to_deprecated_string(), move(args), m_block); return make_ref_counted({}); } ErrorOr FunctionDeclaration::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { editor.stylize({ m_name.position.start_offset, m_name.position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Blue) }); for (auto& arg : m_arguments) editor.stylize({ arg.position.start_offset, arg.position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Italic }); metadata.is_first_in_list = true; if (m_block) TRY(m_block->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult FunctionDeclaration::hit_test_position(size_t offset) const { if (!m_block) return {}; auto result = m_block->hit_test_position(offset); if (result.matching_node && result.matching_node->is_simple_variable()) result.closest_node_with_semantic_meaning = this; return result; } ErrorOr> FunctionDeclaration::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node) return Vector {}; if (!matching_node->is_simple_variable()) return matching_node->complete_for_editor(shell, offset, hit_test_result); auto corrected_offset = offset - matching_node->position().start_offset - 1; // Skip the first '$' auto* node = static_cast(matching_node.ptr()); auto name = node->name().bytes_as_string_view().substring_view(0, corrected_offset); Vector results; for (auto& arg : m_arguments) { if (arg.name.starts_with_bytes(name)) results.append(arg.name.to_deprecated_string()); } results.extend(TRY(matching_node->complete_for_editor(shell, offset, hit_test_result))); return results; } FunctionDeclaration::FunctionDeclaration(Position position, NameWithPosition name, Vector arguments, RefPtr body) : Node(move(position)) , m_name(move(name)) , m_arguments(arguments) , m_block(move(body)) { if (m_block && m_block->is_syntax_error()) set_is_syntax_error(m_block->syntax_error_node()); } FunctionDeclaration::~FunctionDeclaration() { } ErrorOr ForLoop::dump(int level) const { TRY(Node::dump(level)); if (m_variable.has_value()) print_indented(level + 1, "iterating with {} in", m_variable->name); if (m_index_variable.has_value()) print_indented(level + 1, "with index name {} in", m_index_variable->name); if (m_iterated_expression) TRY(m_iterated_expression->dump(level + 2)); else print_indented(level + 2, "(ever)"); print_indented(level + 1, "Running"); if (m_block) TRY(m_block->dump(level + 2)); else print_indented(level + 2, "(null)"); return {}; } ErrorOr> ForLoop::run(RefPtr shell) { if (!m_block) return make_ref_counted({}); size_t consecutive_interruptions = 0; auto run = [&](auto& block_value) { if (shell->has_error(Shell::ShellError::InternalControlFlowBreak)) { shell->take_error(); return IterationDecision::Break; } if (shell->has_error(Shell::ShellError::InternalControlFlowContinue)) { shell->take_error(); return IterationDecision::Continue; } if (shell->has_any_error() && !shell->has_error(Shell::ShellError::InternalControlFlowInterrupted)) return IterationDecision::Break; if (block_value->is_job()) { auto job = static_cast(block_value.ptr())->job(); if (!job || job->is_running_in_background()) return IterationDecision::Continue; shell->block_on_job(job); if (shell->has_any_error()) { if (shell->has_error(Shell::ShellError::InternalControlFlowInterrupted)) ++consecutive_interruptions; if (shell->has_error(Shell::ShellError::InternalControlFlowKilled)) return IterationDecision::Break; } } return IterationDecision::Continue; }; if (m_iterated_expression) { auto variable_name = m_variable.has_value() ? m_variable->name : "it"_short_string; Optional index_name = m_index_variable.has_value() ? Optional(m_index_variable->name) : Optional(); size_t i = 0; TRY(m_iterated_expression->for_each_entry(shell, [&](auto value) -> ErrorOr { if (consecutive_interruptions >= 2) return IterationDecision::Break; if (shell) { if (shell->has_error(Shell::ShellError::InternalControlFlowInterrupted)) shell->take_error(); if (shell->has_any_error()) return IterationDecision::Break; } RefPtr block_value; { auto frame = shell->push_frame(DeprecatedString::formatted("for ({})", this)); shell->set_local_variable(variable_name.bytes_as_string_view(), value, true); if (index_name.has_value()) shell->set_local_variable(index_name.value(), make_ref_counted(TRY(String::number(i))), true); ++i; block_value = TRY(m_block->run(shell)); } return run(block_value); })); } else { for (;;) { if (consecutive_interruptions >= 2) break; if (shell) { if (shell->has_error(Shell::ShellError::InternalControlFlowInterrupted)) shell->take_error(); if (shell->has_any_error()) break; } RefPtr block_value = TRY(m_block->run(shell)); if (run(block_value) == IterationDecision::Break) break; } } return make_ref_counted({}); } ErrorOr ForLoop::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { auto is_loop = m_iterated_expression.is_null(); editor.stylize({ m_position.start_offset, m_position.start_offset + (is_loop ? 4 : 3) }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); if (!is_loop) { if (m_in_kw_position.has_value()) editor.stylize({ m_in_kw_position.value().start_offset, m_in_kw_position.value().end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); if (m_index_kw_position.has_value()) editor.stylize({ m_index_kw_position.value().start_offset, m_index_kw_position.value().end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); metadata.is_first_in_list = false; TRY(m_iterated_expression->highlight_in_editor(editor, shell, metadata)); } if (m_index_variable.has_value()) editor.stylize({ m_index_variable->position.start_offset, m_index_variable->position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Italic }); if (m_variable.has_value()) editor.stylize({ m_variable->position.start_offset, m_variable->position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Italic }); metadata.is_first_in_list = true; if (m_block) TRY(m_block->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult ForLoop::hit_test_position(size_t offset) const { if (m_iterated_expression) { if (auto result = m_iterated_expression->hit_test_position(offset); result.matching_node) return result; } if (!m_block) return {}; return m_block->hit_test_position(offset); } ForLoop::ForLoop(Position position, Optional variable, Optional index_variable, RefPtr iterated_expr, RefPtr block, Optional in_kw_position, Optional index_kw_position) : Node(move(position)) , m_variable(move(variable)) , m_index_variable(move(index_variable)) , m_iterated_expression(move(iterated_expr)) , m_block(move(block)) , m_in_kw_position(move(in_kw_position)) , m_index_kw_position(move(index_kw_position)) { if (m_iterated_expression && m_iterated_expression->is_syntax_error()) set_is_syntax_error(m_iterated_expression->syntax_error_node()); else if (m_block && m_block->is_syntax_error()) set_is_syntax_error(m_block->syntax_error_node()); } ForLoop::~ForLoop() { } ErrorOr Glob::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_text); return {}; } ErrorOr> Glob::run(RefPtr) { return make_ref_counted(m_text, position()); } ErrorOr Glob::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata metadata) { Line::Style style { Line::Style::Foreground(Line::Style::XtermColor::Cyan) }; if (metadata.is_first_in_list) style.unify_with({ Line::Style::Bold }); editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style)); return {}; } Glob::Glob(Position position, String text) : Node(move(position)) , m_text(move(text)) { } Glob::~Glob() { } ErrorOr Heredoc::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(End Key)"); print_indented(level + 2, "{}", m_end); print_indented(level + 1, "(Allows Interpolation)"); print_indented(level + 2, "{}", m_allows_interpolation); if (!evaluates_to_string()) { print_indented(level + 1, "(Target FD)"); print_indented(level + 2, "{}", *m_target_fd); } print_indented(level + 1, "(Contents)"); if (m_contents) TRY(m_contents->dump(level + 2)); else print_indented(level + 2, "(null)"); return {}; } ErrorOr> Heredoc::run(RefPtr shell) { if (!m_contents) { if (shell) shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Attempt to evaluate an unresolved heredoc"sv, position()); return nullptr; } auto value = TRY([&]() -> ErrorOr> { if (!m_deindent) return TRY(m_contents->run(shell)); // To deindent, first split to lines... auto value = TRY(m_contents->run(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); if (!value) return value; auto list = TRY(value->resolve_as_list(shell)); // The list better have one entry, otherwise we've put the wrong kind of node inside this heredoc VERIFY(list.size() == 1); auto lines = list.first().bytes_as_string_view().split_view('\n'); // Now just trim each line and put them back in a string StringBuilder builder { list.first().bytes_as_string_view().length() }; for (auto& line : lines) { builder.append(line.trim_whitespace(TrimMode::Left)); builder.append('\n'); } return make_ref_counted(TRY(builder.to_string())); }()); if (evaluates_to_string()) return value; int fds[2]; auto rc = pipe(fds); if (rc != 0) { // pipe() failed for {} if (shell) shell->raise_error(Shell::ShellError::PipeFailure, DeprecatedString::formatted("heredoc: {}", strerror(errno)), position()); return nullptr; } auto read_end = fds[0]; auto write_end = fds[1]; // Dump all of 'value' into the pipe. auto* file = fdopen(write_end, "wb"); if (!file) { if (shell) shell->raise_error(Shell::ShellError::OpenFailure, "heredoc"sv, position()); return nullptr; } auto text = TRY(value->resolve_as_string(shell)); auto bytes = text.bytes(); auto written = fwrite(bytes.data(), 1, bytes.size(), file); fflush(file); if (written != bytes.size()) { if (shell) shell->raise_error(Shell::ShellError::WriteFailure, "heredoc"sv, position()); } fclose(file); Command command; command.position = position(); command.redirections.append(FdRedirection::create(read_end, *target_fd(), Rewiring::Close::None)); return make_ref_counted(move(command)); } ErrorOr Heredoc::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { Line::Style content_style { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }; if (metadata.is_first_in_list) content_style.unify_with({ Line::Style::Bold }); if (!m_contents) content_style.unify_with({ Line::Style::Foreground(Line::Style::XtermColor::Red) }, true); editor.stylize({ m_position.start_offset, m_position.end_offset }, content_style); if (m_contents) TRY(m_contents->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult Heredoc::hit_test_position(size_t offset) const { if (!m_contents) return {}; return m_contents->hit_test_position(offset); } Heredoc::Heredoc(Position position, String end, bool allow_interpolation, bool deindent, Optional target_fd) : Node(move(position)) , m_end(move(end)) , m_allows_interpolation(allow_interpolation) , m_deindent(deindent) , m_target_fd(target_fd) { } Heredoc::~Heredoc() { } ErrorOr HistoryEvent::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "Event Selector"); switch (m_selector.event.kind) { case HistorySelector::EventKind::IndexFromStart: print_indented(level + 2, "IndexFromStart"); break; case HistorySelector::EventKind::IndexFromEnd: print_indented(level + 2, "IndexFromEnd"); break; case HistorySelector::EventKind::ContainingStringLookup: print_indented(level + 2, "ContainingStringLookup"); break; case HistorySelector::EventKind::StartingStringLookup: print_indented(level + 2, "StartingStringLookup"); break; } print_indented(level + 3, "{}({})", m_selector.event.index, m_selector.event.text); print_indented(level + 1, "Word Selector"); auto print_word_selector = [&](HistorySelector::WordSelector const& selector) { switch (selector.kind) { case HistorySelector::WordSelectorKind::Index: print_indented(level + 3, "Index {}", selector.selector); break; case HistorySelector::WordSelectorKind::Last: print_indented(level + 3, "Last"); break; } }; if (m_selector.word_selector_range.end.has_value()) { print_indented(level + 2, "Range Start"); print_word_selector(m_selector.word_selector_range.start); print_indented(level + 2, "Range End"); print_word_selector(m_selector.word_selector_range.end.value()); } else { print_indented(level + 2, "Direct Address"); print_word_selector(m_selector.word_selector_range.start); } return {}; } ErrorOr> HistoryEvent::run(RefPtr shell) { if (!shell) return make_ref_counted({}); auto editor = shell->editor(); if (!editor) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "No history available!", position()); return make_ref_counted({}); } auto& history = editor->history(); // FIXME: Implement reverse iterators and find()? auto find_reverse = [](auto it_start, auto it_end, auto finder) { auto it = it_end; while (it != it_start) { --it; if (finder(*it)) return it; } return it_end; }; // First, resolve the event itself. DeprecatedString resolved_history; switch (m_selector.event.kind) { case HistorySelector::EventKind::IndexFromStart: if (m_selector.event.index >= history.size()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History event index out of bounds", m_selector.event.text_position); return make_ref_counted({}); } resolved_history = history[m_selector.event.index].entry; break; case HistorySelector::EventKind::IndexFromEnd: if (m_selector.event.index >= history.size()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History event index out of bounds", m_selector.event.text_position); return make_ref_counted({}); } resolved_history = history[history.size() - m_selector.event.index - 1].entry; break; case HistorySelector::EventKind::ContainingStringLookup: { auto it = find_reverse(history.begin(), history.end(), [&](auto& entry) { return entry.entry.contains(m_selector.event.text); }); if (it.is_end()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History event did not match any entry", m_selector.event.text_position); return make_ref_counted({}); } resolved_history = it->entry; break; } case HistorySelector::EventKind::StartingStringLookup: { auto it = find_reverse(history.begin(), history.end(), [&](auto& entry) { return entry.entry.starts_with(m_selector.event.text); }); if (it.is_end()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History event did not match any entry", m_selector.event.text_position); return make_ref_counted({}); } resolved_history = it->entry; break; } } // Then, split it up to "words". auto nodes = Parser { resolved_history }.parse_as_multiple_expressions(); // Now take the "words" as described by the word selectors. bool is_range = m_selector.word_selector_range.end.has_value(); if (is_range) { auto start_index = m_selector.word_selector_range.start.resolve(nodes.size()); auto end_index = m_selector.word_selector_range.end->resolve(nodes.size()); if (start_index >= nodes.size()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History word index out of bounds", m_selector.word_selector_range.start.position); return make_ref_counted({}); } if (end_index >= nodes.size()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History word index out of bounds", m_selector.word_selector_range.end->position); return make_ref_counted({}); } decltype(nodes) resolved_nodes; resolved_nodes.append(nodes.data() + start_index, end_index - start_index + 1); NonnullRefPtr list = make_ref_counted(position(), move(resolved_nodes)); return list->run(shell); } auto index = m_selector.word_selector_range.start.resolve(nodes.size()); if (index >= nodes.size()) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "History word index out of bounds", m_selector.word_selector_range.start.position); return make_ref_counted({}); } return nodes[index]->run(shell); } ErrorOr HistoryEvent::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata metadata) { Line::Style style { Line::Style::Foreground(Line::Style::XtermColor::Green) }; if (metadata.is_first_in_list) style.unify_with({ Line::Style::Bold }); editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style)); return {}; } HistoryEvent::HistoryEvent(Position position, HistorySelector selector) : Node(move(position)) , m_selector(move(selector)) { if (m_selector.word_selector_range.start.syntax_error_node) set_is_syntax_error(*m_selector.word_selector_range.start.syntax_error_node); else if (m_selector.word_selector_range.end.has_value() && m_selector.word_selector_range.end->syntax_error_node) set_is_syntax_error(*m_selector.word_selector_range.end->syntax_error_node); } HistoryEvent::~HistoryEvent() { } ErrorOr Execute::dump(int level) const { TRY(Node::dump(level)); if (m_capture_stdout) print_indented(level + 1, "(Capturing stdout)"); TRY(m_command->dump(level + 1)); return {}; } ErrorOr Execute::for_each_entry(RefPtr shell, Function(NonnullRefPtr)> callback) { if (m_command->would_execute()) return m_command->for_each_entry(shell, move(callback)); auto unexpanded_commands = TRY(TRY(m_command->run(shell))->resolve_as_commands(shell)); if (shell && shell->has_any_error()) return {}; if (!shell) return {}; auto commands = TRY(shell->expand_aliases(move(unexpanded_commands))); if (m_capture_stdout) { // Make sure that we're going to be running _something_. auto has_one_command = false; for (auto& command : commands) { if (command.argv.is_empty() && !command.pipeline && command.next_chain.is_empty()) continue; has_one_command = true; break; } if (!has_one_command) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Cannot capture standard output when no command is being executed", m_position); return {}; } int pipefd[2]; int rc = pipe(pipefd); if (rc < 0) { dbgln("Error: cannot pipe(): {}", strerror(errno)); return {}; } auto& last_in_commands = commands.last(); last_in_commands.redirections.prepend(FdRedirection::create(pipefd[1], STDOUT_FILENO, Rewiring::Close::Old)); last_in_commands.should_wait = false; last_in_commands.should_notify_if_in_background = false; last_in_commands.is_pipe_source = false; Core::EventLoop loop; auto notifier = Core::Notifier::construct(pipefd[0], Core::Notifier::Type::Read); AllocatingMemoryStream stream; enum CheckResult { Continue, Break, NothingLeft, }; auto check_and_call = [&]() -> ErrorOr { auto ifs = TRY(shell->local_variable_or("IFS"sv, "\n"sv)); if (auto offset = TRY(stream.offset_of(ifs.bytes())); offset.has_value()) { auto line_end = offset.value(); if (line_end == 0) { TRY(stream.discard(ifs.length())); if (shell->options.inline_exec_keep_empty_segments) if (TRY(callback(make_ref_counted(String {}))) == IterationDecision::Break) { loop.quit(Break); notifier->set_enabled(false); return Break; } } else { auto entry_result = ByteBuffer::create_uninitialized(line_end + ifs.length()); if (entry_result.is_error()) { loop.quit(Break); notifier->set_enabled(false); return Break; } auto entry = entry_result.release_value(); TRY(stream.read_until_filled(entry)); auto str = TRY(String::from_utf8(StringView(entry.data(), entry.size() - ifs.length()))); if (TRY(callback(make_ref_counted(move(str)))) == IterationDecision::Break) { loop.quit(Break); notifier->set_enabled(false); return Break; } } return Continue; } return NothingLeft; }; notifier->on_activation = [&]() -> void { constexpr static auto buffer_size = 16; u8 buffer[buffer_size]; size_t remaining_size = buffer_size; for (;;) { notifier->set_type(Core::Notifier::Type::None); bool should_enable_notifier = false; ScopeGuard notifier_enabler { [&] { if (should_enable_notifier) notifier->set_type(Core::Notifier::Type::Read); } }; if (check_and_call().release_value_but_fixme_should_propagate_errors() == Break) { loop.quit(Break); return; } auto read_size = read(pipefd[0], buffer, remaining_size); if (read_size < 0) { int saved_errno = errno; if (saved_errno == EINTR) { should_enable_notifier = true; continue; } if (saved_errno == 0) continue; dbgln("read() failed: {}", strerror(saved_errno)); break; } if (read_size == 0) break; should_enable_notifier = true; stream.write_until_depleted({ buffer, (size_t)read_size }).release_value_but_fixme_should_propagate_errors(); } loop.quit(NothingLeft); }; auto jobs = shell->run_commands(commands); ScopeGuard kill_jobs_if_around { [&] { for (auto& job : jobs) { if (job->is_running_in_background() && !job->exited() && !job->signaled()) { job->set_should_announce_signal(false); // We're explicitly killing it here. shell->kill_job(job, SIGTERM); } } } }; auto exit_reason = loop.exec(); notifier->on_activation = nullptr; if (close(pipefd[0]) < 0) { dbgln("close() failed: {}", strerror(errno)); } if (exit_reason != Break && !stream.is_eof()) { auto action = Continue; do { action = TRY(check_and_call()); if (action == Break) return {}; } while (action == Continue); if (!stream.is_eof()) { auto entry_result = ByteBuffer::create_uninitialized(stream.used_buffer_size()); if (entry_result.is_error()) { shell->raise_error(Shell::ShellError::OutOfMemory, {}, position()); return {}; } auto entry = entry_result.release_value(); TRY(stream.read_until_filled(entry)); TRY(callback(make_ref_counted(TRY(String::from_utf8(entry))))); } } return {}; } auto jobs = shell->run_commands(commands); if (!jobs.is_empty()) TRY(callback(make_ref_counted(jobs.last()))); return {}; } ErrorOr> Execute::run(RefPtr shell) { if (shell && shell->has_any_error()) return make_ref_counted({}); if (m_command->would_execute()) return m_command->run(shell); Vector> values; TRY(for_each_entry(shell, [&](auto value) { values.append(*value); return IterationDecision::Continue; })); if (values.size() == 1 && values.first()->is_job()) return values.first(); return make_ref_counted(move(values)); } ErrorOr Execute::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { if (m_capture_stdout) editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Green) }); metadata.is_first_in_list = true; return m_command->highlight_in_editor(editor, shell, metadata); } HitTestResult Execute::hit_test_position(size_t offset) const { auto result = m_command->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning) result.closest_node_with_semantic_meaning = this; if (!result.closest_command_node) result.closest_command_node = m_command; return result; } ErrorOr> Execute::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node || !matching_node->is_bareword()) return Vector {}; auto corrected_offset = offset - matching_node->position().start_offset; auto* node = static_cast(matching_node.ptr()); if (corrected_offset > node->text().bytes_as_string_view().length()) return Vector {}; return shell.complete_program_name(node->text(), corrected_offset); } Execute::Execute(Position position, NonnullRefPtr command, bool capture_stdout) : Node(move(position)) , m_command(move(command)) , m_capture_stdout(capture_stdout) { if (m_command->is_syntax_error()) set_is_syntax_error(m_command->syntax_error_node()); } Execute::~Execute() { } ErrorOr IfCond::dump(int level) const { TRY(Node::dump(level)); print_indented(++level, "Condition"); TRY(m_condition->dump(level + 1)); print_indented(level, "True Branch"); if (m_true_branch) TRY(m_true_branch->dump(level + 1)); else print_indented(level + 1, "(empty)"); print_indented(level, "False Branch"); if (m_false_branch) TRY(m_false_branch->dump(level + 1)); else print_indented(level + 1, "(empty)"); return {}; } ErrorOr> IfCond::run(RefPtr shell) { auto cond = TRY(TRY(m_condition->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); // The condition could be a builtin, in which case it has already run and exited. if (cond->is_job()) { auto cond_job_value = static_cast(cond.ptr()); auto cond_job = cond_job_value->job(); shell->block_on_job(cond_job); } if (shell->last_return_code == 0) { if (m_true_branch) return m_true_branch->run(shell); } else { if (m_false_branch) return m_false_branch->run(shell); } return make_ref_counted({}); } ErrorOr IfCond::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { metadata.is_first_in_list = true; editor.stylize({ m_position.start_offset, m_position.start_offset + 2 }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); if (m_else_position.has_value()) editor.stylize({ m_else_position.value().start_offset, m_else_position.value().start_offset + 4 }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); TRY(m_condition->highlight_in_editor(editor, shell, metadata)); if (m_true_branch) TRY(m_true_branch->highlight_in_editor(editor, shell, metadata)); if (m_false_branch) TRY(m_false_branch->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult IfCond::hit_test_position(size_t offset) const { if (auto result = m_condition->hit_test_position(offset); result.matching_node) return result; if (m_true_branch) { if (auto result = m_true_branch->hit_test_position(offset); result.matching_node) return result; } if (m_false_branch) { if (auto result = m_false_branch->hit_test_position(offset); result.matching_node) return result; } return {}; } IfCond::IfCond(Position position, Optional else_position, NonnullRefPtr condition, RefPtr true_branch, RefPtr false_branch) : Node(move(position)) , m_condition(move(condition)) , m_true_branch(move(true_branch)) , m_false_branch(move(false_branch)) , m_else_position(move(else_position)) { if (m_condition->is_syntax_error()) set_is_syntax_error(m_condition->syntax_error_node()); else if (m_true_branch && m_true_branch->is_syntax_error()) set_is_syntax_error(m_true_branch->syntax_error_node()); else if (m_false_branch && m_false_branch->is_syntax_error()) set_is_syntax_error(m_false_branch->syntax_error_node()); m_condition = make_ref_counted(m_condition->position(), m_condition); if (m_true_branch) { auto true_branch = m_true_branch.release_nonnull(); if (true_branch->is_execute()) m_true_branch = static_ptr_cast(true_branch)->command(); else m_true_branch = move(true_branch); } if (m_false_branch) { auto false_branch = m_false_branch.release_nonnull(); if (false_branch->is_execute()) m_false_branch = static_ptr_cast(false_branch)->command(); else m_false_branch = move(false_branch); } } IfCond::~IfCond() { } ErrorOr ImmediateExpression::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(function)"sv); print_indented(level + 2, "{}", m_function.name); print_indented(level + 1, "(arguments)"); for (auto& argument : arguments()) TRY(argument->dump(level + 2)); return {}; } ErrorOr> ImmediateExpression::run(RefPtr shell) { auto node = TRY(shell->run_immediate_function(m_function.name, *this, arguments())); if (node) return node->run(shell); return make_ref_counted({}); } ErrorOr ImmediateExpression::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { // '${' - FIXME: This could also be '$\\\n{' editor.stylize({ m_position.start_offset, m_position.start_offset + 2 }, { Line::Style::Foreground(Line::Style::XtermColor::Green) }); // Function name Line::Style function_style { Line::Style::Foreground(Line::Style::XtermColor::Red) }; if (shell.has_immediate_function(function_name())) function_style = { Line::Style::Foreground(Line::Style::XtermColor::Green) }; editor.stylize({ m_function.position.start_offset, m_function.position.end_offset }, move(function_style)); // Arguments for (auto& argument : m_arguments) { metadata.is_first_in_list = false; TRY(argument->highlight_in_editor(editor, shell, metadata)); } // Closing brace if (m_closing_brace_position.has_value()) editor.stylize({ m_closing_brace_position->start_offset, m_closing_brace_position->end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Green) }); return {}; } ErrorOr> ImmediateExpression::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node || matching_node != this) return Vector {}; auto corrected_offset = offset - m_function.position.start_offset; if (corrected_offset > m_function.name.bytes_as_string_view().length()) return Vector {}; return shell.complete_immediate_function_name(m_function.name, corrected_offset); } HitTestResult ImmediateExpression::hit_test_position(size_t offset) const { if (m_function.position.contains(offset)) return { this, this, this }; for (auto& argument : m_arguments) { if (auto result = argument->hit_test_position(offset); result.matching_node) return result; } return {}; } ImmediateExpression::ImmediateExpression(Position position, NameWithPosition function, Vector> arguments, Optional closing_brace_position) : Node(move(position)) , m_arguments(move(arguments)) , m_function(move(function)) , m_closing_brace_position(move(closing_brace_position)) { if (is_syntax_error()) return; for (auto& argument : m_arguments) { if (argument->is_syntax_error()) { set_is_syntax_error(argument->syntax_error_node()); return; } } } ImmediateExpression::~ImmediateExpression() { } ErrorOr Join::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> Join::run(RefPtr shell) { auto left = TRY(m_left->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); if (left.last().should_wait && !left.last().next_chain.is_empty()) { // Join (C0s*; C1) X -> (C0s*; Join C1 X) auto& lhs_node = left.last().next_chain.last().node; lhs_node = make_ref_counted(m_position, lhs_node, m_right); return make_ref_counted(move(left)); } auto right = TRY(m_right->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); return make_ref_counted(join_commands(move(left), move(right))); } ErrorOr Join::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_left->highlight_in_editor(editor, shell, metadata)); if (m_left->is_list() || m_left->is_command()) metadata.is_first_in_list = false; return m_right->highlight_in_editor(editor, shell, metadata); } HitTestResult Join::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (result.matching_node) return result; return m_right->hit_test_position(offset); } RefPtr Join::leftmost_trivial_literal() const { if (auto value = m_left->leftmost_trivial_literal()) return value; return m_right->leftmost_trivial_literal(); } Join::Join(Position position, NonnullRefPtr left, NonnullRefPtr right) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } Join::~Join() { } ErrorOr MatchExpr::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(expression: {})", m_expr_name); TRY(m_matched_expr->dump(level + 2)); print_indented(level + 1, "(named: {})", m_expr_name); print_indented(level + 1, "(entries)"); for (auto& entry : m_entries) { StringBuilder builder; builder.append("(match"sv); if (entry.match_names.has_value()) { builder.append(" to names ("sv); bool first = true; for (auto& name : entry.match_names.value()) { if (!first) builder.append(' '); first = false; builder.append(name); } builder.append("))"sv); } else { builder.append(')'); } print_indented(level + 2, "{}", builder.string_view()); TRY(entry.options.visit( [&](Vector> const& options) -> ErrorOr { for (auto& option : options) TRY(option->dump(level + 3)); return {}; }, [&](Vector> const& options) -> ErrorOr { for (auto& option : options) print_indented(level + 3, "(regex: {})", option.pattern_value); return {}; })); print_indented(level + 2, "(execute)"); if (entry.body) TRY(entry.body->dump(level + 3)); else print_indented(level + 3, "(nothing)"sv); } return {}; } ErrorOr> MatchExpr::run(RefPtr shell) { auto value = TRY(TRY(m_matched_expr->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto list = value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); auto list_matches = [&](auto&& pattern, auto& spans) { if constexpr (IsSame, Regex>) { if (list.size() != 1) return false; auto& subject = list.first(); auto match = pattern.match(subject); if (!match.success) return false; spans.ensure_capacity(match.n_capture_groups); for (size_t i = 0; i < match.n_capture_groups; ++i) { auto& capture = match.capture_group_matches[0][i]; spans.append(capture.view.to_string().release_value_but_fixme_should_propagate_errors()); } return true; } else { if (pattern.size() != list.size()) return false; for (size_t i = 0; i < pattern.size(); ++i) { Vector mask_spans; if (!list[i].bytes_as_string_view().matches(pattern[i], mask_spans)) return false; for (auto& span : mask_spans) spans.append(list[i].substring_from_byte_offset(span.start, span.length).release_value_but_fixme_should_propagate_errors()); } return true; } }; auto resolve_pattern = [&](auto& option) -> decltype(auto) { if constexpr (IsSame, Regex>) { return ErrorOr>(move(option)); } else { Vector pattern; if (option->is_glob()) { pattern.append(static_cast(option.ptr())->text()); } else if (option->is_bareword()) { pattern.append(static_cast(option.ptr())->text()); } else { auto list_or_error = option->run(shell); if (list_or_error.is_error() || (shell && shell->has_any_error())) return ErrorOr>(move(pattern)); auto list = list_or_error.release_value(); auto result = option->for_each_entry(shell, [&](auto&& value) -> ErrorOr { pattern.extend(TRY(value->resolve_as_list(nullptr))); // Note: 'nullptr' incurs special behavior, // asking the node for a 'raw' value. return IterationDecision::Continue; }); if (result.is_error()) return ErrorOr>(result.release_error()); } return ErrorOr>(move(pattern)); } }; auto frame = shell->push_frame(DeprecatedString::formatted("match ({})", this)); if (!m_expr_name.is_empty()) shell->set_local_variable(m_expr_name.to_deprecated_string(), value, true); for (auto& entry : m_entries) { auto result = TRY(entry.options.visit([&](auto& options) -> ErrorOr>> { for (auto& option : options) { Vector spans; if (list_matches(TRY(resolve_pattern(option)), spans)) { if (entry.body) { if (entry.match_names.has_value()) { size_t i = 0; for (auto& name : entry.match_names.value()) { if (spans.size() > i) shell->set_local_variable(name.to_deprecated_string(), make_ref_counted(spans[i]), true); ++i; } } return TRY(entry.body->run(shell)); } return RefPtr(make_ref_counted({})); } } return IterationDecision::Continue; })); if (result.has() && result.get() == IterationDecision::Break) break; if (result.has>()) return move(result).get>(); } // Non-exhaustive 'case' statements are valid in POSIX. if (!shell || !shell->posix_mode()) shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Non-exhaustive match rules!", position()); return make_ref_counted({}); } ErrorOr MatchExpr::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { editor.stylize({ m_position.start_offset, m_position.start_offset + 5 }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); if (m_as_position.has_value()) editor.stylize({ m_as_position.value().start_offset, m_as_position.value().end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); metadata.is_first_in_list = false; TRY(m_matched_expr->highlight_in_editor(editor, shell, metadata)); for (auto& entry : m_entries) { metadata.is_first_in_list = false; TRY(entry.options.visit( [&](Vector>& node_options) -> ErrorOr { for (auto& option : node_options) TRY(option->highlight_in_editor(editor, shell, metadata)); return {}; }, [](auto&) -> ErrorOr { return {}; })); metadata.is_first_in_list = true; if (entry.body) TRY(entry.body->highlight_in_editor(editor, shell, metadata)); for (auto& position : entry.pipe_positions) editor.stylize({ position.start_offset, position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); if (entry.match_as_position.has_value()) editor.stylize({ entry.match_as_position.value().start_offset, entry.match_as_position.value().end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); } return {}; } HitTestResult MatchExpr::hit_test_position(size_t offset) const { auto result = m_matched_expr->hit_test_position(offset); if (result.matching_node) return result; for (auto& entry : m_entries) { if (!entry.body) continue; auto result = entry.body->hit_test_position(offset); if (result.matching_node) return result; } return {}; } MatchExpr::MatchExpr(Position position, NonnullRefPtr expr, String name, Optional as_position, Vector entries) : Node(move(position)) , m_matched_expr(move(expr)) , m_expr_name(move(name)) , m_as_position(move(as_position)) , m_entries(move(entries)) { if (m_matched_expr->is_syntax_error()) { set_is_syntax_error(m_matched_expr->syntax_error_node()); } else { for (auto& entry : m_entries) { if (!entry.body) continue; if (entry.body->is_syntax_error()) { set_is_syntax_error(entry.body->syntax_error_node()); break; } } } } MatchExpr::~MatchExpr() { } ErrorOr Or::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> Or::run(RefPtr shell) { auto commands = TRY(m_left->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); commands.last().next_chain.empend(*m_right, NodeWithAction::Or); return make_ref_counted(move(commands)); } ErrorOr Or::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_left->highlight_in_editor(editor, shell, metadata)); return m_right->highlight_in_editor(editor, shell, metadata); } HitTestResult Or::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = m_right; return result; } result = m_right->hit_test_position(offset); if (!result.closest_command_node) result.closest_command_node = m_right; return result; } Or::Or(Position position, NonnullRefPtr left, NonnullRefPtr right, Position or_position) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) , m_or_position(or_position) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } Or::~Or() { } ErrorOr Pipe::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> Pipe::run(RefPtr shell) { auto left = TRY(m_left->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto right = TRY(m_right->to_lazy_evaluated_commands(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto last_in_left = left.take_last(); auto first_in_right = right.take_first(); auto pipe_read_end = FdRedirection::create(-1, STDIN_FILENO, Rewiring::Close::Old); auto pipe_write_end = FdRedirection::create(-1, STDOUT_FILENO, pipe_read_end, Rewiring::Close::RefreshOld); auto insert_at_start_or_after_last_pipe = [&](auto& pipe, auto& command) { size_t insert_index = 0; auto& redirections = command.redirections; for (ssize_t i = redirections.size() - 1; i >= 0; --i) { auto& redirection = redirections[i]; if (!redirection->is_fd_redirection()) continue; auto& fd_redirection = static_cast(*redirection); if (fd_redirection.old_fd == -1) { insert_index = i; break; } } redirections.insert(insert_index, pipe); }; insert_at_start_or_after_last_pipe(pipe_read_end, first_in_right); insert_at_start_or_after_last_pipe(pipe_write_end, last_in_left); last_in_left.should_wait = false; last_in_left.is_pipe_source = true; if (first_in_right.pipeline) { last_in_left.pipeline = first_in_right.pipeline; } else { auto pipeline = make_ref_counted(); last_in_left.pipeline = pipeline; first_in_right.pipeline = pipeline; } Vector commands; commands.extend(left); commands.append(last_in_left); commands.append(first_in_right); commands.extend(right); return make_ref_counted(move(commands)); } ErrorOr Pipe::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_left->highlight_in_editor(editor, shell, metadata)); return m_right->highlight_in_editor(editor, shell, metadata); } HitTestResult Pipe::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = m_right; return result; } result = m_right->hit_test_position(offset); if (!result.closest_command_node) result.closest_command_node = m_right; return result; } Pipe::Pipe(Position position, NonnullRefPtr left, NonnullRefPtr right) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } Pipe::~Pipe() { } PathRedirectionNode::PathRedirectionNode(Position position, int fd, NonnullRefPtr path) : Node(move(position)) , m_fd(fd) , m_path(move(path)) { } ErrorOr PathRedirectionNode::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(0x87, 0x9b, 0xcd) }); // 25% Darkened Periwinkle metadata.is_first_in_list = false; TRY(m_path->highlight_in_editor(editor, shell, metadata)); if (m_path->is_bareword()) { auto path_text = TRY(TRY(m_path->run(nullptr))->resolve_as_list(nullptr)); VERIFY(path_text.size() == 1); // Apply a URL to the path. auto& position = m_path->position(); auto& path = path_text[0]; if (!path.starts_with('/')) path = String::formatted("{}/{}", shell.cwd, path).release_value_but_fixme_should_propagate_errors(); auto url = URL::create_with_file_scheme(path.to_deprecated_string()); url.set_host(TRY(String::from_deprecated_string(shell.hostname))); editor.stylize({ position.start_offset, position.end_offset }, { Line::Style::Hyperlink(url.to_deprecated_string()) }); } return {}; } HitTestResult PathRedirectionNode::hit_test_position(size_t offset) const { auto result = m_path->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning) result.closest_node_with_semantic_meaning = this; return result; } ErrorOr> PathRedirectionNode::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node || !matching_node->is_bareword()) return Vector {}; auto corrected_offset = offset - matching_node->position().start_offset; auto* node = static_cast(matching_node.ptr()); if (corrected_offset > node->text().bytes_as_string_view().length()) return Vector {}; return shell.complete_path(""sv, node->text(), corrected_offset, Shell::ExecutableOnly::No, nullptr, nullptr); } PathRedirectionNode::~PathRedirectionNode() { } ErrorOr Range::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(From)"); TRY(m_start->dump(level + 2)); print_indented(level + 1, "(To)"); TRY(m_end->dump(level + 2)); return {}; } ErrorOr> Range::run(RefPtr shell) { auto interpolate = [position = position()](RefPtr start, RefPtr end, RefPtr shell) -> Vector> { Vector> values; if (start->is_string() && end->is_string()) { auto start_str = start->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors()[0]; auto end_str = end->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors()[0]; Utf8View start_view { start_str }, end_view { end_str }; if (start_view.validate() && end_view.validate()) { if (start_view.length() == 1 && end_view.length() == 1) { // Interpolate between two code points. auto start_code_point = *start_view.begin(); auto end_code_point = *end_view.begin(); auto step = start_code_point > end_code_point ? -1 : 1; StringBuilder builder; for (u32 code_point = start_code_point; code_point != end_code_point; code_point += step) { builder.clear(); builder.append_code_point(code_point); values.append(make_ref_counted(builder.to_string().release_value_but_fixme_should_propagate_errors())); } // Append the ending code point too, most shells treat this as inclusive. builder.clear(); builder.append_code_point(end_code_point); values.append(make_ref_counted(builder.to_string().release_value_but_fixme_should_propagate_errors())); } else { // Could be two numbers? auto start_int = start_str.bytes_as_string_view().to_int(); auto end_int = end_str.bytes_as_string_view().to_int(); if (start_int.has_value() && end_int.has_value()) { auto start = start_int.value(); auto end = end_int.value(); auto step = start > end ? -1 : 1; for (int value = start; value != end; value += step) values.append(make_ref_counted(String::number(value).release_value_but_fixme_should_propagate_errors())); // Append the range end too, most shells treat this as inclusive. values.append(make_ref_counted(String::number(end).release_value_but_fixme_should_propagate_errors())); } else { goto yield_start_end; } } } else { yield_start_end:; 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(move(start_str))); values.append(make_ref_counted(move(end_str))); } return values; } warnln("Shell: Cannot apply the requested interpolation"); return values; }; auto start_value = TRY(m_start->run(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto end_value = TRY(m_end->run(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); if (!start_value || !end_value) return make_ref_counted({}); return make_ref_counted(interpolate(*start_value, *end_value, shell)); } ErrorOr Range::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_start->highlight_in_editor(editor, shell, metadata)); // Highlight the '..' editor.stylize({ m_start->position().end_offset, m_end->position().start_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }); metadata.is_first_in_list = false; return m_end->highlight_in_editor(editor, shell, metadata); } HitTestResult Range::hit_test_position(size_t offset) const { auto result = m_start->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = m_start; return result; } result = m_end->hit_test_position(offset); if (!result.closest_command_node) result.closest_command_node = m_end; return result; } Range::Range(Position position, NonnullRefPtr start, NonnullRefPtr end) : Node(move(position)) , m_start(move(start)) , m_end(move(end)) { if (m_start->is_syntax_error()) set_is_syntax_error(m_start->syntax_error_node()); else if (m_end->is_syntax_error()) set_is_syntax_error(m_end->syntax_error_node()); } Range::~Range() { } ErrorOr ReadRedirection::dump(int level) const { TRY(Node::dump(level)); TRY(m_path->dump(level + 1)); print_indented(level + 1, "To {}", m_fd); return {}; } ErrorOr> ReadRedirection::run(RefPtr shell) { Command command; auto path_segments = TRY(TRY(m_path->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); StringBuilder builder; builder.join(' ', path_segments); command.redirections.append(PathRedirection::create(builder.to_string().release_value_but_fixme_should_propagate_errors(), m_fd, PathRedirection::Read)); return make_ref_counted(move(command)); } ReadRedirection::ReadRedirection(Position position, int fd, NonnullRefPtr path) : PathRedirectionNode(move(position), fd, move(path)) { } ReadRedirection::~ReadRedirection() { } ErrorOr ReadWriteRedirection::dump(int level) const { TRY(Node::dump(level)); TRY(m_path->dump(level + 1)); print_indented(level + 1, "To/From {}", m_fd); return {}; } ErrorOr> ReadWriteRedirection::run(RefPtr shell) { Command command; auto path_segments = TRY(TRY(m_path->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); StringBuilder builder; builder.join(' ', path_segments); command.redirections.append(PathRedirection::create(builder.to_string().release_value_but_fixme_should_propagate_errors(), m_fd, PathRedirection::ReadWrite)); return make_ref_counted(move(command)); } ReadWriteRedirection::ReadWriteRedirection(Position position, int fd, NonnullRefPtr path) : PathRedirectionNode(move(position), fd, move(path)) { } ReadWriteRedirection::~ReadWriteRedirection() { } ErrorOr Sequence::dump(int level) const { TRY(Node::dump(level)); for (auto& entry : m_entries) TRY(entry->dump(level + 1)); return {}; } ErrorOr> Sequence::run(RefPtr shell) { Vector all_commands; Command* last_command_in_sequence = nullptr; for (auto& entry : m_entries) { if (shell && shell->has_any_error()) break; if (!last_command_in_sequence) { auto commands = TRY(entry->to_lazy_evaluated_commands(shell)); all_commands.extend(move(commands)); last_command_in_sequence = &all_commands.last(); continue; } if (last_command_in_sequence->should_wait) { last_command_in_sequence->next_chain.append(NodeWithAction { entry, NodeWithAction::Sequence }); } else { all_commands.extend(TRY(entry->to_lazy_evaluated_commands(shell))); last_command_in_sequence = &all_commands.last(); } } return make_ref_counted(move(all_commands)); } ErrorOr Sequence::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { for (auto& entry : m_entries) TRY(entry->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult Sequence::hit_test_position(size_t offset) const { for (auto& entry : m_entries) { auto result = entry->hit_test_position(offset); if (result.matching_node) { if (!result.closest_command_node) result.closest_command_node = entry; return result; } } return {}; } RefPtr Sequence::leftmost_trivial_literal() const { for (auto& entry : m_entries) { if (auto node = entry->leftmost_trivial_literal()) return node; } return nullptr; } Sequence::Sequence(Position position, Vector> entries, Vector separator_positions) : Node(move(position)) , m_entries(move(entries)) , m_separator_positions(separator_positions) { for (auto& entry : m_entries) { if (entry->is_syntax_error()) { set_is_syntax_error(entry->syntax_error_node()); break; } } } Sequence::~Sequence() { } ErrorOr Subshell::dump(int level) const { TRY(Node::dump(level)); if (m_block) TRY(m_block->dump(level + 1)); return {}; } ErrorOr> Subshell::run(RefPtr shell) { if (!m_block) return make_ref_counted({}); return make_ref_counted(TRY(m_block->to_lazy_evaluated_commands(shell))); } ErrorOr Subshell::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { metadata.is_first_in_list = true; if (m_block) TRY(m_block->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult Subshell::hit_test_position(size_t offset) const { if (m_block) return m_block->hit_test_position(offset); return {}; } Subshell::Subshell(Position position, RefPtr block) : Node(move(position)) , m_block(block) { if (m_block && m_block->is_syntax_error()) set_is_syntax_error(m_block->syntax_error_node()); } Subshell::~Subshell() { } ErrorOr Slice::dump(int level) const { TRY(Node::dump(level)); TRY(m_selector->dump(level + 1)); return {}; } ErrorOr> Slice::run(RefPtr shell) { return m_selector->run(shell); } ErrorOr Slice::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { return m_selector->highlight_in_editor(editor, shell, metadata); } HitTestResult Slice::hit_test_position(size_t offset) const { return m_selector->hit_test_position(offset); } ErrorOr> Slice::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { // TODO: Maybe intercept this, and suggest values in range? return m_selector->complete_for_editor(shell, offset, hit_test_result); } Slice::Slice(Position position, NonnullRefPtr selector) : Node(move(position)) , m_selector(move(selector)) { if (m_selector->is_syntax_error()) set_is_syntax_error(m_selector->syntax_error_node()); } Slice::~Slice() { } ErrorOr SimpleVariable::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(Name)"); print_indented(level + 2, "{}", m_name); print_indented(level + 1, "(Slice)"); if (m_slice) TRY(m_slice->dump(level + 2)); else print_indented(level + 2, "(None)"); return {}; } ErrorOr> SimpleVariable::run(RefPtr) { NonnullRefPtr value = make_ref_counted(m_name); if (m_slice) value = value->with_slices(*m_slice).release_value_but_fixme_should_propagate_errors(); return value; } ErrorOr SimpleVariable::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { Line::Style style { Line::Style::Foreground(214, 112, 214) }; if (metadata.is_first_in_list) style.unify_with({ Line::Style::Bold }); editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style)); if (m_slice) TRY(m_slice->highlight_in_editor(editor, shell, metadata)); return {}; } HitTestResult SimpleVariable::hit_test_position(size_t offset) const { if (!position().contains(offset)) return {}; if (m_slice && m_slice->position().contains(offset)) return m_slice->hit_test_position(offset); return { this, this, nullptr }; } ErrorOr> SimpleVariable::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node) return Vector {}; if (matching_node != this) return Vector {}; auto corrected_offset = offset - matching_node->position().start_offset - 1; if (corrected_offset > m_name.bytes_as_string_view().length() + 1) return Vector {}; return shell.complete_variable(m_name, corrected_offset); } SimpleVariable::SimpleVariable(Position position, String name) : VariableNode(move(position)) , m_name(move(name)) { } SimpleVariable::~SimpleVariable() { } ErrorOr SpecialVariable::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(Name)"); print_indented(level + 1, "{:c}", m_name); print_indented(level + 1, "(Slice)"); if (m_slice) TRY(m_slice->dump(level + 2)); else print_indented(level + 2, "(None)"); return {}; } ErrorOr> SpecialVariable::run(RefPtr) { NonnullRefPtr value = make_ref_counted(m_name); if (m_slice) value = value->with_slices(*m_slice).release_value_but_fixme_should_propagate_errors(); return value; } ErrorOr SpecialVariable::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(214, 112, 214) }); if (m_slice) TRY(m_slice->highlight_in_editor(editor, shell, metadata)); return {}; } ErrorOr> SpecialVariable::complete_for_editor(Shell&, size_t, HitTestResult const&) const { return Vector {}; } HitTestResult SpecialVariable::hit_test_position(size_t offset) const { if (m_slice && m_slice->position().contains(offset)) return m_slice->hit_test_position(offset); return { this, this, nullptr }; } SpecialVariable::SpecialVariable(Position position, char name) : VariableNode(move(position)) , m_name(name) { } SpecialVariable::~SpecialVariable() { } ErrorOr Juxtaposition::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> Juxtaposition::run(RefPtr shell) { auto left_value = TRY(TRY(m_left->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto right_value = TRY(TRY(m_right->run(shell))->resolve_without_cast(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto left = left_value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); auto right = right_value->resolve_as_list(shell).release_value_but_fixme_should_propagate_errors(); if (m_mode == Mode::StringExpand) { Vector result; result.ensure_capacity(left.size() + right.size()); for (auto& left_item : left) result.append(left_item); if (!result.is_empty() && !right.is_empty()) { auto& last = result.last(); last = String::formatted("{}{}", last, right.first()).release_value_but_fixme_should_propagate_errors(); right.take_first(); } for (auto& right_item : right) result.append(right_item); return make_ref_counted(move(result)); } if (left_value->is_string() && right_value->is_string()) { VERIFY(left.size() == 1); VERIFY(right.size() == 1); StringBuilder builder; builder.append(left[0]); builder.append(right[0]); return make_ref_counted(builder.to_string().release_value_but_fixme_should_propagate_errors()); } // Otherwise, treat them as lists and create a list product (or just append). if (left.is_empty() || right.is_empty()) return make_ref_counted({}); Vector result; result.ensure_capacity(left.size() * right.size()); StringBuilder builder; for (auto& left_element : left) { for (auto& right_element : right) { builder.append(left_element); builder.append(right_element); result.append(builder.to_string().release_value_but_fixme_should_propagate_errors()); builder.clear(); } } return make_ref_counted(move(result)); } ErrorOr Juxtaposition::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_left->highlight_in_editor(editor, shell, metadata)); // '~/foo/bar' is special, we have to actually resolve the tilde // since that resolution is a pure operation, we can just go ahead // and do it to get the value :) if (m_right->is_bareword() && m_left->is_tilde()) { auto tilde_value = TRY(TRY(m_left->run(shell))->resolve_as_list(shell))[0]; auto bareword_value = TRY(TRY(m_right->run(shell))->resolve_as_list(shell))[0]; StringBuilder path_builder; path_builder.append(tilde_value); path_builder.append('/'); path_builder.append(bareword_value); auto path = path_builder.to_deprecated_string(); if (FileSystem::exists(path)) { auto realpath = shell.resolve_path(path); auto url = URL::create_with_file_scheme(realpath); url.set_host(TRY(String::from_deprecated_string(shell.hostname))); editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Hyperlink(url.to_deprecated_string()) }); } } else { TRY(m_right->highlight_in_editor(editor, shell, metadata)); } return {}; } ErrorOr> Juxtaposition::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (m_left->would_execute() || m_right->would_execute()) { return Vector {}; } // '~/foo/bar' is special, we have to actually resolve the tilde // then complete the bareword with that path prefix. auto left_values = TRY(TRY(m_left->run(shell))->resolve_as_list(shell)); if (left_values.is_empty()) return m_right->complete_for_editor(shell, offset, hit_test_result); auto& left_value = left_values.first(); auto right_values = TRY(TRY(m_right->run(shell))->resolve_as_list(shell)); StringView right_value {}; auto corrected_offset = offset - matching_node->position().start_offset; if (!right_values.is_empty()) right_value = right_values.first(); if (m_left->is_tilde() && !right_value.is_empty()) { right_value = right_value.substring_view(1); corrected_offset--; } if (corrected_offset > right_value.length()) return Vector {}; return shell.complete_path(left_value, right_value, corrected_offset, Shell::ExecutableOnly::No, hit_test_result.closest_command_node.ptr(), hit_test_result.matching_node); } HitTestResult Juxtaposition::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning) result.closest_node_with_semantic_meaning = this; if (result.matching_node) return result; result = m_right->hit_test_position(offset); if (!result.closest_node_with_semantic_meaning) result.closest_node_with_semantic_meaning = this; return result; } Juxtaposition::Juxtaposition(Position position, NonnullRefPtr left, NonnullRefPtr right, Juxtaposition::Mode mode) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) , m_mode(mode) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } Juxtaposition::~Juxtaposition() { } ErrorOr StringLiteral::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_text); return {}; } ErrorOr> StringLiteral::run(RefPtr) { return make_ref_counted(m_text); } ErrorOr StringLiteral::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata metadata) { if (m_text.is_empty()) return {}; Line::Style style { Line::Style::Foreground(Line::Style::XtermColor::Yellow) }; if (metadata.is_first_in_list) style.unify_with({ Line::Style::Bold }); editor.stylize({ m_position.start_offset, m_position.end_offset }, move(style)); return {}; } StringLiteral::StringLiteral(Position position, String text, EnclosureType enclosure_type) : Node(move(position)) , m_text(move(text)) , m_enclosure_type(enclosure_type) { } StringLiteral::~StringLiteral() { } ErrorOr StringPartCompose::dump(int level) const { TRY(Node::dump(level)); TRY(m_left->dump(level + 1)); TRY(m_right->dump(level + 1)); return {}; } ErrorOr> StringPartCompose::run(RefPtr shell) { auto left = TRY(TRY(m_left->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); auto right = TRY(TRY(m_right->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); StringBuilder builder; builder.join(' ', left); builder.join(' ', right); return make_ref_counted(builder.to_string().release_value_but_fixme_should_propagate_errors()); } ErrorOr StringPartCompose::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { TRY(m_left->highlight_in_editor(editor, shell, metadata)); return m_right->highlight_in_editor(editor, shell, metadata); } HitTestResult StringPartCompose::hit_test_position(size_t offset) const { auto result = m_left->hit_test_position(offset); if (result.matching_node) return result; return m_right->hit_test_position(offset); } StringPartCompose::StringPartCompose(Position position, NonnullRefPtr left, NonnullRefPtr right) : Node(move(position)) , m_left(move(left)) , m_right(move(right)) { if (m_left->is_syntax_error()) set_is_syntax_error(m_left->syntax_error_node()); else if (m_right->is_syntax_error()) set_is_syntax_error(m_right->syntax_error_node()); } StringPartCompose::~StringPartCompose() { } ErrorOr SyntaxError::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "(Error text)"); print_indented(level + 2, "{}", m_syntax_error_text); print_indented(level + 1, "(Can be recovered from)"); print_indented(level + 2, "{}", m_is_continuable); return {}; } ErrorOr> SyntaxError::run(RefPtr shell) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, m_syntax_error_text.to_deprecated_string(), position()); return make_ref_counted(String {}); } ErrorOr SyntaxError::highlight_in_editor(Line::Editor& editor, Shell&, HighlightMetadata) { editor.stylize({ m_position.start_offset, m_position.end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Bold }); return {}; } SyntaxError::SyntaxError(Position position, String error, bool is_continuable) : Node(move(position)) , m_syntax_error_text(move(error)) , m_is_continuable(is_continuable) { } SyntaxError& SyntaxError::syntax_error_node() { return *this; } SyntaxError::~SyntaxError() { } ErrorOr SyntheticNode::dump(int level) const { TRY(Node::dump(level)); return {}; } ErrorOr> SyntheticNode::run(RefPtr) { return m_value; } ErrorOr SyntheticNode::highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata) { return {}; } SyntheticNode::SyntheticNode(Position position, NonnullRefPtr value) : Node(move(position)) , m_value(move(value)) { } ErrorOr Tilde::dump(int level) const { TRY(Node::dump(level)); print_indented(level + 1, "{}", m_username); return {}; } ErrorOr> Tilde::run(RefPtr) { return make_ref_counted(m_username); } ErrorOr Tilde::highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata) { return {}; } HitTestResult Tilde::hit_test_position(size_t offset) const { if (!position().contains(offset)) return {}; return { this, this, nullptr }; } ErrorOr> Tilde::complete_for_editor(Shell& shell, size_t offset, HitTestResult const& hit_test_result) const { auto matching_node = hit_test_result.matching_node; if (!matching_node) return Vector {}; if (matching_node != this) return Vector {}; auto corrected_offset = offset - matching_node->position().start_offset - 1; if (corrected_offset > m_username.bytes_as_string_view().length() + 1) return Vector {}; return shell.complete_user(m_username, corrected_offset); } String Tilde::text() const { StringBuilder builder; builder.append('~'); builder.append(m_username); return builder.to_string().release_value_but_fixme_should_propagate_errors(); } Tilde::Tilde(Position position, String username) : Node(move(position)) , m_username(move(username)) { } Tilde::~Tilde() { } ErrorOr WriteAppendRedirection::dump(int level) const { TRY(Node::dump(level)); TRY(m_path->dump(level + 1)); print_indented(level + 1, "From {}", m_fd); return {}; } ErrorOr> WriteAppendRedirection::run(RefPtr shell) { Command command; auto path_segments = TRY(TRY(m_path->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); StringBuilder builder; builder.join(' ', path_segments); command.redirections.append(PathRedirection::create(builder.to_string().release_value_but_fixme_should_propagate_errors(), m_fd, PathRedirection::WriteAppend)); return make_ref_counted(move(command)); } WriteAppendRedirection::WriteAppendRedirection(Position position, int fd, NonnullRefPtr path) : PathRedirectionNode(move(position), fd, move(path)) { } WriteAppendRedirection::~WriteAppendRedirection() { } ErrorOr WriteRedirection::dump(int level) const { TRY(Node::dump(level)); TRY(m_path->dump(level + 1)); print_indented(level + 1, "From {}", m_fd); return {}; } ErrorOr> WriteRedirection::run(RefPtr shell) { Command command; auto path_segments = TRY(TRY(m_path->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) return make_ref_counted({}); StringBuilder builder; builder.join(' ', path_segments); command.redirections.append(PathRedirection::create(builder.to_string().release_value_but_fixme_should_propagate_errors(), m_fd, PathRedirection::Write)); return make_ref_counted(move(command)); } WriteRedirection::WriteRedirection(Position position, int fd, NonnullRefPtr path) : PathRedirectionNode(move(position), fd, move(path)) { } WriteRedirection::~WriteRedirection() { } ErrorOr VariableDeclarations::dump(int level) const { TRY(Node::dump(level)); for (auto& var : m_variables) { print_indented(level + 1, "Set"); TRY(var.name->dump(level + 2)); TRY(var.value->dump(level + 2)); } return {}; } ErrorOr> VariableDeclarations::run(RefPtr shell) { for (auto& var : m_variables) { auto name_value = TRY(TRY(var.name->run(shell))->resolve_as_list(shell)); if (shell && shell->has_any_error()) break; VERIFY(name_value.size() == 1); auto name = name_value[0]; auto value = TRY(var.value->run(shell)); if (shell && shell->has_any_error()) break; value = TRY(value->resolve_without_cast(shell)); shell->set_local_variable(name.to_deprecated_string(), value.release_nonnull()); } return make_ref_counted({}); } ErrorOr VariableDeclarations::highlight_in_editor(Line::Editor& editor, Shell& shell, HighlightMetadata metadata) { metadata.is_first_in_list = false; for (auto& var : m_variables) { TRY(var.name->highlight_in_editor(editor, shell, metadata)); // Highlight the '='. editor.stylize({ var.name->position().end_offset - 1, var.name->position().end_offset }, { Line::Style::Foreground(Line::Style::XtermColor::Blue) }); TRY(var.value->highlight_in_editor(editor, shell, metadata)); } return {}; } HitTestResult VariableDeclarations::hit_test_position(size_t offset) const { for (auto decl : m_variables) { auto result = decl.value->hit_test_position(offset); if (result.matching_node) return result; } return { nullptr, nullptr, nullptr }; } VariableDeclarations::VariableDeclarations(Position position, Vector variables) : Node(move(position)) , m_variables(move(variables)) { for (auto& decl : m_variables) { if (decl.name->is_syntax_error()) { set_is_syntax_error(decl.name->syntax_error_node()); break; } if (decl.value->is_syntax_error()) { set_is_syntax_error(decl.value->syntax_error_node()); break; } } } VariableDeclarations::~VariableDeclarations() { } Value::~Value() { } ErrorOr Value::resolve_as_string(RefPtr shell) { if (shell) shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Conversion to string not allowed"); return String {}; } ErrorOr> Value::resolve_as_commands(RefPtr shell) { Command command; command.argv = TRY(resolve_as_list(shell)); return Vector { move(command) }; } ListValue::ListValue(Vector values) { if (values.is_empty()) return; m_contained_values.ensure_capacity(values.size()); for (auto& str : values) m_contained_values.append(adopt_ref(*new StringValue(move(str)))); } ErrorOr> Value::with_slices(NonnullRefPtr slice) const& { auto value = TRY(clone()); value->m_slices.append(move(slice)); return value; } ErrorOr> Value::with_slices(Vector> slices) const& { auto value = TRY(clone()); value->m_slices.extend(move(slices)); return value; } ListValue::~ListValue() { } ErrorOr> ListValue::resolve_as_list(RefPtr shell) { Vector values; for (auto& value : m_contained_values) values.extend(TRY(value->resolve_as_list(shell))); return resolve_slices(shell, move(values), m_slices); } ErrorOr ListValue::resolve_as_string(RefPtr shell) { if (!shell || !shell->posix_mode()) return Value::resolve_as_string(shell); if (m_contained_values.is_empty()) return resolve_slices(shell, String {}, m_slices); return resolve_slices(shell, TRY(m_contained_values[0]->resolve_as_string(shell)), m_slices); } ErrorOr> ListValue::resolve_without_cast(RefPtr shell) { Vector> values; for (auto& value : m_contained_values) values.append(TRY(value->resolve_without_cast(shell))); NonnullRefPtr value = make_ref_counted(move(values)); if (!m_slices.is_empty()) value = TRY(value->with_slices(m_slices)); return value; } CommandValue::~CommandValue() { } CommandSequenceValue::~CommandSequenceValue() { } ErrorOr> CommandSequenceValue::resolve_as_list(RefPtr shell) { shell->raise_error(Shell::ShellError::EvaluatedSyntaxError, "Unexpected cast of a command sequence to a list"); return Vector {}; } ErrorOr> CommandSequenceValue::resolve_as_commands(RefPtr) { return m_contained_values; } ErrorOr> CommandValue::resolve_as_list(RefPtr) { return m_command.argv; } ErrorOr> CommandValue::resolve_as_commands(RefPtr) { return Vector { m_command }; } JobValue::~JobValue() { } StringValue::~StringValue() { } ErrorOr StringValue::resolve_as_string(RefPtr shell) { if (m_split.is_empty()) return TRY(resolve_slices(shell, String { m_string }, m_slices)); return Value::resolve_as_string(shell); } ErrorOr> StringValue::resolve_as_list(RefPtr shell) { if (is_list()) { auto parts = StringView(m_string).split_view(m_split, m_keep_empty ? SplitBehavior::KeepEmpty : SplitBehavior::Nothing); Vector result; result.ensure_capacity(parts.size()); for (auto& part : parts) result.append(TRY(String::from_utf8(part))); return resolve_slices(shell, move(result), m_slices); } return Vector { TRY(resolve_slices(shell, String { m_string }, m_slices)) }; } ErrorOr> StringValue::resolve_without_cast(RefPtr shell) { if (is_list()) return try_make_ref_counted(TRY(resolve_as_list(shell))); // No need to reapply the slices. return *this; } GlobValue::~GlobValue() { } ErrorOr> GlobValue::resolve_as_list(RefPtr shell) { if (!shell) return resolve_slices(shell, Vector { m_glob }, m_slices); auto results = shell->expand_globs(m_glob, shell->cwd); if (results.is_empty()) shell->raise_error(Shell::ShellError::InvalidGlobError, "Glob did not match anything!", m_generation_position); Vector strings; TRY(strings.try_ensure_capacity(results.size())); for (auto& entry : results) { TRY(strings.try_append(TRY(String::from_deprecated_string(entry)))); } return resolve_slices(shell, move(strings), m_slices); } SimpleVariableValue::~SimpleVariableValue() { } ErrorOr SimpleVariableValue::resolve_as_string(RefPtr shell) { if (!shell) return resolve_slices(shell, String {}, m_slices); if (auto value = TRY(resolve_without_cast(shell)); value != this) return resolve_slices(shell, TRY(value->resolve_as_string(shell)), m_slices); auto name = m_name.to_deprecated_string(); char const* env_value = getenv(name.characters()); if (!env_value) env_value = ""; return resolve_slices(shell, TRY(String::from_utf8(StringView { env_value, strlen(env_value) })), m_slices); } ErrorOr> SimpleVariableValue::resolve_as_list(RefPtr shell) { if (!shell) return resolve_slices(shell, Vector {}, m_slices); if (auto value = TRY(resolve_without_cast(shell)); value != this) return value->resolve_as_list(shell); auto name = m_name.to_deprecated_string(); char* env_value = getenv(name.characters()); if (env_value == nullptr) return { resolve_slices(shell, Vector { String {} }, m_slices) }; return Vector { TRY(resolve_slices(shell, TRY(String::from_utf8(StringView { env_value, strlen(env_value) })), m_slices)) }; } ErrorOr> SimpleVariableValue::resolve_without_cast(RefPtr shell) { VERIFY(shell); if (auto value = TRY(shell->look_up_local_variable(m_name))) { auto result = value.release_nonnull(); // If a slice is applied, add it. if (!m_slices.is_empty()) result = TRY(result->with_slices(m_slices)); return const_cast(*result); } return *this; } SpecialVariableValue::~SpecialVariableValue() { } ErrorOr SpecialVariableValue::resolve_as_string(RefPtr shell) { if (!shell) return String {}; auto result = TRY(resolve_as_list(shell)); if (result.size() == 1) return result[0]; if (result.is_empty()) return String {}; return Value::resolve_as_string(shell); } ErrorOr> SpecialVariableValue::resolve_as_list(RefPtr shell) { if (!shell) return Vector {}; switch (m_name) { case '?': return { resolve_slices(shell, Vector { TRY(String::number(shell->last_return_code.value_or(0))) }, m_slices) }; case '$': return { resolve_slices(shell, Vector { TRY(String::number(getpid())) }, m_slices) }; case '*': if (auto argv = TRY(shell->look_up_local_variable("ARGV"sv))) return resolve_slices(shell, TRY(const_cast(*argv).resolve_as_list(shell)), m_slices); return resolve_slices(shell, Vector {}, m_slices); case '#': if (auto argv = TRY(shell->look_up_local_variable("ARGV"sv))) { if (argv->is_list()) { auto list_argv = static_cast(argv.ptr()); return { resolve_slices(shell, Vector { TRY(String::number(list_argv->values().size())) }, m_slices) }; } return { resolve_slices(shell, Vector { "1"_short_string }, m_slices) }; } return { resolve_slices(shell, Vector { "0"_short_string }, m_slices) }; default: return { resolve_slices(shell, Vector { String {} }, m_slices) }; } } ErrorOr> SpecialVariableValue::resolve_without_cast(RefPtr shell) { if (!shell) return *this; return try_make_ref_counted(TRY(resolve_as_list(shell))); } TildeValue::~TildeValue() { } ErrorOr TildeValue::resolve_as_string(RefPtr shell) { return TRY(resolve_as_list(shell)).first(); } ErrorOr> TildeValue::resolve_as_list(RefPtr shell) { StringBuilder builder; builder.append('~'); builder.append(m_username); if (!shell) return { resolve_slices(shell, Vector { TRY(builder.to_string()) }, m_slices) }; return { resolve_slices(shell, Vector { TRY(String::from_deprecated_string(shell->expand_tilde(builder.to_deprecated_string()))) }, m_slices) }; } ErrorOr> CloseRedirection::apply() const { return adopt_nonnull_ref_or_enomem(new (nothrow) Rewiring(fd, fd, Rewiring::Close::ImmediatelyCloseNew)); } CloseRedirection::~CloseRedirection() { } ErrorOr> PathRedirection::apply() const { auto check_fd_and_return = [my_fd = this->fd](int fd, String const& path) -> ErrorOr> { if (fd < 0) { auto error = Error::from_errno(errno); dbgln("open() failed for '{}' with {}", path, error); return error; } return adopt_nonnull_ref_or_enomem(new (nothrow) Rewiring(fd, my_fd, Rewiring::Close::Old)); }; auto path_string = path.to_deprecated_string(); switch (direction) { case AST::PathRedirection::WriteAppend: return check_fd_and_return(open(path_string.characters(), O_WRONLY | O_CREAT | O_APPEND, 0666), path); case AST::PathRedirection::Write: return check_fd_and_return(open(path_string.characters(), O_WRONLY | O_CREAT | O_TRUNC, 0666), path); case AST::PathRedirection::Read: return check_fd_and_return(open(path_string.characters(), O_RDONLY), path); case AST::PathRedirection::ReadWrite: return check_fd_and_return(open(path_string.characters(), O_RDWR | O_CREAT, 0666), path); } VERIFY_NOT_REACHED(); } PathRedirection::~PathRedirection() { } FdRedirection::~FdRedirection() { } Redirection::~Redirection() { } }