libguile/init.c

   1 /* Copyright (C) 1995,1996,1997,1998,1999, 2000 Free Software Foundation, Inc.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2, or (at your option)
   6  * any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this software; see the file COPYING.  If not, write to
  15  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  16  * Boston, MA 02111-1307 USA
  17  *
  18  * As a special exception, the Free Software Foundation gives permission
  19  * for additional uses of the text contained in its release of GUILE.
  20  *
  21  * The exception is that, if you link the GUILE library with other files
  22  * to produce an executable, this does not by itself cause the
  23  * resulting executable to be covered by the GNU General Public License.
  24  * Your use of that executable is in no way restricted on account of
  25  * linking the GUILE library code into it.
  26  *
  27  * This exception does not however invalidate any other reasons why
  28  * the executable file might be covered by the GNU General Public License.
  29  *
  30  * This exception applies only to the code released by the
  31  * Free Software Foundation under the name GUILE.  If you copy
  32  * code from other Free Software Foundation releases into a copy of
  33  * GUILE, as the General Public License permits, the exception does
  34  * not apply to the code that you add in this way.  To avoid misleading
  35  * anyone as to the status of such modified files, you must delete
  36  * this exception notice from them.
  37  *
  38  * If you write modifications of your own for GUILE, it is your choice
  39  * whether to permit this exception to apply to your modifications.
  40  * If you do not wish that, delete this exception notice.  */
  41
  42 /* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
  43    gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
  44
  45 \f
  46 /* Include the headers for just about everything.
  47    We call all their initialization functions.  */
  48
  49 #include <stdio.h>
  50 #include <sys/stat.h>
  51 #include <fcntl.h>
  52
  53 #include "libguile/_scm.h"
  54
  55 /* Everybody has an init function.  */
  56 #include "libguile/alist.h"
  57 #include "libguile/arbiters.h"
  58 #include "libguile/async.h"
  59 #include "libguile/backtrace.h"
  60 #include "libguile/boolean.h"
  61 #include "libguile/chars.h"
  62 #include "libguile/continuations.h"
  63 #ifdef DEBUG_EXTENSIONS
  64 #include "libguile/debug.h"
  65 #endif
  66 #ifdef GUILE_DEBUG_MALLOC
  67 #include "libguile/debug-malloc.h"
  68 #endif
  69 #include "libguile/dynl.h"
  70 #include "libguile/dynwind.h"
  71 #include "libguile/environments.h"
  72 #include "libguile/eq.h"
  73 #include "libguile/error.h"
  74 #include "libguile/eval.h"
  75 #include "libguile/evalext.h"
  76 #include "libguile/feature.h"
  77 #include "libguile/filesys.h"
  78 #include "libguile/fluids.h"
  79 #include "libguile/fports.h"
  80 #include "libguile/gc.h"
  81 #include "libguile/gdbint.h"
  82 #include "libguile/goops.h"
  83 #include "libguile/gsubr.h"
  84 #include "libguile/hash.h"
  85 #include "libguile/hashtab.h"
  86 #include "libguile/hooks.h"
  87 #ifdef GUILE_ISELECT
  88 #include "libguile/iselect.h"
  89 #endif
  90 #include "libguile/ioext.h"
  91 #include "libguile/keywords.h"
  92 #include "libguile/lang.h"
  93 #include "libguile/list.h"
  94 #include "libguile/load.h"
  95 #include "libguile/macros.h"
  96 #include "libguile/mallocs.h"
  97 #include "libguile/modules.h"
  98 #include "libguile/net_db.h"
  99 #include "libguile/numbers.h"
 100 #include "libguile/objects.h"
 101 #include "libguile/objprop.h"
 102 #include "libguile/options.h"
 103 #include "libguile/pairs.h"
 104 #include "libguile/ports.h"
 105 #include "libguile/posix.h"
 106 #ifdef HAVE_REGCOMP
 107 #include "libguile/regex-posix.h"
 108 #endif
 109 #include "libguile/print.h"
 110 #include "libguile/procprop.h"
 111 #include "libguile/procs.h"
 112 #include "libguile/properties.h"
 113 #include "libguile/ramap.h"
 114 #include "libguile/random.h"
 115 #include "libguile/read.h"
 116 #include "libguile/scmsigs.h"
 117 #include "libguile/script.h"
 118 #include "libguile/simpos.h"
 119 #include "libguile/smob.h"
 120 #include "libguile/socket.h"
 121 #include "libguile/sort.h"
 122 #include "libguile/srcprop.h"
 123 #include "libguile/stackchk.h"
 124 #include "libguile/stacks.h"
 125 #include "libguile/stime.h"
 126 #include "libguile/strings.h"
 127 #include "libguile/strop.h"
 128 #include "libguile/strorder.h"
 129 #include "libguile/strports.h"
 130 #include "libguile/struct.h"
 131 #include "libguile/symbols.h"
 132 #include "libguile/tag.h"
 133 #include "libguile/throw.h"
 134 #include "libguile/unif.h"
 135 #include "libguile/values.h"
 136 #include "libguile/variable.h"
 137 #include "libguile/vectors.h"
 138 #include "libguile/version.h"
 139 #include "libguile/vports.h"
 140 #include "libguile/weaks.h"
 141 #include "libguile/guardians.h"
 142
 143 #include "libguile/init.h"
 144
 145 #ifdef HAVE_STRING_H
 146 #include <string.h>
 147 #endif
 148 #ifdef HAVE_UNISTD_H
 149 #include <unistd.h>
 150 #endif
 151 \f
 152 /* Setting up the stack.  */
 153
 154 static void
 155 restart_stack (void *base)
 156 {
 157   scm_dynwinds = SCM_EOL;
 158   SCM_DYNENV (scm_rootcont) = SCM_EOL;
 159   SCM_THROW_VALUE (scm_rootcont) = SCM_EOL;
 160 #ifdef DEBUG_EXTENSIONS
 161   SCM_DFRAME (scm_rootcont) = scm_last_debug_frame = 0;
 162 #endif
 163   SCM_BASE (scm_rootcont) = base;
 164   scm_continuation_stack_ptr = SCM_MAKINUM (0);
 165 }
 166
 167 static void
 168 start_stack (void *base)
 169 {
 170   SCM root;
 171
 172   root = scm_permanent_object (scm_make_root (SCM_UNDEFINED));
 173   scm_set_root (SCM_ROOT_STATE (root));
 174   scm_stack_base = base;
 175
 176   scm_exitval = SCM_BOOL_F;     /* vestigial */
 177
 178 #if SCM_DEBUG_DEPRECATED == 0
 179   scm_top_level_lookup_closure_var = SCM_BOOL_F;
 180 #endif
 181   scm_system_transformer = SCM_BOOL_F;
 182
 183   scm_root->fluids = scm_make_initial_fluids ();
 184
 185   /* Create an object to hold the root continuation.
 186    */
 187   {
 188     scm_contregs *contregs = scm_must_malloc (sizeof (scm_contregs),
 189                                               "continuation");
 190     contregs->num_stack_items = 0;
 191     contregs->seq = 0;
 192     SCM_NEWSMOB (scm_rootcont, scm_tc16_continuation, contregs);
 193   }
 194   /* The root continuation is further initialized by restart_stack. */
 195
 196   /* Create the look-aside stack for variables that are shared between
 197    * captured continuations.
 198    */
 199   scm_continuation_stack = scm_make_vector (SCM_MAKINUM (512), SCM_UNDEFINED);
 200   /* The continuation stack is further initialized by restart_stack. */
 201
 202   /* The remainder of stack initialization is factored out to another
 203    * function so that if this stack is ever exitted, it can be
 204    * re-entered using restart_stack.  */
 205   restart_stack (base);
 206 }
 207
 208
 209 #if 0
 210 static char remsg[] = "remove\n#define ", addmsg[] = "add\n#define ";
 211
 212
 213 static void
 214 fixconfig (char *s1,char *s2,int s)
 215 {
 216   fputs (s1, stderr);
 217   fputs (s2, stderr);
 218   fputs ("\nin ", stderr);
 219   fputs (s ? "setjump" : "scmfig", stderr);
 220   fputs (".h and recompile scm\n", stderr);
 221   exit (1);
 222 }
 223
 224
 225 static void
 226 check_config (void)
 227 {
 228   scm_sizet j;
 229
 230   j = HEAP_SEG_SIZE;
 231   if (HEAP_SEG_SIZE != j)
 232     fixconfig ("reduce", "size of HEAP_SEG_SIZE", 0);
 233
 234 #ifdef SCM_BIGDIG
 235   if (2 * SCM_BITSPERDIG / SCM_CHAR_BIT > sizeof (long))
 236       fixconfig (remsg, "SCM_BIGDIG", 0);
 237 #ifndef SCM_DIGSTOOBIG
 238   if (SCM_DIGSPERLONG * sizeof (SCM_BIGDIG) > sizeof (long))
 239       fixconfig (addmsg, "SCM_DIGSTOOBIG", 0);
 240 #endif
 241 #endif
 242
 243 #ifdef SCM_STACK_GROWS_UP
 244   if (((SCM_STACKITEM *) & j - stack_start_ptr) < 0)
 245     fixconfig (remsg, "SCM_STACK_GROWS_UP", 1);
 246 #else
 247   if ((stack_start_ptr - (SCM_STACKITEM *) & j) < 0)
 248     fixconfig (addmsg, "SCM_STACK_GROWS_UP", 1);
 249 #endif
 250 }
 251 #endif
 252
 253
 254 \f
 255 /* initializing standard and current I/O ports */
 256
 257 typedef struct
 258 {
 259   int fdes;
 260   char *mode;
 261   char *name;
 262 } stream_body_data;
 263
 264 /* proc to be called in scope of exception handler stream_handler. */
 265 static SCM
 266 stream_body (void *data)
 267 {
 268   stream_body_data *body_data = (stream_body_data *) data;
 269   SCM port = scm_fdes_to_port (body_data->fdes, body_data->mode,
 270                                scm_makfrom0str (body_data->name));
 271
 272   SCM_REVEALED (port) = 1;
 273   return port;
 274 }
 275
 276 /* exception handler for stream_body.  */
 277 static SCM
 278 stream_handler (void *data, SCM tag, SCM throw_args)
 279 {
 280   return SCM_BOOL_F;
 281 }
 282
 283 /* Convert a file descriptor to a port, using scm_fdes_to_port.
 284    - NAME is a C string, not a Guile string
 285    - set the revealed count for FILE's file descriptor to 1, so
 286    that fdes won't be closed when the port object is GC'd.
 287    - catch exceptions: allow Guile to be able to start up even
 288    if it has been handed bogus stdin/stdout/stderr.  replace the
 289    bad ports with void ports.  */
 290 static SCM
 291 scm_standard_stream_to_port (int fdes, char *mode, char *name)
 292 {
 293   SCM port;
 294   stream_body_data body_data;
 295
 296   body_data.fdes = fdes;
 297   body_data.mode = mode;
 298   body_data.name = name;
 299   port = scm_internal_catch (SCM_BOOL_T, stream_body, &body_data,
 300                              stream_handler, NULL);
 301   if (SCM_FALSEP (port))
 302     port = scm_void_port (mode);
 303   return port;
 304 }
 305
 306 /* Create standard ports from stdin, stdout, and stderr.  */
 307 static void
 308 scm_init_standard_ports ()
 309 {
 310   /* From the SCSH manual:
 311
 312      It can be useful to turn I/O buffering off in some cases, for
 313      example when an I/O stream is to be shared by multiple
 314      subprocesses.  For this reason, scsh allocates an unbuffered port
 315      for file descriptor 0 at start-up time.
 316
 317      Because shells frequently share stdin with subprocesses, if the
 318      shell does buffered reads, it might ``steal'' input intended for
 319      a subprocess.  For this reason, all shells, including sh, csh,
 320      and scsh, read stdin unbuffered.  Applications that can tolerate
 321      buffered input on stdin can reset \ex{(current-input-port)} to
 322      block buffering for higher performance.  */
 323
 324   scm_def_inp
 325     = scm_standard_stream_to_port (0,
 326                                    isatty (0) ? "r0" : "r",
 327                                    "standard input");
 328   scm_def_outp = scm_standard_stream_to_port (1,
 329                                               isatty (1) ? "w0" : "w",
 330                                               "standard output");
 331   scm_def_errp = scm_standard_stream_to_port (2,
 332                                               isatty (2) ? "w0" : "w",
 333                                               "standard error");
 334
 335   scm_cur_inp = scm_def_inp;
 336   scm_cur_outp = scm_def_outp;
 337   scm_cur_errp = scm_def_errp;
 338   scm_cur_loadp = SCM_BOOL_F;
 339 }
 340
 341
 342 \f
 343 /* Loading the startup Scheme files.  */
 344
 345 /* The boot code "ice-9/boot-9" is only loaded by scm_boot_guile when
 346    this is false.  The unexec code uses this, to keep ice_9 from being
 347    loaded into dumped guile executables.  */
 348 int scm_ice_9_already_loaded = 0;
 349
 350 void
 351 scm_load_startup_files ()
 352 {
 353   /* We want a path only containing directories from GUILE_LOAD_PATH,
 354      SCM_SITE_DIR and SCM_LIBRARY_DIR when searching for the site init
 355      file, so we do this before loading Ice-9.  */
 356   SCM init_path = scm_sys_search_load_path (scm_makfrom0str ("init.scm"));
 357
 358   /* Load Ice-9.  */
 359   if (!scm_ice_9_already_loaded)
 360     {
 361       scm_primitive_load_path (scm_makfrom0str ("ice-9/boot-9.scm"));
 362
 363       /* Load the init.scm file.  */
 364       if (SCM_NFALSEP (init_path))
 365         scm_primitive_load (init_path);
 366
 367       scm_post_boot_init_modules ();
 368     }
 369 }
 370
 371 \f
 372 /* The main init code.  */
 373
 374 #ifdef _UNICOS
 375 typedef int setjmp_type;
 376 #else
 377 typedef long setjmp_type;
 378 #endif
 379
 380 /* All the data needed to invoke the main function.  */
 381 struct main_func_closure
 382 {
 383   /* the function to call */
 384   void (*main_func)(void *closure, int argc, char **argv);
 385   void *closure;                /* dummy data to pass it */
 386   int argc;
 387   char **argv;                  /* the argument list it should receive */
 388 };
 389
 390
 391 static void scm_init_guile_1 (SCM_STACKITEM *base);
 392 static void scm_boot_guile_1 (SCM_STACKITEM *base,
 393                               struct main_func_closure *closure);
 394 static SCM invoke_main_func(void *body_data);
 395
 396
 397 /* Fire up the Guile Scheme interpreter.
 398
 399    Call MAIN_FUNC, passing it CLOSURE, ARGC, and ARGV.  MAIN_FUNC
 400    should do all the work of the program (initializing other packages,
 401    reading user input, etc.) before returning.  When MAIN_FUNC
 402    returns, call exit (0); this function never returns.  If you want
 403    some other exit value, MAIN_FUNC may call exit itself.
 404
 405    scm_boot_guile arranges for program-arguments to return the strings
 406    given by ARGC and ARGV.  If MAIN_FUNC modifies ARGC/ARGV, should
 407    call scm_set_program_arguments with the final list, so Scheme code
 408    will know which arguments have been processed.
 409
 410    scm_boot_guile establishes a catch-all catch handler which prints
 411    an error message and exits the process.  This means that Guile
 412    exits in a coherent way when system errors occur and the user isn't
 413    prepared to handle it.  If the user doesn't like this behavior,
 414    they can establish their own universal catcher to shadow this one.
 415
 416    Why must the caller do all the real work from MAIN_FUNC?  The
 417    garbage collector assumes that all local variables of type SCM will
 418    be above scm_boot_guile's stack frame on the stack.  If you try to
 419    manipulate SCM values after this function returns, it's the luck of
 420    the draw whether the GC will be able to find the objects you
 421    allocate.  So, scm_boot_guile function exits, rather than
 422    returning, to discourage people from making that mistake.  */
 423
 424
 425 void
 426 scm_boot_guile (int argc, char ** argv, void (*main_func) (), void *closure)
 427 {
 428   /* The garbage collector uses the address of this variable as one
 429      end of the stack, and the address of one of its own local
 430      variables as the other end.  */
 431   SCM_STACKITEM dummy;
 432   struct main_func_closure c;
 433
 434   c.main_func = main_func;
 435   c.closure = closure;
 436   c.argc = argc;
 437   c.argv = argv;
 438
 439   scm_boot_guile_1 (&dummy, &c);
 440 }
 441
 442 void
 443 scm_init_guile ()
 444 {
 445   scm_init_guile_1 ((SCM_STACKITEM *)scm_get_stack_base ());
 446 }
 447
 448 int scm_initialized_p = 0;
 449
 450 static void
 451 scm_init_guile_1 (SCM_STACKITEM *base)
 452 {
 453   if (scm_initialized_p)
 454     return;
 455
 456   if (base == NULL)
 457     {
 458       fprintf (stderr, "cannot determine stack base!\n");
 459       abort ();
 460     }
 461
 462   scm_ints_disabled = 1;
 463   scm_block_gc = 1;
 464
 465   scm_ports_prehistory ();
 466   scm_smob_prehistory ();
 467   scm_tables_prehistory ();
 468 #ifdef GUILE_DEBUG_MALLOC
 469   scm_debug_malloc_prehistory ();
 470 #endif
 471   scm_init_storage ();
 472   scm_struct_prehistory ();     /* Must come after scm_init_storage */
 473   scm_weaks_prehistory ();      /* Must come after scm_init_storage */
 474   scm_init_subr_table ();
 475   scm_environments_prehistory (); /* create the root environment */
 476   scm_init_continuations ();
 477   scm_init_root ();             /* requires continuations */
 478 #ifdef USE_THREADS
 479   scm_init_threads (base);
 480 #endif
 481   start_stack (base);
 482   scm_init_gsubr ();
 483   scm_init_procprop ();
 484   scm_init_environments ();
 485   scm_init_feature ();
 486   scm_init_alist ();
 487   scm_init_arbiters ();
 488   scm_init_async ();
 489   scm_init_boolean ();
 490   scm_init_chars ();
 491 #ifdef GUILE_DEBUG_MALLOC
 492   scm_init_debug_malloc ();
 493 #endif
 494   scm_init_dynwind ();
 495   scm_init_eq ();
 496   scm_init_error ();
 497   scm_init_fluids ();
 498   scm_init_backtrace ();        /* Requires fluids */
 499   scm_init_fports ();
 500   scm_init_gdbint ();
 501   scm_init_hash ();
 502   scm_init_hashtab ();
 503   scm_init_objprop ();
 504   scm_init_properties ();
 505   scm_init_hooks ();        /* Requires objprop until hook names are removed */
 506   scm_init_gc ();               /* Requires hooks, async */
 507 #ifdef GUILE_ISELECT
 508   scm_init_iselect ();
 509 #endif
 510   scm_init_ioext ();
 511   scm_init_keywords ();
 512   scm_init_list ();
 513   scm_init_macros ();
 514   scm_init_mallocs ();
 515   scm_init_modules ();
 516   scm_init_numbers ();
 517   scm_init_options ();
 518   scm_init_pairs ();
 519   scm_init_ports ();
 520 #ifdef HAVE_POSIX
 521   scm_init_filesys ();
 522   scm_init_posix ();
 523 #endif
 524 #ifdef HAVE_REGCOMP
 525   scm_init_regex_posix ();
 526 #endif
 527   scm_init_procs ();
 528   scm_init_scmsigs ();
 529 #ifdef HAVE_NETWORKING
 530   scm_init_net_db ();
 531   scm_init_socket ();
 532 #endif
 533   scm_init_sort ();
 534 #ifdef DEBUG_EXTENSIONS
 535   scm_init_srcprop ();
 536 #endif
 537   scm_init_stackchk ();
 538   scm_init_struct ();
 539   scm_init_stacks ();   /* Requires struct */
 540   scm_init_strports ();
 541   scm_init_symbols ();
 542   scm_init_tag ();
 543   scm_init_values ();   /* Requires struct */
 544   scm_init_load ();
 545   scm_init_objects ();  /* Requires struct */
 546   scm_init_print ();    /* Requires struct */
 547   scm_init_read ();
 548   scm_init_stime ();
 549   scm_init_strings ();
 550   scm_init_strorder ();
 551   scm_init_strop ();
 552   scm_init_throw ();
 553   scm_init_variable ();
 554   scm_init_vectors ();
 555   scm_init_version ();
 556   scm_init_weaks ();
 557   scm_init_guardian ();
 558   scm_init_vports ();
 559   scm_init_eval ();
 560   scm_init_evalext ();
 561 #ifdef DEBUG_EXTENSIONS
 562   scm_init_debug ();    /* Requires macro smobs */
 563 #endif
 564   scm_init_random ();
 565 #ifdef HAVE_ARRAYS
 566   scm_init_ramap ();
 567   scm_init_unif ();
 568 #endif
 569   scm_init_simpos ();
 570   scm_init_load_path ();
 571   scm_init_standard_ports ();
 572   scm_init_dynamic_linking ();
 573   scm_init_lang ();
 574   scm_init_script ();
 575
 576   scm_init_oop_goops_goopscore_module ();
 577
 578   scm_initialized_p = 1;
 579
 580   scm_block_gc = 0;             /* permit the gc to run */
 581   /* ints still disabled */
 582
 583 #ifdef STACK_CHECKING
 584   scm_stack_checking_enabled_p = SCM_STACK_CHECKING_P;
 585 #endif
 586
 587   scm_load_startup_files ();
 588 }
 589
 590 /* Record here whether SCM_BOOT_GUILE_1 has already been called.  This
 591    variable is now here and not inside SCM_BOOT_GUILE_1 so that one
 592    can tweak it. This is necessary for unexec to work. (Hey, "1-live"
 593    is the name of a local radiostation...) */
 594
 595 int scm_boot_guile_1_live = 0;
 596
 597 static void
 598 scm_boot_guile_1 (SCM_STACKITEM *base, struct main_func_closure *closure)
 599 {
 600   scm_init_guile_1 (base);
 601
 602   /* This function is not re-entrant. */
 603   if (scm_boot_guile_1_live)
 604     abort ();
 605
 606   scm_boot_guile_1_live = 1;
 607
 608   scm_set_program_arguments (closure->argc, closure->argv, 0);
 609   invoke_main_func (closure);
 610
 611   scm_restore_signals ();
 612
 613   /* This tick gives any pending
 614    * asyncs a chance to run.  This must be done after
 615    * the call to scm_restore_signals.
 616    */
 617   SCM_ASYNC_TICK;
 618
 619   /* If the caller doesn't want this, they should return from
 620      main_func themselves.  */
 621   exit (0);
 622 }
 623
 624 static SCM
 625 invoke_main_func (void *body_data)
 626 {
 627   struct main_func_closure *closure = (struct main_func_closure *) body_data;
 628
 629   (*closure->main_func) (closure->closure, closure->argc, closure->argv);
 630
 631   /* never reached */
 632   return SCM_UNDEFINED;
 633 }
 634
 635 /*
 636   Local Variables:
 637   c-file-style: "gnu"
 638   End:
 639 */