Sinipelto
/
banan-os
forked from Bananymous/banan-os
1
0
Fork 0
Code Pull Requests Activity

Shell: Add support for &&, || and ;

This commit is contained in:
Bananymous 2024-10-06 00:17:34 +03:00
parent f75cebac7e
commit d542cd811d
1 changed files with 202 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
userspace/programs/Shell/main.cpp
View File

@ -25,7 +25,47 @@ static int last_return = 0;
static BAN::String hostname; static BAN::String hostname;
static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView); struct SingleCommand
{
BAN::Vector<BAN::String> arguments;
};
struct PipedCommand
{
BAN::Vector<SingleCommand> commands;
};
struct CommandList
{
enum class Condition
{
Always,
OnSuccess,
OnFailure,
};
struct Command
{
BAN::String expression;
Condition condition;
};
BAN::Vector<Command> commands;
};
static BAN::StringView strip_whitespace(BAN::StringView sv)
{
size_t leading = 0;
while (leading < sv.size() && isspace(sv[leading]))
leading++;
sv = sv.substring(leading);
size_t trailing = 0;
while (trailing < sv.size() && isspace(sv[sv.size() - trailing - 1]))
trailing++;
sv = sv.substring(0, sv.size() - trailing);
return sv;
}
static BAN::Optional<BAN::String> parse_dollar(BAN::StringView command, size_t& i) static BAN::Optional<BAN::String> parse_dollar(BAN::StringView command, size_t& i)
{ {
@ -157,22 +197,7 @@ static BAN::Optional<BAN::String> parse_dollar(BAN::StringView command, size_t&
return temp; return temp;
} }
static BAN::StringView strip_whitespace(BAN::StringView sv) static PipedCommand parse_piped_command(BAN::StringView command_view)
{
size_t leading = 0;
while (leading < sv.size() && isspace(sv[leading]))
leading++;
sv = sv.substring(leading);
size_t trailing = 0;
while (trailing < sv.size() && isspace(sv[sv.size() - trailing - 1]))
trailing++;
sv = sv.substring(0, sv.size() - trailing);
return sv;
}
static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView command_view)
{ {
enum class State enum class State
{ {
@ -183,11 +208,10 @@ static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView comma
command_view = strip_whitespace(command_view); command_view = strip_whitespace(command_view);
BAN::Vector<BAN::Vector<BAN::String>> result;
BAN::Vector<BAN::String> command_args;
State state = State::Normal; State state = State::Normal;
BAN::String current_arg; SingleCommand current_command;
BAN::String current_argument;
PipedCommand result;
for (size_t i = 0; i < command_view.size(); i++) for (size_t i = 0; i < command_view.size(); i++)
{ {
char c = command_view[i]; char c = command_view[i];
@ -198,7 +222,7 @@ static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView comma
if (next == '\'' || next == '"') if (next == '\'' || next == '"')
{ {
if (i + 1 < command_view.size()) if (i + 1 < command_view.size())
MUST(current_arg.push_back(next)); MUST(current_argument.push_back(next));
i++; i++;
continue; continue;
} }
@ -219,25 +243,25 @@ static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView comma
fprintf(stderr, "bad substitution\n"); fprintf(stderr, "bad substitution\n");
return {}; return {};
} }
MUST(current_arg.append(expansion.value())); MUST(current_argument.append(expansion.value()));
} }
else if (c == '|') else if (c == '|')
{ {
if (!current_arg.empty()) if (!current_argument.empty())
MUST(command_args.push_back(current_arg)); MUST(current_command.arguments.push_back(current_argument));
current_arg.clear(); current_argument.clear();
MUST(result.push_back(command_args)); MUST(result.commands.push_back(current_command));
command_args.clear(); current_command.arguments.clear();
} }
else if (!isspace(c)) else if (!isspace(c))
MUST(current_arg.push_back(c)); MUST(current_argument.push_back(c));
else else
{ {
if (!current_arg.empty()) if (!current_argument.empty())
{ {
MUST(command_args.push_back(current_arg)); MUST(current_command.arguments.push_back(current_argument));
current_arg.clear(); current_argument.clear();
} }
} }
break; break;
@ -245,13 +269,13 @@ static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView comma
if (c == '\'') if (c == '\'')
state = State::Normal; state = State::Normal;
else else
MUST(current_arg.push_back(c)); MUST(current_argument.push_back(c));
break; break;
case State::DoubleQuote: case State::DoubleQuote:
if (c == '"') if (c == '"')
state = State::Normal; state = State::Normal;
else if (c != '$') else if (c != '$')
MUST(current_arg.push_back(c)); MUST(current_argument.push_back(c));
else else
{ {
auto expansion = parse_dollar(command_view, i); auto expansion = parse_dollar(command_view, i);
@ -260,26 +284,88 @@ static BAN::Vector<BAN::Vector<BAN::String>> parse_command(BAN::StringView comma
fprintf(stderr, "bad substitution\n"); fprintf(stderr, "bad substitution\n");
return {}; return {};
} }
MUST(current_arg.append(expansion.value())); MUST(current_argument.append(expansion.value()));
} }
break; break;
} }
} }
// FIXME: handle state != State::Normal // FIXME: handle state != State::Normal
MUST(command_args.push_back(BAN::move(current_arg))); MUST(current_command.arguments.push_back(BAN::move(current_argument)));
MUST(result.push_back(BAN::move(command_args))); MUST(result.commands.push_back(BAN::move(current_command)));
return result; return BAN::move(result);
} }
static int execute_command(BAN::Vector<BAN::String>& args, int fd_in, int fd_out); static CommandList parse_command_list(BAN::StringView command_view)
{
CommandList result;
CommandList::Condition next_condition = CommandList::Condition::Always;
for (size_t i = 0; i < command_view.size(); i++)
{
const char current = command_view[i];
switch (current)
{
case '\\':
i++;
break;
case '\'':
case '"':
while (++i < command_view.size())
{
if (command_view[i] == '\\')
i++;
else if (command_view[i] == current)
break;
}
break;
case ';':
MUST(result.commands.emplace_back(
strip_whitespace(command_view.substring(0, i)),
next_condition
));
command_view = strip_whitespace(command_view.substring(i + 1));
next_condition = CommandList::Condition::Always;
i = -1;
break;
case '|':
case '&':
if (i + 1 >= command_view.size() || command_view[i + 1] != current)
break;
MUST(result.commands.emplace_back(
strip_whitespace(command_view.substring(0, i)),
next_condition
));
command_view = strip_whitespace(command_view.substring(i + 2));
next_condition = (current == '|') ? CommandList::Condition::OnFailure : CommandList::Condition::OnSuccess;
i = -1;
break;
}
}
MUST(result.commands.emplace_back(
strip_whitespace(command_view),
next_condition
));
for (const auto& [expression, _] : result.commands)
{
if (!expression.empty())
continue;
fprintf(stderr, "expected an expression\n");
return {};
}
return BAN::move(result);
}
static int execute_command(const SingleCommand& command, int fd_in, int fd_out);
static int source_script(const BAN::String& path); static int source_script(const BAN::String& path);
static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd_in, int fd_out) static BAN::Optional<int> execute_builtin(const SingleCommand& command, int fd_in, int fd_out)
{ {
if (args.empty()) if (command.arguments.empty())
return 0; return 0;
FILE* fout = stdout; FILE* fout = stdout;
@ -296,19 +382,19 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
} }
BAN::ScopeGuard _([fout, should_close] { if (should_close) fclose(fout); }); BAN::ScopeGuard _([fout, should_close] { if (should_close) fclose(fout); });
if (args.front() == "clear"_sv) if (command.arguments.front() == "clear"_sv)
{ {
fprintf(fout, "\e[H\e[2J"); fprintf(fout, "\e[H\e[2J");
fflush(fout); fflush(fout);
} }
else if (args.front() == "exit"_sv) else if (command.arguments.front() == "exit"_sv)
{ {
exit(0); exit(0);
} }
else if (args.front() == "export"_sv) else if (command.arguments.front() == "export"_sv)
{ {
bool first = false; bool first = false;
for (const auto& arg : args) for (const auto& argument : command.arguments)
{ {
if (first) if (first)
{ {
@ -316,7 +402,7 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
continue; continue;
} }
auto split = MUST(arg.sv().split('=', true)); auto split = MUST(argument.sv().split('=', true));
if (split.size() != 2) if (split.size() != 2)
continue; continue;
@ -324,24 +410,24 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
ERROR_RETURN("setenv", 1); ERROR_RETURN("setenv", 1);
} }
} }
else if (args.front() == "source"_sv) else if (command.arguments.front() == "source"_sv)
{ {
if (args.size() != 2) if (command.arguments.size() != 2)
{ {
fprintf(fout, "usage: source FILE\n"); fprintf(fout, "usage: source FILE\n");
return 1; return 1;
} }
return source_script(args[1]); return source_script(command.arguments[1]);
} }
else if (args.front() == "env"_sv) else if (command.arguments.front() == "env"_sv)
{ {
char** current = environ; char** current = environ;
while (*current) while (*current)
fprintf(fout, "%s\n", *current++); fprintf(fout, "%s\n", *current++);
} }
else if (args.front() == "cd"_sv) else if (command.arguments.front() == "cd"_sv)
{ {
if (args.size() > 2) if (command.arguments.size() > 2)
{ {
fprintf(fout, "cd: too many arguments\n"); fprintf(fout, "cd: too many arguments\n");
return 1; return 1;
@ -349,7 +435,7 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
BAN::StringView path; BAN::StringView path;
if (args.size() == 1) if (command.arguments.size() == 1)
{ {
if (const char* path_env = getenv("HOME")) if (const char* path_env = getenv("HOME"))
path = path_env; path = path_env;
@ -357,21 +443,24 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
return 0; return 0;
} }
else else
path = args[1]; path = command.arguments[1];
if (chdir(path.data()) == -1) if (chdir(path.data()) == -1)
ERROR_RETURN("chdir", 1); ERROR_RETURN("chdir", 1);
} }
else if (args.front() == "time"_sv) else if (command.arguments.front() == "time"_sv)
{ {
args.remove(0); SingleCommand timed_command;
MUST(timed_command.arguments.reserve(command.arguments.size() - 1));
for (size_t i = 1; i < command.arguments.size(); i++)
timed_command.arguments[i - 1] = command.arguments[i];
timespec start, end; timespec start, end;
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
ERROR_RETURN("clock_gettime", 1); ERROR_RETURN("clock_gettime", 1);
int ret = execute_command(args, fd_in, fd_out); int ret = execute_command(timed_command, fd_in, fd_out);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
ERROR_RETURN("clock_gettime", 1); ERROR_RETURN("clock_gettime", 1);
@ -387,7 +476,7 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
return ret; return ret;
} }
else if (args.front() == "start-gui"_sv) else if (command.arguments.front() == "start-gui"_sv)
{ {
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) if (pid == 0)
@ -404,20 +493,19 @@ static BAN::Optional<int> execute_builtin(BAN::Vector<BAN::String>& args, int fd
return 0; return 0;
} }
static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in, int fd_out, pid_t pgrp) static pid_t execute_command_no_wait(const SingleCommand& command, int fd_in, int fd_out, pid_t pgrp)
{ {
if (args.empty()) ASSERT(!command.arguments.empty());
return 0;
BAN::Vector<char*> cmd_args; BAN::Vector<char*> cmd_args;
MUST(cmd_args.reserve(args.size() + 1)); MUST(cmd_args.reserve(command.arguments.size() + 1));
for (const auto& arg : args) for (const auto& arg : command.arguments)
MUST(cmd_args.push_back((char*)arg.data())); MUST(cmd_args.push_back((char*)arg.data()));
MUST(cmd_args.push_back(nullptr)); MUST(cmd_args.push_back(nullptr));
// do PATH resolution // do PATH resolution
BAN::String executable_file; BAN::String executable_file;
if (!args.front().sv().contains('/')) if (!command.arguments.front().sv().contains('/'))
{ {
const char* path_env_cstr = getenv("PATH"); const char* path_env_cstr = getenv("PATH");
if (path_env_cstr == nullptr) if (path_env_cstr == nullptr)
@ -428,7 +516,7 @@ static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in,
{ {
BAN::String test_file = path_env; BAN::String test_file = path_env;
MUST(test_file.push_back('/')); MUST(test_file.push_back('/'));
MUST(test_file.append(args.front())); MUST(test_file.append(command.arguments.front()));
struct stat st; struct stat st;
if (stat(test_file.data(), &st) == 0) if (stat(test_file.data(), &st) == 0)
@ -440,7 +528,7 @@ static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in,
} }
else else
{ {
executable_file = args.front(); executable_file = command.arguments.front();
} }
// Verify that the file exists is executable // Verify that the file exists is executable
@ -448,7 +536,7 @@ static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in,
struct stat st; struct stat st;
if (executable_file.empty() || stat(executable_file.data(), &st) == -1) if (executable_file.empty() || stat(executable_file.data(), &st) == -1)
{ {
fprintf(stderr, "command not found: %s\n", args.front().data()); fprintf(stderr, "command not found: %s\n", command.arguments.front().data());
return -1; return -1;
} }
if ((st.st_mode & 0111) == 0) if ((st.st_mode & 0111) == 0)
@ -458,7 +546,7 @@ static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in,
} }
} }
pid_t pid = fork(); const pid_t pid = fork();
if (pid == 0) if (pid == 0)
{ {
if (fd_in != STDIN_FILENO) if (fd_in != STDIN_FILENO)
@ -503,9 +591,9 @@ static pid_t execute_command_no_wait(BAN::Vector<BAN::String>& args, int fd_in,
return pid; return pid;
} }
static int execute_command(BAN::Vector<BAN::String>& args, int fd_in, int fd_out) static int execute_command(const SingleCommand& command, int fd_in, int fd_out)
{ {
pid_t pid = execute_command_no_wait(args, fd_in, fd_out, 0); const pid_t pid = execute_command_no_wait(command, fd_in, fd_out, 0);
if (pid == -1) if (pid == -1)
return 1; return 1;
@ -522,27 +610,27 @@ static int execute_command(BAN::Vector<BAN::String>& args, int fd_in, int fd_out
return WEXITSTATUS(status); return WEXITSTATUS(status);
} }
static int execute_piped_commands(BAN::Vector<BAN::Vector<BAN::String>>& commands) static int execute_piped_commands(const PipedCommand& piped_command)
{ {
if (commands.empty()) if (piped_command.commands.empty())
return 0; return 0;
if (commands.size() == 1) if (piped_command.commands.size() == 1)
{ {
auto& command = commands.front(); auto& command = piped_command.commands.front();
if (auto ret = execute_builtin(command, STDIN_FILENO, STDOUT_FILENO); ret.has_value()) if (auto ret = execute_builtin(command, STDIN_FILENO, STDOUT_FILENO); ret.has_value())
return ret.value(); return ret.value();
return execute_command(command, STDIN_FILENO, STDOUT_FILENO); return execute_command(command, STDIN_FILENO, STDOUT_FILENO);
} }
BAN::Vector<int> exit_codes(commands.size(), 0); BAN::Vector<int> exit_codes(piped_command.commands.size(), 0);
BAN::Vector<pid_t> processes(commands.size(), -1); BAN::Vector<pid_t> processes(piped_command.commands.size(), -1);
pid_t pgrp = 0; pid_t pgrp = 0;
int next_stdin = STDIN_FILENO; int next_stdin = STDIN_FILENO;
for (size_t i = 0; i < commands.size(); i++) for (size_t i = 0; i < piped_command.commands.size(); i++)
{ {
bool last = (i == commands.size() - 1); const bool last = (i == piped_command.commands.size() - 1);
int pipefd[2] { -1, STDOUT_FILENO }; int pipefd[2] { -1, STDOUT_FILENO };
if (!last && pipe(pipefd) == -1) if (!last && pipe(pipefd) == -1)
@ -553,12 +641,12 @@ static int execute_piped_commands(BAN::Vector<BAN::Vector<BAN::String>>& command
break; break;
} }
auto builtin_ret = execute_builtin(commands[i], next_stdin, pipefd[1]); auto builtin_ret = execute_builtin(piped_command.commands[i], next_stdin, pipefd[1]);
if (builtin_ret.has_value()) if (builtin_ret.has_value())
exit_codes[i] = builtin_ret.value(); exit_codes[i] = builtin_ret.value();
else else
{ {
pid_t pid = execute_command_no_wait(commands[i], next_stdin, pipefd[1], pgrp); pid_t pid = execute_command_no_wait(piped_command.commands[i], next_stdin, pipefd[1], pgrp);
processes[i] = pid; processes[i] = pid;
if (pgrp == 0) if (pgrp == 0)
pgrp = pid; pgrp = pid;
@ -571,7 +659,7 @@ static int execute_piped_commands(BAN::Vector<BAN::Vector<BAN::String>>& command
next_stdin = pipefd[0]; next_stdin = pipefd[0];
} }
for (size_t i = 0; i < commands.size(); i++) for (size_t i = 0; i < piped_command.commands.size(); i++)
{ {
if (processes[i] == -1) if (processes[i] == -1)
continue; continue;
@ -599,15 +687,42 @@ static int execute_piped_commands(BAN::Vector<BAN::Vector<BAN::String>>& command
static int parse_and_execute_command(BAN::StringView command) static int parse_and_execute_command(BAN::StringView command)
{ {
command = strip_whitespace(command);
if (command.empty()) if (command.empty())
return 0; return 0;
auto parsed_commands = parse_command(command);
if (parsed_commands.empty()) auto command_list = parse_command_list(command);
if (command_list.commands.empty())
return 0; return 0;
tcsetattr(0, TCSANOW, &old_termios); tcsetattr(0, TCSANOW, &old_termios);
int ret = execute_piped_commands(parsed_commands);
last_return = 0;
for (const auto& [expression, condition] : command_list.commands)
{
bool should_run = false;
switch (condition)
{
case CommandList::Condition::Always:
should_run = true;
break;
case CommandList::Condition::OnSuccess:
should_run = (last_return == 0);
break;
case CommandList::Condition::OnFailure:
should_run = (last_return != 0);
break;
}
if (!should_run)
continue;
last_return = execute_piped_commands(parse_piped_command(expression));
}
tcsetattr(0, TCSANOW, &new_termios); tcsetattr(0, TCSANOW, &new_termios);
return ret;
return last_return;
} }
static int source_script(const BAN::String& path) static int source_script(const BAN::String& path)
@ -814,9 +929,7 @@ int main(int argc, char** argv)
printf("-c requires an argument\n"); printf("-c requires an argument\n");
return 1; return 1;
} }
return parse_and_execute_command(BAN::String(argv[i + 1]));
auto commands = parse_command(BAN::String(argv[i + 1]));
return execute_piped_commands(commands);
} }
else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0)
{ {
@ -985,7 +1098,7 @@ int main(int argc, char** argv)
putchar('\n'); putchar('\n');
if (!buffers[index].empty()) if (!buffers[index].empty())
{ {
last_return = parse_and_execute_command(buffers[index]); parse_and_execute_command(buffers[index]);
MUST(history.push_back(buffers[index])); MUST(history.push_back(buffers[index]));
buffers = history; buffers = history;
MUST(buffers.emplace_back(""_sv)); MUST(buffers.emplace_back(""_sv));