X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Falloc.c;h=415eca7317b009b7de552833df61b106ea1fd457;hp=b53f506328aa630f3d7bb1d6dbc67fde0a04240a;hb=33c8db8e2477d62fd8734f65475f2ed516167532;hpb=7049bf113e6f1c9f87b67a82b41a2778a25961e2

diff --git a/src/alloc.c b/src/alloc.c
index b53f506..415eca7 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -635,85 +635,83 @@ gc_record_type_p (Lisp_Object frob, CONST struct lrecord_implementation *type)
 /************************************************************************/
 /*			  Debugger support				*/
 /************************************************************************/
-/* Give gdb/dbx enough information to decode Lisp Objects.
-   We make sure certain symbols are defined, so gdb doesn't complain
-   about expressions in src/gdbinit.  Values are randomly chosen.
-   See src/gdbinit or src/dbxrc to see how this is used.  */
+/* Give gdb/dbx enough information to decode Lisp Objects.  We make
+   sure certain symbols are always defined, so gdb doesn't complain
+   about expressions in src/gdbinit.  See src/gdbinit or src/dbxrc to
+   see how this is used.  */
 
-enum dbg_constants
-{
 #ifdef USE_MINIMAL_TAGBITS
-  dbg_valmask = (EMACS_INT) (((1UL << VALBITS) - 1) << GCBITS),
-  dbg_typemask = (EMACS_INT) ((1UL << GCTYPEBITS) - 1),
-  dbg_USE_MINIMAL_TAGBITS = 1,
-  dbg_Lisp_Type_Int = 100,
-#else /* ! USE_MIMIMAL_TAGBITS */
-  dbg_valmask = (EMACS_INT) ((1UL << VALBITS) - 1),
-  dbg_typemask = (EMACS_INT) (((1UL << GCTYPEBITS) - 1) << (VALBITS + GCMARKBITS)),
-  dbg_USE_MINIMAL_TAGBITS = 0,
-  dbg_Lisp_Type_Int = Lisp_Type_Int,
-#endif /* ! USE_MIMIMAL_TAGBITS */
+EMACS_UINT dbg_valmask = ((1UL << VALBITS) - 1) << GCBITS;
+EMACS_UINT dbg_typemask = (1UL << GCTYPEBITS) - 1;
+unsigned char dbg_USE_MINIMAL_TAGBITS = 1;
+unsigned char Lisp_Type_Int = 100;
+#else
+EMACS_UINT dbg_valmask = (1UL << VALBITS) - 1;
+EMACS_UINT dbg_typemask = ((1UL << GCTYPEBITS) - 1) << (VALBITS + GCMARKBITS);
+unsigned char dbg_USE_MINIMAL_TAGBITS = 0;
+#endif
 
 #ifdef USE_UNION_TYPE
-  dbg_USE_UNION_TYPE = 1,
+unsigned char dbg_USE_UNION_TYPE = 1;
 #else
-  dbg_USE_UNION_TYPE = 0,
+unsigned char dbg_USE_UNION_TYPE = 0;
 #endif
 
 #ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
-  dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 1,
+unsigned char dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 1;
 #else
-  dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 0,
+unsigned char dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 0;
 #endif
 
-  dbg_Lisp_Type_Char = Lisp_Type_Char,
-  dbg_Lisp_Type_Record = Lisp_Type_Record,
 #ifdef LRECORD_CONS
-  dbg_Lisp_Type_Cons = 101,
+unsigned char Lisp_Type_Cons = 101;
 #else
-  dbg_Lisp_Type_Cons = Lisp_Type_Cons,
-  lrecord_cons = 201,
+unsigned char lrecord_cons;
 #endif
+
 #ifdef LRECORD_STRING
-  dbg_Lisp_Type_String = 102,
+unsigned char Lisp_Type_String = 102;
 #else
-  dbg_Lisp_Type_String = Lisp_Type_String,
-  lrecord_string = 202,
+unsigned char lrecord_string;
 #endif
+
 #ifdef LRECORD_VECTOR
-  dbg_Lisp_Type_Vector = 103,
+unsigned char Lisp_Type_Vector = 103;
 #else
-  dbg_Lisp_Type_Vector = Lisp_Type_Vector,
-  lrecord_vector = 203,
+unsigned char lrecord_vector;
 #endif
+
 #ifdef LRECORD_SYMBOL
-  dbg_Lisp_Type_Symbol = 104,
+unsigned char Lisp_Type_Symbol = 104;
 #else
-  dbg_Lisp_Type_Symbol = Lisp_Type_Symbol,
-  lrecord_symbol = 204,
+unsigned char lrecord_symbol;
 #endif
+
 #ifndef MULE
-  lrecord_char_table_entry = 205,
-  lrecord_charset          = 206,
-  lrecord_coding_system    = 207,
+unsigned char lrecord_char_table_entry;
+unsigned char lrecord_charset;
+#ifndef FILE_CODING
+unsigned char lrecord_coding_system;
 #endif
+#endif
+
 #ifndef HAVE_TOOLBARS
-  lrecord_toolbar_button   = 208,
+unsigned char lrecord_toolbar_button;
 #endif
-#ifndef HAVE_TOOLTALK
-  lrecord_tooltalk_message = 210,
-  lrecord_tooltalk_pattern = 211,
+
+#ifndef TOOLTALK
+unsigned char lrecord_tooltalk_message;
+unsigned char lrecord_tooltalk_pattern;
 #endif
+
 #ifndef HAVE_DATABASE
-  lrecord_database = 212,
+unsigned char lrecord_database;
 #endif
-  dbg_valbits = VALBITS,
-  dbg_gctypebits = GCTYPEBITS
-  /* If we don't have an actual object of this enum, pgcc (and perhaps
-     other compilers) might optimize away the entire type declaration :-( */
-} dbg_dummy;
 
