2 * main() entry point for a stand-alone SBCL image
6 * This software is part of the SBCL system. See the README file for
9 * This software is derived from the CMU CL system, which was
10 * written at Carnegie Mellon University and released into the
11 * public domain. The software is in the public domain and is
12 * provided with absolutely no warranty. See the COPYING and CREDITS
13 * files for more information.
21 #ifndef LISP_FEATURE_WIN32
24 #include <sys/types.h>
25 #ifndef LISP_FEATURE_WIN32
31 #include <sys/param.h>
34 #ifndef LISP_FEATURE_WIN32
41 #if defined(SVR4) || defined(__linux__)
45 #if !(defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD))
55 #include "interrupt.h"
64 #include "genesis/static-symbols.h"
65 #include "genesis/symbol.h"
74 #define SBCL_HOME SBCL_PREFIX"/lib/sbcl/"
77 #ifdef LISP_FEATURE_HPUX
78 extern void *return_from_lisp_stub;
79 #include "genesis/closure.h"
80 #include "genesis/simple-fun.h"
84 /* SIGINT handler that invokes the monitor (for when Lisp isn't up to it) */
86 sigint_handler(int signal, siginfo_t *info, os_context_t *context)
88 lose("\nSIGINT hit at 0x%08lX\n",
89 (unsigned long) *os_context_pc_addr(context));
92 /* (This is not static, because we want to be able to call it from
97 SHOW("entering sigint_init()");
98 install_handler(SIGINT, sigint_handler, 1);
99 SHOW("leaving sigint_init()");
103 * helper functions for dealing with command line args
107 successful_malloc(size_t size)
109 void* result = malloc(size);
111 lose("malloc failure\n");
115 return (void *) NULL; /* dummy value: return something ... */
119 copied_string(char *string)
121 return strcpy(successful_malloc(1+strlen(string)), string);
125 copied_existing_filename_or_null(char *filename)
127 struct stat filename_stat;
128 if (stat(filename, &filename_stat)) { /* if failure */
131 return copied_string(filename);
135 #ifndef LISP_FEATURE_WIN32
137 copied_realpath(const char *pathname)
142 /* realpath() supposedly can't be counted on to always return
143 * an absolute path, so we prepend the cwd to relative paths */
145 if (pathname[0] != '/') {
146 messy = successful_malloc(PATH_MAX + 1);
147 if (getcwd(messy, PATH_MAX + 1) == NULL) {
152 snprintf(messy + len, PATH_MAX + 1 - len, "/%s", pathname);
155 tidy = successful_malloc(PATH_MAX + 1);
156 if (realpath((messy ? messy : pathname), tidy) == NULL) {
164 #endif /* LISP_FEATURE_WIN32 */
166 /* miscellaneous chattiness */
172 "Usage: sbcl [runtime-options] [toplevel-options] [user-options]\n\
173 Common runtime options:\n\
174 --help Print this message and exit.\n\
175 --version Print version information and exit.\n\
176 --core <filename> Use the specified core file instead of the default.\n\
177 --dynamic-space-size <MiB> Size of reserved dynamic space in megabytes.\n\
178 --control-stack-size <MiB> Size of reserved control stack in megabytes.\n\
180 Common toplevel options:\n\
181 --sysinit <filename> System-wide init-file to use instead of default.\n\
182 --userinit <filename> Per-user init-file to use instead of default.\n\
183 --no-sysinit Inhibit processing of any system-wide init-file.\n\
184 --no-userinit Inhibit processing of any per-user init-file.\n\
185 --disable-debugger Invoke sb-ext:disable-debugger.\n\
186 --noprint Run a Read-Eval Loop without printing results.\n\
187 --script [<filename>] Skip #! line, disable debugger, avoid verbosity.\n\
188 --quit Exit with code 0 after option processing.\n\
189 --non-interactive Sets both --quit and --disable-debugger.\n\
190 Common toplevel options that are processed in order:\n\
191 --eval <form> Form to eval when processing this option.\n\
192 --load <filename> File to load when processing this option.\n\
194 User options are not processed by SBCL. All runtime options must\n\
195 appear before toplevel options, and all toplevel options must\n\
196 appear before user options.\n\
198 For more information please refer to the SBCL User Manual, which\n\
199 should be installed along with SBCL, and is also available from the\n\
200 website <http://www.sbcl.org/>.\n");
206 printf("SBCL %s\n", SBCL_VERSION_STRING);
213 "This is SBCL %s, an implementation of ANSI Common Lisp.\n\
214 More information about SBCL is available at <http://www.sbcl.org/>.\n\
216 SBCL is free software, provided as is, with absolutely no warranty.\n\
217 It is mostly in the public domain; some portions are provided under\n\
218 BSD-style licenses. See the CREDITS and COPYING files in the\n\
219 distribution for more information.\n\
221 #ifdef LISP_FEATURE_WIN32
223 WARNING: the Windows port is fragile, particularly for multithreaded\n\
224 code. Unfortunately, the development team currently lacks the time\n\
225 and resources this platform demands.\n\
228 , SBCL_VERSION_STRING);
231 /* Look for a core file to load, first in the directory named by the
232 * SBCL_HOME environment variable, then in a hardcoded default
233 * location. Returns a malloced copy of the core filename. */
237 char *sbcl_home = getenv("SBCL_HOME");
239 char *stem = "/sbcl.core";
242 if (!(sbcl_home && *sbcl_home)) sbcl_home = SBCL_HOME;
243 lookhere = (char *) calloc(strlen(sbcl_home) +
247 sprintf(lookhere, "%s%s", sbcl_home, stem);
248 core = copied_existing_filename_or_null(lookhere);
251 lose("can't find core file at %s\n", lookhere);
259 /* Try to find the path to an executable from argv[0], this is only
260 * used when os_get_runtime_executable_path() returns NULL */
261 #ifdef LISP_FEATURE_WIN32
263 search_for_executable(const char *argv0)
267 #else /* LISP_FEATURE_WIN32 */
269 search_for_executable(const char *argv0)
271 char *search, *start, *end, *buf;
273 /* If argv[0] contains a slash then it's probably an absolute path
274 * or relative to the current directory, so check if it exists. */
275 if (strchr(argv0, '/') != NULL && access(argv0, F_OK) == 0)
276 return copied_realpath(argv0);
278 /* Bail on an absolute path which doesn't exist */
282 /* Otherwise check if argv[0] exists relative to any directory in PATH */
283 search = getenv("PATH");
286 search = copied_string(search);
287 buf = successful_malloc(PATH_MAX + 1);
288 for (start = search; (end = strchr(start, ':')) != NULL; start = end + 1) {
290 snprintf(buf, PATH_MAX + 1, "%s/%s", start, argv0);
291 if (access(buf, F_OK) == 0) {
293 search = copied_realpath(buf);
298 /* The above for-loop fails to process the last part of PATH if PATH does
299 * not end with ':'. We may consider appending an extra ':' to the end of
300 * SEARCH. -- houjingyi 2013-05-24 */
301 if (start != NULL && *start != '\0') {
302 snprintf(buf, PATH_MAX + 1, "%s/%s", start, argv0);
303 if (access(buf, F_OK) == 0) {
305 search = copied_realpath(buf);
315 #endif /* LISP_FEATURE_WIN32 */
318 parse_size_arg(char *arg, char *arg_name)
320 char *tail, *power_name;
323 res = strtoul(arg, &tail, 0);
326 lose("%s argument is not a number: %s", arg_name, arg);
327 } else if (tail[0]) {
329 power_name = copied_string(tail);
330 size = strlen(power_name);
331 for (i=0; i<size; i++)
332 power_name[i] = toupper(power_name[i]);
338 if ((0==strcmp("KB", power_name)) ||
339 (0==strcmp("KIB", power_name))) {
341 } else if ((0==strcmp("MB", power_name)) ||
342 (0==strcmp("MIB", power_name))) {
344 } else if ((0==strcmp("GB", power_name)) ||
345 (0==strcmp("GIB", power_name))) {
348 lose("%s argument has an unknown suffix: %s", arg_name, tail);
353 (res >= (SIZE_MAX >> power))) {
354 lose("%s argument is out of range: %s", arg_name, arg);
363 struct runtime_options *runtime_options;
365 char *saved_runtime_path = NULL;
366 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
367 void pthreads_win32_init();
370 void print_locale_variable(const char *name)
372 char *value = getenv(name);
375 fprintf(stderr, "\n %s=%s", name, value);
381 if(setlocale(LC_ALL, "") == NULL) {
382 #ifndef LISP_FEATURE_WIN32
384 fprintf(stderr, "WARNING: Setting locale failed.\n");
385 fprintf(stderr, " Check the following variables for correct values:");
387 if (setlocale(LC_CTYPE, "") == NULL) {
388 print_locale_variable("LC_ALL");
389 print_locale_variable("LC_CTYPE");
390 print_locale_variable("LANG");
393 if (setlocale(LC_MESSAGES, "") == NULL) {
394 print_locale_variable("LC_MESSAGES");
396 if (setlocale(LC_COLLATE, "") == NULL) {
397 print_locale_variable("LC_COLLATE");
399 if (setlocale(LC_MONETARY, "") == NULL) {
400 print_locale_variable("LC_MONETARY");
402 if (setlocale(LC_NUMERIC, "") == NULL) {
403 print_locale_variable("LC_NUMERIC");
405 if (setlocale(LC_TIME, "") == NULL) {
406 print_locale_variable("LC_TIME");
408 fprintf(stderr, "\n");
416 main(int argc, char *argv[], char *envp[])
418 #ifdef LISP_FEATURE_WIN32
419 /* Exception handling support structure. Evil Win32 hack. */
420 struct lisp_exception_frame exception_frame;
423 /* the name of the core file we're to execute. Note that this is
424 * a malloc'ed string which should be freed eventually. */
426 char **sbcl_argv = 0;
427 os_vm_offset_t embedded_core_offset = 0;
428 char *runtime_path = 0;
430 /* other command line options */
431 boolean noinform = 0;
432 boolean end_runtime_options = 0;
433 boolean disable_lossage_handler_p = 0;
435 lispobj initial_function;
436 const char *sbcl_home = getenv("SBCL_HOME");
438 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
440 pthreads_win32_init();
444 block_blockable_signals(0, 0);
446 runtime_options = NULL;
448 /* Save the argv[0] derived runtime path in case
449 * os_get_runtime_executable_path(1) isn't able to get an
450 * externally-usable path later on. */
451 saved_runtime_path = search_for_executable(argv[0]);
453 /* Check early to see if this executable has an embedded core,
454 * which also populates runtime_options if the core has runtime
456 runtime_path = os_get_runtime_executable_path(0);
457 if (runtime_path || saved_runtime_path) {
458 os_vm_offset_t offset = search_for_embedded_core(
459 runtime_path ? runtime_path : saved_runtime_path);
461 embedded_core_offset = offset;
462 core = (runtime_path ? runtime_path :
463 copied_string(saved_runtime_path));
471 /* Parse our part of the command line (aka "runtime options"),
472 * stripping out those options that we handle. */
473 if (runtime_options != NULL) {
474 dynamic_space_size = runtime_options->dynamic_space_size;
475 thread_control_stack_size = runtime_options->thread_control_stack_size;
480 runtime_options = successful_malloc(sizeof(struct runtime_options));
482 while (argi < argc) {
483 char *arg = argv[argi];
484 if (0 == strcmp(arg, "--script")) {
485 /* This is both a runtime and a toplevel option. As a
486 * runtime option, it is equivalent to --noinform.
487 * This exits, and does not increment argi, so that
488 * TOPLEVEL-INIT sees the option. */
490 end_runtime_options = 1;
491 disable_lossage_handler_p = 1;
492 lose_on_corruption_p = 1;
494 } else if (0 == strcmp(arg, "--noinform")) {
497 } else if (0 == strcmp(arg, "--core")) {
499 lose("more than one core file specified\n");
503 lose("missing filename for --core argument\n");
505 core = copied_string(argv[argi]);
508 } else if (0 == strcmp(arg, "--help")) {
509 /* I think this is the (or a) usual convention: upon
510 * seeing "--help" we immediately print our help
511 * string and exit, ignoring everything else. */
514 } else if (0 == strcmp(arg, "--version")) {
515 /* As in "--help" case, I think this is expected. */
518 } else if (0 == strcmp(arg, "--dynamic-space-size")) {
521 lose("missing argument for --dynamic-space-size");
522 dynamic_space_size = parse_size_arg(argv[argi++],
523 "--dynamic-space-size");
524 # ifdef MAX_DYNAMIC_SPACE_END
525 if (!((DYNAMIC_SPACE_START <
526 DYNAMIC_SPACE_START+dynamic_space_size) &&
527 (DYNAMIC_SPACE_START+dynamic_space_size <=
528 MAX_DYNAMIC_SPACE_END))) {
530 char* size = argv[argi-1];
531 if (!strchr(size, 'B') && !strchr(size, 'b')) {
534 lose("--dynamic-space-size argument %s%s is too large, max %lu KB",
536 (MAX_DYNAMIC_SPACE_END-DYNAMIC_SPACE_START) / 1024);
539 } else if (0 == strcmp(arg, "--control-stack-size")) {
542 lose("missing argument for --control-stack-size");
544 thread_control_stack_size = parse_size_arg(argv[argi++], "--control-stack-size");
545 } else if (0 == strcmp(arg, "--debug-environment")) {
547 printf("; Commandline arguments:\n");
549 printf("; %2d: \"%s\"\n", n, argv[n]);
553 printf(";\n; Environment:\n");
555 printf("; %2d: \"%s\"\n", n, ENVIRON[n]);
559 } else if (0 == strcmp(arg, "--disable-ldb")) {
560 disable_lossage_handler_p = 1;
562 } else if (0 == strcmp(arg, "--lose-on-corruption")) {
563 lose_on_corruption_p = 1;
565 } else if (0 == strcmp(arg, "--end-runtime-options")) {
566 end_runtime_options = 1;
569 } else if (0 == strcmp(arg, "--merge-core-pages")) {
571 merge_core_pages = 1;
572 } else if (0 == strcmp(arg, "--no-merge-core-pages")) {
574 merge_core_pages = 0;
575 } else if (0 == strcmp(arg, "--default-merge-core-pages")) {
577 merge_core_pages = -1;
579 /* This option was unrecognized as a runtime option,
580 * so it must be a toplevel option or a user option,
581 * so we must be past the end of the runtime option
586 /* This is where we strip out those options that we handle. We
587 * also take this opportunity to make sure that we don't find
588 * an out-of-place "--end-runtime-options" option. */
590 char *argi0 = argv[argi];
592 /* (argc - argi) for the arguments, one for the binary,
593 and one for the terminating NULL. */
594 sbcl_argv = successful_malloc((2 + argc - argi) * sizeof(char *));
595 sbcl_argv[0] = argv[0];
596 while (argi < argc) {
597 char *arg = argv[argi++];
598 /* If we encounter --end-runtime-options for the first
599 * time after the point where we had to give up on
600 * runtime options, then the point where we had to
601 * give up on runtime options must've been a user
603 if (!end_runtime_options &&
604 0 == strcmp(arg, "--end-runtime-options")) {
605 lose("bad runtime option \"%s\"\n", argi0);
607 sbcl_argv[argj++] = arg;
613 /* Align down to multiple of page_table page size, and to the appropriate
614 * stack alignment. */
615 dynamic_space_size &= ~(sword_t)(PAGE_BYTES-1);
616 #ifdef LISP_FEATURE_GENCGC
617 dynamic_space_size &= ~(sword_t)(GENCGC_CARD_BYTES-1);
619 thread_control_stack_size &= ~(sword_t)(CONTROL_STACK_ALIGNMENT_BYTES-1);
621 /* Preserve the runtime options for possible future core saving */
622 runtime_options->dynamic_space_size = dynamic_space_size;
623 runtime_options->thread_control_stack_size = thread_control_stack_size;
625 /* KLUDGE: os_vm_page_size is set by os_init(), and on some
626 * systems (e.g. Alpha) arch_init() needs need os_vm_page_size, so
627 * it must follow os_init(). -- WHN 2000-01-26 */
629 dyndebug_init(); /* after os_init: do not print output before execve */
636 /* If no core file was specified, look for one. */
638 core = search_for_core();
641 /* Make sure that SBCL_HOME is set and not the empty string,
642 unless loading an embedded core. */
643 if (!(sbcl_home && *sbcl_home) && embedded_core_offset == 0) {
644 char *envstring, *copied_core, *dir;
645 char *stem = "SBCL_HOME=";
646 copied_core = copied_string(core);
647 dir = dirname(copied_core);
648 envstring = (char *) calloc(strlen(stem) +
652 sprintf(envstring, "%s%s", stem, dir);
657 if (!noinform && embedded_core_offset == 0) {
662 if (embedded_core_offset == 0) {
663 /* Here we make a last attempt at recognizing an embedded core,
664 * so that a file with an embedded core is a valid argument to
665 * --core. We take care that any decisions on special behaviour
666 * (suppressed banner, embedded options) have already been made
667 * before we reach this block, so that there is no observable
668 * difference between "embedded" and "bare" images given to
670 os_vm_offset_t offset = search_for_embedded_core(core);
672 embedded_core_offset = offset;
675 #if defined(SVR4) || defined(__linux__) || defined(__NetBSD__)
679 define_var("nil", NIL, 1);
680 define_var("t", T, 1);
682 if (!disable_lossage_handler_p)
683 enable_lossage_handler();
687 initial_function = load_core_file(core, embedded_core_offset);
688 if (initial_function == NIL) {
689 lose("couldn't find initial function\n");
691 #ifdef LISP_FEATURE_SB_DYNAMIC_CORE
694 #ifdef LISP_FEATURE_HPUX
695 /* -1 = CLOSURE_FUN_OFFSET, 23 = SIMPLE_FUN_CODE_OFFSET, we are
696 * not in LANGUAGE_ASSEMBLY so we cant reach them. */
697 return_from_lisp_stub = (void *) ((char *)*((unsigned long *)
698 ((char *)initial_function + -1)) + 23);
701 gc_initialize_pointers();
703 arch_install_interrupt_handlers();
704 #ifndef LISP_FEATURE_WIN32
705 os_install_interrupt_handlers();
707 /* wos_install_interrupt_handlers(handler); */
708 wos_install_interrupt_handlers(&exception_frame);
711 /* Pass core filename and the processed argv into Lisp. They'll
712 * need to be processed further there, to do locale conversion.
715 posix_argv = sbcl_argv;
717 FSHOW((stderr, "/funcalling initial_function=0x%lx\n",
718 (unsigned long)initial_function));
719 create_initial_thread(initial_function);
720 lose("unexpected return from initial thread in main()\n");