/*
    * Copyright (C) 2020-2021 Jo-Philipp Wich <jo@mein.io>
    *
    * Permission to use, copy, modify, and/or distribute this software for any
    * purpose with or without fee is hereby granted, provided that the above
    * copyright notice and this permission notice appear in all copies.
    *
    * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  #include <stdio.h>
  #include <stdbool.h>
  #include <stdint.h>
  #include <unistd.h>
  #include <errno.h>
  #include <fcntl.h>
  #include <getopt.h>
  
  
  #include "ucode/compiler.h"
  #include "ucode/lib.h"
  #include "ucode/vm.h"
  #include "ucode/types.h"
  #include "ucode/source.h"
  #include "ucode/program.h"
  
  #include "ucode/internal/json-c-compat.h"
  
  #ifdef __GLIBC__
  # define POSIXLY_CORRECT_FLAG "+"
  #else
  # define POSIXLY_CORRECT_FLAG ""
  #endif
  
  static FILE *stdin_unused;
  
  static void
  print_usage(const char *app)
  {
          printf(
          "Usage:\n"
          "  %1$s -h\n"
          "  %1$s -e \"expression\"\n"
          "  %1$s input.uc [input2.uc ...]\n"
          "  %1$s -c [-s] [-o output.uc] input.uc [input2.uc ...]\n\n"
  
          "-h\n"
          "  Help display this help.\n\n"
  
          "-e \"expression\"\n"
          "  Execute the given expression as ucode program.\n\n"
  
          "-p \"expression\"\n"
          "  Like `-e` but print the result of expression.\n\n"
  
          "-t\n"
          "  Enable VM execution tracing.\n\n"
  
          "-g interval\n"
          "  Perform periodic garbage collection every `interval` object\n"
          "  allocations.\n\n"
  
          "-S\n"
          "  Enable strict mode.\n\n"
  
          "-R\n"
          "  Process source file(s) as raw script code (default).\n\n"
  
          "-T[flag,flag,...]\n"
          "  Process the source file(s) as templates, not as raw script code.\n"
          "  Supported flags: no-lstrip (don't strip leading whitespace before\n"
          "  block tags), no-rtrim (don't strip trailing newline after block tags).\n\n"
  
          "-D [name=]value\n"
          "  Define global variable. If `name` is omitted, a JSON dictionary is\n"
          "  expected with each property becoming a global variable set to the\n"
          "  corresponding value. If `name` is specified, it is defined as global\n"
          "  variable set to `value` parsed as JSON (or the literal `value` string\n"
          "  if JSON parsing fails).\n\n"
  
          "-F [name=]path\n"
          "  Like `-D` but reading the value from the file in `path`. The given\n"
          "  file must contain a single, well-formed JSON dictionary.\n\n"
  
          "-U name\n"
          "  Undefine the given global variable name.\n\n"
  
          "-l [name=]library\n"
          "  Preload the given `library`, optionally aliased to `name`.\n\n"
  
          "-L pattern\n"
          "  Prepend given `pattern` to default library search paths. If the pattern\n"
          "  contains no `*`, it is added twice, once with `/*.so` and once with\n"
         "  `/*.uc` appended to it.\n\n"
 
         "-c[flag,flag,...]\n"
         "  Compile the given source file(s) to bytecode instead of executing them.\n"
         "  Supported flags: no-interp (omit interpreter line), interp=... (over-\n"
         "  ride interpreter line with ...), dynlink=... (force import from ... to\n"
         "  be treated as shared extensions loaded at runtime), module (build load-\n"
         "  able library).\n\n"
 
         "-o path\n"
         "  Output file path when compiling. If omitted, the compiled byte code\n"
         "  is written to `./uc.out`. Only meaningful in conjunction with `-c`.\n\n"
 
         "-s\n"
         "  Omit (strip) debug information when compiling files.\n"
         "  Only meaningful in conjunction with `-c`.\n\n"
 
         "-x[expr]\n"
         "  Start program in interactive debugger. If given, stop at the location\n"
         "  described by `expr` (a function name, `path:line[:offset]`, or a ucode\n"
         "  expression evaluating to a function - the same grammar the `break`\n"
         "  debugger CLI command accepts) instead of the first instruction.\n\n"
         "-X[expr]\n"
         "  Enable debugger infrastructure (SIGUSR1 break, uloop) without\n"
         "  launching the interactive debugger automatically. If given, `expr` is\n"
         "  resolved the same way as for `-x` and a breakpoint is installed at\n"
         "  that location; once hit, execution pauses and waits for a remote\n"
         "  debugger to attach, the same way the SIGUSR1 break does.\n\n",
                 app);
 }
 
 static bool
 parse_library_load(char *opt, uc_vm_t *vm);
 
 static uc_value_t *
 debug_lookup_fn(uc_vm_t *vm, const char *name)
 {
         uc_value_t *dbgmod = ucv_object_get(uc_vm_scope_get(vm), "debug", NULL);
         uc_value_t *fn = ucv_object_get(dbgmod, name, NULL);
 
         if (ucv_type(fn) != UC_CFUNCTION) {
                 fprintf(stderr, "Unable to locate debug.%s() function\n", name);
 
                 return NULL;
         }
 
         return fn;
 }
 
 typedef enum {
         DEBUG_MODE_NONE,   /* neither -x nor -X given */
         DEBUG_MODE_LOCAL,  /* -x: launch local interactive debugger */
         DEBUG_MODE_REMOTE, /* -X: enable break infrastructure for a remote debugger */
 } debug_mode_t;
 
 typedef struct {
         bool strip;
         char *interpreter;
         bool autoprint;
         debug_mode_t debug;
         char *breakpoint;
 } compile_opts_t;
 
 static int
 compile(uc_vm_t *vm, uc_source_t *src, FILE *precompile, const compile_opts_t *opts)
 {
         uc_value_t *res = NULL;
         bool strip = opts->strip, autoprint = opts->autoprint;
         debug_mode_t debug = opts->debug;
         char *interp = opts->interpreter, *breakpoint = opts->breakpoint;
         uc_program_t *program;
         int rc = 0;
         char *err;
 
         program = uc_compile(vm->config, src, &err);
 
         if (!program) {
                 fprintf(stderr, "%s", err);
                 free(err);
                 rc = -1;
                 goto out;
         }
 
         if (precompile) {
                 if (interp)
                         fprintf(precompile, "#!%s\n", interp);
 
                 uc_program_write(program, precompile, !strip);
                 fclose(precompile);
                 goto out;
         }
 
         if (vm->gc_interval)
                 uc_vm_gc_start(vm, vm->gc_interval);
 
         if (debug != DEBUG_MODE_NONE) {
                 uc_value_t *entryfn;
 
                 if (!parse_library_load("debug", vm)) {
                         fprintf(stderr, "Unable to load debug module\n");
                         rc = -2;
                         goto out;
                 }
 
                 entryfn = uc_program_main(vm, program);
 
                 /* -x: launch local debugger, breaking at `breakpoint` if given,
                  * else at the first instruction.
                  * -X: arm attach mode (wait for a remote debugger on the PID-derived
                  * socket). With `breakpoint` given, break at that location; without
                  * one, break at the first instruction of the entry function - the
                  * remote mirror of `-x` with no argument. Either way this is the
                  * remote equivalent of the local `-x` flow above. */
                 if (debug == DEBUG_MODE_LOCAL) {
                         uc_value_t *dbgfn = debug_lookup_fn(vm, "debugger");
 
                         if (!dbgfn) {
                                 ucv_put(entryfn);
                                 rc = -2;
                                 goto out;
                         }
 
                         uc_vm_stack_push(vm, ucv_get(dbgfn));
                         uc_vm_stack_push(vm, breakpoint ? NULL : ucv_get(entryfn));
 
                         if (uc_vm_call(vm, false, 1) == EXCEPTION_NONE)
                                 ucv_put(uc_vm_stack_pop(vm));
                 }
                 else {
                         /* -X: arm attach mode. Pass entryfn so that, when no explicit
                          * `breakpoint` is given, debug.attach() installs its step
                          * breakpoint at the entry function's first instruction (breaking
                          * at the start of main, mirroring `-x` with no argument). When a
                          * `breakpoint` is given, the explicit breakpoint below is what
                          * pauses first; the entry step breakpoint is then simply
                          * superseded. debug.attach() ignores a non-closure arg, so
                          * passing NULL in that case is harmless. */
                         uc_value_t *attachfn = debug_lookup_fn(vm, "attach");
 
                         if (!attachfn) {
                                 ucv_put(entryfn);
                                 rc = -2;
                                 goto out;
                         }
 
                         uc_vm_stack_push(vm, ucv_get(attachfn));
                         uc_vm_stack_push(vm, breakpoint ? NULL : ucv_get(entryfn));
 
                         if (uc_vm_call(vm, false, 1) == EXCEPTION_NONE)
                                 ucv_put(uc_vm_stack_pop(vm));
                 }
 
                 if (breakpoint) {
                         uc_value_t *bkfn = debug_lookup_fn(vm, "breakpoint");
                         uc_value_t *id;
 
                         if (!bkfn) {
                                 ucv_put(entryfn);
                                 rc = -2;
                                 goto out;
                         }
 
                         uc_vm_stack_push(vm, ucv_get(bkfn));
                         uc_vm_stack_push(vm, ucv_string_new(breakpoint));
                         uc_vm_stack_push(vm, ucv_get(entryfn));
 
                         if (uc_vm_call(vm, false, 2) == EXCEPTION_NONE) {
                                 id = uc_vm_stack_pop(vm);
 
                                 if (!ucv_is_truish(id)) {
                                         fprintf(stderr,
                                                 "Unable to resolve breakpoint location '%s'\n",
                                                 breakpoint);
                                         ucv_put(id);
                                         ucv_put(entryfn);
                                         rc = -2;
                                         goto out;
                                 }
 
                                 ucv_put(id);
                         }
                 }
 
                 ucv_put(entryfn);
         }
 
         uc_vm_status_t status = uc_vm_execute(vm, program, &res);
 
         rc = status;
 
         switch (rc) {
         case STATUS_OK:
                 if (autoprint) {
                         if (ucv_type(res) == UC_STRING) {
                                 fwrite(ucv_string_get(res), ucv_string_length(res), 1, stdout);
                         }
                         else {
                                 uc_stringbuf_t *pb = xprintbuf_new();
 
                                 ucv_to_stringbuf_formatted(vm, pb, res, 0, '\t', 1);
                                 fwrite(pb->buf, pb->bpos, 1, stdout);
                                 printbuf_free(pb);
                         }
                 }
 
                 rc = 0;
                 break;
 
         case STATUS_EXIT:
                 rc = (int)ucv_int64_get(res);
                 break;
 
         case STATUS_BREAK:
                 /* Break requested - in remote debug mode, continue running */
                 if (debug == DEBUG_MODE_REMOTE)
                         rc = 0;
                 else
                         rc = -2;
                 break;
 
         case ERROR_COMPILE:
                 rc = -1;
                 break;
 
         case ERROR_RUNTIME:
                 rc = -2;
                 break;
         }
 
         /* Let an attached remote debugger client know the target is going away
          * and why, instead of it only finding out once the connection drops.
          * Pass the raw VM status rather than the CLI's own exit-code
          * translation above (which flattens both error kinds to the same -2
          * and loses the actual exception), plus the exit code / a full
          * exception object (same {type, message, stacktrace} shape script
          * code sees via try/catch) it corresponds to.
          *
          * These have to be snapshotted into locals *before* the uc_vm_call()
          * below, not read from vm->exception/vm->arg by the callee once
          * inside it: uc_vm_call() unconditionally calls
          * uc_vm_clear_exception() as its very first action (a normal safety
          * reset for ordinary calls, which also frees vm->exception.message/
          * ->stacktrace), which would wipe vm->exception out from under us
          * before debug.notifyExit() ever got to look at it.
          *
          * vm->output (stdout) is fully block-buffered once it's a socket
          * rather than a tty, while the notification itself goes out via a raw
          * write() - flush first, or the event can overtake not-yet-flushed
          * script output that was already written earlier. */
         if (debug != DEBUG_MODE_NONE) {
                 uc_value_t *notifyfn = debug_lookup_fn(vm, "notifyExit");
                 int32_t exit_code = vm->arg.s32;
                 uc_value_t *exception_obj = (status == ERROR_COMPILE || status == ERROR_RUNTIME)
                         ? uc_vm_exception_object(vm) : NULL;
 
                 fflush(vm->output);
 
                 if (notifyfn) {
                         uc_vm_stack_push(vm, ucv_get(notifyfn));
                         uc_vm_stack_push(vm, ucv_int64_new(status));
                         uc_vm_stack_push(vm, ucv_int64_new(exit_code));
                         uc_vm_stack_push(vm, exception_obj);
 
                         if (uc_vm_call(vm, false, 3) == EXCEPTION_NONE)
                                 ucv_put(uc_vm_stack_pop(vm));
                 }
                 else {
                         ucv_put(exception_obj);
                 }
         }
 
 out:
         uc_program_put(program);
         ucv_put(res);
 
         return rc;
 }
 
 static uc_source_t *
 read_stdin(void)
 {
         size_t rlen = 0, tlen = 0;
         char buf[128], *p = NULL;
 
         if (!stdin_unused) {
                 fprintf(stderr, "The stdin can only be read once\n");
                 errno = EINVAL;
 
                 return NULL;
         }
 
         while (true) {
                 rlen = fread(buf, 1, sizeof(buf), stdin_unused);
 
                 if (rlen == 0)
                         break;
 
                 p = xrealloc(p, tlen + rlen);
                 memcpy(p + tlen, buf, rlen);
                 tlen += rlen;
         }
 
         stdin_unused = NULL;
 
         /* On empty stdin, provide a dummy buffer and ensure that it is
          * at least one byte long, due to
          * https://github.com/google/sanitizers/issues/627 */
         if (p == NULL) {
                 p = xstrdup("\n");
                 tlen = 1;
         }
 
         return uc_source_new_buffer("[stdin]", p, tlen);
 }
 
 static void
 parse_template_modeflags(char *opt, uc_parse_config_t *config)
 {
         char *p;
 
         if (!opt)
                 return;
 
         for (p = strtok(opt, ", "); p; p = strtok(NULL, ", ")) {
                 if (!strcmp(p, "no-lstrip"))
                         config->lstrip_blocks = false;
                 else if (!strcmp(p, "no-rtrim"))
                         config->trim_blocks = false;
                 else
                         fprintf(stderr, "Unrecognized -T flag \"%s\", ignoring\n", p);
         }
 }
 
 static void
 parse_compile_flags(char *opt, char **interp, uc_search_path_t *dynlink_list,
                     bool *module)
 {
         char *p, *k, *v;
 
         if (!opt)
                 return;
 
         for (p = strtok(opt, ","); p; p = strtok(NULL, ",")) {
                 k = p;
                 v = strchr(p, '=');
 
                 if (v)
                         *v++ = 0;
 
                 if (!strcmp(k, "no-interp")) {
                         if (v)
                                 fprintf(stderr, "Compile flag \"%s\" takes no value, ignoring\n", k);
 
                         *interp = NULL;
                 }
                 else if (!strcmp(k, "interp")) {
                         if (!v)
                                 fprintf(stderr, "Compile flag \"%s\" requires a value, ignoring\n", k);
                         else
                                 *interp = v;
                 }
                 else if (!strcmp(k, "dynlink")) {
                         if (!v)
                                 fprintf(stderr, "Compile flag \"%s\" requires a value, ignoring\n", k);
                         else
                                 uc_vector_push(dynlink_list, v);
                 }
                 else if (!strcmp(k, "module")) {
                         if (v)
                                 fprintf(stderr, "Compile flag \"%s\" takes no value, ignoring\n", k);
 
                         *module = true;
                 }
                 else {
                         fprintf(stderr, "Unrecognized -c flag \"%s\", ignoring\n", k);
                 }
         }
 }
 
 static bool
 parse_define_file(char *opt, uc_value_t *globals)
 {
         enum json_tokener_error err = json_tokener_continue;
         char buf[128], *name = NULL, *p;
         struct json_tokener *tok;
         json_object *jso = NULL;
         size_t rlen;
         FILE *fp;
 
         p = strchr(opt, '=');
 
         if (p) {
                 name = opt;
                 *p++ = 0;
         }
         else {
                 p = opt;
         }
 
         if (!strcmp(p, "-")) {
                 if (!stdin_unused) {
                         fprintf(stderr, "The stdin can only be read once\n");
 
                         return false;
                 }
 
                 fp = stdin_unused;
                 stdin_unused = NULL;
         }
         else
                 fp = fopen(p, "r");
 
         if (!fp) {
                 fprintf(stderr, "Unable to open definition file \"%s\": %s\n",
                         p, strerror(errno));
 
                 return true;
         }
 
         tok = xjs_new_tokener();
 
         while (true) {
                 rlen = fread(buf, 1, sizeof(buf), fp);
 
                 if (rlen == 0)
                         break;
 
                 jso = json_tokener_parse_ex(tok, buf, rlen);
                 err = json_tokener_get_error(tok);
 
                 if (err != json_tokener_continue)
                         break;
         }
 
         json_tokener_free(tok);
         fclose(fp);
 
         if (err != json_tokener_success || !json_object_is_type(jso, json_type_object)) {
                 json_object_put(jso);
 
                 fprintf(stderr, "Invalid definition file \"%s\": %s\n",
                         p, (err != json_tokener_success)
                              ? "JSON parse failure" : "Not a valid JSON object");
 
                 return false;
         }
 
         if (name && *name) {
                 ucv_object_add(globals, name, ucv_from_json(NULL, jso));
         }
         else {
                 json_object_object_foreach(jso, key, val)
                         ucv_object_add(globals, key, ucv_from_json(NULL, val));
         }
 
         json_object_put(jso);
 
         return true;
 }
 
 static bool
 parse_define_string(char *opt, uc_value_t *globals)
 {
         enum json_tokener_error err;
         struct json_tokener *tok;
         json_object *jso = NULL;
         char *name = NULL, *p;
         bool rv = false;
         size_t len;
 
         p = strchr(opt, '=');
 
         if (p) {
                 name = opt;
                 *p++ = 0;
         }
         else {
                 p = opt;
         }
 
         len = strlen(p);
         tok = xjs_new_tokener();
 
         /* NB: the len + 1 here is intentional to pass the terminating \0 byte
          * to the json-c parser. This is required to work-around upstream
          * issue #681 <https://github.com/json-c/json-c/issues/681> */
         jso = json_tokener_parse_ex(tok, p, len + 1);
 
         err = json_tokener_get_error(tok);
 
         /* Treat trailing bytes after a parsed value as error */
         if (err == json_tokener_success && json_tokener_get_parse_end(tok) < len)
                 err = json_tokener_error_parse_unexpected;
 
         json_tokener_free(tok);
 
         if (err != json_tokener_success) {
                 json_object_put(jso);
 
                 if (!name || !*name) {
                         fprintf(stderr, "Invalid -D option value \"%s\": %s\n",
                                 p, json_tokener_error_desc(err));
 
                         return false;
                 }
 
                 ucv_object_add(globals, name, ucv_string_new(p));
 
                 return true;
         }
 
         if (name && *name) {
                 ucv_object_add(globals, name, ucv_from_json(NULL, jso));
                 rv = true;
         }
         else if (json_object_is_type(jso, json_type_object)) {
                 json_object_object_foreach(jso, key, val)
                         ucv_object_add(globals, key, ucv_from_json(NULL, val));
                 rv = true;
         }
         else {
                 fprintf(stderr, "Invalid -D option value \"%s\": Not a valid JSON object\n", p);
         }
 
         json_object_put(jso);
 
         return rv;
 }
 
 static void
 parse_search_path(char *pattern, uc_parse_config_t *config)
 {
         size_t len;
         char *p;
 
         if (strchr(pattern, '*')) {
                 uc_search_path_add(&config->module_search_path, pattern);
                 return;
         }
 
         len = strlen(pattern);
 
         if (!len)
                 return;
 
         while (pattern[len-1] == '/')
                 pattern[--len] = 0;
 
         xasprintf(&p, "%s/*.so", pattern);
         uc_search_path_add(&config->module_search_path, p);
         free(p);
 
         xasprintf(&p, "%s/*.uc", pattern);
         uc_search_path_add(&config->module_search_path, p);
         free(p);
 }
 
 static bool
 parse_library_load(char *opt, uc_vm_t *vm)
 {
         char *name = NULL, *p;
         uc_value_t *lib, *ctx;
 
         p = strchr(opt, '=');
 
         if (p) {
                 name = opt;
                 *p++ = 0;
         }
         else {
                 p = opt;
         }
 
         lib = ucv_string_new(p);
         ctx = uc_vm_invoke(vm, "require", 1, lib);
         ucv_put(lib);
 
         if (!ctx)
                 return vm->exception.type == EXCEPTION_NONE;
 
         ucv_object_add(uc_vm_scope_get(vm), name ? name : p, ctx);
 
         return true;
 }
 
 static const char *
 appname(const char *argv0)
 {
         const char *p;
 
         if (!argv0)
                 return "ucode";
 
         p = strrchr(argv0, '/');
 
         if (p)
                 return p + 1;
 
         return argv0;
 }
 
 int
 main(int argc, char **argv)
 {
         const char *optspec = POSIXLY_CORRECT_FLAG "he:p:tg:ST::RD:F:U:l:L:c::o:sx::X::";
         bool strip = false, print_result = false;
         debug_mode_t debug = DEBUG_MODE_NONE;
         char *breakpoint = NULL;
         char *interp = "/usr/bin/env ucode";
         uc_source_t *source = NULL;
         FILE *precompile = NULL;
         char *outfile = NULL;
         uc_vm_t vm = { 0 };
         const char *argv0;
         int opt, rv = 0;
         const char *app;
         uc_value_t *o;
         int fd;
 
         uc_parse_config_t config = {
                 .strict_declarations = false,
                 .lstrip_blocks = true,
                 .trim_blocks = true,
                 .raw_mode = true,
                 .setup_signal_handlers = true
         };
 
         app = appname(argv[0]);
 
         if (argc == 1) {
                 print_usage(app);
                 goto out;
         }
 
         if (!strcmp(app, "utpl"))
                 config.raw_mode = false;
         else if (!strcmp(app, "ucc"))
                 outfile = "./uc.out";
 
         stdin_unused = stdin;
 
         /* parse options iteration 1: parse config related options */
         while ((opt = getopt(argc, argv, optspec)) != -1)
         {
                 switch (opt) {
                 case 'L':
                         parse_search_path(optarg, &config);
                         break;
 
                 case 'S':
                         config.strict_declarations = true;
                         break;
 
                 case 'R':
                         config.raw_mode = true;
                         break;
 
                 case 'T':
                         config.raw_mode = false;
                         parse_template_modeflags(optarg, &config);
                         break;
                 }
         }
 
         uc_search_path_init(&config.module_search_path);
 
         argv0 = argv[optind];
         optind = 1;
 
         uc_vm_init(&vm, &config);
 
         /* load std functions into global scope */
         uc_stdlib_load(uc_vm_scope_get(&vm));
 
         /* register ARGV array but populate it later (to allow for -U ARGV) */
         o = ucv_array_new(&vm);
 
         ucv_object_add(uc_vm_scope_get(&vm), "ARGV", ucv_get(o));
         if (argv0)
                 ucv_object_add(uc_vm_scope_get(&vm), "SCRIPT_NAME", ucv_string_new(argv0));
 
         /* parse options iteration 2: process remaining options */
         while ((opt = getopt(argc, argv, optspec)) != -1)
         {
                 switch (opt) {
                 case 'h':
                         print_usage(argv[0]);
                         goto out;
 
                 case 'e':
                         source = uc_source_new_buffer("[-e argument]", xstrdup(optarg), strlen(optarg));
                         break;
 
                 case 'p':
                         source = uc_source_new_buffer("[-p argument]", xstrdup(optarg), strlen(optarg));
                         print_result = true;
                         break;
 
                 case 't':
                         uc_vm_trace_set(&vm, 1);
                         break;
 
                 case 'g':
                         vm.gc_interval = atoi(optarg);
                         break;
 
                 case 'D':
                         if (!parse_define_string(optarg, uc_vm_scope_get(&vm))) {
                                 rv = 1;
                                 goto out;
                         }
 
                         break;
 
                 case 'F':
                         if (!parse_define_file(optarg, uc_vm_scope_get(&vm))) {
                                 rv = 1;
                                 goto out;
                         }
 
                         break;
 
                 case 'U':
                         ucv_object_delete(uc_vm_scope_get(&vm), optarg);
                         break;
 
                 case 'l':
                         if (!parse_library_load(optarg, &vm)) {
                                 rv = 1;
                                 goto out;
                         }
 
                         break;
 
                 case 'c':
                         outfile = "./uc.out";
                         parse_compile_flags(optarg, &interp, &config.force_dynlink_list,
                                             &config.compile_module);
                         break;
 
                 case 's':
                         strip = true;
                         break;
 
                 case 'o':
                         outfile = optarg;
                         break;
 
                 case 'x':
                         debug = DEBUG_MODE_LOCAL;
                         breakpoint = optarg;
                         break;
 
                 case 'X':
                         debug = DEBUG_MODE_REMOTE;
                         breakpoint = optarg;
                         break;
                 }
         }
 
         if (!source && argv[optind] != NULL) {
                 if (!strcmp(argv[optind], "-"))
                         source = read_stdin();
                 else
                         source = uc_source_new_file(argv[optind]);
 
                 if (!source) {
                         fprintf(stderr, "Failed to open \"%s\": %s\n", argv[optind], strerror(errno));
                         rv = 1;
                         goto out;
                 }
 
                 optind++;
         }
 
         if (!source) {
                 fprintf(stderr, "Require either -e/-p expression or source file\n");
                 rv = 1;
                 goto out;
         }
 
         if (outfile) {
                 if (!strcmp(outfile, "-")) {
                         precompile = stdout;
                 }
                 else {
                         fd = open(outfile, O_WRONLY|O_CREAT|O_TRUNC, 0777);
 
                         if (fd == -1) {
                                 fprintf(stderr, "Unable to open output file %s: %s\n",
                                         outfile, strerror(errno));
 
                                 rv = 1;
                                 goto out;
                         }
 
                         precompile = fdopen(fd, "wb");
                 }
         }
 
         /* populate ARGV array */
         for (; optind < argc; optind++)
                 ucv_array_push(o, ucv_string_new(argv[optind]));
 
         ucv_put(o);
 
         rv = compile(&vm, source, precompile, &((compile_opts_t){
                 .strip = strip,
                 .interpreter = interp,
                 .autoprint = print_result,
                 .debug = debug,
                 .breakpoint = breakpoint,
         }));
 
 out:
         uc_search_path_free(&config.module_search_path);
         uc_vector_clear(&config.force_dynlink_list);
 
         uc_source_put(source);
 
         uc_vm_free(&vm);
 
         return rv;
 }
 

• Git
• Wiki