| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| #include "repl.h" |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <cctype> |
| #include <iostream> |
| #include <set> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| namespace shell::repl { |
| |
| Repl::Repl(JSContext* ctx, const std::string& prompt) |
| : li_([this](const std::string& s) { HandleLine(s); }, prompt), |
| ctx_(ctx), |
| output_(&std::cout), |
| exit_shell_cmd_(false), |
| running_(false) { |
| Write("Type \\h for help\n"); |
| li_.SetAutocompleteCallback([this](std::string line_to_complete) { |
| this->line_to_complete_ = line_to_complete; |
| std::string script = "repl.autocompletionCallback();"; |
| JSValue completions_as_js_str = |
| JS_Eval(ctx_, script.c_str(), script.length(), "<evalScript>", JS_EVAL_TYPE_GLOBAL); |
| const char* completions_as_cstr = JS_ToCString(ctx_, completions_as_js_str); |
| if (!completions_as_cstr) { // completion error, return an empty vector |
| return std::vector<std::string>(); |
| } |
| std::string completions_as_str(completions_as_cstr); |
| std::vector<std::string> completions; |
| std::stringstream completions_as_stream(completions_as_str); |
| std::string cur_completion; |
| while (std::getline(completions_as_stream, cur_completion, '/')) { |
| completions.push_back(line_to_complete + cur_completion); |
| } |
| return completions; |
| }); |
| li_.Show(); |
| } |
| |
| Repl::Repl(JSContext* ctx, const std::string& prompt, fit::function<void(const std::string&)> cb) |
| : li_(std::move(cb), prompt), |
| ctx_(ctx), |
| output_(&std::cout), |
| exit_shell_cmd_(false), |
| running_(false) { |
| Write("Type \\h for help\n"); |
| li_.Show(); |
| } |
| |
| void Repl::Write(const char* output) { *output_ << output; } |
| void Repl::ChangeOutput(std::ostream* ss) { output_ = ss; } |
| |
| void Repl::ShowPrompt() { |
| running_ = false; |
| li_.Show(); |
| } |
| |
| const char* Repl::GetCmd() { return cur_cmd_.c_str(); } |
| |
| const char* Repl::GetLine() { return line_to_complete_.c_str(); } |
| |
| bool Repl::FeedInput(uint8_t* bytes, size_t num_bytes) { |
| if (running_) { |
| if (num_bytes >= 1 && |
| bytes[0] == 26) { // shell cmd 'c' to show the prompt in spite of running_ |
| ShowPrompt(); |
| } |
| return false; |
| } |
| for (size_t i = 0; i < num_bytes; i++) { |
| li_.OnInput(static_cast<char>(bytes[i])); |
| if (exit_shell_cmd_) { |
| return true; |
| } |
| if (running_) { // cmd is still running, we discard the rest of the input |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| void Repl::HandleLine(const std::string& line) { |
| li_.Hide(); |
| running_ = true; |
| std::string cmd = mexpr_ + line; |
| std::string shell_cmd = GetAndExecuteShellCmd(cmd); |
| if (shell_cmd == "\\q") { |
| exit_shell_cmd_ = true; |
| } else if (!shell_cmd.empty()) { |
| mexpr_ = ""; |
| exit_shell_cmd_ = false; |
| ShowPrompt(); |
| } else { |
| std::string open_symbols = OpenSymbols(cmd); |
| if (open_symbols.empty()) { |
| mexpr_ = ""; |
| li_.AddToHistory(cmd); |
| EvalCmd(cmd); |
| } else { |
| mexpr_ = cmd; |
| ShowPrompt(); |
| } |
| exit_shell_cmd_ = false; |
| } |
| } |
| |
| std::string Repl::GetAndExecuteShellCmd(std::string cmd) { |
| if (cmd.substr(0, 2) == "\\h") { |
| std::string help_msg = |
| "\\q\texit\n" |
| "\\h\tthis help\n" |
| "Ctrl-Z\tmake the (hidden) prompt show up when a previous command aborted with an error\n"; |
| Write(help_msg.c_str()); |
| return cmd.substr(0, 2); |
| } |
| if (cmd.substr(0, 2) == "\\q") { |
| return cmd.substr(0, 2); |
| } |
| return ""; |
| } |
| |
| void Repl::EvalCmd(const std::string& cmd) { |
| cur_cmd_ = cmd; // saving the cmd in the Repl class instance, to be executed through a JS call |
| std::string script = "repl.evalScriptAwaitsPromise()"; |
| JSValue res = JS_Eval(ctx_, script.c_str(), script.length(), "<evalScript>", JS_EVAL_TYPE_GLOBAL); |
| if (JS_IsException(res)) { // the script above was at fault, that's bad |
| js_std_dump_error(ctx_); |
| ShowPrompt(); |
| } |
| } |
| |
| bool match(char a, char b) { |
| if (a == '(' && b == ')') { |
| return true; |
| } |
| if (a == '{' && b == '}') { |
| return true; |
| } |
| if (a == '[' && b == ']') |
| return true; |
| return false; |
| } |
| |
| bool isIdentifierAllowed(char c) { |
| return std::isalpha(c) || std::isdigit(c) || c == '_' || c == '$'; |
| } |
| |
| std::string Repl::OpenSymbols(const std::string& cmd) { |
| std::string open_symbols; |
| bool regex_possible = true; |
| size_t n = cmd.length(); |
| size_t i = 0; |
| while (i < n) { |
| if (cmd[i] == '\'' || cmd[i] == '\"' || cmd[i] == '`') { // string |
| char delim = cmd[i]; |
| open_symbols.push_back(delim); |
| i++; |
| while (i < n) { |
| if (cmd[i] == '\\') |
| i++; |
| else if (cmd[i] == delim) { |
| open_symbols.pop_back(); |
| i++; |
| break; |
| } |
| i++; |
| } |
| regex_possible = false; |
| } |
| |
| else if (cmd[i] == '/') { |
| if (cmd[i + 1] == '*') { // block comment |
| std::size_t ip = cmd.find("*/", i + 1); |
| if (ip != std::string::npos) |
| i = ip + 1; |
| else { |
| open_symbols.push_back('*'); |
| i = n; |
| } |
| } else if (cmd[i + 1] == '/') { // line comment |
| for (i += 2; i < n; i++) { |
| if (cmd[i] == '\n') |
| break; |
| } |
| i++; |
| } else if (regex_possible) { // regex |
| open_symbols.push_back('/'); |
| for (i++; i < n; i++) { |
| if (cmd[i] == '\\') { |
| if (i < n) |
| i++; |
| } else if (open_symbols.back() == '[') { // ignore / or [ if within [] |
| if (cmd[i] == ']') |
| open_symbols.pop_back(); |
| } else if (cmd[i] == '[') { |
| open_symbols.push_back('['); |
| if (cmd[i] == '[' || cmd[i] == ']') |
| i++; |
| } else if (cmd[i] == '/') { |
| open_symbols.pop_back(); |
| break; |
| } |
| } |
| i++; |
| regex_possible = false; |
| } else { |
| regex_possible = true; |
| i++; |
| } |
| } |
| |
| else if (strchr("{[(", cmd[i])) { |
| open_symbols.push_back(cmd[i]); |
| regex_possible = true; |
| i++; |
| } |
| |
| else if (strchr("}])", cmd[i])) { |
| regex_possible = false; |
| if (match(open_symbols.back(), cmd[i]) && !open_symbols.empty()) { |
| open_symbols.pop_back(); |
| } |
| i++; |
| } |
| |
| else if (std::isspace(cmd[i])) { |
| i++; |
| } |
| |
| else if (strchr("+-", cmd[i])) { |
| regex_possible = true; |
| i++; |
| } |
| |
| else if (std::isdigit(cmd[i])) { // a number |
| while (i < n && (std::isalnum(cmd[i]) || cmd[i] == '.' || cmd[i] == '+' || cmd[i] == '-')) { |
| i++; |
| } |
| } |
| |
| else if (isIdentifierAllowed(cmd[i])) { // an identifier |
| regex_possible = true; |
| int old_i = i; |
| i++; |
| while (i < n && isIdentifierAllowed(cmd[i])) { |
| i++; |
| } |
| std::set<std::string> no_regex_keywords = { |
| "this", "super", "undefined", "null", "true", "false", "Infinity", "NaN", "arguments"}; |
| std::set<std::string> keywords = { |
| "break", "case", "catch", "continue", "debugger", "default", "delete", |
| "do", "else", "finally", "for", "function", "if", "in", |
| "instanceof", "new", "return", "switch", "this", "throw", "try", |
| "typeof", "while", "with", "class", "const", "enum", "import", |
| "export", "extends", "super", "implements", "interface", "let", "package", |
| "private", "protected", "public", "static", "yield", "undefined", "null", |
| "true", "false", "Infinity", "NaN", "eval", "arguments", "await", |
| "void", "var"}; |
| if (keywords.count(cmd.substr(old_i, i - old_i)) > 0) { |
| if (no_regex_keywords.count(cmd.substr(old_i, i - old_i)) > 0) { |
| regex_possible = false; |
| } |
| continue; |
| } |
| size_t ip = i; |
| while (ip < n && std::isspace(cmd[ip])) { |
| ip++; |
| } |
| if (ip < n && cmd[ip] == '(') { // beginning of function, regex possible |
| continue; |
| } |
| regex_possible = false; |
| } else { |
| regex_possible = true; |
| i++; |
| } |
| } |
| return open_symbols; |
| } |
| |
| } // namespace shell::repl |
