X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/fb98ac0c3231f2685211b3120fd3dc315c056d37..c41590b2ad915045995ae5d39b91bc493c4e11d8:/Console.cpp diff --git a/Console.cpp b/Console.cpp index e09ea01..930394b 100644 --- a/Console.cpp +++ b/Console.cpp @@ -1,4 +1,4 @@ -/* Cycript - Remove Execution Server and Disassembler +/* Cycript - Inlining/Optimizing JavaScript Compiler * Copyright (C) 2009 Jay Freeman (saurik) */ @@ -37,18 +37,28 @@ */ /* }}} */ -#define _GNU_SOURCE - -#include <substrate.h> #include "cycript.hpp" +#ifdef CY_EXECUTE +#include "JavaScript.hpp" +#endif + #include <cstdio> #include <sstream> #include <setjmp.h> +#ifdef HAVE_READLINE_H +#include <readline.h> +#else #include <readline/readline.h> +#endif + +#ifdef HAVE_HISTORY_H +#include <history.h> +#else #include <readline/history.h> +#endif #include <sys/mman.h> @@ -65,6 +75,13 @@ #include <sys/socket.h> #include <netinet/in.h> #include <sys/un.h> +#include <pwd.h> + +#include <apr_getopt.h> + +#include <dlfcn.h> + +#include "Replace.hpp" static volatile enum { Working, @@ -95,6 +112,7 @@ static void sigint(int) { static bool bison_; #endif static bool strict_; +static bool pretty_; void Setup(CYDriver &driver, cy::parser &parser) { #if YYDEBUG @@ -105,40 +123,64 @@ void Setup(CYDriver &driver, cy::parser &parser) { driver.strict_ = true; } -void Run(int socket, const char *data, size_t size, FILE *fout = NULL, bool expand = false) { - CYPool pool; +void Setup(CYOutput &out, CYDriver &driver, CYOptions &options) { + out.pretty_ = pretty_; + CYContext context(driver.pool_, options); + driver.program_->Replace(context); +} +static CYUTF8String Run(CYPool &pool, int client, CYUTF8String code) { const char *json; - if (socket == -1) { + size_t size; + + if (client == -1) { mode_ = Running; - json = CYExecute(pool, data); +#ifdef CY_EXECUTE + json = CYExecute(pool, code.data); +#else + json = NULL; +#endif mode_ = Working; if (json != NULL) size = strlen(json); } else { mode_ = Sending; - CYSendAll(socket, &size, sizeof(size)); - CYSendAll(socket, data, size); + CYSendAll(client, &size, sizeof(size)); + CYSendAll(client, code.data, size); mode_ = Waiting; - CYRecvAll(socket, &size, sizeof(size)); + CYRecvAll(client, &size, sizeof(size)); if (size == _not(size_t)) json = NULL; else { char *temp(new(pool) char[size + 1]); - CYRecvAll(socket, temp, size); + CYRecvAll(client, temp, size); temp[size] = '\0'; json = temp; } mode_ = Working; } - if (json != NULL && fout != NULL) { - if (!expand || json[0] != '"' && json[0] != '\'') - fputs(json, fout); + return CYUTF8String(json, size); +} + +static CYUTF8String Run(CYPool &pool, int client, const std::string &code) { + return Run(pool, client, CYUTF8String(code.c_str(), code.size())); +} + +void Run(int client, const char *data, size_t size, FILE *fout = NULL, bool expand = false) { + CYPool pool; + CYUTF8String json(Run(pool, client, CYUTF8String(data, size))); + + data = json.data; + size = json.size; + + if (data != NULL && fout != NULL) { + if (!expand || data[0] != '"' && data[0] != '\'') + fputs(data, fout); else for (size_t i(0); i != size; ++i) - if (json[i] != '\\') - fputc(json[i], fout); - else switch(json[++i]) { + if (data[i] != '\\') + fputc(data[i], fout); + else switch(data[++i]) { case '\0': goto done; case '\\': fputc('\\', fout); break; case '\'': fputc('\'', fout); break; @@ -158,18 +200,203 @@ void Run(int socket, const char *data, size_t size, FILE *fout = NULL, bool expa } } -void Run(int socket, std::string &code, FILE *fout = NULL, bool expand = false) { - Run(socket, code.c_str(), code.size(), fout, expand); +static void Run(int client, std::string &code, FILE *fout = NULL, bool expand = false) { + Run(client, code.c_str(), code.size(), fout, expand); +} + +int (*append_history$)(int, const char *); + +static std::string command_; + +static CYExpression *ParseExpression(CYPool &pool, CYUTF8String code) { + std::ostringstream str; + str << '(' << code << ')'; + std::string string(str.str()); + + CYDriver driver(pool); + driver.data_ = string.c_str(); + driver.size_ = string.size(); + + cy::parser parser(driver); + Setup(driver, parser); + + if (parser.parse() != 0 || !driver.errors_.empty()) + _assert(false); + + CYExpress *express(dynamic_cast<CYExpress *>(driver.program_->statements_)); + _assert(express != NULL); + return express->expression_; } -static void Console(int socket) { +static int client_; + +static char **Complete(const char *word, int start, int end) { + rl_attempted_completion_over = TRUE; + + CYPool pool; + + CYDriver driver(pool); + cy::parser parser(driver); + Setup(driver, parser); + + std::string line(rl_line_buffer, start); + std::string command(command_ + line); + + driver.data_ = command.c_str(); + driver.size_ = command.size(); + + driver.auto_ = true; + + if (parser.parse() != 0 || !driver.errors_.empty()) + return NULL; + + if (driver.mode_ == CYDriver::AutoNone) + return NULL; + + CYExpression *expression; + + CYOptions options; + CYContext context(driver.pool_, options); + + std::ostringstream prefix; + + switch (driver.mode_) { + case CYDriver::AutoPrimary: + expression = $ CYThis(); + break; + + case CYDriver::AutoDirect: + expression = driver.context_; + break; + + case CYDriver::AutoIndirect: + expression = $ CYIndirect(driver.context_); + break; + + case CYDriver::AutoMessage: { + CYDriver::Context &thing(driver.contexts_.back()); + expression = $M($M($ CYIndirect(thing.context_), $S("isa")), $S("messages")); + for (CYDriver::Context::Words::const_iterator part(thing.words_.begin()); part != thing.words_.end(); ++part) + prefix << (*part)->word_ << ':'; + } break; + + default: + _assert(false); + } + + std::string begin(prefix.str() + word); + + driver.program_ = $ CYProgram($ CYExpress($C2(ParseExpression(pool, + " function(object, prefix) {\n" + " var names = [];\n" + " var pattern = '^' + prefix;\n" + " for (name in object)\n" + " if (name.match(pattern) != null)\n" + " names.push(name);\n" + " return names;\n" + " }\n" + ), expression, $S(begin.c_str())))); + + driver.program_->Replace(context); + + std::ostringstream str; + CYOutput out(str, options); + out << *driver.program_; + + std::string code(str.str()); + CYUTF8String json(Run(pool, client_, code)); + + CYExpression *result(ParseExpression(pool, json)); + CYArray *array(dynamic_cast<CYArray *>(result)); + _assert(array != NULL); + + // XXX: use an std::set? + typedef std::vector<std::string> Completions; + Completions completions; + + std::string common; + bool rest(false); + + for (CYElement *element(array->elements_); element != NULL; element = element->next_) { + CYString *string(dynamic_cast<CYString *>(element->value_)); + _assert(string != NULL); + + std::string completion(string->value_, string->size_); + completions.push_back(completion); + + if (!rest) { + common = completion; + rest = true; + } else { + size_t limit(completion.size()), size(common.size()); + if (size > limit) + common = common.substr(0, limit); + else + limit = size; + for (limit = 0; limit != size; ++limit) + if (common[limit] != completion[limit]) + break; + if (limit != size) + common = common.substr(0, limit); + } + } + + size_t count(completions.size()); + if (count == 0) + return NULL; + + if (!common.empty()) { + size_t size(prefix.str().size()); + _assert(common.size() >= size); + common = common.substr(size); + } + + size_t colon(common.find(':')); + if (colon != std::string::npos) + common = common.substr(0, colon + 1); + + char **results(reinterpret_cast<char **>(malloc(sizeof(char *) * (count + 2)))); + + results[0] = strdup(common.c_str()); + size_t index(0); + for (Completions::const_iterator i(completions.begin()); i != completions.end(); ++i) + results[++index] = strdup(i->c_str()); + results[count + 1] = NULL; + + return results; +} + +// need char *, not const char * +static char name_[] = "cycript"; +static char break_[] = " \t\n\"\\'`@$><=;|&{(" ".:"; + +static void Console(apr_pool_t *pool, CYOptions &options) { + passwd *passwd; + if (const char *username = getenv("LOGNAME")) + passwd = getpwnam(username); + else + passwd = getpwuid(getuid()); + + const char *basedir(apr_psprintf(pool, "%s/.cycript", passwd->pw_dir)); + const char *histfile(apr_psprintf(pool, "%s/history", basedir)); + size_t histlines(0); + + rl_initialize(); + rl_readline_name = name_; + + mkdir(basedir, 0700); + read_history(histfile); + bool bypass(false); bool debug(false); bool expand(false); FILE *fout(stdout); - rl_bind_key('\t', rl_insert); + // rl_completer_word_break_characters is broken in libedit + rl_basic_word_break_characters = break_; + rl_attempted_completion_function = &Complete; + rl_bind_key('\t', rl_complete); struct sigaction action; sigemptyset(&action.sa_mask); @@ -178,7 +405,7 @@ static void Console(int socket) { sigaction(SIGINT, &action, NULL); restart: for (;;) { - std::string command; + command_.clear(); std::vector<std::string> lines; bool extra(false); @@ -197,6 +424,8 @@ static void Console(int socket) { mode_ = Working; if (line == NULL) break; + if (line[0] == '\0') + goto read; if (!extra) { extra = true; @@ -216,26 +445,35 @@ static void Console(int socket) { fflush(fout); } add_history(line); + ++histlines; goto restart; } } - command += line; - for (char *state, *token(apr_strtok(line, "\n", &state)); token != NULL; token = apr_strtok(NULL, "\n", &state)) - lines.push_back(token); + command_ += line; + + char *begin(line), *end(line + strlen(line)); + while (char *nl = reinterpret_cast<char *>(memchr(begin, '\n', end - begin))) { + *nl = '\0'; + lines.push_back(begin); + begin = nl + 1; + } + + lines.push_back(begin); + free(line); std::string code; if (bypass) - code = command; + code = command_; else { - CYDriver driver(""); + CYDriver driver; cy::parser parser(driver); Setup(driver, parser); - driver.data_ = command.c_str(); - driver.size_ = command.size(); + driver.data_ = command_.c_str(); + driver.size_ = command_.size(); if (parser.parse() != 0 || !driver.errors_.empty()) { for (CYDriver::Errors::const_iterator error(driver.errors_.begin()); error != driver.errors_.end(); ++error) { @@ -248,7 +486,7 @@ static void Console(int socket) { std::cerr << lines[begin.line - 1] << std::endl; } - std::cerr << " | "; + std::cerr << "...."; for (size_t i(0); i != begin.column - 1; ++i) std::cerr << '.'; if (begin.line != end.line || begin.column == end.column) @@ -260,14 +498,15 @@ static void Console(int socket) { std::cerr << " | "; std::cerr << error->message_ << std::endl; - add_history(command.c_str()); + add_history(command_.c_str()); + ++histlines; goto restart; } } driver.errors_.clear(); - command += '\n'; + command_ += '\n'; prompt = "cy> "; goto read; } @@ -275,22 +514,31 @@ static void Console(int socket) { if (driver.program_ == NULL) goto restart; - if (socket != -1) - code = command; + if (client_ != -1) + code = command_; else { std::ostringstream str; - CYOutput out(str); - driver.program_->Multiple(out); + CYOutput out(str, options); + Setup(out, driver, options); + out << *driver.program_; code = str.str(); } } - add_history(command.c_str()); + add_history(command_.c_str()); + ++histlines; if (debug) std::cout << code << std::endl; - Run(socket, code, fout, expand); + Run(client_, code, fout, expand); + } + + if (append_history$ != NULL) { + _syscall(close(_syscall(open(histfile, O_CREAT | O_WRONLY, 0600)))); + (*append_history$)(histlines, histfile); + } else { + write_history(histfile); } fputs("\n", fout); @@ -314,52 +562,143 @@ static void *Map(const char *path, size_t *psize) { return base; } -int main(int argc, char *argv[]) { +void InjectLibrary(pid_t pid); + +int Main(int argc, char const * const argv[], char const * const envp[]) { bool tty(isatty(STDIN_FILENO)); - pid_t pid(_not(pid_t)); bool compile(false); + CYOptions options; - for (;;) switch (getopt(argc, argv, "cg:p:s")) { - case -1: - goto getopt; - case '?': - fprintf(stderr, "usage: cycript [-c] [-p <pid>] [<script> [<arg>...]]\n"); - return 1; + append_history$ = reinterpret_cast<int (*)(int, const char *)>(dlsym(RTLD_DEFAULT, "append_history")); - case 'c': - compile = true; - break; +#ifdef CY_ATTACH + pid_t pid(_not(pid_t)); +#endif - case 'g': - if (false); -#if YYDEBUG - else if (strcmp(optarg, "bison") == 0) - bison_ = true; + CYPool pool; + apr_getopt_t *state; + _aprcall(apr_getopt_init(&state, pool, argc, argv)); + + for (;;) { + char opt; + const char *arg; + + apr_status_t status(apr_getopt(state, + "cg:n:" +#ifdef CY_ATTACH + "p:" #endif - else { - fprintf(stderr, "invalid name for -g\n"); + "s" + , &opt, &arg)); + + switch (status) { + case APR_EOF: + goto getopt; + case APR_BADCH: + case APR_BADARG: + fprintf(stderr, + "usage: cycript [-c]" +#ifdef CY_ATTACH + " [-p <pid|name>]" +#endif + " [<script> [<arg>...]]\n" + ); return 1; - } - break; + default: + _aprcall(status); + } - case 'p': { - size_t size(strlen(optarg)); - char *end; - pid = strtoul(optarg, &end, 0); - if (optarg + size != end) { - fprintf(stderr, "invalid pid for -p\n"); - return 1; - } - } break; + switch (opt) { + case 'c': + compile = true; + break; - case 's': - strict_ = true; - break; + case 'g': + if (false); + else if (strcmp(arg, "rename") == 0) + options.verbose_ = true; +#if YYDEBUG + else if (strcmp(arg, "bison") == 0) + bison_ = true; +#endif + else { + fprintf(stderr, "invalid name for -g\n"); + return 1; + } + break; + + case 'n': + if (false); + else if (strcmp(arg, "minify") == 0) + pretty_ = true; + else { + fprintf(stderr, "invalid name for -n\n"); + return 1; + } + break; + +#ifdef CY_ATTACH + case 'p': { + size_t size(strlen(arg)); + char *end; + + pid = strtoul(arg, &end, 0); + if (arg + size != end) { + // XXX: arg needs to be escaped in some horrendous way of doom + const char *command(apr_psprintf(pool, "ps axc|sed -e '/^ *[0-9]/{s/^ *\\([0-9]*\\)\\( *[^ ]*\\)\\{3\\} *-*\\([^ ]*\\)/\\3 \\1/;/^%s /{s/^[^ ]* //;q;};};d'", arg)); + + if (FILE *pids = popen(command, "r")) { + char value[32]; + size = 0; + + for (;;) { + size_t read(fread(value + size, 1, sizeof(value) - size, pids)); + if (read == 0) + break; + else { + size += read; + if (size == sizeof(value)) { + pid = _not(pid_t); + goto fail; + } + } + } + + size: + if (size == 0) + goto fail; + if (value[size - 1] == '\n') { + --size; + goto size; + } + + value[size] = '\0'; + size = strlen(value); + pid = strtoul(value, &end, 0); + if (value + size != end) fail: + pid = _not(pid_t); + _syscall(pclose(pids)); + } + + if (pid == _not(pid_t)) { + fprintf(stderr, "invalid pid for -p\n"); + return 1; + } + } + } break; +#endif + + case 's': + strict_ = true; + break; + } } getopt:; const char *script; + int ind(state->ind); - if (pid != _not(pid_t) && optind < argc - 1) { +#ifdef CY_ATTACH + if (pid != _not(pid_t) && ind < argc - 1) { fprintf(stderr, "-p cannot set argv\n"); return 1; } @@ -368,41 +707,63 @@ int main(int argc, char *argv[]) { fprintf(stderr, "-p conflicts with -c\n"); return 1; } +#endif - if (optind == argc) + if (ind == argc) script = NULL; else { +#ifdef CY_EXECUTE // XXX: const_cast?! wtf gcc :( - CYSetArgs(argc - optind - 1, const_cast<const char **>(argv + optind + 1)); - script = argv[optind]; + CYSetArgs(argc - ind - 1, const_cast<const char **>(argv + ind + 1)); +#endif + script = argv[ind]; if (strcmp(script, "-") == 0) script = NULL; } - if (script == NULL && !tty && pid != _not(pid_t)) { - fprintf(stderr, "non-terminal attaching to remove console\n"); +#ifdef CY_ATTACH + if (pid != _not(pid_t) && script == NULL && !tty) { + fprintf(stderr, "non-terminal attaching to remote console\n"); return 1; } +#endif - int socket; - +#ifdef CY_ATTACH if (pid == _not(pid_t)) - socket = -1; + client_ = -1; else { - socket = _syscall(::socket(PF_UNIX, SOCK_STREAM, 0)); - - struct sockaddr_un address; - memset(&address, 0, sizeof(address)); - address.sun_family = AF_UNIX; - sprintf(address.sun_path, "/tmp/.s.cy.%u", pid); - - _syscall(connect(socket, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address))); + int server(_syscall(socket(PF_UNIX, SOCK_STREAM, 0))); try { + struct sockaddr_un address; + memset(&address, 0, sizeof(address)); + address.sun_family = AF_UNIX; + + sprintf(address.sun_path, "/tmp/.s.cy.%u", getpid()); + + _syscall(bind(server, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address))); + _syscall(chmod(address.sun_path, 0777)); + + try { + _syscall(listen(server, 1)); + InjectLibrary(pid); + client_ = _syscall(accept(server, NULL, NULL)); + } catch (...) { + // XXX: exception? + unlink(address.sun_path); + throw; + } + } catch (...) { + _syscall(close(server)); + throw; + } } +#else + client_ = -1; +#endif if (script == NULL && tty) - Console(socket); + Console(pool, options); else { - CYDriver driver(script ?: "<stdin>"); + CYDriver driver(pool, script ?: "<stdin>"); cy::parser parser(driver); Setup(driver, parser); @@ -435,19 +796,36 @@ int main(int argc, char *argv[]) { for (CYDriver::Errors::const_iterator i(driver.errors_.begin()); i != driver.errors_.end(); ++i) std::cerr << i->location_.begin << ": " << i->message_ << std::endl; } else if (driver.program_ != NULL) - if (socket != -1) - Run(socket, start, end - start, stdout); - else { + if (client_ != -1) { + std::string code(start, end-start); + Run(client_, code, stdout); + } else { std::ostringstream str; - CYOutput out(str); - driver.program_->Multiple(out); + CYOutput out(str, options); + Setup(out, driver, options); + out << *driver.program_; std::string code(str.str()); if (compile) std::cout << code; else - Run(socket, code); + Run(client_, code, stdout); } } return 0; } + +int main(int argc, char const * const argv[], char const * const envp[]) { + apr_status_t status(apr_app_initialize(&argc, &argv, &envp)); + + if (status != APR_SUCCESS) { + fprintf(stderr, "apr_app_initialize() != APR_SUCCESS\n"); + return 1; + } else try { + return Main(argc, argv, envp); + } catch (const CYException &error) { + CYPool pool; + fprintf(stderr, "%s\n", error.PoolCString(pool)); + return 1; + } +}