void init(int32_t argc, char *argv[])
{
::setlocale(LC_ALL, "");
if (options(&argc, argv))
_exit(0);
int32_t cpus = 0;
os_base::CPUs(cpus);
if (cpus < 2)
cpus = 2;
exlib::Service::init(cpus + 1);
init_prof();
init_argv(argc, argv);
init_date();
init_rt();
init_sandbox();
init_acThread();
init_logger();
init_net();
init_fiber();
srand((unsigned int)time(0));
v8::Platform *platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::V8::Initialize();
}
virtual void Run()
{
int32_t argc = m_argc;
char** argv = m_argv;
exlib::string exePath;
std::vector<char*> ptrArg;
process_base::get_execPath(exePath);
bool bZip;
ifZipFile(exePath, bZip);
if (bZip) {
exePath.append(1, '$');
ptrArg.resize(argc + 1);
ptrArg[0] = argv[0];
ptrArg[1] = exePath.c_buffer();
int32_t i;
for (i = 1; i < argc; i++)
ptrArg[i + 1] = argv[i];
argv = &ptrArg[0];
argc++;
}
init_start_argv(argc, argv);
int32_t pos = argc;
options(pos, argv);
init();
if (pos < argc) {
if (argv[pos][0] == '-')
m_start = argv[pos];
else {
m_start = s_root;
resolvePath(m_start, argv[pos]);
}
if (pos != 1) {
int32_t p = 1;
for (; pos < argc; pos++)
argv[p++] = argv[pos];
argc = p;
}
}
init_argv(argc, argv);
exlib::Service::Create(start_fiber, this, 256 * 1024, "start");
m_sem.Post();
exlib::Service::dispatch();
}
int main(int argc, char *argv[])
{
const struct option options[] = {
{"help", no_argument, NULL, 'h'},
{"debug", no_argument, NULL, 'd'},
{"version", no_argument, NULL, 'v'},
{"silent", no_argument, NULL, 's'},
{"persist", no_argument, NULL, 'p'},
{0, 0, 0, 0},
};
char opt;
while ((opt = getopt_long(argc, argv, "+hdvsp", options, NULL)) != -1)
{
switch (opt)
{
case 'h':
puts("Usage: vu [OPTIONS] [module [SCRIPT ARGUMENTS]]\n"
" -h, --help Show this help message and exit\n"
" -v, --version Show the VM version and exit\n"
" -d, --debug Enable debugging\n"
" -s, --silent Do not print the stack after running\n"
" -p, --persist Use standard input and output to persist the stack\n"
" This option is intended for internal use; implies --silent");
return 0;
case 'v':
printf("vu virtual machine 0.2\nbyte code protocol %d.%d\n", VERSION >> 4, VERSION & 15);
return 0;
case 's':
vm_silent = true;
break;
case 'd':
vm_debug = true;
break;
case 'p':
vm_persist = true;
vm_silent = true;
break;
}
}
signal(SIGINT, handle_interrupt);
init_module_path();
init_errors();
V global = new_global_scope();
V v_eva = open_std_lib(toHashMap(toScope(global)->env));
Stack *S = new_stack();
init_argv(argc - optind, argv + optind, v_eva);
run(global, S);
clear_stack(S);
return 0;
}
static void Plugin_run(
Plugin* plugin, Array* inputs, Array* outputs, Error* error) {
Array argv = {NULL};
for (size_t i = 0; i < inputs->length; ++i) {
Input* input = (Input*) inputs->data[i];
if ((input == NULL) || (input->fd != IO_INVALID_FD)) {
continue;
}
bool is_valid = is_input_valid(input->name, error);
if (ERROR_HAS(error)) {
Error_add(error, "`" EXTERNAL_BINARY "` error");
return;
}
if (!is_valid) {
continue;
}
if (argv.data == NULL) {
init_argv(&argv, &plugin->options, error);
if (ERROR_HAS(error)) {
return;
}
}
argv.data[argv.length - 1 - 1] = (intptr_t) input->name;
int child_pid;
int fd = fork_exec_fd(
(char*) argv.data[0], (char**) argv.data, &child_pid, error);
if (ERROR_HAS(error)) {
Error_add(error, "`" EXTERNAL_BINARY "` error");
return;
}
input->fd = fd;
input->arg = child_pid;
input->close = Input_close_subprocess;
}
if (argv.data != NULL) {
Array_deinit(&argv);
}
}
void vty_dispatch_command(struct vty_client *c) {
int argc, i;
char *argv[N_ARGS];
init_argv((char *)c->buf, c->buf_off, argv, &argc);
if (argc > 0) {
for (i = 0; i < cmd_tab->n; i++) {
if (strncmp(argv[0], cmd_tab->table[i].name,
strlen(cmd_tab->table[i].name)) == 0) {
cmd_tab->table[i].fn(c->writefd, argc, argv);
break;
}
if (strncmp(argv[0], "quit", 4) == 0) {
vty_close_connection(c);
return;
}
}
}
prompt(c);
}
int main(int argc, char* argv[])
{
char delims[] = ";, \t:=\n";
//char buf[] = "this;test=string,has six:tokens";
char buf[] = " this test : = string,has six tokens;\n";
//char buf[] = "token";
int bufsize = 1 + strlen(buf);
int token_count = 0;
char* token_vec[10];
size_t max_token_count = (sizeof token_vec / sizeof token_vec[0]) - 1;
memset(token_vec, 0, sizeof token_vec);
printf("delimiters: '%s'\n", delims);
printf("original string: '%s'\n", buf);
token_count = tokenize(buf, sizeof(buf), delims);
printf("tokenized string: '");
for (int i = 0; i <bufsize; ++i) {
char c;
c = buf[i];
if (c == 0) c = '0';
putchar(c);
}
printf("' contains %d tokens.\n", token_count);
token_count = init_argv(token_vec, max_token_count, buf, bufsize);
for(int i = 0; i < token_count; ++i) {
printf("argv[%d] = %p \t'%s'\n", i, token_vec[i], token_vec[i]);
}
return 0;
}
static void Output_write(Output* output, Buffer** buffer, Error* error) {
Pager* pager = (Pager*) output->arg;
if (pager->fd == IO_INVALID_FD) {
if (buffer_input(pager, buffer, error)) {
return;
}
Array argv;
init_argv(&argv, pager->options, error);
if (ERROR_HAS(error)) {
return;
}
int read_write_fds[2];
if (pipe(read_write_fds) == -1) {
Error_add(error, strerror(errno));
Array_deinit(&argv);
return;
}
// FIXME: reuse fork_exec_fd?
int child_pid = fork();
if (child_pid == -1) {
Error_add(error, strerror(errno));
Array_deinit(&argv);
return;
}
else if (child_pid) {
// FIXME: cleanup fork
if (dup2(read_write_fds[0], STDIN_FILENO) == -1) {
Error_add(error, strerror(errno));
Array_deinit(&argv);
return;
}
close(read_write_fds[0]);
close(read_write_fds[1]);
execvp((char*) argv.data[0], (char**) argv.data);
// FIXME: cleanup fork
Error_add(error, strerror(errno));
Array_deinit(&argv);
return;
}
Array_deinit(&argv);
close(read_write_fds[0]);
flush_buffer(pager, read_write_fds[1], error);
// FIXME: cleanup fork
if (ERROR_HAS(error)) {
return;
}
}
io_write(pager->fd, *buffer, error);
(*buffer)->length = 0;
}
int main(int argc, char **argv) {
#define FIND_LONG_OPTION(ARRAY) \
{ \
for(i = 0; i < sizeof (ARRAY) / sizeof(struct option); i++) { \
struct option *o = (ARRAY) + i; \
if(o->arg < 2) { \
if(strcmp(arg, o->opt) == 0) { \
const char *a = o->arg ? *++v : argv[0]; \
if(o->arg && !a) { \
fprintf(stderr, "%s: option '%s' need an argument\n", argv[0], *v); \
return 1; \
} \
if(o->act) o->act(a); \
goto first_loop; \
} \
} else { \
size_t len = strlen(o->opt); \
if(strncmp(arg, o->opt, len) == 0) { \
if(arg[len] && arg[len] != '=') continue; \
if(!arg[len] || !arg[len + 1]) { \
fprintf(stderr, "%s: option '%s' need an argument\n", argv[0], *v); \
return 1; \
} \
const char *a = arg + len + 1; \
if(o->act) o->act(a); \
goto first_loop; \
} \
} \
} \
}
#define UNRECOGNIZED_OPTION(O) \
do { \
fprintf(stderr, "%s: error: unrecognized option '%s'\n", \
argv[0], (O)); \
return 1; \
} while(0)
int verbose = 0;
int no_link = 0;
int preprocess_only = -1;
int no_warning = -1;
int end_of_options = 0;
const char *output_file = NULL;
char **v = argv;
init_argv();
const char *vs_path = getenv("VS_PATH");
if(!vs_path) vs_path = getenv("VSINSTALLDIR");
if(!getenv("INCLUDE")) {
if(vs_path) {
size_t len = strlen(vs_path);
if(vs_path[len - 1] == '/' || vs_path[len - 1] == '\\') len--;
char buffer[len + 12 + len + 24 + 1];
memcpy(buffer, vs_path, len);
memcpy(buffer + len, "/VC/include;", 12);
memcpy(buffer + len + 12, vs_path, len);
strcpy(buffer + len + 12 + len, "/VC/PlatformSDK/include;");
setenv("INCLUDE", buffer, 0);
} else {
no_warning = find_argv(argv, "-w");
if(!no_warning) fprintf(stderr, "%s: warning: no system include path set\n", argv[0]);
}
}
if(!getenv("LIB")) {
if(vs_path) {
size_t len = strlen(vs_path);
if(vs_path[len - 1] == '/' || vs_path[len - 1] == '\\') len--;
char buffer[len + 8 + len + 20 + 1];
memcpy(buffer, vs_path, len);
memcpy(buffer + len, "/VC/lib;", 8);
memcpy(buffer + len + 12, vs_path, len);
strcpy(buffer + len + 12 + len, "/VC/PlatformSDK/lib;");
setenv("LIB", buffer, 0);
} else {
if(no_warning == -1) no_warning = find_argv(argv, "-w");
if(!no_warning) fprintf(stderr, "%s: warning: no system library path set\n", argv[0]);
}
}
first_loop:
while(*++v) {
if(!end_of_options && **v == '-') {
int i;
if((*v)[1] == '-') {
const char *arg = *v + 2;
if(!*arg) {
end_of_options = 1;
continue;
}
FIND_LONG_OPTION(double_dash_long_options);
if(strcmp(arg, "verbose") == 0) {
verbose = 1;
} else UNRECOGNIZED_OPTION(*v);
} else {
const char *arg = *v + 1;
FIND_LONG_OPTION(singal_dash_long_options);
switch(*arg) {
case 0:
goto not_an_option;
case 'c':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
add_to_argv("-c");
no_link = 1;
break;
case 'D':
if(arg[1]) add_to_argv(*v);
else {
const char *d = *++v;
if(!d) {
fprintf(stderr, "%s: error: macro name missing after '-D'\n",
argv[0]);
return 1;
}
define(d);
}
break;
case 'E':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
add_to_argv("-E");
preprocess_only = 1;
break;
case 'f':
if(arg[1]) set_feature(arg + 1);
else {
const char *feature = *++v;
if(!feature) {
fprintf(stderr, "%s: error: option '-f' need an argument\n",
argv[0]);
return -1;
}
set_feature(feature);
}
break;
case 'g':
// -g[coff][<level>] (level: 0~3)
if(arg[1]) {
const char *level = arg + 1;
if(strncmp(level, "coff", 4) == 0) level += 4;
if(*level && *level != '-') {
int i = 0;
do {
if(!isdigit(level[i])) {
fprintf(stderr, "%s: error: unrecognized debug output level \"%s\"\n",
argv[0], level);
return 1;
}
} while(level[++i]);
/*
if(i > 1 || *level > '3') {
fprintf(stderr, "%s: error: debug output level %s is too high\n",
argv[0], level);
return 1;
}
if(*level == '0') break;
*/
int l = atoi(level);
if(!l) break;
if(l > 3) {
fprintf(stderr, "%s: error: debug output level %s is too high\n",
argv[0], level);
return 1;
}
}
}
add_to_argv("-Zi");
break;
case 'I':
if(no_warning == -1) no_warning = find_argv(argv, "-w");
//if(arg[1]) add_to_argv(*v);
if(arg[1]) add_include_path(arg + 1, no_warning);
else {
const char *path = *++v;
if(!path) {
fprintf(stderr, "%s: error: option '-I' need an argument\n",
argv[0]);
return 1;
}
add_include_path(path, no_warning);
}
break;
case 'L':
if(no_warning == -1) no_warning = find_argv(argv, "-w");
if(arg[1]) add_library_path(arg + 1, no_warning);
else {
const char *path = *++v;
if(!path) {
fprintf(stderr, "%s: error: option '-L' need an argument\n",
argv[0]);
return 1;
}
add_library_path(path, no_warning);
}
break;
case 'l':
if(arg[1]) add_library(arg + 1);
else {
const char *path = *++v;
if(!path) {
fprintf(stderr, "%s: error: option '-l' need an argument\n",
argv[0]);
return 1;
}
add_library(path);
}
break;
case 'M':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
add_to_argv("-showIncludes");
break;
case 'm':
if(arg[1]) set_machine(arg + 1);
else {
const char *machine = *++v;
if(!machine) {
fprintf(stderr, "%s: argument to `-m' is missing\n",
argv[0]);
return 1;
}
set_machine(machine);
}
break;
case 'O':
if(arg[1]) {
const char *o = arg + 1;
if(strcmp(o, "0") == 0) add_to_argv("-Od");
else if(strcmp(o, "1") == 0) add_to_argv("-O2");
else if(strcmp(o, "3") == 0) add_to_argv("-Ox");
else if(strcmp(o, "s") == 0) add_to_argv("-O1");
else if(strcmp(o, "fast") == 0) add_to_argv("-O2");
else add_to_argv(*v);
} else add_to_argv("-O2");
break;
case 'o':
if(arg[1]) output_file = arg + 1;
else {
output_file = *++v;
if(!output_file) {
fprintf(stderr, "%s: error: option '-o' need an argument\n",
argv[0]);
return 1;
}
}
break;
case 'P':
if(preprocess_only == -1) preprocess_only = find_argv(argv, "-E");
if(preprocess_only) add_to_argv("-EP");
break;
case 's':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
break;
case 'U':
if(arg[1]) add_to_argv(*v);
else {
const char *u = *++v;
if(!u) {
fprintf(stderr, "%s: error: macro name missing after '-U'\n",
argv[0]);
return 1;
}
undefine(u);
}
break;
case 'v':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
verbose = 1;
break;
case 'W':
if(!arg[1]) {
if(no_warning == -1) no_warning = find_argv(argv, "-w");
if(!no_warning) {
fprintf(stderr, "%s: warning: option '-W' is deprecated; use '-Wextra' instead\n",
argv[0]);
}
add_to_argv("-Wall");
break;
}
if(strncmp(arg, "Wa,", 3) == 0 || strncmp(arg, "Wp,", 3) == 0 || strncmp(arg, "Wl,", 3) == 0) {
(*v)[3] = 0; // XXX
fprintf(stderr, "%s: warning: option '%s' is not supported\n", argv[0], *v);
break;
}
if(set_warning(arg + 1)) break;
add_to_argv(*v);
break;
case 'w':
if(arg[1]) UNRECOGNIZED_OPTION(*v);
add_to_argv("-w");
no_warning = 1;
break;
case 'x':
if(arg[1]) set_language(arg + 1);
else {
const char *lang = *++v;
if(!lang) {
fprintf(stderr, "%s: error: missing argument to ‘-x’",
argv[0]);
return 4;
}
set_language(lang);
}
break;
default:
fprintf(stderr, "%s: error: unrecognized option '%s'\n", argv[0], *v);
return 1;
}
}
} else {
not_an_option:
#if defined __INTERIX && !defined _NO_CONV_PATH
if(**v == '/') {
char buffer[PATH_MAX + 1];
if(unixpath2win(*v, 0, buffer, sizeof buffer) == 0) {
add_input_file(buffer);
} else {
if(no_warning == -1) no_warning = find_argv(argv, "-w");
if(!no_warning) {
fprintf(stderr, "%s: warning: cannot convert '%s' to Windows path name, %s\n",
argv[0], *v, strerror(errno));
}
add_input_file(*v);
}
} else
#endif
add_input_file(*v);
}
}
setvbuf(stdout, NULL, _IOLBF, 0);
if(preprocess_only == -1) preprocess_only = 0;
if(no_warning == -1) no_warning = 0;
if(last_language && last_language_unused && !no_warning) {
fprintf(stderr, "%s: warning: '-x %s' after last input file has no effect\n", argv[0], last_language);
}
if(!first_input_file) {
if(verbose) {
if(!no_link) add_to_argv("-c");
start_cl();
return 0;
}
fprintf(stderr, "%s: no input files\n", argv[0]);
return 1;
}
if(multiple_input_files && (preprocess_only || no_link)) {
if(output_file) {
fprintf(stderr, "%s: error: cannot specify -o with -c or -E with multiple files\n", argv[0]);
return 4;
} else if(no_link) {
fprintf(stderr, "%s: error: '-c' with multiple files is currently not supported\n", argv[0]);
return -1;
}
}
if(!output_file && !preprocess_only) {
if(no_link) {
size_t len = strlen(first_input_file);
int n = get_last_dot(first_input_file, len);
if(n >= 0) len = n;
char *p = malloc(len + 3);
if(!p) {
perror(argv[0]);
return 1;
}
memcpy(p, first_input_file, len);
strcpy(p + len, ".o");
output_file = p;
} else output_file = DEFAULT_OUTPUT_FILENAME;
}
if(!verbose) add_to_argv("-nologo");
if(preprocess_only) {
if(output_file) target.name = output_file;
target.type = PREPROCESSED_SOURCE;
} else set_output_file(output_file, no_link, no_warning);
//if(no_static_link) add_to_argv("-MD");
add_to_argv(no_static_link ? "-MD" : "-MT");
add_libraries_to_argv();
if(verbose) print_argv();
return start_cl();
}
