-/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2015 Jay Freeman (saurik)
+/* Cycript - The Truly Universal Scripting Language
+ * Copyright (C) 2009-2016 Jay Freeman (saurik)
*/
/* GNU Affero General Public License, Version 3 {{{ */
#include <mach/mach_time.h>
#endif
+#include "Code.hpp"
#include "Driver.hpp"
#include "Error.hpp"
#include "Highlight.hpp"
case Parsing:
longjmp(ctrlc_, 1);
case Running:
+#ifndef __ANDROID__
CYCancel();
+#endif
return;
case Sending:
return;
static std::ostream *out_;
-static void Output(CYUTF8String json, std::ostream *out, bool expand = false) {
+static void Output(CYUTF8String json, std::ostream *out, bool reparse = false) {
+ CYPool pool;
+
+ if (reparse) do {
+ CYStream stream(json.data, json.data + json.size);
+ CYDriver driver(pool, stream);
+ if (driver.Parse(CYMarkExpression))
+ break;
+ std::stringbuf str;
+ CYOptions options;
+ CYOutput out(str, options);
+ out.pretty_ = true;
+ out << *driver.context_;
+ std::string data(str.str());
+ json = CYPoolUTF8String(pool, data);
+ if (json.size == 0)
+ json.data = NULL;
+ } while (false);
+
const char *data(json.data);
size_t size(json.size);
if (data == NULL || out == NULL)
return;
- if (!expand ||
- data[0] != '@' && data[0] != '"' && data[0] != '\'' ||
- data[0] == '@' && data[1] != '"' && data[1] != '\''
- )
- CYLexerHighlight(data, size, *out);
- else for (size_t i(0); i != size; ++i)
- if (data[i] != '\\')
- *out << data[i];
- else switch(data[++i]) {
- case '\0': goto done;
- case '\\': *out << '\\'; break;
- case '\'': *out << '\''; break;
- case '"': *out << '"'; break;
- case 'b': *out << '\b'; break;
- case 'f': *out << '\f'; break;
- case 'n': *out << '\n'; break;
- case 'r': *out << '\r'; break;
- case 't': *out << '\t'; break;
- case 'v': *out << '\v'; break;
- default: *out << '\\'; --i; break;
- }
-
- done:
+ CYLexerHighlight(data, size, *out);
*out << std::endl;
}
if (*character == '\x01') *character = '\n';
}
- ~History() {
+ ~History() { try {
for (HIST_ENTRY *history((history_set_pos(0), current_history())); history; history = next_history())
for (char *character(history->line); *character; ++character)
if (*character == '\n') *character = '\x01';
} else {
_assert(write_history(histfile_.c_str()) == 0);
}
- }
+ } catch (const CYException &error) {
+ CYPool pool;
+ std::cout << error.PoolCString(pool) << std::endl;
+ } }
void operator +=(std::string command) {
+ if (HIST_ENTRY *entry = history_get(where_history()))
+ if (command == entry->line)
+ return;
add_history(command.c_str());
++histlines_;
}
return NULL;
}
-static int CYConsoleKeyBypass(int count, int key) {
- rl_point = rl_end;
- rl_insert(count, '\n');
- return rl_newline(count, key);
+static void _lblcall(int (*command)(int, int), int count, int key) {
+ int last(_rl_last_c_pos);
+ // rl_rubout crashes in _rl_erase_at_end_of_line if _rl_last_c_pos != 0
+ if (command == &rl_rubout)
+ _rl_last_c_pos = 0;
+ for (int i(0); i != count; ++i)
+ if (command(1, key) != 0)
+ _assert(false);
+ _rl_last_c_pos = last;
}
static int CYConsoleKeyReturn(int count, int key) {
if (rl_point != rl_end) {
- if (memchr(rl_line_buffer, '\n', rl_end) == NULL)
- return CYConsoleKeyBypass(count, key);
+ if (memchr(rl_line_buffer, '\n', rl_end) == NULL) {
+ _lblcall(&rl_newline, count, key);
+ return 0;
+ }
+ insert:
char *before(CYmemrchr(rl_line_buffer, '\n', rl_point));
if (before == NULL)
before = rl_line_buffer;
int adjust(rl_line_buffer + space - 1 - before);
if (space == rl_point && adjust != 0)
- rl_rubout(adjust, '\b');
+ _lblcall(&rl_rubout, adjust, '\b');
- rl_insert(count, '\n');
+ _lblcall(&rl_insert, count, '\n');
if (adjust != 0)
- rl_insert(adjust, ' ');
+ _lblcall(&rl_insert, adjust, ' ');
return 0;
}
- rl_insert(count, '\n');
-
bool done(false);
if (rl_line_buffer[0] == '?')
done = true;
else {
std::string command(rl_line_buffer, rl_end);
- std::istringstream stream(command);
+ command += '\n';
+ std::stringbuf stream(command);
size_t last(std::string::npos);
for (size_t i(0); i != std::string::npos; i = command.find('\n', i + 1))
done = true;
}
- if (done)
- return rl_newline(count, key);
- return 0;
+ if (done) {
+ _lblcall(&rl_newline, count, key);
+ return 0;
+ }
+
+ // XXX: this was the most obvious fix, but is seriously dumb
+ goto insert;
}
static int CYConsoleKeyUp(int count, int key) {
- while (count-- != 0) {
+ for (; count != 0; --count) {
char *after(CYmemrchr(rl_line_buffer, '\n', rl_point));
if (after == NULL) {
if (int value = rl_get_previous_history(1, key))
}
static int CYConsoleKeyDown(int count, int key) {
- while (count-- != 0) {
+ for (; count != 0; --count) {
char *after(static_cast<char *>(memchr(rl_line_buffer + rl_point, '\n', rl_end - rl_point)));
if (after == NULL) {
int where(where_history());
static int CYConsoleLineEnd(int count, int key) {
while (rl_point != rl_end && rl_line_buffer[rl_point] != '\n')
++rl_point;
+ if (rl_point != rl_end && rl_editing_mode == 0)
+ --rl_point;
return 0;
}
static int CYConsoleKeyBack(int count, int key) {
- while (count-- != 0) {
+ for (; count != 0; --count) {
+ if (rl_point == 0)
+ return 1;
+
char *before(CYmemrchr(rl_line_buffer, '\n', rl_point));
- if (before == NULL)
- return rl_rubout(count, key);
+ if (before == NULL) {
+ int adjust(std::min(count, rl_point));
+ _lblcall(&rl_rubout, adjust, key);
+ count -= adjust - 1;
+ continue;
+ }
int start(before + 1 - rl_line_buffer);
if (start == rl_point) rubout: {
- rl_rubout(1, key);
+ _lblcall(&rl_rubout, 1, key);
continue;
}
for (int i(start); i != rl_point; ++i)
if (rl_line_buffer[i] != ' ')
goto rubout;
- rl_rubout((rl_point - start) % 4 ?: 4, key);
+ _lblcall(&rl_rubout, (rl_point - start) % 4 ?: 4, key);
}
return 0;
for (int i(start); i != rl_point; ++i)
if (rl_line_buffer[i] != ' ')
goto complete;
- return rl_insert(4 - (rl_point - start) % 4, ' ');
+ _lblcall(&rl_insert, 4 - (rl_point - start) % 4, ' ');
+ return 0;
}
-static void CYConsoleRemapBind(rl_command_func_t *from, rl_command_func_t *to) {
- char **keyseqs(rl_invoking_keyseqs(from));
+static void CYConsoleRemapBind(Keymap map, rl_command_func_t *from, rl_command_func_t *to) {
+ char **keyseqs(rl_invoking_keyseqs_in_map(from, map));
if (keyseqs == NULL)
return;
for (char **keyseq(keyseqs); *keyseq != NULL; ++keyseq) {
- rl_bind_keyseq(*keyseq, to);
+ rl_bind_keyseq_in_map(*keyseq, to, map);
free(*keyseq);
}
free(keyseqs);
}
+static void CYConsoleRemapKeys(Keymap map) {
+ CYConsoleRemapBind(map, &rl_beg_of_line, &CYConsoleLineBegin);
+ CYConsoleRemapBind(map, &rl_end_of_line, &CYConsoleLineEnd);
+
+ CYConsoleRemapBind(map, &rl_get_previous_history, &CYConsoleKeyUp);
+ CYConsoleRemapBind(map, &rl_get_next_history, &CYConsoleKeyDown);
+
+ CYConsoleRemapBind(map, &rl_rubout, &CYConsoleKeyBack);
+ CYConsoleRemapBind(map, &rl_complete, &CYConsoleKeyTab);
+}
+
static void CYConsolePrepTerm(int meta) {
rl_prep_terminal(meta);
- CYConsoleRemapBind(&rl_beg_of_line, &CYConsoleLineBegin);
- CYConsoleRemapBind(&rl_end_of_line, &CYConsoleLineEnd);
- CYConsoleRemapBind(&rl_rubout, &CYConsoleKeyBack);
+ CYConsoleRemapKeys(emacs_standard_keymap);
+ CYConsoleRemapKeys(emacs_meta_keymap);
+ CYConsoleRemapKeys(emacs_ctlx_keymap);
+ CYConsoleRemapKeys(vi_insertion_keymap);
+ CYConsoleRemapKeys(vi_movement_keymap);
+}
+
+static void CYOutputRun(const std::string &code, bool reparse = false) {
+ CYPool pool;
+ Output(Run(pool, client_, code), &std::cout, reparse);
}
static void Console(CYOptions &options) {
std::string basedir;
+#ifdef __ANDROID__
+ basedir = "/data/local/tmp";
+#else
if (const char *home = getenv("HOME"))
basedir = home;
else {
passwd = getpwuid(getuid());
basedir = passwd->pw_dir;
}
+#endif
basedir += "/.cycript";
mkdir(basedir.c_str(), 0700);
bool bypass(false);
bool debug(false);
- bool expand(false);
bool lower(true);
+ bool reparse(false);
out_ = &std::cout;
rl_completer_word_break_characters = break_;
rl_attempted_completion_function = &Complete;
- rl_bind_key(TAB, &CYConsoleKeyTab);
-
- rl_redisplay_function = CYDisplayUpdate;
- rl_prep_term_function = CYConsolePrepTerm;
-
-#if defined (__MSDOS__)
- rl_bind_keyseq("\033[0A", &CYConsoleKeyUp);
- rl_bind_keyseq("\033[0D", &CYConsoleKeyDown);
-#endif
- rl_bind_keyseq("\033[A", &CYConsoleKeyUp);
- rl_bind_keyseq("\033[B", &CYConsoleKeyDown);
- rl_bind_keyseq("\033OA", &CYConsoleKeyUp);
- rl_bind_keyseq("\033OB", &CYConsoleKeyDown);
-#if defined (__MINGW32__)
- rl_bind_keyseq("\340H", &CYConsoleKeyUp);
- rl_bind_keyseq("\340P", &CYConsoleKeyDown);
- rl_bind_keyseq("\\000H", &CYConsoleKeyUp);
- rl_bind_keyseq("\\000P", &CYConsoleKeyDown);
-#endif
+ if (cur_term != NULL) {
+ rl_redisplay_function = CYDisplayUpdate;
+ rl_prep_term_function = CYConsolePrepTerm;
+ }
- struct sigaction action;
- sigemptyset(&action.sa_mask);
- action.sa_handler = &sigint;
- action.sa_flags = 0;
- sigaction(SIGINT, &action, NULL);
+ CYOutputRun("");
for (;;) {
+ struct sigaction action;
+ sigemptyset(&action.sa_mask);
+ action.sa_handler = &sigint;
+ action.sa_flags = 0;
+ sigaction(SIGINT, &action, NULL);
+
if (setjmp(ctrlc_) != 0) {
mode_ = Working;
*out_ << std::endl;
}
if (bypass) {
- rl_bind_key('\r', &CYConsoleKeyBypass);
- rl_bind_key('\n', &CYConsoleKeyBypass);
+ rl_bind_key('\r', &rl_newline);
+ rl_bind_key('\n', &rl_newline);
} else {
rl_bind_key('\r', &CYConsoleKeyReturn);
rl_bind_key('\n', &CYConsoleKeyReturn);
std::string command(line);
free(line);
- _assert(!command.empty());
- _assert(command[command.size() - 1] == '\n');
- command.resize(command.size() - 1);
if (command.empty())
continue;
+ history += command;
if (command[0] == '?') {
std::string data(command.substr(1));
*out_ << "done." << std::endl;
} else if (data == "exit") {
return;
- } else if (data == "expand") {
- expand = !expand;
- *out_ << "expand == " << (expand ? "true" : "false") << std::endl;
} else if (data == "lower") {
lower = !lower;
*out_ << "lower == " << (lower ? "true" : "false") << std::endl;
+ } else if (data == "reparse") {
+ reparse = !reparse;
+ *out_ << "reparse == " << (reparse ? "true" : "false") << std::endl;
}
- history += command;
continue;
}
std::string code;
if (bypass)
code = command;
- else {
- std::istringstream stream(command);
+ else try {
+ std::stringbuf stream(command);
CYPool pool;
CYDriver driver(pool, stream);
std::cerr << " | ";
std::cerr << error->message_ << std::endl;
- history += command;
break;
}
Setup(out, driver, options, lower);
out << *driver.script_;
code = str.str();
+ } catch (const CYException &error) {
+ CYPool pool;
+ std::cout << error.PoolCString(pool) << std::endl;
+ continue;
}
- history += command;
-
if (debug) {
std::cout << "cy= ";
CYLexerHighlight(code.c_str(), code.size(), std::cout);
std::cout << std::endl;
}
- CYPool pool;
- Output(Run(pool, client_, code), &std::cout, expand);
+ CYOutputRun(code, reparse);
}
}
const char *host(NULL);
const char *port(NULL);
+ const char *argv0(argv[0]);
+
optind = 1;
for (;;) {
if (argc == 0)
script = NULL;
else {
-#ifdef CY_EXECUTE
- // XXX: const_cast?! wtf gcc :(
- CYSetArgs(argc - 1, const_cast<const char **>(argv + 1));
-#endif
script = argv[0];
if (strcmp(script, "-") == 0)
script = NULL;
+ --argc;
+ ++argv;
}
+#ifdef CY_EXECUTE
+ // XXX: const_cast?! wtf gcc :(
+ CYSetArgs(argv0, script, argc, const_cast<const char **>(argv));
+#endif
+
#ifdef CY_ATTACH
if (pid == _not(pid_t))
client_ = -1;
}
} file(address.sun_path);
- _syscall(bind(server, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address)));
+ _syscall(bind(server, reinterpret_cast<sockaddr *>(&address), sizeof(address)));
_syscall(chmod(address.sun_path, 0777));
_syscall(listen(server, 1));
stream = new std::istringstream(buffer.str());
CYPool pool;
- CYDriver driver(pool, *stream, script);
+ CYDriver driver(pool, *stream->rdbuf(), script);
Setup(driver);
uint64_t begin(CYGetTime());
}
CYPool pool;
- CYDriver driver(pool, *stream, script);
+ CYDriver driver(pool, *stream->rdbuf(), script);
Setup(driver);
bool failed(driver.Parse());
if (failed || !driver.errors_.empty()) {
for (CYDriver::Errors::const_iterator i(driver.errors_.begin()); i != driver.errors_.end(); ++i)
std::cerr << i->location_.begin << ": " << i->message_ << std::endl;
+ return 1;
} else if (driver.script_ != NULL) {
std::stringbuf str;
CYOutput out(str, options);
return 0;
}
-int main(int argc, char * const argv[], char const * const envp[]) {
+_visible int main(int argc, char * const argv[], char const * const envp[]) {
try {
return Main(argc, argv, envp);
} catch (const CYException &error) {
projects / cycript.git / blobdiff