X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fruntime.c;h=72fc56a9f90fd62d61ad3d49525e8f717f8b6f2e;hb=c3699db2053ff3b5ac6a98d4431c3789496002d8;hp=efefc8e11abf05a733a9f0f55317d9a776fa9ca9;hpb=81cfdf526490d642c73602ebac9bcacb8af644e1;p=sbcl.git diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c index efefc8e..72fc56a 100644 --- a/src/runtime/runtime.c +++ b/src/runtime/runtime.c @@ -13,18 +13,29 @@ * files for more information. */ +#include "sbcl.h" + #include +#include +#include #include +#include #include #include #include #include #include +#include +#include +#include + +#if defined(SVR4) || defined(__linux__) +#include +#endif #include "signal.h" #include "runtime.h" -#include "sbcl.h" #include "alloc.h" #include "vars.h" #include "globals.h" @@ -35,17 +46,24 @@ #include "interr.h" #include "monitor.h" #include "validate.h" -#if defined GENCGC -#include "gencgc.h" -#endif #include "core.h" #include "save.h" #include "lispregs.h" +#include "thread.h" + +#include "genesis/static-symbols.h" +#include "genesis/symbol.h" + #ifdef irix #include #include "interr.h" #endif + +#ifndef SBCL_HOME +#define SBCL_HOME "/usr/local/lib/sbcl/" +#endif + /* SIGINT handler that invokes the monitor (for when Lisp isn't up to it) */ static void @@ -99,18 +117,68 @@ copied_existing_filename_or_null(char *filename) } /* Convert a null-terminated array of null-terminated strings (e.g. - * argv or envp) into a Lisp list of Lisp strings. */ + * argv or envp) into a Lisp list of Lisp base-strings. */ static lispobj -alloc_string_list(char *array_ptr[]) +alloc_base_string_list(char *array_ptr[]) { if (*array_ptr) { - return alloc_cons(alloc_string(*array_ptr), - alloc_string_list(1 + array_ptr)); + return alloc_cons(alloc_base_string(*array_ptr), + alloc_base_string_list(1 + array_ptr)); } else { return NIL; } } +/* miscellaneous chattiness */ + +void +print_help() +{ + puts( +"SBCL is a Common Lisp programming environment. Ordinarily you shouldn't\n\ +need command line options when you invoke it interactively: you can just\n\ +start it and work with the customary Lisp READ-EVAL-PRINT loop.\n\ +\n\ +One option idiom which is sometimes useful interactively (e.g. when\n\ +exercising a test case for a bug report) is\n\ + sbcl --sysinit /dev/null --userinit /dev/null\n\ +to keep SBCL from reading any initialization files at startup. And some\n\ +people like to suppress the default startup message:\n\ + sbcl --noinform\n\ +\n\ +Other options can be useful when you're running SBCL noninteractively,\n\ +e.g. from a script, or if you have a strange system configuration, so\n\ +that SBCL can't by default find one of the files it needs. For\n\ +information on such options, see the sbcl(1) man page.\n\ +\n\ +More information on SBCL can be found on its man page, or at\n\ +.\n"); +} + +void +print_version() +{ + printf("SBCL %s\n", SBCL_VERSION_STRING); +} + +void +print_banner() +{ + printf( +"This is SBCL %s, an implementation of ANSI Common Lisp.\n\ +\n\ +More information about SBCL is available at .\ +\n\ +SBCL is free software, provided as is, with absolutely no warranty.\n\ +It is mostly in the public domain; some portions are provided under\n\ +BSD-style licenses. See the CREDITS and COPYING files in the\n\ +distribution for more information.\n\ +", SBCL_VERSION_STRING); +} + +FILE *stdlog; + + int main(int argc, char *argv[], char *envp[]) { @@ -146,12 +214,22 @@ main(int argc, char *argv[], char *envp[]) lose("more than one core file specified"); } else { ++argi; - core = copied_string(argv[argi]); if (argi >= argc) { lose("missing filename for --core argument"); } + 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, "--end-runtime-options")) { end_runtime_options = 1; ++argi; @@ -191,51 +269,41 @@ main(int argc, char *argv[], char *envp[]) /* If no core file was specified, look for one. */ if (!core) { char *sbcl_home = getenv("SBCL_HOME"); - if (sbcl_home) { - char *lookhere; - lookhere = (char *) calloc(strlen("/sbcl.core") + strlen(sbcl_home) + 1, - sizeof(char)); - sprintf(lookhere, "%s/sbcl.core", sbcl_home); - core = copied_existing_filename_or_null(lookhere); - free(lookhere); - } else { - core = copied_existing_filename_or_null("/usr/lib/sbcl.core"); - if (!core) { - core = copied_existing_filename_or_null("/usr/local/lib/sbcl.core"); - } - } + char *lookhere; + char *stem = "/sbcl.core"; + if(!sbcl_home) sbcl_home = SBCL_HOME; + lookhere = (char *) calloc(strlen(sbcl_home) + + strlen(stem) + + 1, + sizeof(char)); + sprintf(lookhere, "%s%s", sbcl_home, stem); + core = copied_existing_filename_or_null(lookhere); + free(lookhere); if (!core) { lose("can't find core file"); } } - + /* Make sure that SBCL_HOME is set, no matter where the core was + * found */ + if (!getenv("SBCL_HOME")) { + char *envstring, *copied_core, *dir; + char *stem = "SBCL_HOME="; + copied_core = copied_string(core); + dir = dirname(copied_core); + envstring = (char *) calloc(strlen(stem) + + strlen(dir) + + 1, + sizeof(char)); + sprintf(envstring, "%s%s", stem, dir); + putenv(envstring); + free(copied_core); + } + if (!noinform) { - printf( -"This is SBCL " SBCL_VERSION_STRING ", an implementation of ANSI Common Lisp. - -SBCL is derived from the CMU CL system created at Carnegie Mellon University. -Besides software and documentation originally created at Carnegie Mellon -University, SBCL contains some software originally from the Massachusetts -Institute of Technology, Symbolics Incorporated, and Xerox Corporation, and -material contributed by volunteers since the release of CMU CL into the -public domain. See the CREDITS file in the distribution for more information. - -SBCL is a free software system, provided as is, with absolutely no warranty. -It is mostly in the public domain, but also includes some software copyrighted - Massachusetts Institute of Technology, 1986; - Symbolics, Inc., 1989, 1990, 1991, 1992; and - Xerox Corporation, 1985, 1986, 1987, 1988, 1989, 1990 -used under BSD-style licenses allowing copying only under certain conditions. -See the COPYING file in the distribution for more information. - -More information on SBCL is available at . -"); + print_banner(); fflush(stdout); } -#ifdef MACH - mach_init(); -#endif #if defined(SVR4) || defined(__linux__) tzset(); #endif @@ -245,11 +313,6 @@ More information on SBCL is available at . set_lossage_handler(monitor_or_something); -#if 0 - os_init(); - gc_init(); - validate(); -#endif globals_init(); initial_function = load_core_file(core); @@ -259,43 +322,66 @@ More information on SBCL is available at . SHOW("freeing core"); free(core); -#if defined GENCGC - gencgc_pickup_dynamic(); -#else -#endif - -#ifdef BINDING_STACK_POINTER - SetSymbolValue(BINDING_STACK_POINTER, BINDING_STACK_START); -#endif -#if defined INTERNAL_GC_TRIGGER && !defined __i386__ - SetSymbolValue(INTERNAL_GC_TRIGGER, make_fixnum(-1)); -#endif + gc_initialize_pointers(); interrupt_init(); - arch_install_interrupt_handlers(); os_install_interrupt_handlers(); -#ifdef PSEUDO_ATOMIC_ATOMIC - /* Turn on pseudo atomic for when we call into Lisp. */ - SHOW("turning on pseudo atomic"); - SetSymbolValue(PSEUDO_ATOMIC_ATOMIC, make_fixnum(1)); - SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, make_fixnum(0)); -#endif - /* Convert remaining argv values to something that Lisp can grok. */ SHOW("setting POSIX-ARGV symbol value"); - SetSymbolValue(POSIX_ARGV, alloc_string_list(argv)); + SetSymbolValue(POSIX_ARGV, alloc_base_string_list(argv),0); /* Install a handler to pick off SIGINT until the Lisp system gets * far enough along to install its own handler. */ sigint_init(); FSHOW((stderr, "/funcalling initial_function=0x%lx\n", initial_function)); - funcall0(initial_function); + create_thread(initial_function); + /* in a unithread build, create_thread never returns */ +#ifdef LISP_FEATURE_SB_THREAD + parent_loop(); +#endif +} + +#ifdef LISP_FEATURE_SB_THREAD - /* initial_function() is not supposed to return. */ - lose("Lisp initial_function gave up control."); - return 0; /* dummy value: return something */ +/* this is being pared down as time goes on; eventually we want to get + * to the point that we have no parent loop at all and the parent + * thread runs Lisp just like any other */ + +static void /* noreturn */ parent_loop(void) +{ + struct sigaction sa; + sigset_t sigset; + int status; + pid_t pid=0; + + sigemptyset(&sigset); + sa.sa_handler=SIG_IGN; + sa.sa_mask=sigset; + sa.sa_flags=0; + sigaction(SIGINT, &sa, 0); /* ^c should go to the lisp thread instead */ + sigaction(SIG_THREAD_EXIT, &sa, 0); + sigaction(SIGCHLD, &sa, 0); + + while(!all_threads) { + sched_yield(); + } + while(all_threads && (pid=waitpid(-1,&status,__WALL))) { + struct thread *th; + if(pid==-1) { + if(errno == EINTR) continue; + fprintf(stderr,"waitpid: %s\n",strerror(errno)); + } + else if(WIFEXITED(status) || WIFSIGNALED(status)) { + th=find_thread_by_pid(pid); + if(!th) continue; + destroy_thread(th); + if(!all_threads) break; + } + } + exit(WEXITSTATUS(status)); } +#endif