// SleelaTerminal(TM) shell -- M5 orchestration layer. // Original SLeeLa work (see NOTICE). // // M5 deliberately sits above the existing lexer/parser/executor. This keeps // the mature M1-M4 grammar stable while adding shell constructs whose syntax // needs process/signal resources before ordinary parsing begins. #include "m5.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace sleela::sh { namespace { volatile std::sig_atomic_t pending_signal = 0; void m5SignalHandler(int sig) { pending_signal = sig; } struct Trap { std::string action; bool installed = false; }; Trap traps[NSIG]; bool isSpace(char c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n'; } bool startsWordAt(const std::string& s, std::size_t p, const char* word) { const std::size_t n = std::strlen(word); if (s.compare(p, n, word) != 0) return false; if (p > 0 && !isSpace(s[p - 1]) && s[p - 1] != ';') return false; if (p + n < s.size() && !isSpace(s[p + n]) && s[p + n] != ';') return false; return true; } std::size_t skipWord(const std::string& s, std::size_t p) { char quote = 0; while (p < s.size()) { char c = s[p]; if (quote) { if (c == '\\' && p + 1 < s.size()) { p += 2; continue; } if (c == quote) quote = 0; ++p; continue; } if (c == '\'' || c == '"') { quote = c; ++p; continue; } if (isSpace(c) || c == ';') break; ++p; } return p; } std::string trim(const std::string& s) { std::size_t a = 0, b = s.size(); while (a < b && isSpace(s[a])) ++a; while (b > a && isSpace(s[b - 1])) --b; return s.substr(a, b - a); } bool splitSelect(const std::string& source, std::string& var, std::vector& words, std::string& body) { std::size_t p = 0; while (p < source.size() && isSpace(source[p])) ++p; if (!startsWordAt(source, p, "select")) return false; p += 6; while (p < source.size() && isSpace(source[p]) && source[p] != '\n') ++p; std::size_t varEnd = skipWord(source, p); if (varEnd == p) return false; var = source.substr(p, varEnd - p); p = varEnd; while (p < source.size() && isSpace(source[p])) ++p; if (!startsWordAt(source, p, "in")) return false; p += 2; const std::size_t listStart = p; std::size_t listEnd = std::string::npos; std::size_t scan = p; char quote = 0; while (scan < source.size()) { char c = source[scan]; if (quote) { if (c == '\\' && scan + 1 < source.size()) { scan += 2; continue; } if (c == quote) quote = 0; ++scan; continue; } if (c == '\'' || c == '"') { quote = c; ++scan; continue; } if (c == ';' || c == '\n') { std::size_t q = scan + 1; while (q < source.size() && isSpace(source[q])) ++q; if (startsWordAt(source, q, "do")) { listEnd = scan; p = q + 2; break; } } ++scan; } if (listEnd == std::string::npos) return false; std::string list = trim(source.substr(listStart, listEnd - listStart)); std::size_t i = 0; while (i < list.size()) { while (i < list.size() && isSpace(list[i])) ++i; if (i >= list.size()) break; std::string w; char q = 0; while (i < list.size()) { char c = list[i]; if (q) { if (c == '\\' && i + 1 < list.size()) { w.push_back(list[i + 1]); i += 2; continue; } if (c == q) { q = 0; ++i; continue; } w.push_back(c); ++i; continue; } if (c == '\'' || c == '"') { q = c; ++i; continue; } if (isSpace(c)) break; w.push_back(c); ++i; } if (!w.empty()) words.push_back(w); } std::size_t bodyStart = p; int depth = 1; scan = p; quote = 0; while (scan < source.size()) { if (quote) { if (source[scan] == '\\' && scan + 1 < source.size()) { scan += 2; continue; } if (source[scan] == quote) quote = 0; ++scan; continue; } if (source[scan] == '\'' || source[scan] == '"') { quote = source[scan]; ++scan; continue; } if ((scan == 0 || isSpace(source[scan - 1]) || source[scan - 1] == ';') && startsWordAt(source, scan, "do")) { ++depth; scan += 2; continue; } if ((scan == 0 || isSpace(source[scan - 1]) || source[scan - 1] == ';') && startsWordAt(source, scan, "done")) { --depth; if (depth == 0) { body = trim(source.substr(bodyStart, scan - bodyStart)); return true; } scan += 4; continue; } ++scan; } return false; } int signalNumber(const std::string& name) { if (name == "INT") return SIGINT; if (name == "TERM") return SIGTERM; if (name == "HUP") return SIGHUP; if (name == "QUIT") return SIGQUIT; if (name == "USR1") return SIGUSR1; if (name == "USR2") return SIGUSR2; if (name == "PIPE") return SIGPIPE; if (name == "ALRM") return SIGALRM; return std::atoi(name.c_str()); } void installTrap(int sig, const std::string& action) { if (sig <= 0 || sig >= NSIG) return; traps[sig].action = action; traps[sig].installed = true; struct sigaction sa{}; sa.sa_handler = m5SignalHandler; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; ::sigaction(sig, &sa, nullptr); } bool parseTrap(const std::string& line, int& sig, std::string& action) { std::string t = trim(line); if (!startsWordAt(t, 0, "trap")) return false; std::size_t p = 4; while (p < t.size() && isSpace(t[p])) ++p; if (p >= t.size()) return false; if (t[p] == '\'' || t[p] == '"') { char q = t[p++]; std::string a; while (p < t.size() && t[p] != q) { if (t[p] == '\\' && p + 1 < t.size()) { a.push_back(t[p + 1]); p += 2; } else { a.push_back(t[p]); ++p; } } if (p >= t.size()) return false; action = a; ++p; while (p < t.size() && isSpace(t[p])) ++p; sig = signalNumber(trim(t.substr(p))); return sig > 0; } std::size_t q = p; while (q < t.size() && !isSpace(t[q])) ++q; action = t.substr(p, q - p); while (q < t.size() && isSpace(t[q])) ++q; sig = signalNumber(trim(t.substr(q))); return sig > 0; } bool rewriteProcessSubstitution(const std::string& src, std::string& rewritten, std::vector& children, std::vector& fifos, Environment& env, const M5Runner& runner) { rewritten.clear(); bool found = false; for (std::size_t i = 0; i < src.size();) { if ((src[i] == '<' || src[i] == '>') && i + 1 < src.size() && src[i + 1] == '(') { const char mode = src[i]; std::size_t j = i + 2; int depth = 1; char quote = 0; std::string cmd; while (j < src.size() && depth > 0) { char c = src[j]; if (quote) { cmd.push_back(c); if (c == '\\' && j + 1 < src.size()) cmd.push_back(src[++j]); else if (c == quote) quote = 0; ++j; continue; } if (c == '\'' || c == '"') { quote = c; cmd.push_back(c); ++j; continue; } if (c == '(') { ++depth; cmd.push_back(c); ++j; continue; } if (c == ')') { --depth; if (depth) cmd.push_back(c); ++j; continue; } cmd.push_back(c); ++j; } if (depth != 0) return false; char tmpl[] = "/tmp/slsh-m5-XXXXXX"; int fd = ::mkstemp(tmpl); if (fd < 0) return false; ::close(fd); ::unlink(tmpl); if (::mkfifo(tmpl, 0600) != 0) return false; pid_t pid = ::fork(); if (pid < 0) { ::unlink(tmpl); return false; } if (pid == 0) { Environment childEnv = env; // Open mode is directional: // '<' : the child is the PRODUCER (its stdout feeds the FIFO, // which the parent reads). Open O_RDWR so the child does // not block on open before the parent opens the read end. // '>' : the child is the CONSUMER (it reads the FIFO on stdin; // the parent writes). It MUST open read-only -- holding a // write descriptor (O_RDWR) keeps a writer open, so the // consumer never sees EOF and hangs after the parent is // done. O_RDONLY blocks only until the parent (writer) // opens, which it does, so there is no deadlock. const int flags = (mode == '<' ? O_RDWR : O_RDONLY) | O_CLOEXEC; int io = ::open(tmpl, flags); if (io < 0) _exit(126); ::dup2(io, mode == '<' ? STDOUT_FILENO : STDIN_FILENO); ::close(io); int rc = runner(cmd, childEnv); _exit(rc & 0xff); } children.push_back(pid); fifos.push_back(tmpl); rewritten += tmpl; i = j; found = true; continue; } rewritten.push_back(src[i++]); } return found; } int runSelect(const std::string& source, Environment& env, const M5Runner& runner) { std::string var, body; std::vector words; if (!splitSelect(source, var, words, body)) return 2; const std::string ps3 = env.has("PS3") ? env.get("PS3") : "#? "; int status = 0; for (;;) { for (std::size_t i = 0; i < words.size(); ++i) std::cerr << (i + 1) << ") " << words[i] << '\n'; std::cerr << ps3 << std::flush; std::string line; if (!std::getline(std::cin, line)) { std::cerr << '\n'; break; } env.set("REPLY", line); if (line.empty()) continue; char* end = nullptr; long choice = std::strtol(line.c_str(), &end, 10); if (end == line.c_str() || *end != '\0' || choice < 1 || static_cast(choice) > words.size()) env.set(var, ""); else env.set(var, words[static_cast(choice) - 1]); status = runner(body, env); if (env.shouldExit()) break; if (env.loopSignal() && env.consumeLoopSignal() == 'B') break; } return status; } } // namespace bool hasProcessSubstitution(const std::string& source) { char quote = 0; for (std::size_t i = 0; i + 1 < source.size(); ++i) { if (quote) { if (source[i] == '\\') ++i; else if (source[i] == quote) quote = 0; continue; } if (source[i] == '\'' || source[i] == '"') { quote = source[i]; continue; } if ((source[i] == '<' || source[i] == '>') && source[i + 1] == '(') return true; } return false; } bool runM5(const std::string& source, Environment& env, const M5Runner& runner, int& status) { std::string prepared = source; std::istringstream assignLines(prepared); std::string firstLine, afterAssignments; bool consumedAssignment = false; while (std::getline(assignLines, firstLine)) { std::string t = trim(firstLine); const std::size_t eq = t.find('='); bool simpleName = eq != std::string::npos && eq > 0; if (simpleName) for (std::size_t k = 0; k < eq; ++k) { char c = t[k]; if (!(std::isalnum(static_cast(c)) || c == '_') || (k == 0 && std::isdigit(static_cast(c)))) { simpleName = false; break; } } if (!consumedAssignment && simpleName && t.compare(0, eq, "PS3") == 0) { // Extract only the PS3 assignment's value. It may be the whole line // (`PS3="pick> "`) or be followed on the same line by more commands // (`PS3="pick> "; select ... done`). Scan the value respecting // quotes and stop at the first unquoted ';' so the remainder (e.g. // the select loop) is preserved for the rest of the M5 pipeline. std::string value; std::size_t p = eq + 1; char quote = 0; bool wasQuoted = false; for (; p < t.size(); ++p) { char c = t[p]; if (quote) { if (c == quote) quote = 0; else value.push_back(c); continue; } if (c == '\'' || c == '"') { quote = c; wasQuoted = true; continue; } if (c == ';') { break; } value.push_back(c); } // Preserve quoted content verbatim (e.g. the trailing space in // "pick> "); only trim an entirely unquoted value. if (!wasQuoted) value = trim(value); env.set("PS3", value); consumedAssignment = true; // Preserve anything after the terminating ';' on this line. std::string rest; if (p < t.size() && t[p] == ';') rest = trim(t.substr(p + 1)); if (!rest.empty()) { afterAssignments += rest; afterAssignments.push_back('\n'); } std::string tail; while (std::getline(assignLines, tail)) { afterAssignments += tail; afterAssignments.push_back('\n'); } break; } afterAssignments += firstLine; afterAssignments.push_back('\n'); std::string tail; while (std::getline(assignLines, tail)) { afterAssignments += tail; afterAssignments.push_back('\n'); } break; } if (consumedAssignment) prepared = afterAssignments; std::istringstream lines(prepared); std::string line, remainder; bool consumedTrap = false; while (std::getline(lines, line)) { int sig = 0; std::string action; if (parseTrap(line, sig, action)) { installTrap(sig, action); consumedTrap = true; } else { remainder += line; remainder.push_back('\n'); } } std::vector children; std::vector fifos; std::string rewritten; if (hasProcessSubstitution(remainder)) { if (!rewriteProcessSubstitution(remainder, rewritten, children, fifos, env, runner)) { for (const auto& f : fifos) ::unlink(f.c_str()); status = 2; return true; } status = runner(rewritten, env); for (pid_t pid : children) { int st = 0; ::waitpid(pid, &st, 0); } // Remove the transient FIFOs now that producers/consumers have finished. for (const auto& f : fifos) ::unlink(f.c_str()); return true; } std::string var, body; std::vector words; if (splitSelect(remainder, var, words, body)) { status = runSelect(remainder, env, runner); return true; } // Trap handling. Only engage when a trap was declared *in this script* // (consumedTrap). Engaging merely because some trap is globally installed // would make every later run take this path -- and because the remainder is // re-run through `runner` (which re-enters runM5), that caused unbounded // recursion when the remainder itself raised the trapped signal // (e.g. `trap ... USR1; kill -USR1 $$`). // // The `dispatching` guard prevents the remainder / trap-action sub-runs from // re-triggering this same trap-dispatch logic, so a trapped signal delivered // while the remainder runs is handled exactly once at this level. static bool dispatching = false; if (consumedTrap && !dispatching) { dispatching = true; status = remainder.empty() ? 0 : runner(remainder, env); const int sig = pending_signal; if (sig > 0 && sig < NSIG && traps[sig].installed && !traps[sig].action.empty()) { pending_signal = 0; status = runner(traps[sig].action, env); } dispatching = false; return true; } return false; } } // namespace sleela::sh