-/* Cycript - Remove Execution Server and Disassembler
+/* Cycript - Inlining/Optimizing JavaScript Compiler
* Copyright (C) 2009 Jay Freeman (saurik)
*/
#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>
#include <apr_getopt.h>
+#include <dlfcn.h>
+
+#include "Replace.hpp"
+
static volatile enum {
Working,
Parsing,
driver.strict_ = true;
}
-void Setup(CYOutput &out, CYDriver &driver) {
+void Setup(CYOutput &out, CYDriver &driver, CYOptions &options) {
out.pretty_ = pretty_;
-
- CYContext context(driver.pool_);
+ CYContext context(driver.pool_, options);
driver.program_->Replace(context);
}
-void Run(int socket, const char *data, size_t size, FILE *fout = NULL, bool expand = false) {
- CYPool pool;
-
+static CYUTF8String Run(CYPool &pool, int client, CYUTF8String code) {
const char *json;
- if (socket == -1) {
+ size_t size;
+
+ if (client == -1) {
mode_ = Running;
#ifdef CY_EXECUTE
- json = CYExecute(pool, data);
+ json = CYExecute(pool, code.data);
#else
json = NULL;
#endif
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;
}
}
-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(apr_pool_t *pool, 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);
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);
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);
sigaction(SIGINT, &action, NULL);
restart: for (;;) {
- std::string command;
+ command_.clear();
std::vector<std::string> lines;
bool extra(false);
mode_ = Working;
if (line == NULL)
break;
+ if (line[0] == '\0')
+ goto read;
if (!extra) {
extra = true;
}
}
- command += line;
+ command_ += line;
char *begin(line), *end(line + strlen(line));
while (char *nl = reinterpret_cast<char *>(memchr(begin, '\n', end - begin))) {
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) {
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;
}
if (driver.program_ == NULL)
goto restart;
- if (socket != -1)
- code = command;
+ if (client_ != -1)
+ code = command_;
else {
std::ostringstream str;
- CYOutput out(str);
- Setup(out, driver);
+ 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);
}
- _syscall(close(_syscall(open(histfile, O_CREAT | O_WRONLY, 0600))));
- append_history(histlines, histfile);
+ 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);
fflush(fout);
return base;
}
-int main(int argc, char const * const argv[], char const * const envp[]) {
- _aprcall(apr_app_initialize(&argc, &argv, &envp));
+void InjectLibrary(pid_t pid);
+int Main(int argc, char const * const argv[], char const * const envp[]) {
bool tty(isatty(STDIN_FILENO));
bool compile(false);
+ CYOptions options;
+
+ append_history$ = reinterpret_cast<int (*)(int, const char *)>(dlsym(RTLD_DEFAULT, "append_history"));
#ifdef CY_ATTACH
pid_t pid(_not(pid_t));
fprintf(stderr,
"usage: cycript [-c]"
#ifdef CY_ATTACH
- " [-p <pid>]"
+ " [-p <pid|name>]"
#endif
" [<script> [<arg>...]]\n"
);
case 'g':
if (false);
+ else if (strcmp(arg, "rename") == 0)
+ options.verbose_ = true;
#if YYDEBUG
else if (strcmp(arg, "bison") == 0)
bison_ = true;
case 'p': {
size_t size(strlen(arg));
char *end;
+
pid = strtoul(arg, &end, 0);
if (arg + size != end) {
- fprintf(stderr, "invalid pid for -p\n");
- return 1;
+ // 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
}
#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
- socket = -1;
+ client_ = -1;
#endif
if (script == NULL && tty)
- Console(pool, socket);
+ Console(pool, options);
else {
- CYDriver driver(script ?: "<stdin>");
+ CYDriver driver(pool, script ?: "<stdin>");
cy::parser parser(driver);
Setup(driver, parser);
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);
- Setup(out, driver);
+ 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, stdout);
+ 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;
+ }
+}
projects / cycript.git / blobdiff