beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Userland/Shell/AST.h

1542 lines
52 KiB
C
Raw Normal View History

Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
/*
* Copyright (c) 2020, the SerenityOS developers.
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
*/
#pragma once
#include "Forward.h"
#include "Job.h"
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
#include "NodeVisitor.h"
Shell: Implement AK::Formatter::format() for AST::Command ...and use that to display jobs.
2020-10-25 22:57:19 +00:00
#include <AK/Format.h>
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
#include <AK/NonnullRefPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <LibLine/Editor.h>
Shell: Add support for regex match patterns We previously allowed globs as match pattern, but for more complex matching needs, it's nice to have regular expressions. And as the existing "name a part of the match" concept maps nicely to named capture groups, we can simply reuse the same code and make groups with names available in the match body.
2022-04-14 21:20:36 +00:00
#include <LibRegex/Regex.h>
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Move everything to the Shell namespace Also provide a basic default-constructor.
2020-10-01 14:43:01 +00:00
namespace Shell::AST {
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
using AK::make_ref_counted;
Shell: Move AST::create() into the header and use it
2021-01-03 09:05:06 +00:00
template<typename T>
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
static inline NonnullRefPtr<T> make_ref_counted(std::initializer_list<NonnullRefPtr<Value>> arg)
Shell: Move AST::create() into the header and use it
2021-01-03 09:05:06 +00:00
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 14:46:57 +00:00
return adopt_ref(*new T(arg));
Shell: Move AST::create() into the header and use it
2021-01-03 09:05:06 +00:00
}
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
struct HighlightMetadata {
bool is_first_in_list { true };
};
struct Position {
size_t start_offset { 0 };
size_t end_offset { 0 };
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
struct Line {
size_t line_number { 0 };
size_t line_column { 0 };
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
bool operator==(Line const& other) const
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
{
return line_number == other.line_number && line_column == other.line_column;
}
} start_line, end_line;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
bool contains(size_t offset) const { return start_offset <= offset && offset <= end_offset; }
};
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
struct NameWithPosition {
String name;
Position position;
};
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
struct FdRedirection;
Shell: Allow commands in variables, and properly substitute them on use This allows the below interaction to work: ``` $ silence=(2>&1 >/dev/null) $ do_noisy_thing with these args $silence <nothing here lol> ```
2020-06-22 11:07:20 +00:00
struct Rewiring : public RefCounted<Rewiring> {
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
int old_fd { -1 };
int new_fd { -1 };
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
FdRedirection* other_pipe_end { nullptr };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
enum class Close {
None,
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
Old,
New,
RefreshNew,
RefreshOld,
ImmediatelyCloseNew,
Shell: Allow commands in variables, and properly substitute them on use This allows the below interaction to work: ``` $ silence=(2>&1 >/dev/null) $ do_noisy_thing with these args $silence <nothing here lol> ```
2020-06-22 11:07:20 +00:00
} fd_action { Close::None };
Rewiring(int source, int dest, Close close = Close::None)
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
: old_fd(source)
, new_fd(dest)
Shell: Allow commands in variables, and properly substitute them on use This allows the below interaction to work: ``` $ silence=(2>&1 >/dev/null) $ do_noisy_thing with these args $silence <nothing here lol> ```
2020-06-22 11:07:20 +00:00
, fd_action(close)
{
}
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
Rewiring(int source, int dest, FdRedirection* other_end, Close close)
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
: old_fd(source)
, new_fd(dest)
Shell: Allow commands in variables, and properly substitute them on use This allows the below interaction to work: ``` $ silence=(2>&1 >/dev/null) $ do_noisy_thing with these args $silence <nothing here lol> ```
2020-06-22 11:07:20 +00:00
, other_pipe_end(other_end)
, fd_action(close)
{
}
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
struct Redirection : public RefCounted<Redirection> {
Shell: Replace Result<T, E> use with ErrorOr<T>
2021-11-07 10:36:11 +00:00
virtual ErrorOr<NonnullRefPtr<Rewiring>> apply() const = 0;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Redirection();
virtual bool is_path_redirection() const { return false; }
virtual bool is_fd_redirection() const { return false; }
virtual bool is_close_redirection() const { return false; }
};
struct CloseRedirection : public Redirection {
int fd { -1 };
Shell: Replace Result<T, E> use with ErrorOr<T>
2021-11-07 10:36:11 +00:00
virtual ErrorOr<NonnullRefPtr<Rewiring>> apply() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~CloseRedirection();
CloseRedirection(int fd)
: fd(fd)
{
}
private:
virtual bool is_close_redirection() const override { return true; }
};
struct PathRedirection : public Redirection {
String path;
int fd { -1 };
enum {
Read,
Write,
WriteAppend,
ReadWrite,
} direction { Read };
Shell: Add create() factory function for PathRedirection
2020-08-12 10:15:30 +00:00
static NonnullRefPtr<PathRedirection> create(String path, int fd, decltype(direction) direction)
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 14:46:57 +00:00
return adopt_ref(*new PathRedirection(move(path), fd, direction));
Shell: Add create() factory function for PathRedirection
2020-08-12 10:15:30 +00:00
}
Shell: Replace Result<T, E> use with ErrorOr<T>
2021-11-07 10:36:11 +00:00
virtual ErrorOr<NonnullRefPtr<Rewiring>> apply() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~PathRedirection();
Shell: Add create() factory function for PathRedirection
2020-08-12 10:15:30 +00:00
private:
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
PathRedirection(String path, int fd, decltype(direction) direction)
: path(move(path))
, fd(fd)
, direction(direction)
{
}
virtual bool is_path_redirection() const override { return true; }
};
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
struct FdRedirection : public Redirection {
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
public:
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
static NonnullRefPtr<FdRedirection> create(int old_fd, int new_fd, Rewiring::Close close)
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 14:46:57 +00:00
return adopt_ref(*new FdRedirection(old_fd, new_fd, close));
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
}
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
static NonnullRefPtr<FdRedirection> create(int old_fd, int new_fd, FdRedirection* pipe_end, Rewiring::Close close)
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 14:46:57 +00:00
return adopt_ref(*new FdRedirection(old_fd, new_fd, pipe_end, close));
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
}
virtual ~FdRedirection();
Shell: Replace Result<T, E> use with ErrorOr<T>
2021-11-07 10:36:11 +00:00
virtual ErrorOr<NonnullRefPtr<Rewiring>> apply() const override
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
{
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 14:46:57 +00:00
return adopt_ref(*new Rewiring(old_fd, new_fd, other_pipe_end, action));
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
}
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
int old_fd { -1 };
int new_fd { -1 };
Shell: Fix another FdRedirection reference leak Add a create() factory function to prevent this from happening again.
2020-08-12 10:13:33 +00:00
FdRedirection* other_pipe_end { nullptr };
Rewiring::Close action { Rewiring::Close::None };
private:
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
FdRedirection(int source, int dest, Rewiring::Close close)
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
: FdRedirection(source, dest, nullptr, close)
Shell: Allow commands in variables, and properly substitute them on use This allows the below interaction to work: ``` $ silence=(2>&1 >/dev/null) $ do_noisy_thing with these args $silence <nothing here lol> ```
2020-06-22 11:07:20 +00:00
{
}
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
FdRedirection(int old_fd, int new_fd, FdRedirection* pipe_end, Rewiring::Close close)
: old_fd(old_fd)
, new_fd(new_fd)
Shell: Correct FdRedirection inheriting from two RefCounted bases Also add missing calls to `adopt()`.
2020-08-04 09:53:23 +00:00
, other_pipe_end(pipe_end)
, action(close)
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
virtual bool is_fd_redirection() const override { return true; }
};
Shell: Moves pipelined processes to one process group
2020-08-11 11:24:46 +00:00
class Pipeline : public RefCounted<Pipeline> {
public:
pid_t pgid { -1 };
};
Shell: Fix job control and backgrounding This patchset makes the shell capable of lazily resolving and executing sequences of commands, to allow for putting logical sequences in the background. In particular, it enables And/Or/Sequence nodes to be run in the background, and consequently unmarks them as `would_execute`. Doing so also fixes job control to an extent, as jobs are now capable of having 'tails', so sequences can be put in the background while preserving their following sequences.
2020-09-01 04:12:16 +00:00
struct NodeWithAction {
mutable NonnullRefPtr<Node> node;
enum Action {
And,
Or,
Sequence,
} action;
NodeWithAction(Node& node, Action action)
: node(node)
, action(action)
{
}
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
struct Command {
Vector<String> argv;
Shell: Make Command::redirections a NonnullRefPtrVector
2020-08-07 07:42:12 +00:00
NonnullRefPtrVector<Redirection> redirections;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
bool should_wait { true };
bool is_pipe_source { false };
Shell: Parse a pipe sequence inside $(...)
2020-06-21 20:00:14 +00:00
bool should_notify_if_in_background { true };
Shell: Allow control structures to appear in pipe sequences This makes commands like the following to be possible: ```sh $ ls && for $(seq 10) { echo $it } $ ls | for $(seq 1) { cat > foobar } ```
2020-09-07 16:19:53 +00:00
bool should_immediately_execute_next { false };
Shell: Fix job control and backgrounding This patchset makes the shell capable of lazily resolving and executing sequences of commands, to allow for putting logical sequences in the background. In particular, it enables And/Or/Sequence nodes to be run in the background, and consequently unmarks them as `would_execute`. Doing so also fixes job control to an extent, as jobs are now capable of having 'tails', so sequences can be put in the background while preserving their following sequences.
2020-09-01 04:12:16 +00:00
mutable RefPtr<Pipeline> pipeline;
Vector<NodeWithAction> next_chain;
Shell: Give commands and globs a source position This will help us have nicer error reporting.
2021-01-03 09:06:25 +00:00
Optional<Position> position;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
struct HitTestResult {
RefPtr<Node> matching_node;
RefPtr<Node> closest_node_with_semantic_meaning; // This is used if matching_node is a bareword
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
RefPtr<Node> closest_command_node; // This is used if matching_node is a bareword, and it is not the first in a list
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class Value : public RefCounted<Value> {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) = 0;
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell> shell);
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>);
Shell: Make resolve_without_cast() return NonnullRefPtr<Value>
2020-08-07 07:36:15 +00:00
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) { return *this; }
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
virtual NonnullRefPtr<Value> clone() const = 0;
virtual NonnullRefPtr<Value> with_slices(NonnullRefPtr<Slice> slice) const&;
virtual NonnullRefPtr<Value> with_slices(NonnullRefPtrVector<Slice> slices) const&;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Value();
virtual bool is_command() const { return false; }
virtual bool is_glob() const { return false; }
virtual bool is_job() const { return false; }
virtual bool is_list() const { return false; }
virtual bool is_string() const { return false; }
Shell: Parse lists serially, and flatten them only when needed This allows `((1 2 3) (4 5 6))` to remain nested until we explicitly flatten it out.
2020-07-11 21:11:24 +00:00
virtual bool is_list_without_resolution() const { return false; }
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
protected:
Value& set_slices(NonnullRefPtrVector<Slice> slices)
{
m_slices = move(slices);
return *this;
}
NonnullRefPtrVector<Slice> m_slices;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class CommandValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<CommandValue>(m_command)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~CommandValue();
virtual bool is_command() const override { return true; }
CommandValue(Command command)
: m_command(move(command))
{
}
Shell: Give commands and globs a source position This will help us have nicer error reporting.
2021-01-03 09:06:25 +00:00
CommandValue(Vector<String> argv, Position position)
: m_command({ move(argv), {}, true, false, true, false, nullptr, {}, move(position) })
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
private:
Command m_command;
};
class CommandSequenceValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<CommandSequenceValue>(m_contained_values)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~CommandSequenceValue();
virtual bool is_command() const override { return true; }
CommandSequenceValue(Vector<Command> commands)
: m_contained_values(move(commands))
{
}
private:
Vector<Command> m_contained_values;
};
class JobValue final : public Value {
public:
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override { VERIFY_NOT_REACHED(); }
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell>) override { return String::formatted("%{}", m_job->job_id()); }
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
virtual Vector<Command> resolve_as_commands(RefPtr<Shell>) override { VERIFY_NOT_REACHED(); }
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<JobValue>(m_job)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~JobValue();
virtual bool is_job() const override { return true; }
JobValue(RefPtr<Job> job)
: m_job(move(job))
{
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
RefPtr<Job> const job() const { return m_job; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
RefPtr<Job> m_job;
};
class ListValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
Shell: Make resolve_without_cast() return NonnullRefPtr<Value>
2020-08-07 07:36:15 +00:00
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<ListValue>(m_contained_values)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~ListValue();
virtual bool is_list() const override { return true; }
Shell: Parse lists serially, and flatten them only when needed This allows `((1 2 3) (4 5 6))` to remain nested until we explicitly flatten it out.
2020-07-11 21:11:24 +00:00
virtual bool is_list_without_resolution() const override { return true; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
ListValue(Vector<String> values);
Shell: Store ListValue's values in a NonnullRefPtrVector<Value> A ListValue never stores null Values, so it makes sense to restrict it. This also propagates use of NonnullRefPtr to the create() helpers. There's a small bit of awkwardness around the use of initializer_list, since we cannot directly construct a NonnullRefPtrVector from one.
2020-08-07 07:33:05 +00:00
ListValue(Vector<NonnullRefPtr<Value>> values)
: m_contained_values(move(static_cast<NonnullRefPtrVector<Value>&>(values)))
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
ListValue(NonnullRefPtrVector<Value> values)
: m_contained_values(move(values))
{
}
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtrVector<Value> const& values() const { return m_contained_values; }
Shell: Store ListValue's values in a NonnullRefPtrVector<Value> A ListValue never stores null Values, so it makes sense to restrict it. This also propagates use of NonnullRefPtr to the create() helpers. There's a small bit of awkwardness around the use of initializer_list, since we cannot directly construct a NonnullRefPtrVector from one.
2020-08-07 07:33:05 +00:00
NonnullRefPtrVector<Value>& values() { return m_contained_values; }
Shell: Parse lists serially, and flatten them only when needed This allows `((1 2 3) (4 5 6))` to remain nested until we explicitly flatten it out.
2020-07-11 21:11:24 +00:00
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Store ListValue's values in a NonnullRefPtrVector<Value> A ListValue never stores null Values, so it makes sense to restrict it. This also propagates use of NonnullRefPtr to the create() helpers. There's a small bit of awkwardness around the use of initializer_list, since we cannot directly construct a NonnullRefPtrVector from one.
2020-08-07 07:33:05 +00:00
NonnullRefPtrVector<Value> m_contained_values;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class StringValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell> shell) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<StringValue>(m_string, m_split, m_keep_empty)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~StringValue();
virtual bool is_string() const override { return m_split.is_null(); }
virtual bool is_list() const override { return !m_split.is_null(); }
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
Shell: Add a 'setopt' builtin This builtin sets (and unsets) boolean flags that alter the behaviour of the shell. The only flags added are - inline_exec_keep_empty_segments: Keep empty segments in the result of splitting $(...) by $IFS - verbose: Announce each command before executing it It should be noted that the (rather extreme) verbosity of the names is intentional, and will hopefully be alleviated by the next commit :^)
2020-06-29 01:52:58 +00:00
StringValue(String string, String split_by = {}, bool keep_empty = false)
Shell: Add some obvious move() calls in AST constructors
2020-08-07 07:19:59 +00:00
: m_string(move(string))
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
, m_split(move(split_by))
Shell: Add a 'setopt' builtin This builtin sets (and unsets) boolean flags that alter the behaviour of the shell. The only flags added are - inline_exec_keep_empty_segments: Keep empty segments in the result of splitting $(...) by $IFS - verbose: Announce each command before executing it It should be noted that the (rather extreme) verbosity of the names is intentional, and will hopefully be alleviated by the next commit :^)
2020-06-29 01:52:58 +00:00
, m_keep_empty(keep_empty)
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
private:
String m_string;
String m_split;
Shell: Add a 'setopt' builtin This builtin sets (and unsets) boolean flags that alter the behaviour of the shell. The only flags added are - inline_exec_keep_empty_segments: Keep empty segments in the result of splitting $(...) by $IFS - verbose: Announce each command before executing it It should be noted that the (rather extreme) verbosity of the names is intentional, and will hopefully be alleviated by the next commit :^)
2020-06-29 01:52:58 +00:00
bool m_keep_empty { false };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class GlobValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<GlobValue>(m_glob, m_generation_position)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~GlobValue();
virtual bool is_glob() const override { return true; }
Shell: Give commands and globs a source position This will help us have nicer error reporting.
2021-01-03 09:06:25 +00:00
GlobValue(String glob, Position position)
Shell: Add some obvious move() calls in AST constructors
2020-08-07 07:19:59 +00:00
: m_glob(move(glob))
Shell: Give commands and globs a source position This will help us have nicer error reporting.
2021-01-03 09:06:25 +00:00
, m_generation_position(move(position))
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
private:
String m_glob;
Shell: Give commands and globs a source position This will help us have nicer error reporting.
2021-01-03 09:06:25 +00:00
Position m_generation_position;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class SimpleVariableValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell>) override;
Shell: Make resolve_without_cast() return NonnullRefPtr<Value>
2020-08-07 07:36:15 +00:00
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<SimpleVariableValue>(m_name)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~SimpleVariableValue();
SimpleVariableValue(String name)
Shell: Add some obvious move() calls in AST constructors
2020-08-07 07:19:59 +00:00
: m_name(move(name))
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
private:
String m_name;
};
class SpecialVariableValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell>) override;
Shell: Immediately resolve value when setting a variable The lazy resolution mechanism made it so that the variables were linked together, causing unexpected behaviour: true x=$? # expected: x=0 false echo $x # expected: 0, actual: 1
2022-07-02 15:00:22 +00:00
virtual NonnullRefPtr<Value> resolve_without_cast(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<SpecialVariableValue>(m_name)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~SpecialVariableValue();
SpecialVariableValue(char name)
: m_name(name)
{
}
private:
Userland: Allow building SerenityOS with -funsigned-char Some of the code assumed that chars were always signed while that is not the case on ARM hosts. Also, some of the code tried to use EOF (-1) in a way similar to what fgetc() does, however instead of storing the characters in an int variable a char was used. While this seemed to work it also meant that character 0xFF would be incorrectly seen as an end-of-file. Careful reading of fgetc() reveals that fgetc() stores character data in an int where valid characters are in the range of 0-255 and the EOF value is explicitly outside of that range (usually -1).
2021-06-13 07:15:00 +00:00
char m_name { 0 };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class TildeValue final : public Value {
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual Vector<String> resolve_as_list(RefPtr<Shell>) override;
Shell: Implement program-aware autocompletion A program can either respond to `--complete -- some args to complete` directly, or add a `_complete_<program name>` invokable (i.e. shell function, or just a plain binary in PATH) that completes the given command and lists the completions on stdout. Should such a completion fail or yield no results, we'll fall back to the previous completion algorithm.
2022-03-22 20:44:48 +00:00
virtual String resolve_as_string(RefPtr<Shell>) override;
AK: Rename create<T> => make_ref_counted<T> And also try_create<T> => try_make_ref_counted<T>. A global "create" was a bit much. The new name matches make<T> better, which we've used for making single-owner objects since forever.
2021-09-02 22:07:29 +00:00
virtual NonnullRefPtr<Value> clone() const override { return make_ref_counted<TildeValue>(m_username)->set_slices(m_slices); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~TildeValue();
virtual bool is_string() const override { return true; }
TildeValue(String name)
Shell: Add some obvious move() calls in AST constructors
2020-08-07 07:19:59 +00:00
: m_username(move(name))
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
}
private:
String m_username;
};
class Node : public RefCounted<Node> {
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
AK_MAKE_NONCOPYABLE(Node);
AK_MAKE_NONMOVABLE(Node);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
public:
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual void dump(int level) const = 0;
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
virtual void for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback);
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) = 0;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) = 0;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Vector<Line::CompletionSuggestion> complete_for_editor(Shell& shell, size_t offset);
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t offset) const
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
{
if (m_position.contains(offset))
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
return { this, nullptr, nullptr };
return { nullptr, nullptr, nullptr };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
}
virtual String class_name() const { return "Node"; }
Node(Position);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~Node() = default;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_bareword() const { return false; }
virtual bool is_command() const { return false; }
virtual bool is_execute() const { return false; }
virtual bool is_glob() const { return false; }
virtual bool is_tilde() const { return false; }
virtual bool is_variable_decls() const { return false; }
Shell: Complete named function parameters inside the function body
2020-09-14 09:29:06 +00:00
virtual bool is_simple_variable() const { return false; }
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
virtual bool is_syntax_error() const;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_list() const { return false; }
Shell: Mark And and Or nodes as execute nodes
2020-06-24 03:15:24 +00:00
virtual bool would_execute() const { return false; }
Shell: Run function declarations in the current process Fixes #4817
2021-01-06 12:53:28 +00:00
virtual bool should_override_execution_in_current_process() const { return false; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Position const& position() const { return m_position; }
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
virtual void clear_syntax_error();
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual void set_is_syntax_error(SyntaxError const& error_node);
virtual SyntaxError const& syntax_error_node() const
Shell: Show descriptions about syntax errors The description contains an error message and where in the source the error happened.
2020-06-28 14:12:57 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(is_syntax_error());
Shell: Show descriptions about syntax errors The description contains an error message and where in the source the error happened.
2020-06-28 14:12:57 +00:00
return *m_syntax_error_node;
}
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const { return nullptr; }
Shell: Allow control structures to appear in pipe sequences This makes commands like the following to be possible: ```sh $ ls && for $(seq 10) { echo $it } $ ls | for $(seq 1) { cat > foobar } ```
2020-09-07 16:19:53 +00:00
Vector<Command> to_lazy_evaluated_commands(RefPtr<Shell> shell);
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
virtual void visit(NodeVisitor&) { VERIFY_NOT_REACHED(); }
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) const { const_cast<Node*>(this)->visit(visitor); }
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
enum class Kind : u32 {
And,
Background,
BarewordLiteral,
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
BraceExpansion,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
CastToCommand,
CastToList,
CloseFdRedirection,
CommandLiteral,
Comment,
Shell: Add runtime errors and implement break/continue Such errors are raised when SyntaxError nodes are executed, and are also used for internal control flow. The 'break' and 'continue' commands are currently only allowed inside for loops, and outside function bodies. This also adds a 'loop' keyword for infinite loops.
2020-12-10 14:55:13 +00:00
ContinuationControl,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
DoubleQuotedString,
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
DynamicEvaluate,
Execute,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Fd2FdRedirection,
ForLoop,
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
FunctionDeclaration,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Glob,
Shell: Add support for heredocs Closes #4283. Heredocs are implemented in a way that makes them feel more like a string (and not a weird redirection, a la bash). There are two tunables, whether the string is dedented (`<<-` vs `<<~`) and whether it allows interpolation (quoted key vs not). To the familiar people, this is how Ruby handles them, and I feel is the most elegant heredoc syntax. Unlike the oddjob that is bash, heredocs are treated exactly as normal strings, and can be used _anywhere_ where a string can be used. They are *required* to appear in the same order as used after a newline is seen when parsing the sequence that the heredoc is used in. For instance: ```sh echo <<-doc1 <<-doc2 | blah blah contents for doc1 doc1 contents for doc2 doc2 ``` The typical nice errors are also implemented :^)
2021-04-29 02:34:00 +00:00
Heredoc,
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
HistoryEvent,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
IfCond,
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
ImmediateExpression,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Join,
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
Juxtaposition,
ListConcatenate,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
MatchExpr,
Or,
Pipe,
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
Range,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
ReadRedirection,
ReadWriteRedirection,
Sequence,
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
Slice,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
SimpleVariable,
SpecialVariable,
StringLiteral,
StringPartCompose,
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
Subshell,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
SyntaxError,
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
SyntheticValue,
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Tilde,
VariableDeclarations,
WriteAppendRedirection,
WriteRedirection,
__Count,
};
virtual Kind kind() const = 0;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
protected:
Position m_position;
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
RefPtr<SyntaxError> m_syntax_error_node;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Immediately resolve value when setting a variable The lazy resolution mechanism made it so that the variables were linked together, causing unexpected behaviour: true x=$? # expected: x=0 false echo $x # expected: 0, actual: 1
2022-07-02 15:00:22 +00:00
#define NODE(name) \
virtual String class_name() const override \
{ \
return #name; \
} \
virtual Kind kind() const override \
{ \
return Kind::name; \
}
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class PathRedirectionNode : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
PathRedirectionNode(Position, int, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~PathRedirectionNode();
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t offset) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_command() const override { return true; }
virtual bool is_list() const override { return true; }
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& path() const { return m_path; }
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
int fd() const { return m_fd; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
protected:
int m_fd { -1 };
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_path;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class And final : public Node {
public:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
And(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>, Position and_position);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~And() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Position const& and_position() const { return m_and_position; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(And);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Position m_and_position;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class ListConcatenate final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
ListConcatenate(Position, Vector<NonnullRefPtr<Node>>);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~ListConcatenate() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Vector<NonnullRefPtr<Node>> const list() const { return m_list; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(ListConcatenate);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Implement `for_each_entry()` for syntactic list nodes This allows correct iteration over nested lists. Also store values to variables without resolving them, to delay the resolution step as much as possible (this helps with storing nested lists in variables).
2021-01-18 01:06:19 +00:00
virtual void for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback) override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_list() const override { return true; }
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Vector<NonnullRefPtr<Node>> m_list;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class Background final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Background(Position, NonnullRefPtr<Node>);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~Background() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& command() const { return m_command; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Background);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_command;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class BarewordLiteral final : public Node {
public:
BarewordLiteral(Position, String);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~BarewordLiteral() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& text() const { return m_text; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(BarewordLiteral);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual bool is_bareword() const override { return true; }
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
String m_text;
};
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
class BraceExpansion final : public Node {
public:
BraceExpansion(Position, NonnullRefPtrVector<Node>);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~BraceExpansion() = default;
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtrVector<Node> const& entries() const { return m_entries; }
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
private:
NODE(BraceExpansion);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
NonnullRefPtrVector<Node> m_entries;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class CastToCommand final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
CastToCommand(Position, NonnullRefPtr<Node>);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~CastToCommand() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& inner() const { return m_inner; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(CastToCommand);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_command() const override { return true; }
virtual bool is_list() const override { return true; }
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_inner;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class CastToList final : public Node {
public:
CastToList(Position, RefPtr<Node>);
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~CastToList() = default;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
RefPtr<Node> const& inner() const { return m_inner; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(CastToList);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Implement `for_each_entry()` for syntactic list nodes This allows correct iteration over nested lists. Also store values to variables without resolving them, to delay the resolution step as much as possible (this helps with storing nested lists in variables).
2021-01-18 01:06:19 +00:00
virtual void for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_list() const override { return true; }
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
RefPtr<Node> m_inner;
};
class CloseFdRedirection final : public Node {
public:
CloseFdRedirection(Position, int);
virtual ~CloseFdRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
int fd() const { return m_fd; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(CloseFdRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual bool is_command() const override { return true; }
int m_fd { -1 };
};
class CommandLiteral final : public Node {
public:
CommandLiteral(Position, Command);
virtual ~CommandLiteral();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Command const& command() const { return m_command; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(CommandLiteral);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override { VERIFY_NOT_REACHED(); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_command() const override { return true; }
virtual bool is_list() const override { return true; }
Command m_command;
};
class Comment : public Node {
public:
Comment(Position, String);
virtual ~Comment();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& text() const { return m_text; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Comment);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
String m_text;
};
Shell: Add runtime errors and implement break/continue Such errors are raised when SyntaxError nodes are executed, and are also used for internal control flow. The 'break' and 'continue' commands are currently only allowed inside for loops, and outside function bodies. This also adds a 'loop' keyword for infinite loops.
2020-12-10 14:55:13 +00:00
class ContinuationControl final : public Node {
public:
enum ContinuationKind {
Break,
Continue,
};
ContinuationControl(Position position, ContinuationKind kind)
: Node(move(position))
, m_kind(kind)
{
}
Shell: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-24 03:05:02 +00:00
virtual ~ContinuationControl() = default;
Shell: Add runtime errors and implement break/continue Such errors are raised when SyntaxError nodes are executed, and are also used for internal control flow. The 'break' and 'continue' commands are currently only allowed inside for loops, and outside function bodies. This also adds a 'loop' keyword for infinite loops.
2020-12-10 14:55:13 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
ContinuationKind continuation_kind() const { return m_kind; }
private:
NODE(ContinuationControl);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
ContinuationKind m_kind { ContinuationKind::Break };
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class DynamicEvaluate final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
DynamicEvaluate(Position, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~DynamicEvaluate();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& inner() const { return m_inner; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(DynamicEvaluate);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_bareword() const override { return m_inner->is_bareword(); }
virtual bool is_command() const override { return is_list(); }
virtual bool is_execute() const override { return true; }
virtual bool is_glob() const override { return m_inner->is_glob(); }
virtual bool is_list() const override
{
return m_inner->is_list() || m_inner->is_command() || m_inner->is_glob(); // Anything that generates a list.
}
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_inner;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class DoubleQuotedString final : public Node {
public:
DoubleQuotedString(Position, RefPtr<Node>);
virtual ~DoubleQuotedString();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
RefPtr<Node> const& inner() const { return m_inner; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(DoubleQuotedString);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
RefPtr<Node> m_inner;
};
class Fd2FdRedirection final : public Node {
public:
Fd2FdRedirection(Position, int, int);
virtual ~Fd2FdRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
int source_fd() const { return m_old_fd; }
int dest_fd() const { return m_new_fd; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Fd2FdRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual bool is_command() const override { return true; }
Shell: Rename {source,dest}_fd to {old,new}_fd This makes `Rewiring' much more understandable, and un-confuses the uses of `dup2()'. Also fixes `dup2()' bugs.
2020-10-27 18:08:37 +00:00
int m_old_fd { -1 };
int m_new_fd { -1 };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add support for functions This implementation does not have support for 'return' yet.
2020-09-13 11:24:33 +00:00
class FunctionDeclaration final : public Node {
public:
FunctionDeclaration(Position, NameWithPosition name, Vector<NameWithPosition> argument_names, RefPtr<AST::Node> body);
virtual ~FunctionDeclaration();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NameWithPosition const& name() const { return m_name; }
Vector<NameWithPosition> const arguments() const { return m_arguments; }
RefPtr<Node> const& block() const { return m_block; }
Shell: Add support for functions This implementation does not have support for 'return' yet.
2020-09-13 11:24:33 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(FunctionDeclaration);
Shell: Add support for functions This implementation does not have support for 'return' yet.
2020-09-13 11:24:33 +00:00
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Add support for functions This implementation does not have support for 'return' yet.
2020-09-13 11:24:33 +00:00
virtual bool would_execute() const override { return true; }
Shell: Run function declarations in the current process Fixes #4817
2021-01-06 12:53:28 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Add support for functions This implementation does not have support for 'return' yet.
2020-09-13 11:24:33 +00:00
NameWithPosition m_name;
Vector<NameWithPosition> m_arguments;
RefPtr<AST::Node> m_block;
};
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
class ForLoop final : public Node {
public:
Shell: Add support for enumerating lists in for loops With some odd syntax to boot: ```sh $ for index i x in $whatever {} ```
2021-03-05 14:55:09 +00:00
ForLoop(Position, Optional<NameWithPosition> variable, Optional<NameWithPosition> index_variable, RefPtr<AST::Node> iterated_expr, RefPtr<AST::Node> block, Optional<Position> in_kw_position = {}, Optional<Position> index_kw_position = {});
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
virtual ~ForLoop();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Optional<NameWithPosition> const& variable() const { return m_variable; }
Optional<NameWithPosition> const& index_variable() const { return m_index_variable; }
RefPtr<Node> const& iterated_expression() const { return m_iterated_expression; }
RefPtr<Node> const& block() const { return m_block; }
Optional<Position> const index_keyword_position() const { return m_index_kw_position; }
Optional<Position> const in_keyword_position() const { return m_in_kw_position; }
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(ForLoop);
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Mark ForLoop as would_execute This fixes #2825.
2020-07-16 20:41:23 +00:00
virtual bool would_execute() const override { return true; }
Shell: Mark control structures to be executed in the current process
2021-01-18 01:25:07 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
Shell: Add support for enumerating lists in for loops With some odd syntax to boot: ```sh $ for index i x in $whatever {} ```
2021-03-05 14:55:09 +00:00
Optional<NameWithPosition> m_variable;
Optional<NameWithPosition> m_index_variable;
Shell: Add runtime errors and implement break/continue Such errors are raised when SyntaxError nodes are executed, and are also used for internal control flow. The 'break' and 'continue' commands are currently only allowed inside for loops, and outside function bodies. This also adds a 'loop' keyword for infinite loops.
2020-12-10 14:55:13 +00:00
RefPtr<AST::Node> m_iterated_expression;
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
RefPtr<AST::Node> m_block;
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Optional<Position> m_in_kw_position;
Shell: Add support for enumerating lists in for loops With some odd syntax to boot: ```sh $ for index i x in $whatever {} ```
2021-03-05 14:55:09 +00:00
Optional<Position> m_index_kw_position;
Shell: Add a 'for' loop Closes #2760. This commit adds a 'for' loop, and tweaks the syntax slightly to make && bind more tightly than || (allowing for `expr && if_ok || if_bad`) :^)
2020-07-11 21:12:46 +00:00
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class Glob final : public Node {
public:
Glob(Position, String);
virtual ~Glob();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& text() const { return m_text; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Glob);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual bool is_glob() const override { return true; }
virtual bool is_list() const override { return true; }
String m_text;
};
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
struct HistorySelector {
enum EventKind {
IndexFromStart,
IndexFromEnd,
StartingStringLookup,
ContainingStringLookup,
};
enum WordSelectorKind {
Index,
Last,
};
struct {
EventKind kind { IndexFromStart };
size_t index { 0 };
Position text_position;
String text;
} event;
struct WordSelector {
WordSelectorKind kind { Index };
size_t selector { 0 };
Position position;
Shell: Make history range values larger than u32 a syntax error Found by oss-fuzz: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=29792&sort=reported&q=serenity
2021-02-02 16:50:05 +00:00
RefPtr<AST::SyntaxError> syntax_error_node;
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
size_t resolve(size_t size) const
{
if (kind == Index)
return selector;
if (kind == Last)
Shell: Improve the parsing of history event designators
2021-07-30 10:55:57 +00:00
return size - selector - 1;
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_NOT_REACHED();
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
}
};
struct {
WordSelector start;
Optional<WordSelector> end;
} word_selector_range;
};
class HistoryEvent final : public Node {
public:
HistoryEvent(Position, HistorySelector);
virtual ~HistoryEvent();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
HistorySelector const& selector() const { return m_selector; }
Shell: Add (basic) support for history event designators Closes #4888
2021-01-11 09:34:59 +00:00
private:
NODE(HistoryEvent);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
HistorySelector m_selector;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class Execute final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Execute(Position, NonnullRefPtr<Node>, bool capture_stdout = false);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Execute();
void capture_stdout() { m_capture_stdout = true; }
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
NonnullRefPtr<Node>& command() { return m_command; }
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
virtual void for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback) override;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& command() const { return m_command; }
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
bool does_capture_stdout() const { return m_capture_stdout; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Execute);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_execute() const override { return true; }
Shell: Mark And and Or nodes as execute nodes
2020-06-24 03:15:24 +00:00
virtual bool would_execute() const override { return true; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_command;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
bool m_capture_stdout { false };
};
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
class IfCond final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
IfCond(Position, Optional<Position> else_position, NonnullRefPtr<AST::Node> cond_expr, RefPtr<AST::Node> true_branch, RefPtr<AST::Node> false_branch);
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
virtual ~IfCond();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& condition() const { return m_condition; }
RefPtr<Node> const& true_branch() const { return m_true_branch; }
RefPtr<Node> const& false_branch() const { return m_false_branch; }
Optional<Position> const else_position() const { return m_else_position; }
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(IfCond);
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Mark control structures to be executed in the current process
2021-01-18 01:25:07 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<AST::Node> m_condition;
Shell: Add 'if' expressions ```sh if foo bar baz { quux } else if foobar || whatever { echo I ran out of example words } else { exit 2 } ```
2020-08-11 07:35:46 +00:00
RefPtr<AST::Node> m_true_branch;
RefPtr<AST::Node> m_false_branch;
Optional<Position> m_else_position;
};
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
class ImmediateExpression final : public Node {
public:
ImmediateExpression(Position, NameWithPosition function, NonnullRefPtrVector<AST::Node> arguments, Optional<Position> closing_brace_position);
virtual ~ImmediateExpression();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtrVector<Node> const& arguments() const { return m_arguments; }
auto const& function() const { return m_function; }
String const& function_name() const { return m_function.name; }
Position const& function_position() const { return m_function.position; }
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
bool has_closing_brace() const { return m_closing_brace_position.has_value(); }
private:
NODE(ImmediateExpression);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
NonnullRefPtrVector<AST::Node> m_arguments;
NameWithPosition m_function;
Optional<Position> m_closing_brace_position;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class Join final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Join(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Join();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Join);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_command() const override { return true; }
virtual bool is_list() const override { return true; }
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
struct MatchEntry {
Shell: Add support for regex match patterns We previously allowed globs as match pattern, but for more complex matching needs, it's nice to have regular expressions. And as the existing "name a part of the match" concept maps nicely to named capture groups, we can simply reuse the same code and make groups with names available in the match body.
2022-04-14 21:20:36 +00:00
Variant<NonnullRefPtrVector<Node>, Vector<Regex<ECMA262>>> options;
Shell: Allow parts of globs to be named in match expressions This patchset allows a match expression to have a list of names for its glob parts, which are assigned to the matched values in the body of the match. For example, ```sh stuff=foobarblahblah/target_{1..30} for $stuff { match $it { */* as (dir sub) { echo "doing things with $sub in $dir" make -C $dir $sub # or whatever... } } } ``` With this, match expressions are now significantly more powerful!
2020-10-25 07:12:03 +00:00
Optional<Vector<String>> match_names;
Optional<Position> match_as_position;
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
Vector<Position> pipe_positions;
RefPtr<Node> body;
};
class MatchExpr final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
MatchExpr(Position, NonnullRefPtr<Node> expr, String name, Optional<Position> as_position, Vector<MatchEntry> entries);
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
virtual ~MatchExpr();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& matched_expr() const { return m_matched_expr; }
String const& expr_name() const { return m_expr_name; }
Vector<MatchEntry> const& entries() const { return m_entries; }
Optional<Position> const& as_position() const { return m_as_position; }
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(MatchExpr);
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
virtual bool would_execute() const override { return true; }
Shell: Mark control structures to be executed in the current process
2021-01-18 01:25:07 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_matched_expr;
Shell: Add 'match' expressions This commit adds an equivalent to the sh 'case' construct, except it's much more pleasing to look at and write: ```sh match "$something" { p1 { echo "p1!" } p2 { echo "p2!" } * { echo "string catch-all!" } } ``` is the equivalent of: ```sh case $something in p1) echo "p1!" ;; p2) echo "p2!" ;; *) echo "catch-all!" ;; esac ``` Since our shell does not treat lists as strings, matching lists is also possible: ```sh match (1foo 2foo foo3) { (?foo 2* *) { echo wowzers! } (* * *) { echo 3-element list catch-all } } ```
2020-09-14 15:02:21 +00:00
String m_expr_name;
Optional<Position> m_as_position;
Vector<MatchEntry> m_entries;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class Or final : public Node {
public:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Or(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>, Position or_position);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Or();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Position const& or_position() const { return m_or_position; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Or);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Position m_or_position;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class Pipe final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Pipe(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Pipe();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Pipe);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual bool is_command() const override { return true; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
class Range final : public Node {
public:
Range(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>);
virtual ~Range();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& start() const { return m_start; }
NonnullRefPtr<Node> const& end() const { return m_end; }
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
private:
NODE(Range);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Add support for brace expansions This adds support for (basic) brace expansions with the following syntaxes: - `{expr?,expr?,expr?,...}` which is directly equivalent to `(expr expr expr ...)`, with the missing expressions replaced with an empty string literal. - `{expr..expr}` which is a new range expansion, with two modes: - if both expressions are one unicode code point long, the range is equivalent to the two code points and all code points between the two (numerically). - if both expressions are numeric, the range is equivalent to both numbers, and all numbers between the two. - otherwise, it is equivalent to `(expr expr)`. Closes #3832.
2020-10-24 14:43:02 +00:00
NonnullRefPtr<Node> m_start;
NonnullRefPtr<Node> m_end;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class ReadRedirection final : public PathRedirectionNode {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
ReadRedirection(Position, int, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~ReadRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(ReadRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class ReadWriteRedirection final : public PathRedirectionNode {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
ReadWriteRedirection(Position, int, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~ReadWriteRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(ReadWriteRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class Sequence final : public Node {
public:
Shell: Make the parser read consecutive sequences without recursing This fixes (the easy) part of #4976.
2021-01-16 19:50:52 +00:00
Sequence(Position, NonnullRefPtrVector<Node>, Vector<Position> separator_positions);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~Sequence();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtrVector<Node> const& entries() const { return m_entries; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Vector<Position> const& separator_positions() const { return m_separator_positions; }
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Sequence);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_list() const override { return true; }
Shell: Mark control structures to be executed in the current process
2021-01-18 01:25:07 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Implement leftmost_trivial_literal() for Sequence nodes
2022-03-06 09:34:11 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Make the parser read consecutive sequences without recursing This fixes (the easy) part of #4976.
2021-01-16 19:50:52 +00:00
NonnullRefPtrVector<Node> m_entries;
Vector<Position> m_separator_positions;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add the (now) free subshell support
2020-09-08 11:29:07 +00:00
class Subshell final : public Node {
public:
Subshell(Position, RefPtr<Node> block);
virtual ~Subshell();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
RefPtr<Node> const& block() const { return m_block; }
Shell: Add the (now) free subshell support
2020-09-08 11:29:07 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Subshell);
Shell: Add the (now) free subshell support
2020-09-08 11:29:07 +00:00
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Make Subshell actually create a subshell Previously, a "subshell" would just be executed in the parent shell.
2020-12-14 19:39:17 +00:00
virtual bool would_execute() const override { return false; }
Shell: Mark control structures to be executed in the current process
2021-01-18 01:25:07 +00:00
virtual bool should_override_execution_in_current_process() const override { return true; }
Shell: Add the (now) free subshell support
2020-09-08 11:29:07 +00:00
RefPtr<AST::Node> m_block;
};
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
class Slice final : public Node {
public:
Slice(Position, NonnullRefPtr<AST::Node>);
virtual ~Slice() override;
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
NonnullRefPtr<AST::Node> selector() const { return m_selector; }
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
protected:
NODE(Slice);
NonnullRefPtr<AST::Node> m_selector;
};
class VariableNode : public Node {
public:
VariableNode(Position position)
: Node(move(position))
{
}
void set_slice(NonnullRefPtr<Slice>&& slice)
{
VERIFY(!m_slice);
m_slice = move(slice);
if (m_slice->is_syntax_error())
set_is_syntax_error(m_slice->syntax_error_node());
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Slice const* slice() const { return m_slice.ptr(); }
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
protected:
RefPtr<Slice> m_slice;
};
class SimpleVariable final : public VariableNode {
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
public:
SimpleVariable(Position, String);
virtual ~SimpleVariable();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& name() const { return m_name; }
Shell: Complete named function parameters inside the function body
2020-09-14 09:29:06 +00:00
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(SimpleVariable);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Complete named function parameters inside the function body
2020-09-14 09:29:06 +00:00
virtual bool is_simple_variable() const override { return true; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
String m_name;
};
Shell: Add support for indexing into variables Now a variable may have an optional slice (only _one_ slice), which can also use negative indices to index from the end. This works on both lists and strings. The contents of the slice have the same semantics as brace expansions. For example: ```sh $ x=(1 2 3 4 5 6) $ echo $x[1..3] # select indices 1, 2, 3 2 3 4 $ echo $x[3,4,1,0] # select indices 3, 4, 1, 0 (in that order) 4 5 2 1 $ x="Well Hello Friends!" $ echo $x[5..9] Hello ```
2021-03-12 23:40:18 +00:00
class SpecialVariable final : public VariableNode {
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
public:
SpecialVariable(Position, char);
virtual ~SpecialVariable();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
char name() const { return m_name; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(SpecialVariable);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Userland: Allow building SerenityOS with -funsigned-char Some of the code assumed that chars were always signed while that is not the case on ARM hosts. Also, some of the code tried to use EOF (-1) in a way similar to what fgetc() does, however instead of storing the characters in an int variable a char was used. While this seemed to work it also meant that character 0xFF would be incorrectly seen as an end-of-file. Careful reading of fgetc() reveals that fgetc() stores character data in an int where valid characters are in the range of 0-255 and the EOF value is explicitly outside of that range (usually -1).
2021-06-13 07:15:00 +00:00
char m_name { 0 };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Expand Juxtaposition of lists to list products This commit makes `echo x(foo bar)` create an argv of `echo xfoo xbar`, essentially modeling brace expansions in some shells.
2020-06-20 13:30:45 +00:00
class Juxtaposition final : public Node {
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
Juxtaposition(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>);
Shell: Expand Juxtaposition of lists to list products This commit makes `echo x(foo bar)` create an argv of `echo xfoo xbar`, essentially modeling brace expansions in some shells.
2020-06-20 13:30:45 +00:00
virtual ~Juxtaposition();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Juxtaposition);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add support for heredocs Closes #4283. Heredocs are implemented in a way that makes them feel more like a string (and not a weird redirection, a la bash). There are two tunables, whether the string is dedented (`<<-` vs `<<~`) and whether it allows interpolation (quoted key vs not). To the familiar people, this is how Ruby handles them, and I feel is the most elegant heredoc syntax. Unlike the oddjob that is bash, heredocs are treated exactly as normal strings, and can be used _anywhere_ where a string can be used. They are *required* to appear in the same order as used after a newline is seen when parsing the sequence that the heredoc is used in. For instance: ```sh echo <<-doc1 <<-doc2 | blah blah contents for doc1 doc1 contents for doc2 doc2 ``` The typical nice errors are also implemented :^)
2021-04-29 02:34:00 +00:00
class Heredoc final : public Node {
public:
Heredoc(Position, String end, bool allow_interpolation, bool deindent);
virtual ~Heredoc();
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& end() const { return m_end; }
Shell: Add support for heredocs Closes #4283. Heredocs are implemented in a way that makes them feel more like a string (and not a weird redirection, a la bash). There are two tunables, whether the string is dedented (`<<-` vs `<<~`) and whether it allows interpolation (quoted key vs not). To the familiar people, this is how Ruby handles them, and I feel is the most elegant heredoc syntax. Unlike the oddjob that is bash, heredocs are treated exactly as normal strings, and can be used _anywhere_ where a string can be used. They are *required* to appear in the same order as used after a newline is seen when parsing the sequence that the heredoc is used in. For instance: ```sh echo <<-doc1 <<-doc2 | blah blah contents for doc1 doc1 contents for doc2 doc2 ``` The typical nice errors are also implemented :^)
2021-04-29 02:34:00 +00:00
bool allow_interpolation() const { return m_allows_interpolation; }
bool deindent() const { return m_deindent; }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
RefPtr<AST::Node> const& contents() const { return m_contents; }
Shell: Add support for heredocs Closes #4283. Heredocs are implemented in a way that makes them feel more like a string (and not a weird redirection, a la bash). There are two tunables, whether the string is dedented (`<<-` vs `<<~`) and whether it allows interpolation (quoted key vs not). To the familiar people, this is how Ruby handles them, and I feel is the most elegant heredoc syntax. Unlike the oddjob that is bash, heredocs are treated exactly as normal strings, and can be used _anywhere_ where a string can be used. They are *required* to appear in the same order as used after a newline is seen when parsing the sequence that the heredoc is used in. For instance: ```sh echo <<-doc1 <<-doc2 | blah blah contents for doc1 doc1 contents for doc2 doc2 ``` The typical nice errors are also implemented :^)
2021-04-29 02:34:00 +00:00
void set_contents(RefPtr<AST::Node> contents)
{
m_contents = move(contents);
if (m_contents->is_syntax_error())
set_is_syntax_error(m_contents->syntax_error_node());
else
clear_syntax_error();
}
private:
NODE(Heredoc);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
virtual HitTestResult hit_test_position(size_t) const override;
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; };
String m_end;
bool m_allows_interpolation { false };
bool m_deindent { false };
RefPtr<AST::Node> m_contents;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class StringLiteral final : public Node {
public:
Shell: Allow completing StringLiterals as paths This auto-escapes the token as well :^)
2022-03-06 08:28:49 +00:00
enum class EnclosureType {
None,
SingleQuotes,
DoubleQuotes,
};
StringLiteral(Position, String, EnclosureType);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~StringLiteral();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& text() const { return m_text; }
Shell: Allow completing StringLiterals as paths This auto-escapes the token as well :^)
2022-03-06 08:28:49 +00:00
EnclosureType enclosure_type() const { return m_enclosure_type; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(StringLiteral);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Initial support for 'option' completions Take one small step towards #2357. Handle completing barewords starting with '-' by piping the requests to the Shell::complete_option(program_name, option) :^) Also implements completion for a single builtin (setopt) until we figure out how to handle #2357.
2020-06-29 01:56:06 +00:00
virtual RefPtr<Node> leftmost_trivial_literal() const override { return this; };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
String m_text;
Shell: Allow completing StringLiterals as paths This auto-escapes the token as well :^)
2022-03-06 08:28:49 +00:00
EnclosureType m_enclosure_type;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class StringPartCompose final : public Node {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
StringPartCompose(Position, NonnullRefPtr<Node>, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~StringPartCompose();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtr<Node> const& left() const { return m_left; }
NonnullRefPtr<Node> const& right() const { return m_right; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(StringPartCompose);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
NonnullRefPtr<Node> m_left;
NonnullRefPtr<Node> m_right;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class SyntaxError final : public Node {
public:
Shell: Make <return> go to a new line when the command is incomplete "incomplete" meaning that it has a syntax error that can be recovered from by continuing the input.
2020-12-01 09:25:14 +00:00
SyntaxError(Position, String, bool is_continuable = false);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~SyntaxError();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
String const& error_text() const { return m_syntax_error_text; }
Shell: Make <return> go to a new line when the command is incomplete "incomplete" meaning that it has a syntax error that can be recovered from by continuing the input.
2020-12-01 09:25:14 +00:00
bool is_continuable() const { return m_is_continuable; }
Shell: Show descriptions about syntax errors The description contains an error message and where in the source the error happened.
2020-06-28 14:12:57 +00:00
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
virtual void clear_syntax_error() override
{
m_is_cleared = true;
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual void set_is_syntax_error(SyntaxError const& error) override
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
{
Shell: Make set_is_syntax_error() also copy the error location
2021-05-01 08:13:12 +00:00
m_position = error.position();
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
m_is_cleared = error.m_is_cleared;
m_is_continuable = error.m_is_continuable;
m_syntax_error_text = error.error_text();
}
virtual bool is_syntax_error() const override { return !m_is_cleared; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(SyntaxError);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override { return { nullptr, nullptr, nullptr }; }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual SyntaxError const& syntax_error_node() const override;
Shell: Show descriptions about syntax errors The description contains an error message and where in the source the error happened.
2020-06-28 14:12:57 +00:00
String m_syntax_error_text;
Shell: Make <return> go to a new line when the command is incomplete "incomplete" meaning that it has a syntax error that can be recovered from by continuing the input.
2020-12-01 09:25:14 +00:00
bool m_is_continuable { false };
Shell: Allow Syntax errors to be mutated while parsing Some nodes (such as heredocs) cannot be validated immediately, so the entire tree will need to be revalidated if we don't allow mutating syntax errors.
2021-04-29 02:28:46 +00:00
bool m_is_cleared { false };
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
class SyntheticNode final : public Node {
public:
SyntheticNode(Position, NonnullRefPtr<Value>);
virtual ~SyntheticNode() = default;
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Value const& value() const { return m_value; }
Shell: Add support for 'immediate' expressions as variable substitutions This commit adds a few basic variable substitution operations: - length Find the length of a string or a list - length_across Find the lengths of things inside a list - remove_{suffix,prefix} Remove a suffix or a prefix from all the passed values - regex_replace Replace all matches of a given regex with a given template - split Split the given string with the given delimiter (or to its code points if the delimiter is empty) - concat_lists concatenates any given lists into one Closes #4316 (the ancient version of this same feature)
2021-03-05 13:03:23 +00:00
private:
NODE(SyntheticValue);
virtual void dump(int level) const override;
virtual RefPtr<Value> run(RefPtr<Shell>) override;
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
NonnullRefPtr<Value> m_value;
};
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
class Tilde final : public Node {
public:
Tilde(Position, String);
virtual ~Tilde();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
String text() const;
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(Tilde);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual Vector<Line::CompletionSuggestion> complete_for_editor(Shell&, size_t, HitTestResult const&) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_tilde() const override { return true; }
String m_username;
};
class VariableDeclarations final : public Node {
public:
struct Variable {
Shell: Make VariableDeclarations::Variable store NonnullRefPtrs
2020-08-07 07:41:04 +00:00
NonnullRefPtr<Node> name;
NonnullRefPtr<Node> value;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
VariableDeclarations(Position, Vector<Variable> variables);
virtual ~VariableDeclarations();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Vector<Variable> const& variables() const { return m_variables; }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(VariableDeclarations);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
Shell: Make Node::hit_test_position() const
2021-03-02 06:05:04 +00:00
virtual HitTestResult hit_test_position(size_t) const override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual bool is_variable_decls() const override { return true; }
Vector<Variable> m_variables;
};
class WriteAppendRedirection final : public PathRedirectionNode {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
WriteAppendRedirection(Position, int, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~WriteAppendRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(WriteAppendRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
class WriteRedirection final : public PathRedirectionNode {
public:
Shell: Use NonnullRefPtr to store non-null subnodes Also replaces null-is-invalid nodes with syntax error nodes.
2020-09-16 00:37:14 +00:00
WriteRedirection(Position, int, NonnullRefPtr<Node>);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual ~WriteRedirection();
Shell: Add a (very basic) formatter
2020-09-16 00:43:04 +00:00
virtual void visit(NodeVisitor& visitor) override { visitor.visit(this); }
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
private:
Shell: Track line numbers and the positions of some keywords
2020-09-28 10:57:20 +00:00
NODE(WriteRedirection);
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
virtual void dump(int level) const override;
Shell: Provide completions to Tilde and its Juxtaposition. This commit also removes the ExecutionInputType and directly uses RefPtr<Shell> instead, since nothing else is needed for execution purposes, and also makes the shell refuse to evaluate commands with any sort of syntax error.
2020-06-23 14:40:41 +00:00
virtual RefPtr<Value> run(RefPtr<Shell>) override;
Shell: Switch to a new parser and AST This commit also completely reworks the execution, highlighting and completion model to work with the new AST. New additions: - $(...) stdout captures - fd>&fd redirections - fd>&- redirections (close fd) - read-write redirections (<> path) - completely event-based execution - the weird idea of allowing the user to redirect the shell's own fds - variables in strings - local variables - minimal list support - adding hyperlinks to all paths that exist
2020-06-17 13:35:06 +00:00
};
}
Shell: Implement AK::Formatter::format() for AST::Command ...and use that to display jobs.
2020-10-25 22:57:19 +00:00
namespace AK {
template<>
struct Formatter<Shell::AST::Command> : StandardFormatter {
Shell: Use default instead of an empty constructor/destructor Default implementations allow for more optimizations. See: https://pvs-studio.com/en/docs/warnings/v832/
2021-09-16 07:23:29 +00:00
Formatter() = default;
Shell: Implement AK::Formatter::format() for AST::Command ...and use that to display jobs.
2020-10-25 22:57:19 +00:00
explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter)
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, Shell::AST::Command const& value);
Shell: Implement AK::Formatter::format() for AST::Command ...and use that to display jobs.
2020-10-25 22:57:19 +00:00
};
}
Reference in a new issue Copy permalink