// First argument is the usr/lib directory where libjulia is, or NULL to guess. // if that doesn't work, try the full path to the "lib" directory that // contains lib/julia/sys.ji // Second argument is the path of a system image file (*.ji) relative to the // first argument path, or relative to the default julia home dir. The default // is something like ../lib/julia/sys.ji JL_DLLEXPORT void jl_init_with_image(const char *julia_home_dir, const char *image_relative_path) { if (jl_is_initialized()) return; libsupport_init(); jl_options.julia_home = julia_home_dir; if (image_relative_path != NULL) jl_options.image_file = image_relative_path; else jl_options.image_file = jl_get_default_sysimg_path(); julia_init(JL_IMAGE_JULIA_HOME); jl_exception_clear(); }
JL_DLLEXPORT void jl_init(void) { char *libjldir = NULL; void *hdl = (void*)jl_load_dynamic_library_e(NULL, JL_RTLD_DEFAULT); if (hdl) libjldir = dirname((char*)jl_pathname_for_handle(hdl)); if (libjldir) jl_init_with_image(libjldir, jl_get_default_sysimg_path()); else { printf("jl_init unable to find libjulia!\n"); abort(); } }
JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp) { enum { opt_machinefile = 300, opt_color, opt_history_file, opt_startup_file, opt_compile, opt_code_coverage, opt_track_allocation, opt_check_bounds, opt_output_jit_bc, opt_output_unopt_bc, opt_output_bc, opt_depwarn, opt_warn_overwrite, opt_inline, opt_polly, opt_trace_compile, opt_math_mode, opt_worker, opt_bind_to, opt_handle_signals, opt_output_o, opt_output_ji, opt_use_precompiled, opt_use_compilecache, opt_incremental, opt_help_hidden, opt_banner, opt_sysimage_native_code, opt_compiled_modules, opt_machine_file, opt_project, }; static const char* const shortopts = "+vhqH:e:E:L:J:C:ip:O:g:"; static const struct option longopts[] = { // exposed command line options // NOTE: This set of required arguments need to be kept in sync // with the required arguments defined in base/client.jl `process_options()` { "version", no_argument, 0, 'v' }, { "help", no_argument, 0, 'h' }, { "help-hidden", no_argument, 0, opt_help_hidden }, { "quiet", no_argument, 0, 'q' }, { "banner", required_argument, 0, opt_banner }, { "home", required_argument, 0, 'H' }, { "eval", required_argument, 0, 'e' }, { "print", required_argument, 0, 'E' }, { "load", required_argument, 0, 'L' }, { "sysimage", required_argument, 0, 'J' }, { "sysimage-native-code", required_argument, 0, opt_sysimage_native_code }, { "compiled-modules", required_argument, 0, opt_compiled_modules }, { "cpu-target", required_argument, 0, 'C' }, { "procs", required_argument, 0, 'p' }, { "machine-file", required_argument, 0, opt_machine_file }, { "project", optional_argument, 0, opt_project }, { "color", required_argument, 0, opt_color }, { "history-file", required_argument, 0, opt_history_file }, { "startup-file", required_argument, 0, opt_startup_file }, { "compile", required_argument, 0, opt_compile }, { "code-coverage", optional_argument, 0, opt_code_coverage }, { "track-allocation",optional_argument, 0, opt_track_allocation }, { "optimize", optional_argument, 0, 'O' }, { "check-bounds", required_argument, 0, opt_check_bounds }, { "output-bc", required_argument, 0, opt_output_bc }, { "output-unopt-bc", required_argument, 0, opt_output_unopt_bc }, { "output-jit-bc", required_argument, 0, opt_output_jit_bc }, { "output-o", required_argument, 0, opt_output_o }, { "output-ji", required_argument, 0, opt_output_ji }, { "output-incremental",required_argument, 0, opt_incremental }, { "depwarn", required_argument, 0, opt_depwarn }, { "warn-overwrite", required_argument, 0, opt_warn_overwrite }, { "inline", required_argument, 0, opt_inline }, { "polly", required_argument, 0, opt_polly }, { "trace-compile", required_argument, 0, opt_trace_compile }, { "math-mode", required_argument, 0, opt_math_mode }, { "handle-signals", required_argument, 0, opt_handle_signals }, // hidden command line options { "worker", optional_argument, 0, opt_worker }, { "bind-to", required_argument, 0, opt_bind_to }, { "lisp", no_argument, 0, 1 }, { 0, 0, 0, 0 } }; // If CPUID specific binaries are enabled, this varies between runs, so initialize // it here, rather than as part of the static initialization above. jl_options.image_file = jl_get_default_sysimg_path(); jl_options.cmds = NULL; int ncmds = 0; const char **cmds = NULL; int codecov = JL_LOG_NONE; int malloclog = JL_LOG_NONE; // getopt handles argument parsing up to -- delineator int argc = *argcp; char **argv = *argvp; if (argc > 0) { for (int i = 0; i < argc; i++) { if (!strcmp(argv[i], "--")) { argc = i; break; } } } char *endptr; opterr = 0; // suppress getopt warning messages while (1) { int lastind = optind; int c = getopt_long(argc, argv, shortopts, longopts, 0); if (c == -1) break; restart_switch: switch (c) { case 0: break; case 1: jl_errorf("--lisp must be specified as the first argument"); break; case '?': case ':': if (optopt) { if (optopt == 'g') { c = 'g'; goto restart_switch; } for (const struct option *o = longopts; o->val; o++) { if (optopt == o->val) { if (o->has_arg == optional_argument) { c = o->val; goto restart_switch; } else if (strchr(shortopts, o->val)) { jl_errorf("option `-%c/--%s` is missing an argument", o->val, o->name); } else { jl_errorf("option `--%s` is missing an argument", o->name); } } } jl_errorf("unknown option `-%c`", optopt); } else { jl_errorf("unknown option `%s`", argv[lastind]); } break; case 'v': // version jl_printf(JL_STDOUT, "julia version %s\n", JULIA_VERSION_STRING); exit(0); case 'h': // help jl_printf(JL_STDOUT, "%s%s", usage, opts); exit(0); case opt_help_hidden: jl_printf(JL_STDOUT, "%s%s", usage, opts_hidden); exit(0); case 'g': // debug info if (optarg != NULL) { if (!strcmp(optarg,"0")) jl_options.debug_level = 0; else if (!strcmp(optarg,"1")) jl_options.debug_level = 1; else if (!strcmp(optarg,"2")) jl_options.debug_level = 2; else jl_errorf("julia: invalid argument to -g (%s)", optarg); break; } else { jl_options.debug_level = 2; } break; case 'H': // home jl_options.julia_bindir = strdup(optarg); if (!jl_options.julia_bindir) jl_errorf("fatal error: failed to allocate memory: %s", strerror(errno)); break; case 'e': // eval case 'E': // print case 'L': // load { size_t sz = strlen(optarg) + 1; char *arg = (char*)malloc(sz + 1); const char **newcmds; if (!arg) jl_errorf("fatal error: failed to allocate memory: %s", strerror(errno)); arg[0] = c; memcpy(arg + 1, optarg, sz); newcmds = (const char**)realloc(cmds, (ncmds + 2) * sizeof(char*)); if (!newcmds) { free(cmds); jl_errorf("fatal error: failed to allocate memory: %s", strerror(errno)); } cmds = newcmds; cmds[ncmds] = arg; ncmds++; cmds[ncmds] = 0; jl_options.cmds = cmds; break; } case 'J': // sysimage jl_options.image_file = strdup(optarg); if (!jl_options.image_file) jl_errorf("fatal error: failed to allocate memory: %s", strerror(errno)); jl_options.image_file_specified = 1; break; case 'q': // quiet jl_options.quiet = 1; if (jl_options.banner < 0) jl_options.banner = 0; break; case opt_banner: // banner if (!strcmp(optarg, "yes")) jl_options.banner = 1; else if (!strcmp(optarg, "no")) jl_options.banner = 0; else if (!strcmp(optarg, "auto")) jl_options.banner = -1; else jl_errorf("julia: invalid argument to --banner={yes|no|auto} (%s)", optarg); break; case opt_sysimage_native_code: if (!strcmp(optarg,"yes")) jl_options.use_sysimage_native_code = JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES; else if (!strcmp(optarg,"no")) jl_options.use_sysimage_native_code = JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_NO; else jl_errorf("julia: invalid argument to --sysimage-native-code={yes|no} (%s)", optarg); break; case opt_compiled_modules: if (!strcmp(optarg,"yes")) jl_options.use_compiled_modules = JL_OPTIONS_USE_COMPILED_MODULES_YES; else if (!strcmp(optarg,"no")) jl_options.use_compiled_modules = JL_OPTIONS_USE_COMPILED_MODULES_NO; else jl_errorf("julia: invalid argument to --compiled-modules={yes|no} (%s)", optarg); break; case 'C': // cpu-target jl_options.cpu_target = strdup(optarg); if (!jl_options.cpu_target) jl_error("julia: failed to allocate memory"); break; case 'p': // procs errno = 0; if (!strcmp(optarg,"auto")) { jl_options.nprocs = jl_cpu_threads(); } else { long nprocs = strtol(optarg, &endptr, 10); if (errno != 0 || optarg == endptr || *endptr != 0 || nprocs < 1 || nprocs >= INT_MAX) jl_errorf("julia: -p,--procs=<n> must be an integer >= 1"); jl_options.nprocs = (int)nprocs; } break; case opt_machine_file: jl_options.machine_file = strdup(optarg); if (!jl_options.machine_file) jl_error("julia: failed to allocate memory"); break; case opt_project: jl_options.project = optarg ? strdup(optarg) : "@."; break; case opt_color: if (!strcmp(optarg, "yes")) jl_options.color = JL_OPTIONS_COLOR_ON; else if (!strcmp(optarg, "no")) jl_options.color = JL_OPTIONS_COLOR_OFF; else if (!strcmp(optarg, "auto")) jl_options.color = JL_OPTIONS_COLOR_AUTO; else jl_errorf("julia: invalid argument to --color={yes|no|auto} (%s)", optarg); break; case opt_history_file: if (!strcmp(optarg,"yes")) jl_options.historyfile = JL_OPTIONS_HISTORYFILE_ON; else if (!strcmp(optarg,"no")) jl_options.historyfile = JL_OPTIONS_HISTORYFILE_OFF; else jl_errorf("julia: invalid argument to --history-file={yes|no} (%s)", optarg); break; case opt_startup_file: if (!strcmp(optarg,"yes")) jl_options.startupfile = JL_OPTIONS_STARTUPFILE_ON; else if (!strcmp(optarg,"no")) jl_options.startupfile = JL_OPTIONS_STARTUPFILE_OFF; else jl_errorf("julia: invalid argument to --startup-file={yes|no} (%s)", optarg); break; case opt_compile: if (!strcmp(optarg,"yes")) jl_options.compile_enabled = JL_OPTIONS_COMPILE_ON; else if (!strcmp(optarg,"no")) jl_options.compile_enabled = JL_OPTIONS_COMPILE_OFF; else if (!strcmp(optarg,"all")) jl_options.compile_enabled = JL_OPTIONS_COMPILE_ALL; else if (!strcmp(optarg,"min")) jl_options.compile_enabled = JL_OPTIONS_COMPILE_MIN; else jl_errorf("julia: invalid argument to --compile (%s)", optarg); break; case opt_code_coverage: if (optarg != NULL) { size_t endof = strlen(optarg); if (!strcmp(optarg, "user")) codecov = JL_LOG_USER; else if (!strcmp(optarg, "all")) codecov = JL_LOG_ALL; else if (!strcmp(optarg, "none")) codecov = JL_LOG_NONE; else if (endof > 5 && !strcmp(optarg + endof - 5, ".info")) { if (codecov == JL_LOG_NONE) codecov = JL_LOG_ALL; jl_options.output_code_coverage = optarg; } else jl_errorf("julia: invalid argument to --code-coverage (%s)", optarg); break; } else { codecov = JL_LOG_USER; } break; case opt_track_allocation: if (optarg != NULL) { if (!strcmp(optarg,"user")) malloclog = JL_LOG_USER; else if (!strcmp(optarg,"all")) malloclog = JL_LOG_ALL; else if (!strcmp(optarg,"none")) malloclog = JL_LOG_NONE; else jl_errorf("julia: invalid argument to --track-allocation (%s)", optarg); break; } else { malloclog = JL_LOG_USER; } break; case 'O': // optimize if (optarg != NULL) { if (!strcmp(optarg,"0")) jl_options.opt_level = 0; else if (!strcmp(optarg,"1")) jl_options.opt_level = 1; else if (!strcmp(optarg,"2")) jl_options.opt_level = 2; else if (!strcmp(optarg,"3")) jl_options.opt_level = 3; else jl_errorf("julia: invalid argument to -O (%s)", optarg); break; } else { jl_options.opt_level = 3; } break; case 'i': // isinteractive jl_options.isinteractive = 1; break; case opt_check_bounds: if (!strcmp(optarg,"yes")) jl_options.check_bounds = JL_OPTIONS_CHECK_BOUNDS_ON; else if (!strcmp(optarg,"no")) jl_options.check_bounds = JL_OPTIONS_CHECK_BOUNDS_OFF; else jl_errorf("julia: invalid argument to --check-bounds={yes|no} (%s)", optarg); break; case opt_output_bc: jl_options.outputbc = optarg; if (!jl_options.image_file_specified) jl_options.image_file = NULL; break; case opt_output_jit_bc: jl_options.outputjitbc = optarg; break; case opt_output_unopt_bc: jl_options.outputunoptbc = optarg; if (!jl_options.image_file_specified) jl_options.image_file = NULL; break; case opt_output_o: jl_options.outputo = optarg; if (!jl_options.image_file_specified) jl_options.image_file = NULL; break; case opt_output_ji: jl_options.outputji = optarg; if (!jl_options.image_file_specified) jl_options.image_file = NULL; break; case opt_incremental: if (!strcmp(optarg,"yes")) jl_options.incremental = 1; else if (!strcmp(optarg,"no")) jl_options.incremental = 0; else jl_errorf("julia: invalid argument to --output-incremental={yes|no} (%s)", optarg); break; case opt_depwarn: if (!strcmp(optarg,"yes")) jl_options.depwarn = JL_OPTIONS_DEPWARN_ON; else if (!strcmp(optarg,"no")) jl_options.depwarn = JL_OPTIONS_DEPWARN_OFF; else if (!strcmp(optarg,"error")) jl_options.depwarn = JL_OPTIONS_DEPWARN_ERROR; else jl_errorf("julia: invalid argument to --depwarn={yes|no|error} (%s)", optarg); break; case opt_warn_overwrite: if (!strcmp(optarg,"yes")) jl_options.warn_overwrite = JL_OPTIONS_WARN_OVERWRITE_ON; else if (!strcmp(optarg,"no")) jl_options.warn_overwrite = JL_OPTIONS_WARN_OVERWRITE_OFF; else jl_errorf("julia: invalid argument to --warn-overwrite={yes|no|} (%s)", optarg); break; case opt_inline: if (!strcmp(optarg,"yes")) jl_options.can_inline = 1; else if (!strcmp(optarg,"no")) jl_options.can_inline = 0; else { jl_errorf("julia: invalid argument to --inline (%s)", optarg); } break; case opt_polly: if (!strcmp(optarg,"yes")) jl_options.polly = JL_OPTIONS_POLLY_ON; else if (!strcmp(optarg,"no")) jl_options.polly = JL_OPTIONS_POLLY_OFF; else { jl_errorf("julia: invalid argument to --polly (%s)", optarg); } break; case opt_trace_compile: jl_options.trace_compile = strdup(optarg); if (!jl_options.trace_compile) jl_errorf("fatal error: failed to allocate memory: %s", strerror(errno)); break; case opt_math_mode: if (!strcmp(optarg,"ieee")) jl_options.fast_math = JL_OPTIONS_FAST_MATH_OFF; else if (!strcmp(optarg,"fast")) jl_options.fast_math = JL_OPTIONS_FAST_MATH_ON; else if (!strcmp(optarg,"user")) jl_options.fast_math = JL_OPTIONS_FAST_MATH_DEFAULT; else jl_errorf("julia: invalid argument to --math-mode (%s)", optarg); break; case opt_worker: jl_options.worker = 1; if (optarg != NULL) { jl_options.cookie = strdup(optarg); if (!jl_options.cookie) jl_error("julia: failed to allocate memory"); } break; case opt_bind_to: jl_options.bindto = strdup(optarg); if (!jl_options.bindto) jl_error("julia: failed to allocate memory"); break; case opt_handle_signals: if (!strcmp(optarg,"yes")) jl_options.handle_signals = JL_OPTIONS_HANDLE_SIGNALS_ON; else if (!strcmp(optarg,"no")) jl_options.handle_signals = JL_OPTIONS_HANDLE_SIGNALS_OFF; else jl_errorf("julia: invalid argument to --handle-signals (%s)", optarg); break; default: jl_errorf("julia: unhandled option -- %c\n" "This is a bug, please report it.", c); } } jl_options.code_coverage = codecov; jl_options.malloc_log = malloclog; int proc_args = *argcp < optind ? *argcp : optind; *argvp += proc_args; *argcp -= proc_args; }