-/* A few macros turned into functions for ease of debugging.
+unsigned char dbg_valbits = VALBITS;
+unsigned char dbg_gctypebits = GCTYPEBITS;
+
+/* Macros turned into functions for ease of debugging.
    Debuggers don't know about macros! */
 int dbg_eq (Lisp_Object obj1, Lisp_Object obj2);
 int
@@ -4248,6 +4246,10 @@ disksave_object_finalization (void)
   Vexec_path = Qnil;
   Vload_path = Qnil;
   /* Vdump_load_path = Qnil; */
+  /* Release hash tables for locate_file */
+  Fset (intern ("early-package-load-path"), Qnil);
+  Fset (intern ("late-package-load-path"),  Qnil);
+  Fset (intern ("last-package-load-path"),  Qnil);
   uncache_home_directory();
 
 #if defined(LOADHIST) && !(defined(LOADHIST_DUMPED) || \
@@ -4308,7 +4310,6 @@ garbage_collect_1 (void)
   char stack_top_variable;
   extern char *stack_bottom;
 #endif
-  int i;
   struct frame *f;
   int speccount;
   int cursor_changed;
@@ -4425,38 +4426,45 @@ garbage_collect_1 (void)
   cleanup_specifiers ();
 
   /* Mark all the special slots that serve as the roots of accessibility. */
-  {
-    struct gcpro *tail;
-    struct catchtag *catch;
-    struct backtrace *backlist;
-    struct specbinding *bind;
 
+  { /* staticpro() */
+    int i;
     for (i = 0; i < staticidx; i++)
-      {
-        mark_object (*(staticvec[i]));
-      }
+      mark_object (*(staticvec[i]));
+  }
 
+  { /* GCPRO() */
+    struct gcpro *tail;
+    int i;
     for (tail = gcprolist; tail; tail = tail->next)
-      {
-	for (i = 0; i < tail->nvars; i++)
-	  mark_object (tail->var[i]);
-      }
+      for (i = 0; i < tail->nvars; i++)
+	mark_object (tail->var[i]);
+  }
 
+  { /* specbind() */
+    struct specbinding *bind;
     for (bind = specpdl; bind != specpdl_ptr; bind++)
       {
 	mark_object (bind->symbol);
 	mark_object (bind->old_value);
       }
+  }
 
+  {
+    struct catchtag *catch;
     for (catch = catchlist; catch; catch = catch->next)
       {
 	mark_object (catch->tag);
 	mark_object (catch->val);
       }
+  }
 
+  {
+    struct backtrace *backlist;
     for (backlist = backtrace_list; backlist; backlist = backlist->next)
       {
 	int nargs = backlist->nargs;
+	int i;
 
 	mark_object (*backlist->function);
 	if (nargs == UNEVALLED || nargs == MANY)
@@ -4465,11 +4473,11 @@ garbage_collect_1 (void)
 	  for (i = 0; i < nargs; i++)
 	    mark_object (backlist->args[i]);
       }
-
-    mark_redisplay (mark_object);
-    mark_profiling_info (mark_object);
   }
 
+  mark_redisplay (mark_object);
+  mark_profiling_info (mark_object);
+
   /* OK, now do the after-mark stuff.  This is for things that
      are only marked when something else is marked (e.g. weak hash tables).
      There may be complex dependencies between such objects -- e.g.