+ const char *sbcl_home = getenv("SBCL_HOME");
+
+ interrupt_init();
+ block_blockable_signals(0, 0);
+
+ setlocale(LC_ALL, "");
+
+ runtime_options = NULL;
+
+ /* Check early to see if this executable has an embedded core,
+ * which also populates runtime_options if the core has runtime
+ * options */
+ runtime_path = os_get_runtime_executable_path();
+ if (runtime_path) {
+ os_vm_offset_t offset = search_for_embedded_core(runtime_path);
+ if (offset != -1) {
+ embedded_core_offset = offset;
+ core = runtime_path;
+ } else {
+ free(runtime_path);
+ }
+ }
+
+
+ /* Parse our part of the command line (aka "runtime options"),
+ * stripping out those options that we handle. */
+ if (runtime_options != NULL) {
+ dynamic_space_size = runtime_options->dynamic_space_size;
+ thread_control_stack_size = runtime_options->thread_control_stack_size;
+ sbcl_argv = argv;
+ } else {
+ int argi = 1;
+
+ runtime_options = successful_malloc(sizeof(struct runtime_options));
+
+ while (argi < argc) {
+ char *arg = argv[argi];
+ if (0 == strcmp(arg, "--script")) {
+ /* This is both a runtime and a toplevel option. As a
+ * runtime option, it is equivalent to --noinform.
+ * This exits, and does not increment argi, so that
+ * TOPLEVEL-INIT sees the option. */
+ noinform = 1;
+ end_runtime_options = 1;
+ disable_lossage_handler_p = 1;
+ lose_on_corruption_p = 1;
+ break;
+ } else if (0 == strcmp(arg, "--noinform")) {
+ noinform = 1;
+ ++argi;
+ } else if (0 == strcmp(arg, "--core")) {
+ if (core) {
+ lose("more than one core file specified\n");
+ } else {
+ ++argi;
+ if (argi >= argc) {
+ lose("missing filename for --core argument\n");
+ }
+ core = copied_string(argv[argi]);
+ ++argi;
+ }
+ } else if (0 == strcmp(arg, "--help")) {
+ /* I think this is the (or a) usual convention: upon
+ * seeing "--help" we immediately print our help
+ * string and exit, ignoring everything else. */
+ print_help();
+ exit(0);
+ } else if (0 == strcmp(arg, "--version")) {
+ /* As in "--help" case, I think this is expected. */
+ print_version();
+ exit(0);
+ } else if (0 == strcmp(arg, "--dynamic-space-size")) {
+ ++argi;
+ if (argi >= argc)
+ lose("missing argument for --dynamic-space-size");
+ errno = 0;
+ dynamic_space_size = strtol(argv[argi++], 0, 0) << 20;
+ if (errno)
+ lose("argument to --dynamic-space-size is not a number");
+# ifdef MAX_DYNAMIC_SPACE_END
+ if (!((DYNAMIC_SPACE_START <
+ DYNAMIC_SPACE_START+dynamic_space_size) &&
+ (DYNAMIC_SPACE_START+dynamic_space_size <=
+ MAX_DYNAMIC_SPACE_END)))
+ lose("specified --dynamic-space-size too large");
+# endif
+ } else if (0 == strcmp(arg, "--control-stack-size")) {
+ ++argi;
+ if (argi >= argc)
+ lose("missing argument for --control-stack-size");
+ errno = 0;
+ thread_control_stack_size = strtol(argv[argi++], 0, 0) << 20;
+ if (errno)
+ lose("argument to --control-stack-size is not a number");
+ } else if (0 == strcmp(arg, "--debug-environment")) {
+ int n = 0;
+ printf("; Commandline arguments:\n");
+ while (n < argc) {
+ printf("; %2d: \"%s\"\n", n, argv[n]);
+ ++n;
+ }
+ n = 0;
+ printf(";\n; Environment:\n");
+ while (ENVIRON[n]) {
+ printf("; %2d: \"%s\"\n", n, ENVIRON[n]);
+ ++n;
+ }
+ ++argi;
+ } else if (0 == strcmp(arg, "--disable-ldb")) {
+ disable_lossage_handler_p = 1;
+ ++argi;
+ } else if (0 == strcmp(arg, "--lose-on-corruption")) {
+ lose_on_corruption_p = 1;
+ ++argi;
+ } else if (0 == strcmp(arg, "--end-runtime-options")) {
+ end_runtime_options = 1;
+ ++argi;
+ break;
+ } else {
+ /* This option was unrecognized as a runtime option,
+ * so it must be a toplevel option or a user option,
+ * so we must be past the end of the runtime option
+ * section. */
+ break;
+ }
+ }
+ /* This is where we strip out those options that we handle. We
+ * also take this opportunity to make sure that we don't find
+ * an out-of-place "--end-runtime-options" option. */
+ {
+ char *argi0 = argv[argi];
+ int argj = 1;
+ /* (argc - argi) for the arguments, one for the binary,
+ and one for the terminating NULL. */
+ sbcl_argv = successful_malloc((2 + argc - argi) * sizeof(char *));
+ sbcl_argv[0] = argv[0];
+ while (argi < argc) {
+ char *arg = argv[argi++];
+ /* If we encounter --end-runtime-options for the first
+ * time after the point where we had to give up on
+ * runtime options, then the point where we had to
+ * give up on runtime options must've been a user
+ * error. */
+ if (!end_runtime_options &&
+ 0 == strcmp(arg, "--end-runtime-options")) {
+ lose("bad runtime option \"%s\"\n", argi0);
+ }
+ sbcl_argv[argj++] = arg;
+ }
+ sbcl_argv[argj] = 0;
+ }
+ }
+
+ /* Align down to multiple of page_table page size, and to the appropriate
+ * stack alignment. */
+ dynamic_space_size &= ~(PAGE_BYTES-1);
+ thread_control_stack_size &= ~(CONTROL_STACK_ALIGNMENT_BYTES-1);
+
+ /* Preserve the runtime options for possible future core saving */
+ runtime_options->dynamic_space_size = dynamic_space_size;
+ runtime_options->thread_control_stack_size = thread_control_stack_size;