Macintosh-SW/mpw-shell
1
0
Fork 0
mirror of https://github.com/ksherlock/mpw-shell.git synced 2024-12-27 18:30:39 +00:00
Code Issues Projects Releases Wiki Activity

update the parser/lexer to make it more reusable. For example, subshells are now handled.

Browse Source
This commit is contained in:
Kelvin Sherlock 2016-08-16 16:47:20 -04:00
parent 548880a517
commit 33dd3228f8
16 changed files with 458 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CMakeLists.txt
View File

@ -85,17 +85,17 @@ RAGEL_TARGET(value value.rl value.cpp COMPILE_FLAGS "-p -G2")
# need to copy all OUTPUT file to the build dir # need to copy all OUTPUT file to the build dir
add_custom_command( add_custom_command(
OUTPUT phase2-parser.cpp phase2-parser.h phase2-parser.out OUTPUT phase3.cpp phase3.h phase3.out
COMMAND lemon++ phase2-parser.lemon COMMAND lemon++ phase3.lemon
COMMAND mv -f phase2-parser.cpp phase2-parser.h phase2-parser.out ${CMAKE_CURRENT_BINARY_DIR}/ COMMAND mv -f phase3.cpp phase3.h phase3.out ${CMAKE_CURRENT_BINARY_DIR}/
MAIN_DEPENDENCY phase2-parser.lemon MAIN_DEPENDENCY phase3.lemon
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
) )
add_executable(mpw-shell mpw-shell.cpp mpw-shell-token.cpp mpw-shell-expand.cpp add_executable(mpw-shell mpw-shell.cpp mpw-shell-token.cpp mpw-shell-expand.cpp
mpw-shell-parser.cpp value.cpp mpw-shell-quote.cpp mpw-shell-parser.cpp mpw_parser.cpp value.cpp mpw-shell-quote.cpp
phase1.cpp phase2.cpp phase2-parser.cpp command.cpp environment.cpp builtins.cpp phase1.cpp phase2.cpp phase3.cpp command.cpp environment.cpp builtins.cpp
pathnames.cpp pathnames.cpp
macroman.cpp macroman.cpp
cxx/mapped_file.cpp cxx/mapped_file.cpp

23
builtins.cpp
View File

@ -855,12 +855,15 @@ int builtin_which(Environment &env, const std::vector<std::string> &tokens, cons
"catenate", "catenate",
"directory", "directory",
"echo", "echo",
"execute",
"exists", "exists",
"export", "export",
"false", // not in MPW
"parameters", "parameters",
"quote", "quote",
"set", "set",
"shift", "shift",
"true", // not in MPW
"unalias", "unalias",
"unexport", "unexport",
"unset", "unset",
@ -1034,3 +1037,23 @@ int builtin_true(Environment &, const std::vector<std::string> &, const fdmask &
int builtin_false(Environment &, const std::vector<std::string> &, const fdmask &) { int builtin_false(Environment &, const std::vector<std::string> &, const fdmask &) {
return 1; return 1;
} }
int builtin_execute(Environment &e, const std::vector<std::string> &tokens, const fdmask &fds) {
// runs argv[1] in the current environment. unlike MPW, argv[1] must be a script.
// special enhancement -- '-' means execute stdin.
if (tokens.size() < 2) return 0;
std::string filename = tokens[1];
if (filename == "-") {
// since we're parsing stdin, don't let any children read it. [???]
fdset new_fds;
int fd = open("/dev/null", O_RDONLY);
new_fds.set(0, fd);
return read_fd(e, fds[0], new_fds | fds);
}
return read_file(e, filename, fds);
}

6
builtins.h
View File

@ -25,6 +25,12 @@ int builtin_which(Environment &e, const std::vector<std::string> &, const fdmask
int builtin_alias(Environment &e, const std::vector<std::string> &, const fdmask &); int builtin_alias(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_unalias(Environment &e, const std::vector<std::string> &, const fdmask &); int builtin_unalias(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_execute(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_true(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_false(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_execute(Environment &e, const std::vector<std::string> &, const fdmask &);
int builtin_evaluate(Environment &e, std::vector<token> &&, const fdmask &); int builtin_evaluate(Environment &e, std::vector<token> &&, const fdmask &);
#endif #endif

287
command.cpp
View File

@ -1,5 +1,5 @@
#include "command.h" #include "command.h"
#include "phase2-parser.h" #include "phase3.h"
#include "environment.h" #include "environment.h"
#include "fdset.h" #include "fdset.h"
#include "builtins.h" #include "builtins.h"
@ -198,6 +198,7 @@ namespace {
{"catenate", builtin_catenate}, {"catenate", builtin_catenate},
{"directory", builtin_directory}, {"directory", builtin_directory},
{"echo", builtin_echo}, {"echo", builtin_echo},
{"execute", builtin_execute},
{"exists", builtin_exists}, {"exists", builtin_exists},
{"export", builtin_export}, {"export", builtin_export},
{"parameters", builtin_parameters}, {"parameters", builtin_parameters},
@ -209,6 +210,10 @@ namespace {
{"unset", builtin_unset}, {"unset", builtin_unset},
{"version", builtin_version}, {"version", builtin_version},
{"which", builtin_which}, {"which", builtin_which},
// not in MPW.
{"true", builtin_true},
{"false", builtin_false},
}; };
@ -278,9 +283,6 @@ namespace {
} }
//std::string expand_vars(const std::string &s, const class Environment &);
command::~command() command::~command()
{} {}
@ -293,7 +295,7 @@ command::~command()
template<class F> template<class F>
int exec(std::string command, Environment &env, bool throwup, F &&fx) { int exec(std::string command, Environment &env, const fdmask &fds, bool throwup, F &&fx) {
bool echo = true; bool echo = true;
int rv = 0; int rv = 0;
@ -302,7 +304,7 @@ int exec(std::string command, Environment &env, bool throwup, F &&fx) {
try { try {
process p; process p;
command = expand_vars(command, env); command = expand_vars(command, env, fds);
auto tokens = tokenize(command, false); auto tokens = tokenize(command, false);
if (tokens.empty()) return 0; if (tokens.empty()) return 0;
parse_tokens(std::move(tokens), p); parse_tokens(std::move(tokens), p);
@ -330,7 +332,7 @@ int exec(std::string command, Environment &env, bool throwup, F &&fx) {
int simple_command::execute(Environment &env, const fdmask &fds, bool throwup) { int simple_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return exec(text, env, throwup, [&](process &p){ return exec(text, env, fds, throwup, [&](process &p){
fdmask newfds = p.fds | fds; fdmask newfds = p.fds | fds;
@ -367,7 +369,7 @@ int simple_command::execute(Environment &env, const fdmask &fds, bool throwup) {
} }
template<class F> template<class F>
int eval_exec(std::string command, Environment &env, bool throwup, F &&fx){ int eval_exec(std::string command, Environment &env, const fdmask &fds, bool throwup, F &&fx){
std::string name; std::string name;
bool echo = true; bool echo = true;
@ -376,7 +378,7 @@ int eval_exec(std::string command, Environment &env, bool throwup, F &&fx){
if (control_c) throw execution_of_input_terminated(); if (control_c) throw execution_of_input_terminated();
try { try {
command = expand_vars(command, env); command = expand_vars(command, env, fds);
auto tokens = tokenize(command, true); auto tokens = tokenize(command, true);
if (tokens.empty()) return 0; if (tokens.empty()) return 0;
@ -406,29 +408,8 @@ int eval_exec(std::string command, Environment &env, bool throwup, F &&fx){
int evaluate_command::execute(Environment &env, const fdmask &fds, bool throwup) { int evaluate_command::execute(Environment &env, const fdmask &fds, bool throwup) {
#if 0
if (control_c) throw execution_of_input_terminated();
std::string s = expand_vars(text, env); return eval_exec(text, env, fds, throwup, [&](token_vector &tokens){
env.set("command", "evaluate");
env.echo("%s", s.c_str());
try {
auto tokens = tokenize(s, true);
if (tokens.empty()) return 0;
int status = builtin_evaluate(env, std::move(tokens), fds);
return env.status(status, throwup);
} catch (std::exception &e) {
fprintf(stderr, "%s\n", e.what());
return env.status(1, throwup);
}
#endif
return eval_exec(text, env, throwup, [&](token_vector &tokens){
env.set("command", "evaluate"); env.set("command", "evaluate");
return builtin_evaluate(env, std::move(tokens), fds); return builtin_evaluate(env, std::move(tokens), fds);
}); });
@ -439,7 +420,7 @@ int evaluate_command::execute(Environment &env, const fdmask &fds, bool throwup)
int break_command::execute(Environment &env, const fdmask &fds, bool throwup) { int break_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return eval_exec(text, env, throwup, [&](token_vector &tokens){ return eval_exec(text, env, fds, throwup, [&](token_vector &tokens){
env.set("command", "break"); env.set("command", "break");
if (!env.loop()) throw break_error(); if (!env.loop()) throw break_error();
int status = evaluate(BREAK, std::move(tokens), env); int status = evaluate(BREAK, std::move(tokens), env);
@ -447,30 +428,11 @@ int break_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return status; return status;
}); });
#if 0
if (control_c) throw execution_of_input_terminated();
std::string s = expand_vars(text, env);
env.set("command", "break");
env.echo("%s", s.c_str());
if (!env.loop()) {
fputs("### MPW Shell - Break must be within for or loop.\n", stderr);
return env.status(-3, throwup);
}
// check/evaluate if clause.
int status = evaluate(BREAK, s, env);
if (status > 0)
throw break_command_t();
return env.status(status, throwup);
#endif
} }
int continue_command::execute(Environment &env, const fdmask &fds, bool throwup) { int continue_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return eval_exec(text, env, throwup, [&](token_vector &tokens){ return eval_exec(text, env, fds, throwup, [&](token_vector &tokens){
env.set("command", "continue"); env.set("command", "continue");
if (!env.loop()) throw continue_error(); if (!env.loop()) throw continue_error();
int status = evaluate(CONTINUE, std::move(tokens), env); int status = evaluate(CONTINUE, std::move(tokens), env);
@ -478,26 +440,6 @@ int continue_command::execute(Environment &env, const fdmask &fds, bool throwup)
return status; return status;
}); });
#if 0
if (control_c) throw execution_of_input_terminated();
std::string s = expand_vars(text, env);
env.set("command", "continue");
env.echo("%s", s.c_str());
if (!env.loop()) {
fputs("### MPW Shell - Continue must be within for or loop.\n", stderr);
return env.status(-3, throwup);
}
// check/evaluate if clause.
int status = evaluate(CONTINUE, s, env);
if (status > 0)
throw continue_command_t();
return env.status(status, throwup);
#endif
} }
int or_command::execute(Environment &e, const fdmask &fds, bool throwup) { int or_command::execute(Environment &e, const fdmask &fds, bool throwup) {
@ -577,7 +519,7 @@ int error_command::execute(Environment &e, const fdmask &fds, bool throwup) {
return e.status(-3); return e.status(-3);
} }
std::string s = expand_vars(text, e); std::string s = expand_vars(text, e, fds);
e.echo("%s", s.c_str()); e.echo("%s", s.c_str());
@ -601,7 +543,7 @@ int error_command::execute(Environment &e, const fdmask &fds, bool throwup) {
} }
template<class F> template<class F>
int begin_end_exec(std::string begin, std::string end, Environment &env, bool throwup, F &&fx) { int begin_end_exec(std::string begin, std::string end, Environment &env, const fdmask &fds, bool throwup, F &&fx) {
bool echo = true; bool echo = true;
@ -611,8 +553,8 @@ int begin_end_exec(std::string begin, std::string end, Environment &env, bool th
try { try {
process p; process p;
begin = expand_vars(begin, env); begin = expand_vars(begin, env, fds);
end = expand_vars(end, env); end = expand_vars(end, env, fds);
auto b = tokenize(begin, true); auto b = tokenize(begin, true);
auto e = tokenize(end, false); auto e = tokenize(end, false);
@ -639,12 +581,11 @@ int begin_end_exec(std::string begin, std::string end, Environment &env, bool th
} }
return env.status(rv, throwup); return env.status(rv, throwup);
} }
int begin_command::execute(Environment &env, const fdmask &fds, bool throwup) { int begin_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return begin_end_exec(begin, end, env, throwup, [&](token_vector &b, process &p){ return begin_end_exec(begin, end, env, fds, throwup, [&](token_vector &b, process &p){
env.set("command", type == BEGIN ? "end" : ")"); env.set("command", type == BEGIN ? "end" : ")");
if (b.size() != 1) { if (b.size() != 1) {
@ -664,53 +605,12 @@ int begin_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return rv; return rv;
}); });
#if 0
std::string b = expand_vars(begin, env);
std::string e = expand_vars(end, env);
env.set("command", type == BEGIN ? "end" : ")");
// echo!
env.echo("%s ... %s",
b.c_str(),
e.c_str()
);
// tokenize the begin and end commands.
// begin may not have extra arguments. end may have redirection.
auto bt = tokenize(b, true);
if (bt.size() != 1) {
fprintf(stderr, "### Begin - Too many parameters were specified.\n");
fprintf(stderr, "Usage - Begin\n");
return env.status(-3);
}
fdmask newfds;
int status = check_ends(e, newfds);
newfds |= fds;
if (status) return env.status(status);
int rv;
env.indent_and([&]{
rv = vector_command::execute(env, newfds);
});
env.echo("%s", type == BEGIN ? "end" : ")");
return env.status(rv);
#endif
} }
int loop_command::execute(Environment &env, const fdmask &fds, bool throwup) { int loop_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return begin_end_exec(begin, end, env, throwup, [&](token_vector &b, process &p){ return begin_end_exec(begin, end, env, fds, throwup, [&](token_vector &b, process &p){
env.set("command", "end"); env.set("command", "end");
if (b.size() != 1) { if (b.size() != 1) {
@ -742,58 +642,11 @@ int loop_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return rv; return rv;
}); });
#if 0
std::string b = expand_vars(begin, env);
std::string e = expand_vars(end, env);
env.set("command", "end");
// echo!
env.echo("%s ... %s",
b.c_str(),
e.c_str()
);
// check for extra tokens...
auto bt = tokenize(b, true);
if (bt.size() != 1) {
fprintf(stderr, "### Loop - Too many parameters were specified.\n");
fprintf(stderr, "Usage - Loop\n");
return env.status(-3);
}
fdmask newfds;
int status = check_ends(e, newfds);
newfds |= fds;
if (status) return env.status(status);
int rv = 0;
for(;;) {
if (control_c) throw execution_of_input_terminated();
try {
env.loop_indent_and([&]{
rv = vector_command::execute(env, newfds);
});
}
catch (break_command_t &ex) {
env.echo("end");
break;
}
catch (continue_command_t &ex) {}
env.echo("end");
}
return env.status(rv);
#endif
} }
int for_command::execute(Environment &env, const fdmask &fds, bool throwup) { int for_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return begin_end_exec(begin, end, env, throwup, [&](token_vector &b, process &p){ return begin_end_exec(begin, end, env, fds, throwup, [&](token_vector &b, process &p){
env.set("command", "end"); env.set("command", "end");
@ -827,56 +680,6 @@ int for_command::execute(Environment &env, const fdmask &fds, bool throwup) {
return rv; return rv;
}); });
#if 0
std::string b = expand_vars(begin, env);
std::string e = expand_vars(end, env);
env.set("command", "end");
// echo!
env.echo("%s ... %s",
b.c_str(),
e.c_str()
);
// check for extra tokens...
auto bt = tokenize(b, true);
if (bt.size() < 3 || strcasecmp(bt[2].string.c_str(), "in")) {
fprintf(stderr, "### For - Missing in keyword.\n");
fprintf(stderr, "Usage - For name in [word...]\n");
return env.status(-3);
}
fdmask newfds;
int status = check_ends(e, newfds);
newfds |= fds;
if (status) return env.status(status);
int rv = 0;
for (int i = 3; i < bt.size(); ++i ) {
if (control_c) throw execution_of_input_terminated();
env.set(bt[1].string, bt[i].string);
try {
env.loop_indent_and([&]{
rv = vector_command::execute(env, newfds);
});
}
catch (break_command_t &ex) {
env.echo("end");
break;
}
catch (continue_command_t &ex) {}
env.echo("end");
}
return env.status(rv);
#endif
} }
@ -901,7 +704,7 @@ int if_command::execute(Environment &env, const fdmask &fds, bool throwup) {
int tmp; int tmp;
if (first) { if (first) {
first = false; first = false;
tmp = begin_end_exec(c->clause, end, env, false, [&](token_vector &b, process &p){ tmp = begin_end_exec(c->clause, end, env, fds, false, [&](token_vector &b, process &p){
newfds = p.fds | fds; newfds = p.fds | fds;
@ -923,7 +726,7 @@ int if_command::execute(Environment &env, const fdmask &fds, bool throwup) {
} }
else { else {
// second... // second...
tmp = eval_exec(c->clause, env, false, [&](token_vector &b){ tmp = eval_exec(c->clause, env, fds, false, [&](token_vector &b){
if (skip || error) return 0; if (skip || error) return 0;
int status = evaluate(c->type, std::move(b), env); int status = evaluate(c->type, std::move(b), env);
@ -946,49 +749,5 @@ int if_command::execute(Environment &env, const fdmask &fds, bool throwup) {
env.echo("end"); env.echo("end");
if (error) return env.status(error, throwup); if (error) return env.status(error, throwup);
return env.status(rv, throwup); return env.status(rv, throwup);
#if 0
int rv = 0;
bool ok = false;
std::string e = expand_vars(end, env);
env.set("command", "end");
// parse end for indirection.
fdmask newfds;
int status = check_ends(e, newfds);
newfds |= fds;
if (status) {
rv = status;
ok = true;
}
for (auto &c : clauses) {
std::string s = expand_vars(c->clause, env);
if (c->type == IF)
env.echo("%s ... %s", s.c_str(), e.c_str());
else
env.echo("%s", s.c_str());
if (ok) continue;
int tmp = evaluate(c->type, s, env);
if (tmp < 0) { ok = true; rv = tmp; continue; }
if (tmp == 0) continue;
env.indent_and([&](){
rv = c->execute(env, newfds);
});
}
env.echo("end");
return env.status(rv);
#endif
} }

2
command.h
View File

@ -6,7 +6,7 @@
#include <vector> #include <vector>
#include <array> #include <array>
#include <string> #include <string>
#include "phase2-parser.h" #include "phase3.h"
typedef std::unique_ptr<struct command> command_ptr; typedef std::unique_ptr<struct command> command_ptr;
typedef std::vector<command_ptr> command_ptr_vector; typedef std::vector<command_ptr> command_ptr_vector;

66
mpw-shell-expand.rl
View File

@ -4,6 +4,8 @@
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <stdexcept> #include <stdexcept>
#include <system_error>
#include <algorithm>
#include <stdio.h> #include <stdio.h>
@ -42,16 +44,29 @@
fgoto *xcs; fgoto *xcs;
} }
action einit{ /* einit */ ev.clear(); xcs = fcurs; fgoto estring_state; } action einit { /* einit */ ev.clear(); xcs = fcurs; fgoto estring_state; }
action epush{ /* epush */ ev.push_back(fc); } action epush { /* epush */ ev.push_back(fc); }
action efinish1{ action efinish1 {
/* efinish1 */ /* efinish1 */
/*
throw std::runtime_error("MPW Shell - `...` not yet supported."); throw std::runtime_error("MPW Shell - `...` not yet supported.");
*/
std::string s = subshell(ev, env, fds);
scratch.append(s);
fgoto *xcs; fgoto *xcs;
} }
action efinish2{ action efinish2 {
/* efinish2 */ /* efinish2 */
throw std::runtime_error("MPW Shell - `...` not yet supported.");
std::string s = subshell(ev, env, fds);
for (auto c : s) {
if (c == '\'' || c == '"' ) scratch.push_back(escape);
scratch.push_back(c);
}
fgoto *xcs; fgoto *xcs;
} }
@ -110,9 +125,48 @@
namespace { namespace {
%% write data; %% write data;
std::string subshell(const std::string &s, Environment &env, const fdmask &fds) {
char temp[32] = "/tmp/mpw-shell-XXXXXXXX";
int fd = mkstemp(temp);
unlink(temp);
fdset new_fds;
new_fds.set(1, fd);
int rv = 0;
env.indent_and([&](){
rv = read_string(env, s, new_fds | fds);
});
std::string tmp;
lseek(fd, 0, SEEK_SET);
for(;;) {
uint8_t buffer[1024];
ssize_t len = read(fd, buffer, sizeof(buffer));
if (len == 0) break;
if (len < 0) {
if (errno == EINTR) continue;
throw std::system_error(errno, std::system_category(), "read");
}
tmp.append(buffer, buffer + len);
}
std::transform(tmp.begin(), tmp.end(), tmp.begin(), [](uint8_t x){
if (x == '\r' || x == '\n') x = ' ';
return x;
});
return tmp;
} }
std::string expand_vars(const std::string &s, const Environment &env) { }
std::string expand_vars(const std::string &s, Environment &env, const fdmask &fds) {
if (s.find_first_of("{`", 0, 2) == s.npos) return s; if (s.find_first_of("{`", 0, 2) == s.npos) return s;
int cs; int cs;

155
mpw-shell.cpp
View File

@ -12,14 +12,12 @@
#include <sys/wait.h> #include <sys/wait.h>
#include "mpw-shell.h" #include "mpw-shell.h"
#include "mpw_parser.h"
#include "fdset.h" #include "fdset.h"
#include "macroman.h" #include "macroman.h"
#include "phase1.h"
#include "phase2.h"
#include "command.h"
#include "cxx/mapped_file.h" #include "cxx/mapped_file.h"
#include "cxx/filesystem.h" #include "cxx/filesystem.h"
#include "cxx/string_splitter.h" #include "cxx/string_splitter.h"
@ -80,48 +78,60 @@ void init(Environment &env) {
} }
int read_file(phase1 &p, const std::string &file) {
int read_file(Environment &e, const std::string &file, const fdmask &fds) {
std::error_code ec; std::error_code ec;
const mapped_file mf(file, mapped_file::readonly, ec); const mapped_file mf(file, mapped_file::readonly, ec);
if (ec) { if (ec) {
fprintf(stderr, "# Error reading %s: %s\n", file.c_str(), ec.message().c_str()); fprintf(stderr, "# Error reading %s: %s\n", file.c_str(), ec.message().c_str());
return 0; return e.status(-1, false);
} }
p.process(mf.begin(), mf.end(), false);
mpw_parser p(e, fds);
e.status(0, false);
p.parse(mf.begin(), mf.end());
p.finish(); p.finish();
return 0; return e.status();
} }
int read_fd(phase1 &p, int fd) {
int read_string(Environment &e, const std::string &s, const fdmask &fds) {
mpw_parser p(e, fds);
e.status(0, false);
p.parse(s);
p.finish();
return e.status();
}
int read_fd(Environment &e, int fd, const fdmask &fds) {
unsigned char buffer[2048]; unsigned char buffer[2048];
ssize_t size; ssize_t size;
mpw_parser p(e, fds);
e.status(0, false);
for (;;) { for (;;) {
size = read(fd, buffer, sizeof(buffer)); size = read(fd, buffer, sizeof(buffer));
if (size < 0) { if (size < 0) {
if (errno == EINTR) continue; if (errno == EINTR) continue;
perror("read: "); perror("read");
return -1; e.status(-1, false);
}
try {
if (size == 0) p.finish();
else p.process(buffer, buffer + size);
} catch(std::exception &ex) {
fprintf(stderr, "### %s\n", ex.what());
p.reset();
} }
if (size == 0) break; if (size == 0) break;
p.parse(buffer, buffer + size);
} }
p.finish();
return 0; return e.status();
} }
void launch_mpw(const Environment &env, const std::vector<std::string> &argv, const fdmask &fds); void launch_mpw(const Environment &env, const std::vector<std::string> &argv, const fdmask &fds);
fs::path which(const Environment &env, const std::string &name); fs::path which(const Environment &env, const std::string &name);
int read_make(phase1 &p1, phase2 &p2, Environment &env, const std::vector<std::string> &argv) { int read_make(Environment &env, const std::vector<std::string> &argv) {
int out[2]; int out[2];
int ok; int ok;
@ -153,10 +163,9 @@ int read_make(phase1 &p1, phase2 &p2, Environment &env, const std::vector<std::s
} }
close(out[1]); close(out[1]);
int rv = read_fd(p1, out[0]); int rv = read_fd(env, out[0]);
close(out[0]); close(out[0]);
p1.finish();
p2.finish();
// check for make errors. // check for make errors.
for(;;) { for(;;) {
@ -182,7 +191,7 @@ int read_make(phase1 &p1, phase2 &p2, Environment &env, const std::vector<std::s
exit(EX_OSERR); exit(EX_OSERR);
} }
return env.status(); return rv;
} }
std::atomic<int> control_c{0}; std::atomic<int> control_c{0};
@ -196,7 +205,7 @@ void control_c_handler(int signal, siginfo_t *sinfo, void *context) {
} }
int interactive(Environment &env, phase1 &p1, phase2& p2) { int interactive(Environment &env) {
std::string history_file = root(); std::string history_file = root();
history_file += ".history"; history_file += ".history";
@ -213,18 +222,18 @@ int interactive(Environment &env, phase1 &p1, phase2& p2) {
sigaction(SIGINT, &act, &old_act); sigaction(SIGINT, &act, &old_act);
mpw_parser p(env, true);
for(;;) { for(;;) {
const char *prompt = "# "; const char *prompt = "# ";
if (p1.continuation() || p2.continuation()) prompt = "> "; if (p.continuation()) prompt = "> ";
char *cp = readline(prompt); char *cp = readline(prompt);
if (!cp) { if (!cp) {
if (control_c) { if (control_c) {
control_c = 0; control_c = 0;
fprintf(stdout, "\n"); fprintf(stdout, "\n");
p1.abort(); p.abort();
p2.abort();
env.status(-9, false); env.status(-9, false);
continue; continue;
} }
@ -246,29 +255,17 @@ int interactive(Environment &env, phase1 &p1, phase2& p2) {
s = utf8_to_macroman(s); s = utf8_to_macroman(s);
s.push_back('\n'); s.push_back('\n');
try {
p1.process(s);
} catch(std::exception &ex) { p.parse(s);
fprintf(stderr, "### %s\n", ex.what());
p1.reset();
}
} }
p.finish();
try {
p1.finish();
} catch(std::exception &ex) {
fprintf(stderr, "### %s\n", ex.what());
p1.reset();
}
sigaction(SIGINT, &old_act, nullptr); sigaction(SIGINT, &old_act, nullptr);
write_history(history_file.c_str()); write_history(history_file.c_str());
fprintf(stdout, "\n"); fprintf(stdout, "\n");
return 0; return 0;
} }
@ -361,34 +358,8 @@ int make(int argc, char **argv) {
} }
phase1 p1;
phase2 p2;
p1 >>= [&p2](std::string &&s) {
if (s.empty()) p2.finish();
else p2(std::move(s));
};
p2 >>= [&e](command_ptr_vector &&v) {
for (auto iter = v.begin(); iter != v.end(); ++iter) {
auto &ptr = *iter;
fdmask fds;
try {
ptr->execute(e, fds);
} catch (execution_of_input_terminated &ex) {
control_c = 0;
fprintf(stderr, "### %s\n", ex.what());
if (e.exit())
exit(ex.status());
e.status(ex.status(), false);
}
}
};
e.startup(true); e.startup(true);
read_file(p1, root() / "Startup"); read_file(e, root() / "Startup");
e.startup(false); e.startup(false);
auto path = which(e, "Make"); auto path = which(e, "Make");
@ -399,7 +370,7 @@ int make(int argc, char **argv) {
e.set("command", path); e.set("command", path);
args[0] = path; args[0] = path;
return read_make(p1, p2, e, args); return read_make(e, args);
} }
@ -517,40 +488,14 @@ int main(int argc, char **argv) {
phase1 p1;
phase2 p2;
p1 >>= [&p2](std::string &&s) {
if (s.empty()) p2.finish();
else p2(std::move(s));
};
p2 >>= [&e](command_ptr_vector &&v) {
for (auto iter = v.begin(); iter != v.end(); ++iter) {
auto &ptr = *iter;
fdmask fds;
try {
ptr->execute(e, fds);
} catch (execution_of_input_terminated &ex) {
control_c = 0;
if (!(ptr->terminal() && ++iter == v.end())) {
fprintf(stderr, "### %s\n", ex.what());
}
e.status(ex.status(), false);
return;
}
}
};
if (!cflag) fprintf(stdout, "MPW Shell " VERSION "\n"); if (!cflag) fprintf(stdout, "MPW Shell " VERSION "\n");
if (!fflag) { if (!fflag) {
fs::path startup = root() / "Startup"; fs::path startup = root() / "Startup";
e.startup(true); e.startup(true);
mpw_parser p(e);
try { try {
read_file(p1, startup); read_file(e, startup);
} catch (const std::system_error &ex) { } catch (const std::system_error &ex) {
fprintf(stderr, "### %s: %s\n", startup.c_str(), ex.what()); fprintf(stderr, "### %s: %s\n", startup.c_str(), ex.what());
} }
@ -558,18 +503,14 @@ int main(int argc, char **argv) {
} }
if (cflag) { if (cflag) {
std::string s(cflag); read_string(e, cflag);
s.push_back('\n');
p1.process(s, true);
p2.finish();
exit(e.status()); exit(e.status());
} }
if (isatty(STDIN_FILENO)) if (isatty(STDIN_FILENO))
interactive(e, p1, p2); interactive(e);
else else
read_fd(p1, STDIN_FILENO); read_fd(e, STDIN_FILENO);
p2.finish();
exit(e.status()); exit(e.status());
} }

8
mpw-shell.h
View File

@ -8,6 +8,7 @@
#include <cstdint> #include <cstdint>
#include "environment.h" #include "environment.h"
#include "fdset.h"
const unsigned char escape = 0xb6; const unsigned char escape = 0xb6;
@ -49,7 +50,7 @@ public:
std::vector<token> tokenize(std::string &s, bool eval = false); std::vector<token> tokenize(std::string &s, bool eval = false);
std::string expand_vars(const std::string &s, const class Environment &); std::string expand_vars(const std::string &s, class Environment &, const fdmask &fds = fdmask());
//std::string quote(std::string &&s); //std::string quote(std::string &&s);
std::string quote(const std::string &s); std::string quote(const std::string &s);
@ -67,4 +68,9 @@ int32_t evaluate_expression(const std::string &name, std::vector<token> &&tokens
int read_file(Environment &e, const std::string &file, const fdmask &fds = fdmask());
int read_string(Environment &e, const std::string &s, const fdmask &fds = fdmask());
int read_fd(Environment &e, int fd, const fdmask &fds = fdmask());
#endif #endif

104
mpw_parser.cpp Normal file
View File

@ -0,0 +1,104 @@
#include "mpw_parser.h"
#include "phase3_parser.h"
#include "command.h"
#include "error.h"
mpw_parser::mpw_parser(Environment &e, fdmask fds, bool interactive) : _env(e), _fds(fds), _interactive(interactive)
{
_p3 = phase3::make();
_p2.set_next([this](int type, std::string &&s){
_p3->parse(type, std::move(s));
});
_p1.set_next([this](std::string &&s){
_p2.parse(std::move(s));
});
}
mpw_parser::~mpw_parser() {
}
bool mpw_parser::continuation() const {
if (_p1.continuation()) return true;
if (_p2.continuation()) return true;
if (_p3->continuation()) return true;
return false;
}
void mpw_parser::finish() {
_p1.finish();
_p2.finish();
_p3->parse(0, "");
// and now execute the commands...
execute();
}
void mpw_parser::reset() {
_p1.reset();
_p2.reset();
_p3->reset();
_abort = false;
}
void mpw_parser::abort() {
_p1.abort();
_p2.abort();
//_p3->abort();
_p3->reset();
_abort = true;
}
void mpw_parser::parse(const void *begin, const void *end) {
if (_abort) return;
_p1.parse((const unsigned char *)begin, (const unsigned char *)end);
// and execute...
execute();
}
void mpw_parser::execute() {
if (_abort) {
_p3->command_queue.clear();
return;
}
auto commands = std::move(_p3->command_queue);
_p3->command_queue.clear();
std::reverse(commands.begin(), commands.end());
command_ptr cmd;
try {
while (!commands.empty()) {
cmd = std::move(commands.back());
commands.pop_back();
cmd->execute(_env, _fds);
}
} catch (execution_of_input_terminated &ex) {
_env.status(ex.status(), false);
if (_interactive) {
if (!cmd->terminal() || !commands.empty()) {
fprintf(stderr, "### %s\n", ex.what());
}
return;
}
_abort = true;
throw;
}
}

59
mpw_parser.h Normal file
View File

@ -0,0 +1,59 @@
#ifndef __mpw_parser__
#define __mpw_parser__
#include <string>
#include <memory>
#include "Environment.h"
#include "fdset.h"
#include "phase1.h"
#include "phase2.h"
class mpw_parser {
public:
mpw_parser(Environment &e, fdmask fds = fdmask(), bool interactive = false);
mpw_parser(Environment &e, bool interactive) : mpw_parser(e, fdmask(), interactive)
{}
~mpw_parser();
void parse(const void *begin, const void *end);
void parse(const std::string &s) {
parse(s.data(), s.data() + s.size());
}
void parse(const void *begin, size_t length) {
parse(begin, (const char *)begin + length);
}
void reset();
void abort();
void finish();
bool continuation() const;
private:
mpw_parser& operator=(const mpw_parser &) = delete;
mpw_parser& operator=(mpw_parser &&) = delete;
mpw_parser(const mpw_parser &) = delete;
mpw_parser(mpw_parser &&) = delete;
void execute();
Environment &_env;
fdmask _fds;
bool _interactive = false;
bool _abort = false;
phase1 _p1;
phase2 _p2;
std::unique_ptr<class phase3> _p3;
};
#endif

14
phase1.cpp
View File

@ -150,19 +150,10 @@ text:
} }
void phase1::process(const std::string &s, bool final) { void phase1::parse(const unsigned char *begin, const unsigned char *end) {
for (auto c : s) {
cs = process(c, cs);
}
if (final) finish();
}
void phase1::process(const unsigned char *begin, const unsigned char *end, bool final) {
while (begin != end) { while (begin != end) {
cs = process(*begin++, cs); cs = process(*begin++, cs);
} }
if (final) finish();
} }
void phase1::finish() { void phase1::finish() {
@ -181,7 +172,6 @@ void phase1::reset() {
void phase1::flush() { void phase1::flush() {
multiline = false; multiline = false;
if (scratch.empty()) return; if (scratch.empty()) return;
// strip trailing whitespace? if (_then) _then(std::move(scratch));
if (pipe_to) pipe_to(std::move(scratch));
scratch.clear(); scratch.clear();
} }

32
phase1.h
View File

@ -8,47 +8,33 @@
class phase1 { class phase1 {
public: public:
typedef std::function<void(std::string &&)> pipe_function;
typedef std::function<void(std::string &&)> next_function_type;
phase1() = default; phase1() = default;
void process(const unsigned char *begin, const unsigned char *end, bool final = false); void parse(const unsigned char *begin, const unsigned char *end);
void parse(const std::string &s) { parse((const unsigned char *)s.data(), (const unsigned char *)s.data() + s.size()); }
void process(const char *begin, const char *end, bool final = false) { void finish();
process((const unsigned char *)begin, (const unsigned char *)end, final);
}
void process(const std::string &s, bool final = false);// { process(s.data(), s.data() + s.size(), final); }
void finish();// { const char *tmp = "\n"; process(tmp, tmp+1, true); }
void reset(); void reset();
void abort() { reset(); } void abort() { reset(); }
phase1 &operator >>= (pipe_function f) { pipe_to = f; return *this; }
template<class F>
phase1 &operator >>= (F &f) {
using std::placeholders::_1;
pipe_to = std::bind(&F::operator(), &f, _1);
return *this;
}
bool continuation() const { return multiline; } bool continuation() const { return multiline; }
void set_next(next_function_type &&fx) { _then = std::move(fx); }
private: private:
int process(unsigned char, int); int process(unsigned char, int);
void flush(); void flush();
std::string scratch; std::string scratch;
pipe_function pipe_to;
int line = 1; int line = 1;
int cs = 0; int cs = 0;
bool multiline = false; bool multiline = false;
next_function_type _then;
}; };
#endif #endif

72
phase2.h
View File

@ -3,95 +3,41 @@
#define __phase2_h__ #define __phase2_h__
#include <string> #include <string>
#include <vector>
#include <functional> #include <functional>
#include <memory>
#include "command.h"
#include <lemon_base.h>
//typedef std::unique_ptr<struct command> command_ptr;
//typedef std::vector<command_ptr> command_ptr_vector;
class phase2_parser : public lemon_base<std::string> {
public:
static std::unique_ptr<phase2_parser> make();
virtual void syntax_error(int yymajor, std::string &yyminor) override final;
virtual void parse_accept() override final;
virtual void parse_failure() override final;
bool continuation() const;
private:
friend class phase2;
phase2_parser(const phase2_parser &) = delete;
phase2_parser(phase2_parser &&) = delete;
phase2_parser& operator=(const phase2_parser &) = delete;
phase2_parser& operator=(phase2_parser &&) = delete;
protected:
// these need to be accessible to the lemon-generated parser.
phase2_parser() = default;
command_ptr_vector command_queue;
bool error = false;
};
class phase2 { class phase2 {
public: public:
typedef std::function<void(command_ptr_vector &&)> pipe_function;
phase2(); typedef std::function<void(int, std::string &&)> next_function_type;
phase2(const phase2 &) = delete;
phase2(phase2 &&) = default;
phase2 & operator=(const phase2 &) = delete; phase2() = default;
phase2 & operator=(phase2 &&) = default;
void operator()(const std::string &line) { process(line); } void parse(std::string &&);
void process(const std::string &line);
void finish(); void finish();
phase2 &operator >>=(pipe_function f) { pipe_to = f; return *this; } void reset();
void abort() { reset(); }
template<class F> bool continuation() const { return false; }
phase2 &operator >>= (F &f) {
using std::placeholders::_1;
pipe_to = std::bind(&F::operator(), &f, _1);
return *this;
}
bool continuation() const { void set_next(next_function_type &&fx) { _then = std::move(fx); }
return parser ? parser->continuation() : false;
}
void abort();
private: private:
void parse(int, std::string &&); void parse(int type, std::string &&s);
std::unique_ptr<phase2_parser> parser;
std::string scratch; std::string scratch;
int type = 0; int type = 0;
int pcount = 0; int pcount = 0;
pipe_function pipe_to;
void flush(); void flush();
bool special(); bool special();
int classify(); int classify();
void exec(); void exec();
next_function_type _then;
}; };

97
phase2.rl
View File

@ -4,9 +4,8 @@
* *
*/ */
#include "phase2-parser.h"
#include "phase2.h" #include "phase2.h"
#include "command.h" #include "phase3.h"
%%{ %%{
machine main; machine main;
@ -217,9 +216,7 @@ void phase2::flush() {
while (!scratch.empty() && isspace(scratch.back())) scratch.pop_back(); while (!scratch.empty() && isspace(scratch.back())) scratch.pop_back();
if (!scratch.empty()) { if (!scratch.empty()) parse(classify(), std::move(scratch));
parse(classify(), std::move(scratch));
}
type = 0; type = 0;
pcount = 0; pcount = 0;
@ -242,14 +239,14 @@ bool phase2::special() {
} }
} }
void phase2::process(const std::string &line) { void phase2::parse(int type, std::string &&s) {
if (_then) _then(type, std::move(s));
}
void phase2::parse(std::string &&line) {
//fprintf(stderr, "-> %s\n", line.c_str()); //fprintf(stderr, "-> %s\n", line.c_str());
// still needed?
if (line.empty()) { finish(); return; }
int cs; int cs;
const unsigned char *p = (const unsigned char *)line.data(); const unsigned char *p = (const unsigned char *)line.data();
const unsigned char *pe = p + line.size(); const unsigned char *pe = p + line.size();
@ -264,81 +261,19 @@ void phase2::process(const std::string &line) {
%% write exec; %% write exec;
flush(); flush();
// 2 NLs to make the stack reduce. harmless if in a multi-line constuct. if (_then) {
parse(NL, ""); _then(NL, "");
parse(NL, ""); _then(NL, "");
}
exec();
} }
void phase2::finish() { void phase2::finish() {
parse(0, "");
exec();
} }
void phase2::parse(int token, std::string &&s) { void phase2::reset() {
if (parser) parser->parse(token, std::move(s));
} type = 0;
pcount = 0;
void phase2::exec() { scratch.clear();
if (pipe_to && parser) {
command_ptr_vector tmp;
for (auto &p : parser->command_queue) {
if (p) tmp.emplace_back(std::move(p));
}
parser->command_queue.clear();
if (!tmp.empty()) pipe_to(std::move(tmp));
}
}
phase2::phase2() {
parser = phase2_parser::make();
//parser->trace(stdout, " ] ");
}
void phase2::abort() {
parser = nullptr;
parser = phase2_parser::make();
}
#pragma mark - phase2_parser
void phase2_parser::parse_accept() {
error = false;
}
void phase2_parser::parse_failure() {
error = false;
}
void phase2_parser::syntax_error(int yymajor, std::string &yyminor) {
/*
switch (yymajor) {
case END:
fprintf(stderr, "### MPW Shell - Extra END command.\n");
break;
case RPAREN:
fprintf(stderr, "### MPW Shell - Extra ) command.\n");
break;
case ELSE:
case ELSE_IF:
fprintf(stderr, "### MPW Shell - ELSE must be within IF ... END.\n");
break;
default:
fprintf(stderr, "### Parse error near %s\n", yyminor.c_str());
break;
}
*/
fprintf(stderr, "### MPW Shell - Parse error near %s\n", yymajor ? yyminor.c_str() : "EOF");
error = true;
} }

47
phase2-parser.lemon → phase3.lemon
View File

@ -6,19 +6,19 @@
%include { %include {
#include "phase2.h" #include "phase3_parser.h"
#include "command.h" #include "command.h"
#define LEMON_SUPER phase2_parser #define LEMON_SUPER phase3
#include "phase2-parser.h"
} }
%code { %code {
std::unique_ptr<phase2_parser> phase2_parser::make() { std::unique_ptr<phase3> phase3::make() {
return std::make_unique<yypParser>(); return std::make_unique<yypParser>();
} }
bool phase2_parser::continuation() const { bool phase3::continuation() const {
yypParser *self = (yypParser *)this; yypParser *self = (yypParser *)this;
for (const auto &e : *self) { for (const auto &e : *self) {
@ -36,6 +36,43 @@ bool phase2_parser::continuation() const {
return false; return false;
} }
void phase3::parse_accept() {
error = false;
}
void phase3::parse_failure() {
error = false;
}
void phase3::syntax_error(int yymajor, std::string &yyminor) {
/*
switch (yymajor) {
case END:
fprintf(stderr, "### MPW Shell - Extra END command.\n");
break;
case RPAREN:
fprintf(stderr, "### MPW Shell - Extra ) command.\n");
break;
case ELSE:
case ELSE_IF:
fprintf(stderr, "### MPW Shell - ELSE must be within IF ... END.\n");
break;
default:
fprintf(stderr, "### Parse error near %s\n", yyminor.c_str());
break;
}
*/
fprintf(stderr, "### MPW Shell - Parse error near %s\n", yymajor ? yyminor.c_str() : "EOF");
error = true;
}
} }
%left PIPE_PIPE AMP_AMP. %left PIPE_PIPE AMP_AMP.

43
phase3_parser.h Normal file
View File

@ -0,0 +1,43 @@
#ifndef __phase3_h__
#define __phase3_h__
#include <string>
#include <vector>
#include <memory>
#include "command.h"
#include <lemon_base.h>
class phase3 : public lemon_base<std::string> {
public:
static std::unique_ptr<phase3> make();
virtual void syntax_error(int yymajor, std::string &yyminor) override final;
virtual void parse_accept() override final;
virtual void parse_failure() override final;
bool continuation() const;
//void parse(int type, std::string &&s) override final;
private:
phase3(const phase3 &) = delete;
phase3(phase3 &&) = delete;
phase3& operator=(const phase3 &) = delete;
phase3& operator=(phase3 &&) = delete;
protected:
// these need to be accessible to the lemon-generated parser.
phase3() = default;
command_ptr_vector command_queue;
bool error = false;
friend class mpw_parser;
};
#endif