Added lcrecord lists for 19.14.
slb: Lots of work on the purification and dump time code.
Synched Doug Lea malloc support from Emacs 20.2.
+ og: Killed the purespace. Portable dumper (moved to dumper.c)
*/
#include <config.h>
#include "extents.h"
#include "frame.h"
#include "glyphs.h"
+#include "opaque.h"
#include "redisplay.h"
#include "specifier.h"
#include "sysfile.h"
+#include "sysdep.h"
#include "window.h"
+#include "console-stream.h"
#ifdef DOUG_LEA_MALLOC
#include <malloc.h>
#endif
-EXFUN (Fgarbage_collect, 0);
+#ifdef PDUMP
+#include "dumper.h"
+#endif
-/* #define GDB_SUCKS */
+EXFUN (Fgarbage_collect, 0);
#if 0 /* this is _way_ too slow to be part of the standard debug options */
#if defined(DEBUG_XEMACS) && defined(MULE)
#endif
#endif
-/* Define this to see where all that space is going... */
-/* But the length of the printout is obnoxious, so limit it to testers */
-/* If somebody wants to see this they can ask for it.
-#ifdef DEBUG_XEMACS
-#define PURESTAT
-#endif
-*/
-
/* Define this to use malloc/free with no freelist for all datatypes,
the hope being that some debugging tools may help detect
freed memory references */
#define ALLOC_NO_POOLS
#endif
-#include "puresize.h"
-
#ifdef DEBUG_XEMACS
-int debug_allocation;
-
-int debug_allocation_backtrace_length;
+static Fixnum debug_allocation;
+static Fixnum debug_allocation_backtrace_length;
#endif
/* Number of bytes of consing done since the last gc */
EMACS_INT consing_since_gc;
-#ifdef EMACS_BTL
-extern void cadillac_record_backtrace ();
-#define INCREMENT_CONS_COUNTER_1(size) \
- do { \
- EMACS_INT __sz__ = ((EMACS_INT) (size)); \
- consing_since_gc += __sz__; \
- cadillac_record_backtrace (2, __sz__); \
- } while (0)
-#else
#define INCREMENT_CONS_COUNTER_1(size) (consing_since_gc += (size))
-#endif /* EMACS_BTL */
#define debug_allocation_backtrace() \
do { \
INCREMENT_CONS_COUNTER_1 (size)
#endif
-#define DECREMENT_CONS_COUNTER(size) \
- do { \
- EMACS_INT __sz__ = ((EMACS_INT) (size)); \
- if (consing_since_gc >= __sz__) \
- consing_since_gc -= __sz__; \
- else \
- consing_since_gc = 0; \
- } while (0)
+#define DECREMENT_CONS_COUNTER(size) do { \
+ consing_since_gc -= (size); \
+ if (consing_since_gc < 0) \
+ consing_since_gc = 0; \
+} while (0)
/* Number of bytes of consing since gc before another gc should be done. */
EMACS_INT gc_cons_threshold;
/* "Garbage collecting" */
Lisp_Object Vgc_message;
Lisp_Object Vgc_pointer_glyph;
-static CONST char gc_default_message[] = "Garbage collecting";
+static const char gc_default_message[] = "Garbage collecting";
Lisp_Object Qgarbage_collecting;
-#ifndef VIRT_ADDR_VARIES
-extern
-#endif /* VIRT_ADDR_VARIES */
- EMACS_INT malloc_sbrk_used;
-
-#ifndef VIRT_ADDR_VARIES
-extern
-#endif /* VIRT_ADDR_VARIES */
- EMACS_INT malloc_sbrk_unused;
-
-/* Non-zero means defun should do purecopy on the function definition */
+/* Non-zero means we're in the process of doing the dump */
int purify_flag;
-#ifdef HEAP_IN_DATA
-extern void sheap_adjust_h();
-#endif
-
-#define PUREBEG ((char *) pure)
-
-#if 0 /* This is breathing_space in XEmacs */
-/* Points to memory space allocated as "spare",
- to be freed if we run out of memory. */
-static char *spare_memory;
-
-/* Amount of spare memory to keep in reserve. */
-#define SPARE_MEMORY (1 << 14)
-#endif
-
-/* Index in pure at which next pure object will be allocated. */
-static size_t pure_bytes_used;
-
-#define PURIFIED(ptr) \
-((char *) (ptr) >= PUREBEG && \
- (char *) (ptr) < PUREBEG + get_PURESIZE())
-
-/* Non-zero if pure_bytes_used > get_PURESIZE(); accounts for excess purespace needs. */
-static size_t pure_lossage;
-
#ifdef ERROR_CHECK_TYPECHECK
Error_behavior ERROR_ME, ERROR_ME_NOT, ERROR_ME_WARN;
#endif
int
-purified (Lisp_Object obj)
-{
- return POINTER_TYPE_P (XGCTYPE (obj)) && PURIFIED (XPNTR (obj));
-}
-
-size_t
-purespace_usage (void)
-{
- return pure_bytes_used;
-}
-
-static int
-check_purespace (size_t size)
+c_readonly (Lisp_Object obj)
{
- if (pure_lossage)
- {
- pure_lossage += size;
- return 0;
- }
- else if (pure_bytes_used + size > get_PURESIZE())
- {
- /* This can cause recursive bad behavior, we'll yell at the end */
- /* when we're done. */
- /* message ("\nERROR: Pure Lisp storage exhausted!\n"); */
- pure_lossage = size;
- return 0;
- }
- else
- return 1;
-}
-
-
-\f
-#ifndef PURESTAT
-
-#define bump_purestat(p,b) DO_NOTHING
-
-#else /* PURESTAT */
-
-static int purecopying_for_bytecode;
-
-static size_t pure_sizeof (Lisp_Object /*, int recurse */);
-
-/* Keep statistics on how much of what is in purespace */
-static struct purestat
-{
- int nobjects;
- int nbytes;
- CONST char *name;
+ return POINTER_TYPE_P (XTYPE (obj)) && C_READONLY (obj);
}
- purestat_cons = {0, 0, "cons cells"},
- purestat_float = {0, 0, "float objects"},
- purestat_string_pname = {0, 0, "symbol-name strings"},
- purestat_bytecode = {0, 0, "compiled-function objects"},
- purestat_string_bytecodes = {0, 0, "byte-code strings"},
- purestat_vector_bytecode_constants = {0, 0, "byte-constant vectors"},
- purestat_string_interactive = {0, 0, "interactive strings"},
-#ifdef I18N3
- purestat_string_domain = {0, 0, "domain strings"},
-#endif
- purestat_string_documentation = {0, 0, "documentation strings"},
- purestat_string_other_function = {0, 0, "other function strings"},
- purestat_vector_other = {0, 0, "other vectors"},
- purestat_string_other = {0, 0, "other strings"},
- purestat_string_all = {0, 0, "all strings"},
- purestat_vector_all = {0, 0, "all vectors"};
-
-static struct purestat *purestats[] =
-{
- &purestat_cons,
- &purestat_float,
- &purestat_string_pname,
- &purestat_bytecode,
- &purestat_string_bytecodes,
- &purestat_vector_bytecode_constants,
- &purestat_string_interactive,
-#ifdef I18N3
- &purestat_string_domain,
-#endif
- &purestat_string_documentation,
- &purestat_string_other_function,
- &purestat_vector_other,
- &purestat_string_other,
- 0,
- &purestat_string_all,
- &purestat_vector_all
-};
-static void
-bump_purestat (struct purestat *purestat, size_t nbytes)
+int
+lisp_readonly (Lisp_Object obj)
{
- if (pure_lossage) return;
- purestat->nobjects += 1;
- purestat->nbytes += nbytes;
+ return POINTER_TYPE_P (XTYPE (obj)) && LISP_READONLY (obj);
}
-#endif /* PURESTAT */
\f
/* Maximum amount of C stack to save when a GC happens. */
#ifndef MAX_SAVE_STACK
-#define MAX_SAVE_STACK 16000
+#define MAX_SAVE_STACK 0 /* 16000 */
#endif
/* Non-zero means ignore malloc warnings. Set during initialization. */
/* malloc calls this if it finds we are near exhausting storage */
void
-malloc_warning (CONST char *str)
+malloc_warning (const char *str)
{
if (ignore_malloc_warnings)
return;
/* like malloc and realloc but check for no memory left, and block input. */
-#ifdef xmalloc
#undef xmalloc
-#endif
-
void *
xmalloc (size_t size)
{
- void *val = (void *) malloc (size);
+ void *val = malloc (size);
if (!val && (size != 0)) memory_full ();
return val;
}
+#undef xcalloc
+static void *
+xcalloc (size_t nelem, size_t elsize)
+{
+ void *val = calloc (nelem, elsize);
+
+ if (!val && (nelem != 0)) memory_full ();
+ return val;
+}
+
void *
xmalloc_and_zero (size_t size)
{
- void *val = xmalloc (size);
- memset (val, 0, size);
- return val;
+ return xcalloc (size, sizeof (char));
}
-#ifdef xrealloc
#undef xrealloc
-#endif
-
void *
xrealloc (void *block, size_t size)
{
/* We must call malloc explicitly when BLOCK is 0, since some
reallocs don't do this. */
- void *val = (void *) (block ? realloc (block, size) : malloc (size));
+ void *val = block ? realloc (block, size) : malloc (size);
if (!val && (size != 0)) memory_full ();
return val;
#endif /* !ERROR_CHECK_GC */
-#ifdef xstrdup
#undef xstrdup
-#endif
-
char *
-xstrdup (CONST char *str)
+xstrdup (const char *str)
{
int len = strlen (str) + 1; /* for stupid terminating 0 */
void *val = xmalloc (len);
if (val == 0) return 0;
- memcpy (val, str, len);
- return (char *) val;
+ return (char *) memcpy (val, str, len);
}
#ifdef NEED_STRDUP
char *
-strdup (CONST char *s)
+strdup (const char *s)
{
return xstrdup (s);
}
static void *
allocate_lisp_storage (size_t size)
{
- void *p = xmalloc (size);
-#ifndef USE_MINIMAL_TAGBITS
- char *lim = ((char *) p) + size;
- Lisp_Object val;
-
- XSETOBJ (val, Lisp_Type_Record, lim);
- if ((char *) XPNTR (val) != lim)
- {
- xfree (p);
- memory_full ();
- }
-#endif /* ! USE_MINIMAL_TAGBITS */
- return p;
+ return xmalloc (size);
}
-/* lrecords are chained together through their "next.v" field.
- * After doing the mark phase, the GC will walk this linked
- * list and free any record which hasn't been marked.
- */
+/* lcrecords are chained together through their "next" field.
+ After doing the mark phase, GC will walk this linked list
+ and free any lcrecord which hasn't been marked. */
static struct lcrecord_header *all_lcrecords;
void *
-alloc_lcrecord (size_t size, CONST struct lrecord_implementation *implementation)
+alloc_lcrecord (size_t size, const struct lrecord_implementation *implementation)
{
struct lcrecord_header *lcheader;
- if (size <= 0) abort ();
- if (implementation->static_size == 0)
- {
- if (!implementation->size_in_bytes_method)
- abort ();
- }
- else if (implementation->static_size != size)
- abort ();
+ type_checking_assert
+ ((implementation->static_size == 0 ?
+ implementation->size_in_bytes_method != NULL :
+ implementation->static_size == size)
+ &&
+ (! implementation->basic_p)
+ &&
+ (! (implementation->hash == NULL && implementation->equal != NULL)));
lcheader = (struct lcrecord_header *) allocate_lisp_storage (size);
- set_lheader_implementation(&(lcheader->lheader), implementation);
+ set_lheader_implementation (&lcheader->lheader, implementation);
lcheader->next = all_lcrecords;
#if 1 /* mly prefers to see small ID numbers */
lcheader->uid = lrecord_uid_counter++;
}
}
if (lrecord->implementation->finalizer)
- ((lrecord->implementation->finalizer) (lrecord, 0));
+ lrecord->implementation->finalizer (lrecord, 0);
xfree (lrecord);
return;
}
for (header = all_lcrecords; header; header = header->next)
{
- if (LHEADER_IMPLEMENTATION(&header->lheader)->finalizer &&
+ if (LHEADER_IMPLEMENTATION (&header->lheader)->finalizer &&
!header->free)
- ((LHEADER_IMPLEMENTATION(&header->lheader)->finalizer)
- (header, 1));
+ LHEADER_IMPLEMENTATION (&header->lheader)->finalizer (header, 1);
}
}
+\f
+/************************************************************************/
+/* Debugger support */
+/************************************************************************/
+/* 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. */
-/* This must not be called -- it just serves as for EQ test
- * If lheader->implementation->finalizer is this_marks_a_marked_record,
- * then lrecord has been marked by the GC sweeper
- * header->implementation is put back to its correct value by
- * sweep_records */
-void
-this_marks_a_marked_record (void *dummy0, int dummy1)
-{
- abort ();
-}
+EMACS_UINT dbg_valmask = ((1UL << VALBITS) - 1) << GCBITS;
+EMACS_UINT dbg_typemask = (1UL << GCTYPEBITS) - 1;
-/* Semi-kludge -- lrecord_symbol_value_forward objects get stuck
- in CONST space and you get SEGV's if you attempt to mark them.
- This sits in lheader->implementation->marker. */
+#ifdef USE_UNION_TYPE
+unsigned char dbg_USE_UNION_TYPE = 1;
+#else
+unsigned char dbg_USE_UNION_TYPE = 0;
+#endif
-Lisp_Object
-this_one_is_unmarkable (Lisp_Object obj, void (*markobj) (Lisp_Object))
+unsigned char dbg_valbits = VALBITS;
+unsigned char dbg_gctypebits = GCTYPEBITS;
+
+/* On some systems, the above definitions will be optimized away by
+ the compiler or linker unless they are referenced in some function. */
+long dbg_inhibit_dbg_symbol_deletion (void);
+long
+dbg_inhibit_dbg_symbol_deletion (void)
{
- abort ();
- return Qnil;
+ return
+ (dbg_valmask +
+ dbg_typemask +
+ dbg_USE_UNION_TYPE +
+ dbg_valbits +
+ dbg_gctypebits);
}
-/* XGCTYPE for records */
+/* Macros turned into functions for ease of debugging.
+ Debuggers don't know about macros! */
+int dbg_eq (Lisp_Object obj1, Lisp_Object obj2);
int
-gc_record_type_p (Lisp_Object frob, CONST struct lrecord_implementation *type)
+dbg_eq (Lisp_Object obj1, Lisp_Object obj2)
{
- CONST struct lrecord_implementation *imp;
-
- if (XGCTYPE (frob) != Lisp_Type_Record)
- return 0;
-
- imp = XRECORD_LHEADER_IMPLEMENTATION (frob);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- return imp == type;
-#else
- return imp == type || imp == type + 1;
-#endif
+ return EQ (obj1, obj2);
}
\f
-/**********************************************************************/
-/* 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. */
-
-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 */
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- dbg_USE_INDEXED_LRECORD_IMPLEMENTATION = 1,
-#else
- 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,
-#else
- dbg_Lisp_Type_Cons = Lisp_Type_Cons,
- lrecord_cons = 201,
-#endif
-#ifdef LRECORD_STRING
- dbg_Lisp_Type_String = 102,
-#else
- dbg_Lisp_Type_String = Lisp_Type_String,
- lrecord_string = 202,
-#endif
-#ifdef LRECORD_VECTOR
- dbg_Lisp_Type_Vector = 103,
-#else
- dbg_Lisp_Type_Vector = Lisp_Type_Vector,
- lrecord_vector = 203,
-#endif
-#ifdef LRECORD_SYMBOL
- dbg_Lisp_Type_Symbol = 104,
-#else
- dbg_Lisp_Type_Symbol = Lisp_Type_Symbol,
- lrecord_symbol = 204,
-#endif
-#ifndef MULE
- lrecord_char_table_entry = 205,
- lrecord_charset = 206,
- lrecord_coding_system = 207,
-#endif
-#ifndef HAVE_TOOLBARS
- lrecord_toolbar_button = 208,
-#endif
-#ifndef HAVE_TOOLTALK
- lrecord_tooltalk_message = 210,
- lrecord_tooltalk_pattern = 211,
-#endif
-#ifndef HAVE_DATABASE
- lrecord_database = 212,
-#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;
-
-\f
-/**********************************************************************/
-/* Fixed-size type macros */
-/**********************************************************************/
+/************************************************************************/
+/* Fixed-size type macros */
+/************************************************************************/
/* For fixed-size types that are commonly used, we malloc() large blocks
of memory at a time and subdivide them into chunks of the correct
pointer to the actual string data, which is stored in structures of
type struct string_chars_block. Each string_chars_block consists
of a pointer to a struct Lisp_String, followed by the data for that
- string, followed by another pointer to a struct Lisp_String,
- followed by the data for that string, etc. At GC time, the data in
- these blocks is compacted by searching sequentially through all the
+ string, followed by another pointer to a Lisp_String, followed by
+ the data for that string, etc. At GC time, the data in these
+ blocks is compacted by searching sequentially through all the
blocks and compressing out any holes created by unmarked strings.
Strings that are more than a certain size (bigger than the size of
a string_chars_block, although something like half as big might
currently executing functions; the gcpro list; etc.) and
recursively marking all objects that are accessible.
- At the beginning of the sweep stage, the conses in the cons
- blocks are in one of three states: in use and marked, in use
- but not marked, and not in use (already freed). Any conses
- that are marked have been marked in the mark stage just
- executed, because as part of the sweep stage we unmark any
- marked objects. The way we tell whether or not a cons cell
- is in use is through the FREE_STRUCT_P macro. This basically
- looks at the first 4 bytes (or however many bytes a pointer
- fits in) to see if all the bits in those bytes are 1. The
- resulting value (0xFFFFFFFF) is not a valid pointer and is
- not a valid Lisp_Object. All current fixed-size types have
- a pointer or Lisp_Object as their first element with the
- exception of strings; they have a size value, which can
- never be less than zero, and so 0xFFFFFFFF is invalid for
- strings as well. Now assuming that a cons cell is in use,
- the way we tell whether or not it is marked is to look at
- the mark bit of its car (each Lisp_Object has one bit
- reserved as a mark bit, in case it's needed). Note that
- different types of objects use different fields to indicate
- whether the object is marked, but the principle is the same.
-
- Conses on the free_cons_list are threaded through a pointer
- stored in the bytes directly after the bytes that are set
- to 0xFFFFFFFF (we cannot overwrite these because the cons
- is still in a cons_block and needs to remain marked as
- not in use for the next time that GC happens). This
- implies that all fixed-size types must be at least big
- enough to store two pointers, which is indeed the case
- for all current fixed-size types.
+ At the beginning of the sweep stage, the conses in the cons blocks
+ are in one of three states: in use and marked, in use but not
+ marked, and not in use (already freed). Any conses that are marked
+ have been marked in the mark stage just executed, because as part
+ of the sweep stage we unmark any marked objects. The way we tell
+ whether or not a cons cell is in use is through the LRECORD_FREE_P
+ macro. This uses a special lrecord type `lrecord_type_free',
+ which is never associated with any valid object.
+
+ Conses on the free_cons_list are threaded through a pointer stored
+ in the conses themselves. Because the cons is still in a
+ cons_block and needs to remain marked as not in use for the next
+ time that GC happens, we need room to store both the "free"
+ indicator and the chaining pointer. So this pointer is stored
+ after the lrecord header (actually where C places a pointer after
+ the lrecord header; they are not necessarily contiguous). This
+ implies that all fixed-size types must be big enough to contain at
+ least one pointer. This is true for all current fixed-size types,
+ with the possible exception of Lisp_Floats, for which we define the
+ meat of the struct using a union of a pointer and a double to
+ ensure adequate space for the free list chain pointer.
Some types of objects need additional "finalization" done
when an object is converted from in use to not in use;
WARNING: Things are in an extremely bizarre state when
the ADDITIONAL_FREE_type macros are called, so beware!
- When ERROR_CHECK_GC is defined, we do things differently
- so as to maximize our chances of catching places where
- there is insufficient GCPROing. The thing we want to
- avoid is having an object that we're using but didn't
- GCPRO get freed by GC and then reallocated while we're
- in the process of using it -- this will result in something
- seemingly unrelated getting trashed, and is extremely
- difficult to track down. If the object gets freed but
- not reallocated, we can usually catch this because we
- set all bytes of a freed object to 0xDEADBEEF. (The
- first four bytes, however, are 0xFFFFFFFF, and the next
- four are a pointer used to chain freed objects together;
- we play some tricks with this pointer to make it more
+ When ERROR_CHECK_GC is defined, we do things differently so as to
+ maximize our chances of catching places where there is insufficient
+ GCPROing. The thing we want to avoid is having an object that
+ we're using but didn't GCPRO get freed by GC and then reallocated
+ while we're in the process of using it -- this will result in
+ something seemingly unrelated getting trashed, and is extremely
+ difficult to track down. If the object gets freed but not
+ reallocated, we can usually catch this because we set most of the
+ bytes of a freed object to 0xDEADBEEF. (The lisp object type is set
+ to the invalid type `lrecord_type_free', however, and a pointer
+ used to chain freed objects together is stored after the lrecord
+ header; we play some tricks with this pointer to make it more
bogus, so crashes are more likely to occur right away.)
We want freed objects to stay free as long as possible,
varies depending on type) of them already on the list.
This way, we ensure that an object that gets freed will
remain free for the next 1000 (or whatever) times that
- an object of that type is allocated.
-*/
+ an object of that type is allocated. */
#ifndef MALLOC_OVERHEAD
#ifdef GNU_MALLOC
This is called when a relocatable block is freed in ralloc.c. */
void refill_memory_reserve (void);
void
-refill_memory_reserve ()
+refill_memory_reserve (void)
{
if (breathing_space == 0)
breathing_space = (char *) malloc (4096 - MALLOC_OVERHEAD);
/ sizeof (structtype))
#endif /* ALLOC_NO_POOLS */
-#define DECLARE_FIXED_TYPE_ALLOC(type, structtype) \
- \
-struct type##_block \
-{ \
- struct type##_block *prev; \
- structtype block[TYPE_ALLOC_SIZE (type, structtype)]; \
-}; \
- \
-static struct type##_block *current_##type##_block; \
-static int current_##type##_block_index; \
- \
-static structtype *type##_free_list; \
-static structtype *type##_free_list_tail; \
- \
-static void \
-init_##type##_alloc (void) \
-{ \
- current_##type##_block = 0; \
- current_##type##_block_index = countof (current_##type##_block->block); \
- type##_free_list = 0; \
- type##_free_list_tail = 0; \
-} \
- \
-static int gc_count_num_##type##_in_use, gc_count_num_##type##_freelist
-
-#define ALLOCATE_FIXED_TYPE_FROM_BLOCK(type, result) \
- do { \
- if (current_##type##_block_index \
- == countof (current_##type##_block->block)) \
+#define DECLARE_FIXED_TYPE_ALLOC(type, structtype) \
+ \
+struct type##_block \
+{ \
+ struct type##_block *prev; \
+ structtype block[TYPE_ALLOC_SIZE (type, structtype)]; \
+}; \
+ \
+static struct type##_block *current_##type##_block; \
+static int current_##type##_block_index; \
+ \
+static Lisp_Free *type##_free_list; \
+static Lisp_Free *type##_free_list_tail; \
+ \
+static void \
+init_##type##_alloc (void) \
+{ \
+ current_##type##_block = 0; \
+ current_##type##_block_index = \
+ countof (current_##type##_block->block); \
+ type##_free_list = 0; \
+ type##_free_list_tail = 0; \
+} \
+ \
+static int gc_count_num_##type##_in_use; \
+static int gc_count_num_##type##_freelist
+
+#define ALLOCATE_FIXED_TYPE_FROM_BLOCK(type, result) do { \
+ if (current_##type##_block_index \
+ == countof (current_##type##_block->block)) \
{ \
- struct type##_block *__new__ = (struct type##_block *) \
- allocate_lisp_storage (sizeof (struct type##_block)); \
- __new__->prev = current_##type##_block; \
- current_##type##_block = __new__; \
+ struct type##_block *AFTFB_new = (struct type##_block *) \
+ allocate_lisp_storage (sizeof (struct type##_block)); \
+ AFTFB_new->prev = current_##type##_block; \
+ current_##type##_block = AFTFB_new; \
current_##type##_block_index = 0; \
} \
- (result) = \
- &(current_##type##_block->block[current_##type##_block_index++]); \
- } while (0)
+ (result) = \
+ &(current_##type##_block->block[current_##type##_block_index++]); \
+} while (0)
/* Allocate an instance of a type that is stored in blocks.
TYPE is the "name" of the type, STRUCTTYPE is the corresponding
cell was not GC-protected and was getting collected before
free_cons() was called. */
-#define ALLOCATE_FIXED_TYPE_1(type, structtype, result) \
-do \
-{ \
- if (gc_count_num_##type##_freelist > \
- MINIMUM_ALLOWED_FIXED_TYPE_CELLS_##type) \
- { \
- result = type##_free_list; \
- /* Before actually using the chain pointer, we complement all its \
- bits; see FREE_FIXED_TYPE(). */ \
- type##_free_list = \
- (structtype *) ~(unsigned long) \
- (* (structtype **) ((char *) result + sizeof (void *))); \
- gc_count_num_##type##_freelist--; \
- } \
- else \
- ALLOCATE_FIXED_TYPE_FROM_BLOCK (type, result); \
- MARK_STRUCT_AS_NOT_FREE (result); \
+#define ALLOCATE_FIXED_TYPE_1(type, structtype, result) do { \
+ if (gc_count_num_##type##_freelist > \
+ MINIMUM_ALLOWED_FIXED_TYPE_CELLS_##type) \
+ { \
+ result = (structtype *) type##_free_list; \
+ /* Before actually using the chain pointer, \
+ we complement all its bits; see FREE_FIXED_TYPE(). */ \
+ type##_free_list = (Lisp_Free *) \
+ (~ (EMACS_UINT) (type##_free_list->chain)); \
+ gc_count_num_##type##_freelist--; \
+ } \
+ else \
+ ALLOCATE_FIXED_TYPE_FROM_BLOCK (type, result); \
+ MARK_LRECORD_AS_NOT_FREE (result); \
} while (0)
#else /* !ERROR_CHECK_GC */
-#define ALLOCATE_FIXED_TYPE_1(type, structtype, result) \
-do \
-{ \
+#define ALLOCATE_FIXED_TYPE_1(type, structtype, result) do { \
if (type##_free_list) \
{ \
- result = type##_free_list; \
- type##_free_list = \
- * (structtype **) ((char *) result + sizeof (void *)); \
+ result = (structtype *) type##_free_list; \
+ type##_free_list = type##_free_list->chain; \
} \
else \
ALLOCATE_FIXED_TYPE_FROM_BLOCK (type, result); \
- MARK_STRUCT_AS_NOT_FREE (result); \
+ MARK_LRECORD_AS_NOT_FREE (result); \
} while (0)
#endif /* !ERROR_CHECK_GC */
+
#define ALLOCATE_FIXED_TYPE(type, structtype, result) \
do \
{ \
NOSEEUM_INCREMENT_CONS_COUNTER (sizeof (structtype), #type); \
} while (0)
-/* INVALID_POINTER_VALUE should be a value that is invalid as a pointer
- to a Lisp object and invalid as an actual Lisp_Object value. We have
- to make sure that this value cannot be an integer in Lisp_Object form.
- 0xFFFFFFFF could be so on a 64-bit system, so we extend it to 64 bits.
- On a 32-bit system, the type bits will be non-zero, making the value
- be a pointer, and the pointer will be misaligned.
-
- Even if Emacs is run on some weirdo system that allows and allocates
- byte-aligned pointers, this pointer is at the very top of the address
- space and so it's almost inconceivable that it could ever be valid. */
-
-#if INTBITS == 32
-# define INVALID_POINTER_VALUE 0xFFFFFFFF
-#elif INTBITS == 48
-# define INVALID_POINTER_VALUE 0xFFFFFFFFFFFF
-#elif INTBITS == 64
-# define INVALID_POINTER_VALUE 0xFFFFFFFFFFFFFFFF
+
+/* Lisp_Free is the type to represent a free list member inside a frob
+ block of any lisp object type. */
+typedef struct Lisp_Free
+{
+ struct lrecord_header lheader;
+ struct Lisp_Free *chain;
+} Lisp_Free;
+
+#define LRECORD_FREE_P(ptr) \
+((ptr)->lheader.type == lrecord_type_free)
+
+#define MARK_LRECORD_AS_FREE(ptr) \
+((void) ((ptr)->lheader.type = lrecord_type_free))
+
+#ifdef ERROR_CHECK_GC
+#define MARK_LRECORD_AS_NOT_FREE(ptr) \
+((void) ((ptr)->lheader.type = lrecord_type_undefined))
#else
-You have some weird system and need to supply a reasonable value here.
+#define MARK_LRECORD_AS_NOT_FREE(ptr) DO_NOTHING
#endif
-#define FREE_STRUCT_P(ptr) \
- (* (void **) ptr == (void *) INVALID_POINTER_VALUE)
-#define MARK_STRUCT_AS_FREE(ptr) \
- (* (void **) ptr = (void *) INVALID_POINTER_VALUE)
-#define MARK_STRUCT_AS_NOT_FREE(ptr) \
- (* (void **) ptr = 0)
-
#ifdef ERROR_CHECK_GC
-#define PUT_FIXED_TYPE_ON_FREE_LIST(type, structtype, ptr) \
-do { if (type##_free_list_tail) \
- { \
- /* When we store the chain pointer, we complement all \
- its bits; this should significantly increase its \
- bogosity in case someone tries to use the value, and \
- should make us dump faster if someone stores something \
- over the pointer because when it gets un-complemented in \
- ALLOCATED_FIXED_TYPE(), the resulting pointer will be \
- extremely bogus. */ \
- * (structtype **) \
- ((char *) type##_free_list_tail + sizeof (void *)) = \
- (structtype *) ~(unsigned long) ptr; \
- } \
- else \
- type##_free_list = ptr; \
- type##_free_list_tail = ptr; \
- } while (0)
+#define PUT_FIXED_TYPE_ON_FREE_LIST(type, structtype, ptr) do { \
+ if (type##_free_list_tail) \
+ { \
+ /* When we store the chain pointer, we complement all \
+ its bits; this should significantly increase its \
+ bogosity in case someone tries to use the value, and \
+ should make us crash faster if someone overwrites the \
+ pointer because when it gets un-complemented in \
+ ALLOCATED_FIXED_TYPE(), the resulting pointer will be \
+ extremely bogus. */ \
+ type##_free_list_tail->chain = \
+ (Lisp_Free *) ~ (EMACS_UINT) (ptr); \
+ } \
+ else \
+ type##_free_list = (Lisp_Free *) (ptr); \
+ type##_free_list_tail = (Lisp_Free *) (ptr); \
+} while (0)
#else /* !ERROR_CHECK_GC */
-#define PUT_FIXED_TYPE_ON_FREE_LIST(type, structtype, ptr) \
-do { * (structtype **) ((char *) ptr + sizeof (void *)) = \
- type##_free_list; \
- type##_free_list = ptr; \
- } while (0)
+#define PUT_FIXED_TYPE_ON_FREE_LIST(type, structtype, ptr) do { \
+ ((Lisp_Free *) (ptr))->chain = type##_free_list; \
+ type##_free_list = (Lisp_Free *) (ptr); \
+} while (0) \
#endif /* !ERROR_CHECK_GC */
/* TYPE and STRUCTTYPE are the same as in ALLOCATE_FIXED_TYPE(). */
-#define FREE_FIXED_TYPE(type, structtype, ptr) \
-do { structtype *_weird_ = (ptr); \
- ADDITIONAL_FREE_##type (_weird_); \
- deadbeef_memory (ptr, sizeof (structtype)); \
- PUT_FIXED_TYPE_ON_FREE_LIST (type, structtype, ptr); \
- MARK_STRUCT_AS_FREE (_weird_); \
- } while (0)
+#define FREE_FIXED_TYPE(type, structtype, ptr) do { \
+ structtype *FFT_ptr = (ptr); \
+ ADDITIONAL_FREE_##type (FFT_ptr); \
+ deadbeef_memory (FFT_ptr, sizeof (structtype)); \
+ PUT_FIXED_TYPE_ON_FREE_LIST (type, structtype, FFT_ptr); \
+ MARK_LRECORD_AS_FREE (FFT_ptr); \
+} while (0)
/* Like FREE_FIXED_TYPE() but used when we are explicitly
freeing a structure through free_cons(), free_marker(), etc.
\f
-/**********************************************************************/
-/* Cons allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Cons allocation */
+/************************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (cons, struct Lisp_Cons);
+DECLARE_FIXED_TYPE_ALLOC (cons, Lisp_Cons);
/* conses are used and freed so often that we set this really high */
/* #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 20000 */
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_cons 2000
-#ifdef LRECORD_CONS
static Lisp_Object
-mark_cons (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_cons (Lisp_Object obj)
{
if (NILP (XCDR (obj)))
return XCAR (obj);
- (markobj) (XCAR (obj));
+ mark_object (XCAR (obj));
return XCDR (obj);
}
static int
cons_equal (Lisp_Object ob1, Lisp_Object ob2, int depth)
{
- while (internal_equal (XCAR (ob1), XCAR (ob2), depth + 1))
+ depth++;
+ while (internal_equal (XCAR (ob1), XCAR (ob2), depth))
{
ob1 = XCDR (ob1);
ob2 = XCDR (ob2);
if (! CONSP (ob1) || ! CONSP (ob2))
- return internal_equal (ob1, ob2, depth + 1);
+ return internal_equal (ob1, ob2, depth);
}
return 0;
}
+static const struct lrecord_description cons_description[] = {
+ { XD_LISP_OBJECT, offsetof (Lisp_Cons, car) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Cons, cdr) },
+ { XD_END }
+};
+
DEFINE_BASIC_LRECORD_IMPLEMENTATION ("cons", cons,
mark_cons, print_cons, 0,
cons_equal,
* handle conses.
*/
0,
- struct Lisp_Cons);
-#endif /* LRECORD_CONS */
+ cons_description,
+ Lisp_Cons);
DEFUN ("cons", Fcons, 2, 2, 0, /*
Create a new cons, give it CAR and CDR as components, and return it.
{
/* This cannot GC. */
Lisp_Object val;
- struct Lisp_Cons *c;
+ Lisp_Cons *c;
- ALLOCATE_FIXED_TYPE (cons, struct Lisp_Cons, c);
-#ifdef LRECORD_CONS
- set_lheader_implementation (&(c->lheader), lrecord_cons);
-#endif
+ ALLOCATE_FIXED_TYPE (cons, Lisp_Cons, c);
+ set_lheader_implementation (&c->lheader, &lrecord_cons);
XSETCONS (val, c);
c->car = car;
c->cdr = cdr;
noseeum_cons (Lisp_Object car, Lisp_Object cdr)
{
Lisp_Object val;
- struct Lisp_Cons *c;
+ Lisp_Cons *c;
- NOSEEUM_ALLOCATE_FIXED_TYPE (cons, struct Lisp_Cons, c);
-#ifdef LRECORD_CONS
- set_lheader_implementation (&(c->lheader), lrecord_cons);
-#endif
+ NOSEEUM_ALLOCATE_FIXED_TYPE (cons, Lisp_Cons, c);
+ set_lheader_implementation (&c->lheader, &lrecord_cons);
XSETCONS (val, c);
XCAR (val) = car;
XCDR (val) = cdr;
Lisp_Object val = Qnil;
Lisp_Object *argp = args + nargs;
- while (nargs-- > 0)
+ while (argp > args)
val = Fcons (*--argp, val);
return val;
}
}
DEFUN ("make-list", Fmake_list, 2, 2, 0, /*
-Return a new list of length LENGTH, with each element being INIT.
+Return a new list of length LENGTH, with each element being OBJECT.
*/
- (length, init))
+ (length, object))
{
CHECK_NATNUM (length);
{
Lisp_Object val = Qnil;
- int size = XINT (length);
+ size_t size = XINT (length);
- while (size-- > 0)
- val = Fcons (init, val);
+ while (size--)
+ val = Fcons (object, val);
return val;
}
}
\f
-/**********************************************************************/
-/* Float allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Float allocation */
+/************************************************************************/
#ifdef LISP_FLOAT_TYPE
-DECLARE_FIXED_TYPE_ALLOC (float, struct Lisp_Float);
+DECLARE_FIXED_TYPE_ALLOC (float, Lisp_Float);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_float 1000
Lisp_Object
make_float (double float_value)
{
Lisp_Object val;
- struct Lisp_Float *f;
+ Lisp_Float *f;
+
+ ALLOCATE_FIXED_TYPE (float, Lisp_Float, f);
- ALLOCATE_FIXED_TYPE (float, struct Lisp_Float, f);
- set_lheader_implementation (&(f->lheader), lrecord_float);
+ /* Avoid dump-time `uninitialized memory read' purify warnings. */
+ if (sizeof (struct lrecord_header) + sizeof (double) != sizeof (*f))
+ xzero (*f);
+
+ set_lheader_implementation (&f->lheader, &lrecord_float);
float_data (f) = float_value;
XSETFLOAT (val, f);
return val;
#endif /* LISP_FLOAT_TYPE */
\f
-/**********************************************************************/
-/* Vector allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Vector allocation */
+/************************************************************************/
-#ifdef LRECORD_VECTOR
static Lisp_Object
-mark_vector (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_vector (Lisp_Object obj)
{
- struct Lisp_Vector *ptr = XVECTOR (obj);
+ Lisp_Vector *ptr = XVECTOR (obj);
int len = vector_length (ptr);
int i;
for (i = 0; i < len - 1; i++)
- (markobj) (ptr->contents[i]);
+ mark_object (ptr->contents[i]);
return (len > 0) ? ptr->contents[len - 1] : Qnil;
}
static size_t
-size_vector (CONST void *lheader)
+size_vector (const void *lheader)
{
- /* * -1 because struct Lisp_Vector includes 1 slot */
- return sizeof (struct Lisp_Vector) +
- ((((struct Lisp_Vector *) lheader)->size - 1) * sizeof (Lisp_Object));
+ return FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object, contents,
+ ((Lisp_Vector *) lheader)->size);
}
static int
-vector_equal (Lisp_Object o1, Lisp_Object o2, int depth)
+vector_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- int indice;
- int len = XVECTOR_LENGTH (o1);
- if (len != XVECTOR_LENGTH (o2))
+ int len = XVECTOR_LENGTH (obj1);
+ if (len != XVECTOR_LENGTH (obj2))
return 0;
- for (indice = 0; indice < len; indice++)
- {
- if (!internal_equal (XVECTOR_DATA (o1) [indice],
- XVECTOR_DATA (o2) [indice],
- depth + 1))
+
+ {
+ Lisp_Object *ptr1 = XVECTOR_DATA (obj1);
+ Lisp_Object *ptr2 = XVECTOR_DATA (obj2);
+ while (len--)
+ if (!internal_equal (*ptr1++, *ptr2++, depth + 1))
return 0;
- }
+ }
return 1;
}
-DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION("vector", vector,
- mark_vector, print_vector, 0,
- vector_equal,
- /*
- * No `hash' method needed for
- * vectors. internal_hash
- * knows how to handle vectors.
- */
- 0,
- size_vector, struct Lisp_Vector);
-
-/* #### should allocate `small' vectors from a frob-block */
-static struct Lisp_Vector *
-make_vector_internal (size_t sizei)
+static hashcode_t
+vector_hash (Lisp_Object obj, int depth)
{
- size_t sizem = (sizeof (struct Lisp_Vector)
- /* -1 because struct Lisp_Vector includes 1 slot */
- + (sizei - 1) * sizeof (Lisp_Object));
- struct Lisp_Vector *p =
- (struct Lisp_Vector *) alloc_lcrecord (sizem, lrecord_vector);
-
- p->size = sizei;
- return p;
+ return HASH2 (XVECTOR_LENGTH (obj),
+ internal_array_hash (XVECTOR_DATA (obj),
+ XVECTOR_LENGTH (obj),
+ depth + 1));
}
-#else /* ! LRECORD_VECTOR */
+static const struct lrecord_description vector_description[] = {
+ { XD_LONG, offsetof (Lisp_Vector, size) },
+ { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Vector, contents), XD_INDIRECT(0, 0) },
+ { XD_END }
+};
-static Lisp_Object all_vectors;
+DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION("vector", vector,
+ mark_vector, print_vector, 0,
+ vector_equal,
+ vector_hash,
+ vector_description,
+ size_vector, Lisp_Vector);
/* #### should allocate `small' vectors from a frob-block */
-static struct Lisp_Vector *
+static Lisp_Vector *
make_vector_internal (size_t sizei)
{
- size_t sizem = (sizeof (struct Lisp_Vector)
- /* -1 because struct Lisp_Vector includes 1 slot,
- * +1 to account for vector_next */
- + (sizei - 1 + 1) * sizeof (Lisp_Object));
- struct Lisp_Vector *p = (struct Lisp_Vector *) allocate_lisp_storage (sizem);
-
- INCREMENT_CONS_COUNTER (sizem, "vector");
+ /* no vector_next */
+ size_t sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object,
+ contents, sizei);
+ Lisp_Vector *p = (Lisp_Vector *) alloc_lcrecord (sizem, &lrecord_vector);
p->size = sizei;
- vector_next (p) = all_vectors;
- XSETVECTOR (all_vectors, p);
return p;
}
-#endif /* ! LRECORD_VECTOR */
-
Lisp_Object
-make_vector (EMACS_INT length, Lisp_Object init)
+make_vector (size_t length, Lisp_Object object)
{
- int elt;
- Lisp_Object vector;
- struct Lisp_Vector *p;
-
- if (length < 0)
- length = XINT (wrong_type_argument (Qnatnump, make_int (length)));
+ Lisp_Vector *vecp = make_vector_internal (length);
+ Lisp_Object *p = vector_data (vecp);
- p = make_vector_internal (length);
- XSETVECTOR (vector, p);
+ while (length--)
+ *p++ = object;
-#if 0
- /* Initialize big arrays full of 0's quickly, for what that's worth */
{
- char *travesty = (char *) &init;
- for (i = 1; i < sizeof (Lisp_Object); i++)
- {
- if (travesty[i] != travesty[0])
- goto fill;
- }
- memset (vector_data (p), travesty[0], length * sizeof (Lisp_Object));
+ Lisp_Object vector;
+ XSETVECTOR (vector, vecp);
return vector;
}
- fill:
-#endif
- for (elt = 0; elt < length; elt++)
- vector_data(p)[elt] = init;
-
- return vector;
}
DEFUN ("make-vector", Fmake_vector, 2, 2, 0, /*
-Return a new vector of length LENGTH, with each element being INIT.
+Return a new vector of length LENGTH, with each element being OBJECT.
See also the function `vector'.
*/
- (length, init))
+ (length, object))
{
- CHECK_NATNUM (length);
- return make_vector (XINT (length), init);
+ CONCHECK_NATNUM (length);
+ return make_vector (XINT (length), object);
}
DEFUN ("vector", Fvector, 0, MANY, 0, /*
*/
(int nargs, Lisp_Object *args))
{
- Lisp_Object vector;
- int elt;
- struct Lisp_Vector *p = make_vector_internal (nargs);
+ Lisp_Vector *vecp = make_vector_internal (nargs);
+ Lisp_Object *p = vector_data (vecp);
- for (elt = 0; elt < nargs; elt++)
- vector_data(p)[elt] = args[elt];
+ while (nargs--)
+ *p++ = *args++;
- XSETVECTOR (vector, p);
- return vector;
+ {
+ Lisp_Object vector;
+ XSETVECTOR (vector, vecp);
+ return vector;
+ }
}
Lisp_Object
}
#endif /* unused */
-/**********************************************************************/
-/* Bit Vector allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Bit Vector allocation */
+/************************************************************************/
static Lisp_Object all_bit_vectors;
/* #### should allocate `small' bit vectors from a frob-block */
-static struct Lisp_Bit_Vector *
+static Lisp_Bit_Vector *
make_bit_vector_internal (size_t sizei)
{
- size_t sizem = sizeof (struct Lisp_Bit_Vector) +
- /* -1 because struct Lisp_Bit_Vector includes 1 slot */
- sizeof (long) * (BIT_VECTOR_LONG_STORAGE (sizei) - 1);
- struct Lisp_Bit_Vector *p =
- (struct Lisp_Bit_Vector *) allocate_lisp_storage (sizem);
- set_lheader_implementation (&(p->lheader), lrecord_bit_vector);
+ size_t num_longs = BIT_VECTOR_LONG_STORAGE (sizei);
+ size_t sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, unsigned long,
+ bits, num_longs);
+ Lisp_Bit_Vector *p = (Lisp_Bit_Vector *) allocate_lisp_storage (sizem);
+ set_lheader_implementation (&p->lheader, &lrecord_bit_vector);
INCREMENT_CONS_COUNTER (sizem, "bit-vector");
bit_vector_length (p) = sizei;
- bit_vector_next (p) = all_bit_vectors;
+ bit_vector_next (p) = all_bit_vectors;
/* make sure the extra bits in the last long are 0; the calling
functions might not set them. */
- p->bits[BIT_VECTOR_LONG_STORAGE (sizei) - 1] = 0;
+ p->bits[num_longs - 1] = 0;
XSETBIT_VECTOR (all_bit_vectors, p);
return p;
}
Lisp_Object
-make_bit_vector (EMACS_INT length, Lisp_Object init)
+make_bit_vector (size_t length, Lisp_Object bit)
{
- Lisp_Object bit_vector;
- struct Lisp_Bit_Vector *p;
- EMACS_INT num_longs;
-
- CHECK_BIT (init);
+ Lisp_Bit_Vector *p = make_bit_vector_internal (length);
+ size_t num_longs = BIT_VECTOR_LONG_STORAGE (length);
- num_longs = BIT_VECTOR_LONG_STORAGE (length);
- p = make_bit_vector_internal (length);
- XSETBIT_VECTOR (bit_vector, p);
+ CHECK_BIT (bit);
- if (ZEROP (init))
+ if (ZEROP (bit))
memset (p->bits, 0, num_longs * sizeof (long));
else
{
- EMACS_INT bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
+ size_t bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
memset (p->bits, ~0, num_longs * sizeof (long));
/* But we have to make sure that the unused bits in the
- last integer are 0, so that equal/hash is easy. */
+ last long are 0, so that equal/hash is easy. */
if (bits_in_last)
p->bits[num_longs - 1] &= (1 << bits_in_last) - 1;
}
- return bit_vector;
+ {
+ Lisp_Object bit_vector;
+ XSETBIT_VECTOR (bit_vector, p);
+ return bit_vector;
+ }
}
Lisp_Object
-make_bit_vector_from_byte_vector (unsigned char *bytevec, EMACS_INT length)
+make_bit_vector_from_byte_vector (unsigned char *bytevec, size_t length)
{
- Lisp_Object bit_vector;
- struct Lisp_Bit_Vector *p;
- int i;
-
- if (length < 0)
- length = XINT (wrong_type_argument (Qnatnump, make_int (length)));
-
- p = make_bit_vector_internal (length);
- XSETBIT_VECTOR (bit_vector, p);
+ size_t i;
+ Lisp_Bit_Vector *p = make_bit_vector_internal (length);
for (i = 0; i < length; i++)
set_bit_vector_bit (p, i, bytevec[i]);
- return bit_vector;
+ {
+ Lisp_Object bit_vector;
+ XSETBIT_VECTOR (bit_vector, p);
+ return bit_vector;
+ }
}
DEFUN ("make-bit-vector", Fmake_bit_vector, 2, 2, 0, /*
-Return a new bit vector of length LENGTH. with each bit being INIT.
-Each element is set to INIT. See also the function `bit-vector'.
+Return a new bit vector of length LENGTH. with each bit set to BIT.
+BIT must be one of the integers 0 or 1. See also the function `bit-vector'.
*/
- (length, init))
+ (length, bit))
{
CONCHECK_NATNUM (length);
- return make_bit_vector (XINT (length), init);
+ return make_bit_vector (XINT (length), bit);
}
DEFUN ("bit-vector", Fbit_vector, 0, MANY, 0, /*
Return a newly created bit vector with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.
+Each argument must be one of the integers 0 or 1.
*/
(int nargs, Lisp_Object *args))
{
- Lisp_Object bit_vector;
- int elt;
- struct Lisp_Bit_Vector *p;
-
- for (elt = 0; elt < nargs; elt++)
- CHECK_BIT (args[elt]);
-
- p = make_bit_vector_internal (nargs);
+ int i;
+ Lisp_Bit_Vector *p = make_bit_vector_internal (nargs);
- for (elt = 0; elt < nargs; elt++)
- set_bit_vector_bit (p, elt, !ZEROP (args[elt]));
+ for (i = 0; i < nargs; i++)
+ {
+ CHECK_BIT (args[i]);
+ set_bit_vector_bit (p, i, !ZEROP (args[i]));
+ }
- XSETBIT_VECTOR (bit_vector, p);
- return bit_vector;
+ {
+ Lisp_Object bit_vector;
+ XSETBIT_VECTOR (bit_vector, p);
+ return bit_vector;
+ }
}
\f
-/**********************************************************************/
-/* Compiled-function allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Compiled-function allocation */
+/************************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (compiled_function, struct Lisp_Compiled_Function);
+DECLARE_FIXED_TYPE_ALLOC (compiled_function, Lisp_Compiled_Function);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_compiled_function 1000
static Lisp_Object
-make_compiled_function (int make_pure)
-{
- struct Lisp_Compiled_Function *b;
- Lisp_Object new;
- size_t size = sizeof (struct Lisp_Compiled_Function);
-
- if (make_pure && check_purespace (size))
- {
- b = (struct Lisp_Compiled_Function *) (PUREBEG + pure_bytes_used);
- set_lheader_implementation (&(b->lheader), lrecord_compiled_function);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- b->lheader.pure = 1;
-#endif
- pure_bytes_used += size;
- bump_purestat (&purestat_bytecode, size);
- }
- else
- {
- ALLOCATE_FIXED_TYPE (compiled_function, struct Lisp_Compiled_Function,
- b);
- set_lheader_implementation (&(b->lheader), lrecord_compiled_function);
- }
- b->maxdepth = 0;
- b->flags.documentationp = 0;
- b->flags.interactivep = 0;
- b->flags.domainp = 0; /* I18N3 */
- b->bytecodes = Qzero;
- b->constants = Qzero;
- b->arglist = Qnil;
- b->doc_and_interactive = Qnil;
+make_compiled_function (void)
+{
+ Lisp_Compiled_Function *f;
+ Lisp_Object fun;
+
+ ALLOCATE_FIXED_TYPE (compiled_function, Lisp_Compiled_Function, f);
+ set_lheader_implementation (&f->lheader, &lrecord_compiled_function);
+
+ f->stack_depth = 0;
+ f->specpdl_depth = 0;
+ f->flags.documentationp = 0;
+ f->flags.interactivep = 0;
+ f->flags.domainp = 0; /* I18N3 */
+ f->instructions = Qzero;
+ f->constants = Qzero;
+ f->arglist = Qnil;
+ f->doc_and_interactive = Qnil;
#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
- b->annotated = Qnil;
+ f->annotated = Qnil;
#endif
- XSETCOMPILED_FUNCTION (new, b);
- return new;
+ XSETCOMPILED_FUNCTION (fun, f);
+ return fun;
}
DEFUN ("make-byte-code", Fmake_byte_code, 4, MANY, 0, /*
Return a new compiled-function object.
-Usage: (arglist instructions constants stack-size
- &optional doc-string interactive-spec)
+Usage: (arglist instructions constants stack-depth
+ &optional doc-string interactive)
Note that, unlike all other emacs-lisp functions, calling this with five
arguments is NOT the same as calling it with six arguments, the last of
which is nil. If the INTERACTIVE arg is specified as nil, then that means
that this function was defined with `(interactive)'. If the arg is not
specified, then that means the function is not interactive.
This is terrible behavior which is retained for compatibility with old
-`.elc' files which expected these semantics.
+`.elc' files which expect these semantics.
*/
(int nargs, Lisp_Object *args))
{
-/* In a non-insane world this function would have this arglist...
- (arglist, instructions, constants, stack_size, doc_string, interactive)
- Lisp_Object arglist, instructions, constants, stack_size, doc_string,
- interactive;
+/* In a non-insane world this function would have this arglist...
+ (arglist instructions constants stack_depth &optional doc_string interactive)
*/
+ Lisp_Object fun = make_compiled_function ();
+ Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun);
+
Lisp_Object arglist = args[0];
Lisp_Object instructions = args[1];
Lisp_Object constants = args[2];
- Lisp_Object stack_size = args[3];
+ Lisp_Object stack_depth = args[3];
Lisp_Object doc_string = (nargs > 4) ? args[4] : Qnil;
Lisp_Object interactive = (nargs > 5) ? args[5] : Qunbound;
- /* Don't purecopy the doc references in instructions because it's
- wasteful; they will get fixed up later.
-
- #### If something goes wrong and they don't get fixed up,
- we're screwed, because pure stuff isn't marked and thus the
- cons references won't be marked and will get reused.
-
- Note: there will be a window after the byte code is created and
- before the doc references are fixed up in which there will be
- impure objects inside a pure object, which apparently won't
- get marked, leading the trouble. But during that entire window,
- the objects are sitting on Vload_force_doc_string_list, which
- is staticpro'd, so we're OK. */
- int purecopy_instructions = 1;
-
- if (nargs > 6)
+
+ if (nargs < 4 || nargs > 6)
return Fsignal (Qwrong_number_of_arguments,
list2 (intern ("make-byte-code"), make_int (nargs)));
- CHECK_LIST (arglist);
- /* instructions is a string or a cons (string . int) for a
+ /* Check for valid formal parameter list now, to allow us to use
+ SPECBIND_FAST_UNSAFE() later in funcall_compiled_function(). */
+ {
+ EXTERNAL_LIST_LOOP_3 (symbol, arglist, tail)
+ {
+ CHECK_SYMBOL (symbol);
+ if (EQ (symbol, Qt) ||
+ EQ (symbol, Qnil) ||
+ SYMBOL_IS_KEYWORD (symbol))
+ signal_simple_error_2
+ ("Invalid constant symbol in formal parameter list",
+ symbol, arglist);
+ }
+ }
+ f->arglist = arglist;
+
+ /* `instructions' is a string or a cons (string . int) for a
lazy-loaded function. */
if (CONSP (instructions))
{
CHECK_STRING (XCAR (instructions));
CHECK_INT (XCDR (instructions));
- if (!NILP (constants))
- CHECK_VECTOR (constants);
- purecopy_instructions = 0;
}
else
{
CHECK_STRING (instructions);
- CHECK_VECTOR (constants);
}
- CHECK_NATNUM (stack_size);
- /* doc_string may be nil, string, int, or a cons (string . int). */
+ f->instructions = instructions;
- /* interactive may be list or string (or unbound). */
+ if (!NILP (constants))
+ CHECK_VECTOR (constants);
+ f->constants = constants;
- if (purify_flag)
- {
- if (!purified (arglist))
- arglist = Fpurecopy (arglist);
- if (purecopy_instructions && !purified (instructions))
- instructions = Fpurecopy (instructions);
- if (!purified (doc_string))
- doc_string = Fpurecopy (doc_string);
- if (!purified (interactive) && !UNBOUNDP (interactive))
- interactive = Fpurecopy (interactive);
-
- /* Statistics are kept differently for the constants */
- if (!purified (constants))
-#ifdef PURESTAT
- {
- int old = purecopying_for_bytecode;
- purecopying_for_bytecode = 1;
- constants = Fpurecopy (constants);
- purecopying_for_bytecode = old;
- }
-#else
- constants = Fpurecopy (constants);
-#endif /* PURESTAT */
-
-#ifdef PURESTAT
- if (STRINGP (instructions))
- bump_purestat (&purestat_string_bytecodes, pure_sizeof (instructions));
- if (VECTORP (constants))
- bump_purestat (&purestat_vector_bytecode_constants,
- pure_sizeof (constants));
- if (STRINGP (doc_string))
- /* These should be have been snagged by make-docfile... */
- bump_purestat (&purestat_string_documentation,
- pure_sizeof (doc_string));
- if (STRINGP (interactive))
- bump_purestat (&purestat_string_interactive,
- pure_sizeof (interactive));
-#endif /* PURESTAT */
- }
+ CHECK_NATNUM (stack_depth);
+ f->stack_depth = (unsigned short) XINT (stack_depth);
- {
- int docp = !NILP (doc_string);
- int intp = !UNBOUNDP (interactive);
-#ifdef I18N3
- int domp = !NILP (Vfile_domain);
-#endif
- Lisp_Object val = make_compiled_function (purify_flag);
- struct Lisp_Compiled_Function *b = XCOMPILED_FUNCTION (val);
- b->flags.documentationp = docp;
- b->flags.interactivep = intp;
-#ifdef I18N3
- b->flags.domainp = domp;
-#endif
- b->maxdepth = XINT (stack_size);
- b->bytecodes = instructions;
- b->constants = constants;
- b->arglist = arglist;
#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
- if (!NILP (Vcurrent_compiled_function_annotation))
- b->annotated = Fpurecopy (Vcurrent_compiled_function_annotation);
- else if (!NILP (Vload_file_name_internal_the_purecopy))
- b->annotated = Vload_file_name_internal_the_purecopy;
- else if (!NILP (Vload_file_name_internal))
- {
- struct gcpro gcpro1;
- GCPRO1(val); /* don't let val or b get reaped */
- Vload_file_name_internal_the_purecopy =
- Fpurecopy (Ffile_name_nondirectory (Vload_file_name_internal));
- b->annotated = Vload_file_name_internal_the_purecopy;
- UNGCPRO;
- }
+ if (!NILP (Vcurrent_compiled_function_annotation))
+ f->annotated = Fcopy (Vcurrent_compiled_function_annotation);
+ else if (!NILP (Vload_file_name_internal_the_purecopy))
+ f->annotated = Vload_file_name_internal_the_purecopy;
+ else if (!NILP (Vload_file_name_internal))
+ {
+ struct gcpro gcpro1;
+ GCPRO1 (fun); /* don't let fun get reaped */
+ Vload_file_name_internal_the_purecopy =
+ Ffile_name_nondirectory (Vload_file_name_internal);
+ f->annotated = Vload_file_name_internal_the_purecopy;
+ UNGCPRO;
+ }
#endif /* COMPILED_FUNCTION_ANNOTATION_HACK */
+ /* doc_string may be nil, string, int, or a cons (string . int).
+ interactive may be list or string (or unbound). */
+ f->doc_and_interactive = Qunbound;
#ifdef I18N3
- if (docp && intp && domp)
- b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
- (doc_string,
- (((purify_flag) ? pure_cons : Fcons)
- (interactive, Vfile_domain))));
- else if (docp && domp)
- b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
- (doc_string, Vfile_domain));
- else if (intp && domp)
- b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
- (interactive, Vfile_domain));
- else
-#endif
- if (docp && intp)
- b->doc_and_interactive = (((purify_flag) ? pure_cons : Fcons)
- (doc_string, interactive));
- else if (intp)
- b->doc_and_interactive = interactive;
-#ifdef I18N3
- else if (domp)
- b->doc_and_interactive = Vfile_domain;
+ if ((f->flags.domainp = !NILP (Vfile_domain)) != 0)
+ f->doc_and_interactive = Vfile_domain;
#endif
- else
- b->doc_and_interactive = doc_string;
+ if ((f->flags.interactivep = !UNBOUNDP (interactive)) != 0)
+ {
+ f->doc_and_interactive
+ = (UNBOUNDP (f->doc_and_interactive) ? interactive :
+ Fcons (interactive, f->doc_and_interactive));
+ }
+ if ((f->flags.documentationp = !NILP (doc_string)) != 0)
+ {
+ f->doc_and_interactive
+ = (UNBOUNDP (f->doc_and_interactive) ? doc_string :
+ Fcons (doc_string, f->doc_and_interactive));
+ }
+ if (UNBOUNDP (f->doc_and_interactive))
+ f->doc_and_interactive = Qnil;
- return val;
- }
+ return fun;
}
\f
-/**********************************************************************/
-/* Symbol allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Symbol allocation */
+/************************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (symbol, struct Lisp_Symbol);
+DECLARE_FIXED_TYPE_ALLOC (symbol, Lisp_Symbol);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_symbol 1000
DEFUN ("make-symbol", Fmake_symbol, 1, 1, 0, /*
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is nil.
*/
- (str))
+ (name))
{
Lisp_Object val;
- struct Lisp_Symbol *p;
+ Lisp_Symbol *p;
- CHECK_STRING (str);
+ CHECK_STRING (name);
- ALLOCATE_FIXED_TYPE (symbol, struct Lisp_Symbol, p);
-#ifdef LRECORD_SYMBOL
- set_lheader_implementation (&(p->lheader), lrecord_symbol);
-#endif
- p->name = XSTRING (str);
- p->plist = Qnil;
- p->value = Qunbound;
+ ALLOCATE_FIXED_TYPE (symbol, Lisp_Symbol, p);
+ set_lheader_implementation (&p->lheader, &lrecord_symbol);
+ p->name = XSTRING (name);
+ p->plist = Qnil;
+ p->value = Qunbound;
p->function = Qunbound;
- p->obarray = Qnil;
symbol_next (p) = 0;
XSETSYMBOL (val, p);
return val;
}
\f
-/**********************************************************************/
-/* Extent allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Extent allocation */
+/************************************************************************/
DECLARE_FIXED_TYPE_ALLOC (extent, struct extent);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_extent 1000
struct extent *e;
ALLOCATE_FIXED_TYPE (extent, struct extent, e);
- /* xzero (*e); */
- set_lheader_implementation (&(e->lheader), lrecord_extent);
+ set_lheader_implementation (&e->lheader, &lrecord_extent);
extent_object (e) = Qnil;
set_extent_start (e, -1);
set_extent_end (e, -1);
}
\f
-/**********************************************************************/
-/* Event allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Event allocation */
+/************************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (event, struct Lisp_Event);
+DECLARE_FIXED_TYPE_ALLOC (event, Lisp_Event);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_event 1000
Lisp_Object
allocate_event (void)
{
Lisp_Object val;
- struct Lisp_Event *e;
+ Lisp_Event *e;
- ALLOCATE_FIXED_TYPE (event, struct Lisp_Event, e);
- set_lheader_implementation (&(e->lheader), lrecord_event);
+ ALLOCATE_FIXED_TYPE (event, Lisp_Event, e);
+ set_lheader_implementation (&e->lheader, &lrecord_event);
XSETEVENT (val, e);
return val;
}
\f
-/**********************************************************************/
-/* Marker allocation */
-/**********************************************************************/
+/************************************************************************/
+/* Marker allocation */
+/************************************************************************/
-DECLARE_FIXED_TYPE_ALLOC (marker, struct Lisp_Marker);
+DECLARE_FIXED_TYPE_ALLOC (marker, Lisp_Marker);
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_marker 1000
DEFUN ("make-marker", Fmake_marker, 0, 0, 0, /*
())
{
Lisp_Object val;
- struct Lisp_Marker *p;
+ Lisp_Marker *p;
- ALLOCATE_FIXED_TYPE (marker, struct Lisp_Marker, p);
- set_lheader_implementation (&(p->lheader), lrecord_marker);
+ ALLOCATE_FIXED_TYPE (marker, Lisp_Marker, p);
+ set_lheader_implementation (&p->lheader, &lrecord_marker);
p->buffer = 0;
p->memind = 0;
marker_next (p) = 0;
noseeum_make_marker (void)
{
Lisp_Object val;
- struct Lisp_Marker *p;
+ Lisp_Marker *p;
- NOSEEUM_ALLOCATE_FIXED_TYPE (marker, struct Lisp_Marker, p);
- set_lheader_implementation (&(p->lheader), lrecord_marker);
+ NOSEEUM_ALLOCATE_FIXED_TYPE (marker, Lisp_Marker, p);
+ set_lheader_implementation (&p->lheader, &lrecord_marker);
p->buffer = 0;
p->memind = 0;
marker_next (p) = 0;
}
\f
-/**********************************************************************/
-/* String allocation */
-/**********************************************************************/
+/************************************************************************/
+/* String allocation */
+/************************************************************************/
/* The data for "short" strings generally resides inside of structs of type
string_chars_block. The Lisp_String structure is allocated just like any
This new method makes things somewhat bigger, but it is MUCH safer. */
-DECLARE_FIXED_TYPE_ALLOC (string, struct Lisp_String);
+DECLARE_FIXED_TYPE_ALLOC (string, Lisp_String);
/* strings are used and freed quite often */
/* #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_string 10000 */
#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_string 1000
-#ifdef LRECORD_STRING
static Lisp_Object
-mark_string (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_string (Lisp_Object obj)
{
- struct Lisp_String *ptr = XSTRING (obj);
+ Lisp_String *ptr = XSTRING (obj);
- if (GC_CONSP (ptr->plist) && GC_EXTENT_INFOP (XCAR (ptr->plist)))
+ if (CONSP (ptr->plist) && EXTENT_INFOP (XCAR (ptr->plist)))
flush_cached_extent_info (XCAR (ptr->plist));
return ptr->plist;
}
static int
-string_equal (Lisp_Object o1, Lisp_Object o2, int depth)
+string_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
Bytecount len;
- return (((len = XSTRING_LENGTH (o1)) == XSTRING_LENGTH (o2)) &&
- !memcmp (XSTRING_DATA (o1), XSTRING_DATA (o2), len));
+ return (((len = XSTRING_LENGTH (obj1)) == XSTRING_LENGTH (obj2)) &&
+ !memcmp (XSTRING_DATA (obj1), XSTRING_DATA (obj2), len));
}
-DEFINE_BASIC_LRECORD_IMPLEMENTATION ("string", string,
- mark_string, print_string,
- /*
- * No `finalize', or `hash' methods.
- * internal_hash already knows how
- * to hash strings and finalization
- * is done with the
- * ADDITIONAL_FREE_string macro,
- * which is the standard way to do
- * finalization when using
- * SWEEP_FIXED_TYPE_BLOCK().
- */
- 0, string_equal, 0,
- struct Lisp_String);
-#endif /* LRECORD_STRING */
+static const struct lrecord_description string_description[] = {
+ { XD_BYTECOUNT, offsetof (Lisp_String, size) },
+ { XD_OPAQUE_DATA_PTR, offsetof (Lisp_String, data), XD_INDIRECT(0, 1) },
+ { XD_LISP_OBJECT, offsetof (Lisp_String, plist) },
+ { XD_END }
+};
+
+/* We store the string's extent info as the first element of the string's
+ property list; and the string's MODIFF as the first or second element
+ of the string's property list (depending on whether the extent info
+ is present), but only if the string has been modified. This is ugly
+ but it reduces the memory allocated for the string in the vast
+ majority of cases, where the string is never modified and has no
+ extent info.
+
+ #### This means you can't use an int as a key in a string's plist. */
+
+static Lisp_Object *
+string_plist_ptr (Lisp_Object string)
+{
+ Lisp_Object *ptr = &XSTRING (string)->plist;
+
+ if (CONSP (*ptr) && EXTENT_INFOP (XCAR (*ptr)))
+ ptr = &XCDR (*ptr);
+ if (CONSP (*ptr) && INTP (XCAR (*ptr)))
+ ptr = &XCDR (*ptr);
+ return ptr;
+}
+
+static Lisp_Object
+string_getprop (Lisp_Object string, Lisp_Object property)
+{
+ return external_plist_get (string_plist_ptr (string), property, 0, ERROR_ME);
+}
+
+static int
+string_putprop (Lisp_Object string, Lisp_Object property, Lisp_Object value)
+{
+ external_plist_put (string_plist_ptr (string), property, value, 0, ERROR_ME);
+ return 1;
+}
+
+static int
+string_remprop (Lisp_Object string, Lisp_Object property)
+{
+ return external_remprop (string_plist_ptr (string), property, 0, ERROR_ME);
+}
+
+static Lisp_Object
+string_plist (Lisp_Object string)
+{
+ return *string_plist_ptr (string);
+}
+
+/* No `finalize', or `hash' methods.
+ internal_hash() already knows how to hash strings and finalization
+ is done with the ADDITIONAL_FREE_string macro, which is the
+ standard way to do finalization when using
+ SWEEP_FIXED_TYPE_BLOCK(). */
+DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("string", string,
+ mark_string, print_string,
+ 0, string_equal, 0,
+ string_description,
+ string_getprop,
+ string_putprop,
+ string_remprop,
+ string_plist,
+ Lisp_String);
/* String blocks contain this many useful bytes. */
#define STRING_CHARS_BLOCK_SIZE \
unsigned char string_chars[STRING_CHARS_BLOCK_SIZE];
};
-struct string_chars_block *first_string_chars_block;
-struct string_chars_block *current_string_chars_block;
+static struct string_chars_block *first_string_chars_block;
+static struct string_chars_block *current_string_chars_block;
/* If SIZE is the length of a string, this returns how many bytes
* the string occupies in string_chars_block->string_chars
* (including alignment padding).
*/
-#define STRING_FULLSIZE(s) \
- ALIGN_SIZE (((s) + 1 + sizeof (struct Lisp_String *)),\
- ALIGNOF (struct Lisp_String *))
+#define STRING_FULLSIZE(size) \
+ ALIGN_SIZE (((size) + 1 + sizeof (Lisp_String *)),\
+ ALIGNOF (Lisp_String *))
#define BIG_STRING_FULLSIZE_P(fullsize) ((fullsize) >= STRING_CHARS_BLOCK_SIZE)
#define BIG_STRING_SIZE_P(size) (BIG_STRING_FULLSIZE_P (STRING_FULLSIZE(size)))
-#define CHARS_TO_STRING_CHAR(x) \
- ((struct string_chars *) \
- (((char *) (x)) - (slot_offset (struct string_chars, chars[0]))))
-
+#define STRING_CHARS_FREE_P(ptr) ((ptr)->string == NULL)
+#define MARK_STRING_CHARS_AS_FREE(ptr) ((void) ((ptr)->string = NULL))
struct string_chars
{
- struct Lisp_String *string;
+ Lisp_String *string;
unsigned char chars[1];
};
struct unused_string_chars
{
- struct Lisp_String *string;
+ Lisp_String *string;
EMACS_INT fullsize;
};
}
static struct string_chars *
-allocate_string_chars_struct (struct Lisp_String *string_it_goes_with,
+allocate_string_chars_struct (Lisp_String *string_it_goes_with,
EMACS_INT fullsize)
{
struct string_chars *s_chars;
- /* Allocate the string's actual data */
- if (BIG_STRING_FULLSIZE_P (fullsize))
- {
- s_chars = (struct string_chars *) xmalloc (fullsize);
- }
- else if (fullsize <=
- (countof (current_string_chars_block->string_chars)
- - current_string_chars_block->pos))
+ if (fullsize <=
+ (countof (current_string_chars_block->string_chars)
+ - current_string_chars_block->pos))
{
/* This string can fit in the current string chars block */
s_chars = (struct string_chars *)
else
{
/* Make a new current string chars block */
- struct string_chars_block *new = xnew (struct string_chars_block);
+ struct string_chars_block *new_scb = xnew (struct string_chars_block);
- current_string_chars_block->next = new;
- new->prev = current_string_chars_block;
- new->next = 0;
- current_string_chars_block = new;
- new->pos = fullsize;
+ current_string_chars_block->next = new_scb;
+ new_scb->prev = current_string_chars_block;
+ new_scb->next = 0;
+ current_string_chars_block = new_scb;
+ new_scb->pos = fullsize;
s_chars = (struct string_chars *)
current_string_chars_block->string_chars;
}
Lisp_Object
make_uninit_string (Bytecount length)
{
- struct Lisp_String *s;
- struct string_chars *s_chars;
+ Lisp_String *s;
EMACS_INT fullsize = STRING_FULLSIZE (length);
Lisp_Object val;
- if ((length < 0) || (fullsize <= 0))
- abort ();
+ assert (length >= 0 && fullsize > 0);
/* Allocate the string header */
- ALLOCATE_FIXED_TYPE (string, struct Lisp_String, s);
-#ifdef LRECORD_STRING
- set_lheader_implementation (&(s->lheader), lrecord_string);
-#endif
+ ALLOCATE_FIXED_TYPE (string, Lisp_String, s);
+ set_lheader_implementation (&s->lheader, &lrecord_string);
- s_chars = allocate_string_chars_struct (s, fullsize);
+ set_string_data (s, BIG_STRING_FULLSIZE_P (fullsize)
+ ? xnew_array (Bufbyte, length + 1)
+ : allocate_string_chars_struct (s, fullsize)->chars);
- set_string_data (s, &(s_chars->chars[0]));
set_string_length (s, length);
s->plist = Qnil;
*/
void
-resize_string (struct Lisp_String *s, Bytecount pos, Bytecount delta)
+resize_string (Lisp_String *s, Bytecount pos, Bytecount delta)
{
+ Bytecount oldfullsize, newfullsize;
#ifdef VERIFY_STRING_CHARS_INTEGRITY
verify_string_chars_integrity ();
#endif
}
#endif /* ERROR_CHECK_BUFPOS */
- if (pos >= 0 && delta < 0)
- /* If DELTA < 0, the functions below will delete the characters
- before POS. We want to delete characters *after* POS, however,
- so convert this to the appropriate form. */
- pos += -delta;
-
if (delta == 0)
/* simplest case: no size change. */
return;
- else
- {
- Bytecount oldfullsize = STRING_FULLSIZE (string_length (s));
- Bytecount newfullsize = STRING_FULLSIZE (string_length (s) + delta);
- if (oldfullsize == newfullsize)
+ if (pos >= 0 && delta < 0)
+ /* If DELTA < 0, the functions below will delete the characters
+ before POS. We want to delete characters *after* POS, however,
+ so convert this to the appropriate form. */
+ pos += -delta;
+
+ oldfullsize = STRING_FULLSIZE (string_length (s));
+ newfullsize = STRING_FULLSIZE (string_length (s) + delta);
+
+ if (BIG_STRING_FULLSIZE_P (oldfullsize))
+ {
+ if (BIG_STRING_FULLSIZE_P (newfullsize))
+ {
+ /* Both strings are big. We can just realloc().
+ But careful! If the string is shrinking, we have to
+ memmove() _before_ realloc(), and if growing, we have to
+ memmove() _after_ realloc() - otherwise the access is
+ illegal, and we might crash. */
+ Bytecount len = string_length (s) + 1 - pos;
+
+ if (delta < 0 && pos >= 0)
+ memmove (string_data (s) + pos + delta, string_data (s) + pos, len);
+ set_string_data (s, (Bufbyte *) xrealloc (string_data (s),
+ string_length (s) + delta + 1));
+ if (delta > 0 && pos >= 0)
+ memmove (string_data (s) + pos + delta, string_data (s) + pos, len);
+ }
+ else /* String has been demoted from BIG_STRING. */
{
- /* next simplest case; size change but the necessary
- allocation size won't change (up or down; code somewhere
- depends on there not being any unused allocation space,
- modulo any alignment constraints). */
+ Bufbyte *new_data =
+ allocate_string_chars_struct (s, newfullsize)->chars;
+ Bufbyte *old_data = string_data (s);
+
if (pos >= 0)
{
- Bufbyte *addroff = pos + string_data (s);
-
- memmove (addroff + delta, addroff,
- /* +1 due to zero-termination. */
- string_length (s) + 1 - pos);
+ memcpy (new_data, old_data, pos);
+ memcpy (new_data + pos + delta, old_data + pos,
+ string_length (s) + 1 - pos);
}
+ set_string_data (s, new_data);
+ xfree (old_data);
}
- else if (BIG_STRING_FULLSIZE_P (oldfullsize) &&
- BIG_STRING_FULLSIZE_P (newfullsize))
+ }
+ else /* old string is small */
+ {
+ if (oldfullsize == newfullsize)
{
- /* next simplest case; the string is big enough to be malloc()ed
- itself, so we just realloc.
-
- It's important not to let the string get below the threshold
- for making big strings and still remain malloc()ed; if that
- were the case, repeated calls to this function on the same
- string could result in memory leakage. */
- set_string_data (s, (Bufbyte *) xrealloc (string_data (s),
- newfullsize));
+ /* special case; size change but the necessary
+ allocation size won't change (up or down; code
+ somewhere depends on there not being any unused
+ allocation space, modulo any alignment
+ constraints). */
if (pos >= 0)
{
Bufbyte *addroff = pos + string_data (s);
}
else
{
- /* worst case. We make a new string_chars struct and copy
- the string's data into it, inserting/deleting the delta
- in the process. The old string data will either get
- freed by us (if it was malloc()ed) or will be reclaimed
- in the normal course of garbage collection. */
- struct string_chars *s_chars =
- allocate_string_chars_struct (s, newfullsize);
- Bufbyte *new_addr = &(s_chars->chars[0]);
- Bufbyte *old_addr = string_data (s);
+ Bufbyte *old_data = string_data (s);
+ Bufbyte *new_data =
+ BIG_STRING_FULLSIZE_P (newfullsize)
+ ? xnew_array (Bufbyte, string_length (s) + delta + 1)
+ : allocate_string_chars_struct (s, newfullsize)->chars;
+
if (pos >= 0)
{
- memcpy (new_addr, old_addr, pos);
- memcpy (new_addr + pos + delta, old_addr + pos,
+ memcpy (new_data, old_data, pos);
+ memcpy (new_data + pos + delta, old_data + pos,
string_length (s) + 1 - pos);
}
- set_string_data (s, new_addr);
- if (BIG_STRING_FULLSIZE_P (oldfullsize))
- xfree (old_addr);
- else
- {
- /* We need to mark this chunk of the string_chars_block
- as unused so that compact_string_chars() doesn't
- freak. */
- struct string_chars *old_s_chars =
- (struct string_chars *) ((char *) old_addr -
- sizeof (struct Lisp_String *));
- /* Sanity check to make sure we aren't hosed by strange
- alignment/padding. */
- assert (old_s_chars->string == s);
- MARK_STRUCT_AS_FREE (old_s_chars);
- ((struct unused_string_chars *) old_s_chars)->fullsize =
- oldfullsize;
- }
+ set_string_data (s, new_data);
+
+ {
+ /* We need to mark this chunk of the string_chars_block
+ as unused so that compact_string_chars() doesn't
+ freak. */
+ struct string_chars *old_s_chars = (struct string_chars *)
+ ((char *) old_data - offsetof (struct string_chars, chars));
+ /* Sanity check to make sure we aren't hosed by strange
+ alignment/padding. */
+ assert (old_s_chars->string == s);
+ MARK_STRING_CHARS_AS_FREE (old_s_chars);
+ ((struct unused_string_chars *) old_s_chars)->fullsize =
+ oldfullsize;
+ }
}
+ }
- set_string_length (s, string_length (s) + delta);
- /* If pos < 0, the string won't be zero-terminated.
- Terminate now just to make sure. */
- string_data (s)[string_length (s)] = '\0';
+ set_string_length (s, string_length (s) + delta);
+ /* If pos < 0, the string won't be zero-terminated.
+ Terminate now just to make sure. */
+ string_data (s)[string_length (s)] = '\0';
- if (pos >= 0)
- {
- Lisp_Object string;
-
- XSETSTRING (string, s);
- /* We also have to adjust all of the extent indices after the
- place we did the change. We say "pos - 1" because
- adjust_extents() is exclusive of the starting position
- passed to it. */
- adjust_extents (string, pos - 1, string_length (s),
- delta);
- }
+ if (pos >= 0)
+ {
+ Lisp_Object string;
+
+ XSETSTRING (string, s);
+ /* We also have to adjust all of the extent indices after the
+ place we did the change. We say "pos - 1" because
+ adjust_extents() is exclusive of the starting position
+ passed to it. */
+ adjust_extents (string, pos - 1, string_length (s),
+ delta);
}
#ifdef VERIFY_STRING_CHARS_INTEGRITY
#ifdef MULE
void
-set_string_char (struct Lisp_String *s, Charcount i, Emchar c)
+set_string_char (Lisp_String *s, Charcount i, Emchar c)
{
- Bytecount oldlen, newlen;
Bufbyte newstr[MAX_EMCHAR_LEN];
Bytecount bytoff = charcount_to_bytecount (string_data (s), i);
-
- oldlen = charcount_to_bytecount (string_data (s) + bytoff, 1);
- newlen = set_charptr_emchar (newstr, c);
+ Bytecount oldlen = charcount_to_bytecount (string_data (s) + bytoff, 1);
+ Bytecount newlen = set_charptr_emchar (newstr, c);
if (oldlen != newlen)
resize_string (s, bytoff, newlen - oldlen);
#endif /* MULE */
DEFUN ("make-string", Fmake_string, 2, 2, 0, /*
-Return a new string of length LENGTH, with each character being INIT.
-LENGTH must be an integer and INIT must be a character.
+Return a new string consisting of LENGTH copies of CHARACTER.
+LENGTH must be a non-negative integer.
*/
- (length, init))
+ (length, character))
{
- Lisp_Object val;
-
CHECK_NATNUM (length);
- CHECK_CHAR_COERCE_INT (init);
+ CHECK_CHAR_COERCE_INT (character);
{
- Bufbyte str[MAX_EMCHAR_LEN];
- int len = set_charptr_emchar (str, XCHAR (init));
+ Bufbyte init_str[MAX_EMCHAR_LEN];
+ int len = set_charptr_emchar (init_str, XCHAR (character));
+ Lisp_Object val = make_uninit_string (len * XINT (length));
- val = make_uninit_string (len * XINT (length));
if (len == 1)
/* Optimize the single-byte case */
- memset (XSTRING_DATA (val), XCHAR (init), XSTRING_LENGTH (val));
+ memset (XSTRING_DATA (val), XCHAR (character), XSTRING_LENGTH (val));
else
{
- int i, j, k;
+ size_t i;
Bufbyte *ptr = XSTRING_DATA (val);
- k = 0;
- for (i = 0; i < XINT (length); i++)
- for (j = 0; j < len; j++)
- ptr[k++] = str[j];
+ for (i = XINT (length); i; i--)
+ {
+ Bufbyte *init_ptr = init_str;
+ switch (len)
+ {
+#ifdef UTF2000
+ case 6: *ptr++ = *init_ptr++;
+ case 5: *ptr++ = *init_ptr++;
+#endif
+ case 4: *ptr++ = *init_ptr++;
+ case 3: *ptr++ = *init_ptr++;
+ case 2: *ptr++ = *init_ptr++;
+ case 1: *ptr++ = *init_ptr++;
+ }
+ }
}
+ return val;
}
- return val;
}
DEFUN ("string", Fstring, 0, MANY, 0, /*
return make_string (storage, p - storage);
}
+
/* Take some raw memory, which MUST already be in internal format,
and package it up into a Lisp string. */
Lisp_Object
-make_string (CONST Bufbyte *contents, Bytecount length)
+make_string (const Bufbyte *contents, Bytecount length)
{
Lisp_Object val;
/* Take some raw memory, encoded in some external data format,
and convert it into a Lisp string. */
Lisp_Object
-make_ext_string (CONST Extbyte *contents, EMACS_INT length,
- enum external_data_format fmt)
+make_ext_string (const Extbyte *contents, EMACS_INT length,
+ Lisp_Object coding_system)
{
- Bufbyte *intstr;
- Bytecount intlen;
-
- GET_CHARPTR_INT_DATA_ALLOCA (contents, length, fmt, intstr, intlen);
- return make_string (intstr, intlen);
+ Lisp_Object string;
+ TO_INTERNAL_FORMAT (DATA, (contents, length),
+ LISP_STRING, string,
+ coding_system);
+ return string;
}
Lisp_Object
-build_string (CONST char *str)
+build_string (const char *str)
{
/* Some strlen's crash and burn if passed null. */
- return make_string ((CONST Bufbyte *) str, (str ? strlen(str) : 0));
+ return make_string ((const Bufbyte *) str, (str ? strlen(str) : 0));
}
Lisp_Object
-build_ext_string (CONST char *str, enum external_data_format fmt)
+build_ext_string (const char *str, Lisp_Object coding_system)
{
/* Some strlen's crash and burn if passed null. */
- return make_ext_string ((CONST Extbyte *) str, (str ? strlen(str) : 0), fmt);
+ return make_ext_string ((const Extbyte *) str, (str ? strlen(str) : 0),
+ coding_system);
}
Lisp_Object
-build_translated_string (CONST char *str)
+build_translated_string (const char *str)
{
return build_string (GETTEXT (str));
}
+Lisp_Object
+make_string_nocopy (const Bufbyte *contents, Bytecount length)
+{
+ Lisp_String *s;
+ Lisp_Object val;
+
+ /* Make sure we find out about bad make_string_nocopy's when they happen */
+#if defined (ERROR_CHECK_BUFPOS) && defined (MULE)
+ bytecount_to_charcount (contents, length); /* Just for the assertions */
+#endif
+
+ /* Allocate the string header */
+ ALLOCATE_FIXED_TYPE (string, Lisp_String, s);
+ set_lheader_implementation (&s->lheader, &lrecord_string);
+ SET_C_READONLY_RECORD_HEADER (&s->lheader);
+ s->plist = Qnil;
+ set_string_data (s, (Bufbyte *)contents);
+ set_string_length (s, length);
+
+ XSETSTRING (val, s);
+ return val;
+}
+
\f
/************************************************************************/
/* lcrecord lists */
It works like this:
1) Create an lcrecord-list object using make_lcrecord_list().
- This is often done at initialization. Remember to staticpro
+ This is often done at initialization. Remember to staticpro_nodump
this object! The arguments to make_lcrecord_list() are the
same as would be passed to alloc_lcrecord().
2) Instead of calling alloc_lcrecord(), call allocate_managed_lcrecord()
*/
static Lisp_Object
-mark_lcrecord_list (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_lcrecord_list (Lisp_Object obj)
{
struct lcrecord_list *list = XLCRECORD_LIST (obj);
Lisp_Object chain = list->free;
struct free_lcrecord_header *free_header =
(struct free_lcrecord_header *) lheader;
-#ifdef ERROR_CHECK_GC
- CONST struct lrecord_implementation *implementation
- = LHEADER_IMPLEMENTATION(lheader);
-
- /* There should be no other pointers to the free list. */
- assert (!MARKED_RECORD_HEADER_P (lheader));
- /* Only lcrecords should be here. */
- assert (!implementation->basic_p);
- /* Only free lcrecords should be here. */
- assert (free_header->lcheader.free);
- /* The type of the lcrecord must be right. */
- assert (implementation == list->implementation);
- /* So must the size. */
- assert (implementation->static_size == 0
- || implementation->static_size == list->size);
-#endif /* ERROR_CHECK_GC */
+ gc_checking_assert
+ (/* There should be no other pointers to the free list. */
+ ! MARKED_RECORD_HEADER_P (lheader)
+ &&
+ /* Only lcrecords should be here. */
+ ! LHEADER_IMPLEMENTATION (lheader)->basic_p
+ &&
+ /* Only free lcrecords should be here. */
+ free_header->lcheader.free
+ &&
+ /* The type of the lcrecord must be right. */
+ LHEADER_IMPLEMENTATION (lheader) == list->implementation
+ &&
+ /* So must the size. */
+ (LHEADER_IMPLEMENTATION (lheader)->static_size == 0 ||
+ LHEADER_IMPLEMENTATION (lheader)->static_size == list->size)
+ );
MARK_RECORD_HEADER (lheader);
chain = free_header->chain;
DEFINE_LRECORD_IMPLEMENTATION ("lcrecord-list", lcrecord_list,
mark_lcrecord_list, internal_object_printer,
- 0, 0, 0, struct lcrecord_list);
+ 0, 0, 0, 0, struct lcrecord_list);
Lisp_Object
make_lcrecord_list (size_t size,
- CONST struct lrecord_implementation *implementation)
+ const struct lrecord_implementation *implementation)
{
struct lcrecord_list *p = alloc_lcrecord_type (struct lcrecord_list,
- lrecord_lcrecord_list);
+ &lrecord_lcrecord_list);
Lisp_Object val;
p->implementation = implementation;
(struct free_lcrecord_header *) XPNTR (val);
#ifdef ERROR_CHECK_GC
- struct lrecord_header *lheader =
- (struct lrecord_header *) free_header;
- CONST struct lrecord_implementation *implementation
- = LHEADER_IMPLEMENTATION (lheader);
+ struct lrecord_header *lheader = &free_header->lcheader.lheader;
/* There should be no other pointers to the free list. */
- assert (!MARKED_RECORD_HEADER_P (lheader));
+ assert (! MARKED_RECORD_HEADER_P (lheader));
/* Only lcrecords should be here. */
- assert (!implementation->basic_p);
+ assert (! LHEADER_IMPLEMENTATION (lheader)->basic_p);
/* Only free lcrecords should be here. */
assert (free_header->lcheader.free);
/* The type of the lcrecord must be right. */
- assert (implementation == list->implementation);
+ assert (LHEADER_IMPLEMENTATION (lheader) == list->implementation);
/* So must the size. */
- assert (implementation->static_size == 0
- || implementation->static_size == list->size);
+ assert (LHEADER_IMPLEMENTATION (lheader)->static_size == 0 ||
+ LHEADER_IMPLEMENTATION (lheader)->static_size == list->size);
#endif /* ERROR_CHECK_GC */
+
list->free = free_header->chain;
free_header->lcheader.free = 0;
return val;
{
Lisp_Object val;
- XSETOBJ (val, Lisp_Type_Record,
- alloc_lcrecord (list->size, list->implementation));
+ XSETOBJ (val, alloc_lcrecord (list->size, list->implementation));
return val;
}
}
struct lcrecord_list *list = XLCRECORD_LIST (lcrecord_list);
struct free_lcrecord_header *free_header =
(struct free_lcrecord_header *) XPNTR (lcrecord);
- struct lrecord_header *lheader =
- (struct lrecord_header *) free_header;
- CONST struct lrecord_implementation *implementation
+ struct lrecord_header *lheader = &free_header->lcheader.lheader;
+ const struct lrecord_implementation *implementation
= LHEADER_IMPLEMENTATION (lheader);
-#ifdef ERROR_CHECK_GC
/* Make sure the size is correct. This will catch, for example,
putting a window configuration on the wrong free list. */
- if (implementation->size_in_bytes_method)
- assert (((implementation->size_in_bytes_method) (lheader))
- == list->size);
- else
- assert (implementation->static_size == list->size);
-#endif /* ERROR_CHECK_GC */
+ gc_checking_assert ((implementation->size_in_bytes_method ?
+ implementation->size_in_bytes_method (lheader) :
+ implementation->static_size)
+ == list->size);
if (implementation->finalizer)
- ((implementation->finalizer) (lheader, 0));
+ implementation->finalizer (lheader, 0);
free_header->chain = list->free;
free_header->lcheader.free = 1;
list->free = lcrecord;
}
\f
-/**********************************************************************/
-/* Purity of essence, peace on earth */
-/**********************************************************************/
-
-static int symbols_initialized;
-
-Lisp_Object
-make_pure_string (CONST Bufbyte *data, Bytecount length,
- Lisp_Object plist, int no_need_to_copy_data)
-{
- Lisp_Object new;
- struct Lisp_String *s;
- size_t size = sizeof (struct Lisp_String) +
- (no_need_to_copy_data ? 0 : (length + 1)); /* + 1 for terminating 0 */
- size = ALIGN_SIZE (size, ALIGNOF (Lisp_Object));
-
- if (symbols_initialized && !pure_lossage)
- {
- /* Try to share some names. Saves a few kbytes. */
- Lisp_Object tem = oblookup (Vobarray, data, length);
- if (SYMBOLP (tem))
- {
- s = XSYMBOL (tem)->name;
- if (!PURIFIED (s)) abort ();
- XSETSTRING (new, s);
- return new;
- }
- }
-
- if (!check_purespace (size))
- return make_string (data, length);
-
- s = (struct Lisp_String *) (PUREBEG + pure_bytes_used);
-#ifdef LRECORD_STRING
- set_lheader_implementation (&(s->lheader), lrecord_string);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- s->lheader.pure = 1;
-#endif
-#endif
- set_string_length (s, length);
- if (no_need_to_copy_data)
- {
- set_string_data (s, (Bufbyte *) data);
- }
- else
- {
- set_string_data (s, (Bufbyte *) s + sizeof (struct Lisp_String));
- memcpy (string_data (s), data, length);
- set_string_byte (s, length, 0);
- }
- s->plist = Qnil;
- pure_bytes_used += size;
-
-#ifdef PURESTAT
- bump_purestat (&purestat_string_all, size);
- if (purecopying_for_bytecode)
- bump_purestat (&purestat_string_other_function, size);
-#endif /* PURESTAT */
-
- /* Do this after the official "completion" of the purecopying. */
- s->plist = Fpurecopy (plist);
-
- XSETSTRING (new, s);
- return new;
-}
-
-
-Lisp_Object
-make_pure_pname (CONST Bufbyte *data, Bytecount length,
- int no_need_to_copy_data)
-{
- Lisp_Object name = make_pure_string (data, length, Qnil,
- no_need_to_copy_data);
- bump_purestat (&purestat_string_pname, pure_sizeof (name));
-
- /* We've made (at least) Qnil now, and Vobarray will soon be set up. */
- symbols_initialized = 1;
-
- return name;
-}
-
-
-Lisp_Object
-pure_cons (Lisp_Object car, Lisp_Object cdr)
-{
- Lisp_Object new;
- struct Lisp_Cons *c;
-
- if (!check_purespace (sizeof (struct Lisp_Cons)))
- return Fcons (Fpurecopy (car), Fpurecopy (cdr));
-
- c = (struct Lisp_Cons *) (PUREBEG + pure_bytes_used);
-#ifdef LRECORD_CONS
- set_lheader_implementation (&(c->lheader), lrecord_cons);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- c->lheader.pure = 1;
-#endif
-#endif
- pure_bytes_used += sizeof (struct Lisp_Cons);
- bump_purestat (&purestat_cons, sizeof (struct Lisp_Cons));
-
- c->car = Fpurecopy (car);
- c->cdr = Fpurecopy (cdr);
- XSETCONS (new, c);
- return new;
-}
-
-Lisp_Object
-pure_list (int nargs, Lisp_Object *args)
-{
- Lisp_Object val = Qnil;
-
- for (--nargs; nargs >= 0; nargs--)
- val = pure_cons (args[nargs], val);
-
- return val;
-}
-
-#ifdef LISP_FLOAT_TYPE
-
-static Lisp_Object
-make_pure_float (double num)
-{
- struct Lisp_Float *f;
- Lisp_Object val;
-
- /* Make sure that PUREBEG + pure_bytes_used is aligned on at least a sizeof
- (double) boundary. Some architectures (like the sparc) require
- this, and I suspect that floats are rare enough that it's no
- tragedy for those that don't. */
- {
-#if defined (__GNUC__) && (__GNUC__ >= 2)
- /* In gcc, we can directly ask what the alignment constraints of a
- structure are, but in general, that's not possible... Arrgh!!
- */
- int alignment = __alignof (struct Lisp_Float);
-#else /* !GNUC */
- /* Best guess is to make the `double' slot be aligned to the size
- of double (which is probably 8 bytes). This assumes that it's
- ok to align the beginning of the structure to the same boundary
- that the `double' slot in it is supposed to be aligned to; this
- should be ok because presumably there is padding in the layout
- of the struct to account for this.
- */
- int alignment = sizeof (float_data (f));
-#endif /* !GNUC */
- char *p = ((char *) PUREBEG + pure_bytes_used);
-
- p = (char *) (((EMACS_UINT) p + alignment - 1) & - alignment);
- pure_bytes_used = p - (char *) PUREBEG;
- }
-
- if (!check_purespace (sizeof (struct Lisp_Float)))
- return make_float (num);
-
- f = (struct Lisp_Float *) (PUREBEG + pure_bytes_used);
- set_lheader_implementation (&(f->lheader), lrecord_float);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- f->lheader.pure = 1;
-#endif
- pure_bytes_used += sizeof (struct Lisp_Float);
- bump_purestat (&purestat_float, sizeof (struct Lisp_Float));
-
- float_data (f) = num;
- XSETFLOAT (val, f);
- return val;
-}
-
-#endif /* LISP_FLOAT_TYPE */
-
-Lisp_Object
-make_pure_vector (size_t len, Lisp_Object init)
-{
- Lisp_Object new;
- struct Lisp_Vector *v;
- size_t size = (sizeof (struct Lisp_Vector)
- + (len - 1) * sizeof (Lisp_Object));
-
- init = Fpurecopy (init);
-
- if (!check_purespace (size))
- return make_vector (len, init);
-
- v = (struct Lisp_Vector *) (PUREBEG + pure_bytes_used);
-#ifdef LRECORD_VECTOR
- set_lheader_implementation (&(v->header.lheader), lrecord_vector);
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- v->header.lheader.pure = 1;
-#endif
-#endif
- pure_bytes_used += size;
- bump_purestat (&purestat_vector_all, size);
-
- v->size = len;
-
- for (size = 0; size < len; size++)
- v->contents[size] = init;
-
- XSETVECTOR (new, v);
- return new;
-}
-
-#if 0
-/* Presently unused */
-void *
-alloc_pure_lrecord (int size, struct lrecord_implementation *implementation)
-{
- struct lrecord_header *header = (void *) (PUREBEG + pure_bytes_used);
-
- if (pure_bytes_used + size > get_PURESIZE())
- pure_storage_exhausted ();
-
- set_lheader_implementation (header, implementation);
- header->next = 0;
- return header;
-}
-#endif /* unused */
-
\f
DEFUN ("purecopy", Fpurecopy, 1, 1, 0, /*
+Kept for compatibility, returns its argument.
+Old:
Make a copy of OBJECT in pure storage.
Recursively copies contents of vectors and cons cells.
Does not copy symbols.
*/
- (obj))
+ (object))
{
- int i;
- if (!purify_flag)
- return obj;
-
- if (!POINTER_TYPE_P (XTYPE (obj))
- || PURIFIED (XPNTR (obj))
- /* happens when bootstrapping Qnil */
- || EQ (obj, Qnull_pointer))
- return obj;
-
- switch (XTYPE (obj))
- {
-#ifndef LRECORD_CONS
- case Lisp_Type_Cons:
- return pure_cons (XCAR (obj), XCDR (obj));
-#endif
-
-#ifndef LRECORD_STRING
- case Lisp_Type_String:
- return make_pure_string (XSTRING_DATA (obj),
- XSTRING_LENGTH (obj),
- XSTRING (obj)->plist,
- 0);
-#endif /* ! LRECORD_STRING */
-
-#ifndef LRECORD_VECTOR
- case Lisp_Type_Vector:
- {
- struct Lisp_Vector *o = XVECTOR (obj);
- Lisp_Object new = make_pure_vector (vector_length (o), Qnil);
- for (i = 0; i < vector_length (o); i++)
- XVECTOR_DATA (new)[i] = Fpurecopy (o->contents[i]);
- return new;
- }
-#endif /* !LRECORD_VECTOR */
-
- default:
- {
- if (COMPILED_FUNCTIONP (obj))
- {
- struct Lisp_Compiled_Function *o = XCOMPILED_FUNCTION (obj);
- Lisp_Object new = make_compiled_function (1);
- /* How on earth could this code have worked before? -sb */
- struct Lisp_Compiled_Function *n = XCOMPILED_FUNCTION (new);
- n->flags = o->flags;
- n->bytecodes = Fpurecopy (o->bytecodes);
- n->constants = Fpurecopy (o->constants);
- n->arglist = Fpurecopy (o->arglist);
- n->doc_and_interactive = Fpurecopy (o->doc_and_interactive);
- n->maxdepth = o->maxdepth;
- return new;
- }
-#ifdef LRECORD_CONS
- else if (CONSP (obj))
- return pure_cons (XCAR (obj), XCDR (obj));
-#endif /* LRECORD_CONS */
-#ifdef LRECORD_VECTOR
- else if (VECTORP (obj))
- {
- struct Lisp_Vector *o = XVECTOR (obj);
- Lisp_Object new = make_pure_vector (vector_length (o), Qnil);
- for (i = 0; i < vector_length (o); i++)
- XVECTOR_DATA (new)[i] = Fpurecopy (o->contents[i]);
- return new;
- }
-#endif /* LRECORD_VECTOR */
-#ifdef LRECORD_STRING
- else if (STRINGP (obj))
- {
- return make_pure_string (XSTRING_DATA (obj),
- XSTRING_LENGTH (obj),
- XSTRING (obj)->plist,
- 0);
- }
-#endif /* LRECORD_STRING */
-#ifdef LISP_FLOAT_TYPE
- else if (FLOATP (obj))
- return make_pure_float (float_data (XFLOAT (obj)));
-#endif /* LISP_FLOAT_TYPE */
- else if (SYMBOLP (obj))
- {
- /*
- * Symbols can't be made pure (and thus read-only),
- * because assigning to their function, value or plist
- * slots would produced a SEGV in the dumped XEmacs. So
- * we previously would just return the symbol unchanged.
- *
- * But purified aggregate objects like lists and vectors
- * can contain uninterned symbols. If there are no
- * other non-pure references to the symbol, then the
- * symbol is not protected from garbage collection
- * because the collector does not mark the contents of
- * purified objects. So to protect the symbols, an impure
- * reference has to be kept for each uninterned symbol
- * that is referenced by a pure object. All such
- * symbols are stored in the hashtable pointed to by
- * Vpure_uninterned_symbol_table, which is itself
- * staticpro'd.
- */
- if (!NILP (XSYMBOL (obj)->obarray))
- return obj;
- Fputhash (obj, Qnil, Vpure_uninterned_symbol_table);
- return obj;
- }
- else
- signal_simple_error ("Can't purecopy %S", obj);
- }
- }
- return obj;
+ return object;
}
-
\f
-static void
-puresize_adjust_h (size_t puresize)
-{
- FILE *stream = fopen ("puresize-adjust.h", "w");
-
- if (stream == NULL)
- report_file_error ("Opening puresize adjustment file",
- Fcons (build_string ("puresize-adjust.h"), Qnil));
-
- fprintf (stream,
- "/*\tDo not edit this file!\n"
- "\tAutomatically generated by XEmacs */\n"
- "# define PURESIZE_ADJUSTMENT (%ld)\n",
- (long) (puresize - RAW_PURESIZE));
- fclose (stream);
-}
-
-void
-report_pure_usage (int report_impurities,
- int die_if_pure_storage_exceeded)
-{
- int rc = 0;
-
- if (pure_lossage)
- {
- message ("\n****\tPure Lisp storage exhausted!\n"
- "\tPurespace usage: %ld of %ld\n"
- "****",
- (long) get_PURESIZE() + pure_lossage,
- (long) get_PURESIZE());
- if (die_if_pure_storage_exceeded)
- {
- puresize_adjust_h (get_PURESIZE() + pure_lossage);
-#ifdef HEAP_IN_DATA
- sheap_adjust_h();
-#endif
- rc = -1;
- }
- }
- else
- {
- size_t lost = (get_PURESIZE() - pure_bytes_used) / 1024;
- char buf[200];
- /* extern Lisp_Object Vemacs_beta_version; */
- /* This used to be NILP(Vemacs_beta_version) ? 512 : 4; */
-#ifndef PURESIZE_SLOP
-#define PURESIZE_SLOP 0
-#endif
- size_t slop = PURESIZE_SLOP;
-
- sprintf (buf, "Purespace usage: %ld of %ld (%d%%",
- (long) pure_bytes_used,
- (long) get_PURESIZE(),
- (int) (pure_bytes_used / (get_PURESIZE() / 100.0) + 0.5));
- if (lost > ((slop ? slop : 1) / 1024)) {
- sprintf (buf + strlen (buf), " -- %ldk wasted", (long)lost);
- if (die_if_pure_storage_exceeded) {
- puresize_adjust_h (pure_bytes_used + slop);
-#ifdef HEAP_IN_DATA
- sheap_adjust_h();
-#endif
- rc = -1;
- }
- }
-
- strcat (buf, ").");
- message ("%s", buf);
- }
-
-#ifdef PURESTAT
-
- purestat_vector_other.nbytes =
- purestat_vector_all.nbytes -
- purestat_vector_bytecode_constants.nbytes;
- purestat_vector_other.nobjects =
- purestat_vector_all.nobjects -
- purestat_vector_bytecode_constants.nobjects;
-
- purestat_string_other.nbytes =
- purestat_string_all.nbytes -
- (purestat_string_pname.nbytes +
- purestat_string_bytecodes.nbytes +
- purestat_string_interactive.nbytes +
- purestat_string_documentation.nbytes +
-#ifdef I18N3
- purestat_string_domain.nbytes +
-#endif
- purestat_string_other_function.nbytes);
-
- purestat_string_other.nobjects =
- purestat_string_all.nobjects -
- (purestat_string_pname.nobjects +
- purestat_string_bytecodes.nobjects +
- purestat_string_interactive.nobjects +
- purestat_string_documentation.nobjects +
-#ifdef I18N3
- purestat_string_domain.nobjects +
-#endif
- purestat_string_other_function.nobjects);
-
- message (" %-26s Total Bytes", "");
+/************************************************************************/
+/* Garbage Collection */
+/************************************************************************/
- {
- int j;
-
- for (j = 0; j < countof (purestats); j++)
- if (!purestats[j])
- clear_message ();
- else
- {
- char buf [100];
- sprintf(buf, "%s:", purestats[j]->name);
- message (" %-26s %5d %7d %2d%%",
- buf,
- purestats[j]->nobjects,
- purestats[j]->nbytes,
- (int) (purestats[j]->nbytes / (pure_bytes_used / 100.0) + 0.5));
- }
- }
-#endif /* PURESTAT */
+/* All the built-in lisp object types are enumerated in `enum lrecord_type'.
+ Additional ones may be defined by a module (none yet). We leave some
+ room in `lrecord_implementations_table' for such new lisp object types. */
+const struct lrecord_implementation *lrecord_implementations_table[(unsigned int)lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT];
+unsigned int lrecord_type_count = (unsigned int)lrecord_type_last_built_in_type;
+/* Object marker functions are in the lrecord_implementation structure.
+ But copying them to a parallel array is much more cache-friendly.
+ This hack speeds up (garbage-collect) by about 5%. */
+Lisp_Object (*lrecord_markers[countof (lrecord_implementations_table)]) (Lisp_Object);
+struct gcpro *gcprolist;
- if (report_impurities)
- {
- Lisp_Object tem = Felt (Fgarbage_collect (), make_int (5));
- struct gcpro gcpro1;
- GCPRO1 (tem);
- message ("\nImpurities:");
- while (!NILP (tem))
- {
- if (CONSP (tem) && SYMBOLP (Fcar (tem)) && CONSP (Fcdr (tem)))
- {
- int total = XINT (Fcar (Fcdr (tem)));
- if (total > 0)
- {
- char buf [100];
- char *s = buf;
- memcpy (buf, string_data (XSYMBOL (Fcar (tem))->name),
- string_length (XSYMBOL (Fcar (tem))->name) + 1);
- while (*s++) if (*s == '-') *s = ' ';
- s--; *s++ = ':'; *s = 0;
- message (" %-33s %6d", buf, total);
- }
- tem = Fcdr (Fcdr (tem));
- }
- else /* WTF?! */
- {
- Fprin1 (tem, Qexternal_debugging_output);
- tem = Qnil;
- }
- }
- UNGCPRO;
- garbage_collect_1 (); /* GC garbage_collect's garbage */
- }
- clear_message ();
+/* We want the staticpros relocated, but not the pointers found therein.
+ Hence we use a trivial description, as for pointerless objects. */
+static const struct lrecord_description staticpro_description_1[] = {
+ { XD_END }
+};
- if (rc < 0) {
- unlink("SATISFIED");
- fatal ("Pure size adjusted, Don't Panic! I will restart the `make'");
- } else if (pure_lossage && die_if_pure_storage_exceeded) {
- fatal ("Pure storage exhausted");
- }
-}
+static const struct struct_description staticpro_description = {
+ sizeof (Lisp_Object *),
+ staticpro_description_1
+};
-\f
-/**********************************************************************/
-/* staticpro */
-/**********************************************************************/
+static const struct lrecord_description staticpros_description_1[] = {
+ XD_DYNARR_DESC (Lisp_Object_ptr_dynarr, &staticpro_description),
+ { XD_END }
+};
-struct gcpro *gcprolist;
+static const struct struct_description staticpros_description = {
+ sizeof (Lisp_Object_ptr_dynarr),
+ staticpros_description_1
+};
-/* 415 used Mly 29-Jun-93 */
-/* 1327 used slb 28-Feb-98 */
-#ifdef HAVE_SHLIB
-#define NSTATICS 4000
-#else
-#define NSTATICS 2000
-#endif
-/* Not "static" because of linker lossage on some systems */
-Lisp_Object *staticvec[NSTATICS]
- /* Force it into data space! */
- = {0};
-static int staticidx;
+Lisp_Object_ptr_dynarr *staticpros;
-/* Put an entry in staticvec, pointing at the variable whose address is given
- */
+/* Mark the Lisp_Object at non-heap VARADDRESS as a root object for
+ garbage collection, and for dumping. */
void
staticpro (Lisp_Object *varaddress)
{
- if (staticidx >= countof (staticvec))
- /* #### This is now a dubious abort() since this routine may be called */
- /* by Lisp attempting to load a DLL. */
- abort ();
- staticvec[staticidx++] = varaddress;
+ Dynarr_add (staticpros, varaddress);
+ dump_add_root_object (varaddress);
}
-\f
-/* Mark reference to a Lisp_Object. If the object referred to has not been
- seen yet, recursively mark all the references contained in it. */
-
-static void
-mark_object (Lisp_Object obj)
-{
- tail_recurse:
-
- if (EQ (obj, Qnull_pointer))
- return;
- if (!POINTER_TYPE_P (XGCTYPE (obj)))
- return;
- if (PURIFIED (XPNTR (obj)))
- return;
- switch (XGCTYPE (obj))
- {
-#ifndef LRECORD_CONS
- case Lisp_Type_Cons:
- {
- struct Lisp_Cons *ptr = XCONS (obj);
- if (CONS_MARKED_P (ptr))
- break;
- MARK_CONS (ptr);
- /* If the cdr is nil, tail-recurse on the car. */
- if (NILP (ptr->cdr))
- {
- obj = ptr->car;
- }
- else
- {
- mark_object (ptr->car);
- obj = ptr->cdr;
- }
- goto tail_recurse;
- }
-#endif
-
- case Lisp_Type_Record:
- /* case Lisp_Symbol_Value_Magic: */
- {
- struct lrecord_header *lheader = XRECORD_LHEADER (obj);
- CONST struct lrecord_implementation *implementation
- = LHEADER_IMPLEMENTATION (lheader);
-
- if (! MARKED_RECORD_HEADER_P (lheader) &&
- ! UNMARKABLE_RECORD_HEADER_P (lheader))
- {
- MARK_RECORD_HEADER (lheader);
-#ifdef ERROR_CHECK_GC
- if (!implementation->basic_p)
- assert (! ((struct lcrecord_header *) lheader)->free);
-#endif
- if (implementation->marker != 0)
- {
- obj = ((implementation->marker) (obj, mark_object));
- if (!NILP (obj)) goto tail_recurse;
- }
- }
- }
- break;
-
-#ifndef LRECORD_STRING
- case Lisp_Type_String:
- {
- struct Lisp_String *ptr = XSTRING (obj);
-
- if (!XMARKBIT (ptr->plist))
- {
- if (CONSP (ptr->plist) &&
- EXTENT_INFOP (XCAR (ptr->plist)))
- flush_cached_extent_info (XCAR (ptr->plist));
- XMARK (ptr->plist);
- obj = ptr->plist;
- goto tail_recurse;
- }
- }
- break;
-#endif /* ! LRECORD_STRING */
-
-#ifndef LRECORD_VECTOR
- case Lisp_Type_Vector:
- {
- struct Lisp_Vector *ptr = XVECTOR (obj);
- int len = vector_length (ptr);
- int i;
-
- if (len < 0)
- break; /* Already marked */
- ptr->size = -1 - len; /* Else mark it */
- for (i = 0; i < len - 1; i++) /* and then mark its elements */
- mark_object (ptr->contents[i]);
- if (len > 0)
- {
- obj = ptr->contents[len - 1];
- goto tail_recurse;
- }
- }
- break;
-#endif /* !LRECORD_VECTOR */
-
-#ifndef LRECORD_SYMBOL
- case Lisp_Type_Symbol:
- {
- struct Lisp_Symbol *sym = XSYMBOL (obj);
-
- while (!XMARKBIT (sym->plist))
- {
- XMARK (sym->plist);
- mark_object (sym->value);
- mark_object (sym->function);
- {
- /*
- * symbol->name is a struct Lisp_String *, not a
- * Lisp_Object. Fix it up and pass to mark_object.
- */
- Lisp_Object symname;
- XSETSTRING(symname, sym->name);
- mark_object(symname);
- }
- if (!symbol_next (sym))
- {
- obj = sym->plist;
- goto tail_recurse;
- }
- mark_object (sym->plist);
- /* Mark the rest of the symbols in the hash-chain */
- sym = symbol_next (sym);
- }
- }
- break;
-#endif /* !LRECORD_SYMBOL */
-
- default:
- abort ();
- }
-}
-/* mark all of the conses in a list and mark the final cdr; but
- DO NOT mark the cars.
+Lisp_Object_ptr_dynarr *staticpros_nodump;
- Use only for internal lists! There should never be other pointers
- to the cons cells, because if so, the cars will remain unmarked
- even when they maybe should be marked. */
+/* Mark the Lisp_Object at non-heap VARADDRESS as a root object for
+ garbage collection, but not for dumping. */
void
-mark_conses_in_list (Lisp_Object obj)
-{
- Lisp_Object rest;
-
- for (rest = obj; CONSP (rest); rest = XCDR (rest))
- {
- if (CONS_MARKED_P (XCONS (rest)))
- return;
- MARK_CONS (XCONS (rest));
- }
-
- mark_object (rest);
-}
-
-\f
-#ifdef PURESTAT
-/* Simpler than mark-object, because pure structure can't
- have any circularities */
-
-#if 0 /* unused */
-static int idiot_c_doesnt_have_closures;
-static void
-idiot_c (Lisp_Object obj)
+staticpro_nodump (Lisp_Object *varaddress)
{
- idiot_c_doesnt_have_closures += pure_sizeof (obj, 1);
+ Dynarr_add (staticpros_nodump, varaddress);
}
-#endif /* unused */
-
-static size_t
-pure_string_sizeof (Lisp_Object obj)
-{
- struct Lisp_String *ptr = XSTRING (obj);
-
- if (string_data (ptr) != (Bufbyte *) ptr + sizeof (*ptr))
- {
- /* string-data not allocated contiguously.
- Probably (better be!!) a pointer constant "C" data. */
- return sizeof (*ptr);
- }
- else
- {
- size_t size = sizeof (*ptr) + string_length (ptr) + 1;
- size = ALIGN_SIZE (size, sizeof (Lisp_Object));
- return size;
- }
-}
-
-/* recurse arg isn't actually used */
-static size_t
-pure_sizeof (Lisp_Object obj /*, int recurse */)
-{
- size_t total = 0;
-
- /*tail_recurse: */
- if (!POINTER_TYPE_P (XTYPE (obj))
- || !PURIFIED (XPNTR (obj)))
- return total;
- /* symbol's sizes are accounted for separately */
- if (SYMBOLP (obj))
- return total;
+#ifdef ERROR_CHECK_GC
+#define GC_CHECK_LHEADER_INVARIANTS(lheader) do { \
+ struct lrecord_header * GCLI_lh = (lheader); \
+ assert (GCLI_lh != 0); \
+ assert (GCLI_lh->type < lrecord_type_count); \
+ assert (! C_READONLY_RECORD_HEADER_P (GCLI_lh) || \
+ (MARKED_RECORD_HEADER_P (GCLI_lh) && \
+ LISP_READONLY_RECORD_HEADER_P (GCLI_lh))); \
+} while (0)
+#else
+#define GC_CHECK_LHEADER_INVARIANTS(lheader)
+#endif
- switch (XTYPE (obj))
- {
+\f
+/* Mark reference to a Lisp_Object. If the object referred to has not been
+ seen yet, recursively mark all the references contained in it. */
-#ifndef LRECORD_STRING
- case Lisp_Type_String:
- total += pure_string_sizeof (obj);
- break;
-#endif /* ! LRECORD_STRING */
+void
+mark_object (Lisp_Object obj)
+{
+ tail_recurse:
-#ifndef LRECORD_VECTOR
- case Lisp_Type_Vector:
- {
- struct Lisp_Vector *ptr = XVECTOR (obj);
- int len = vector_length (ptr);
-
- total += (sizeof (struct Lisp_Vector)
- + (len - 1) * sizeof (Lisp_Object));
-#if 0 /* unused */
- if (!recurse)
- break;
- {
- int i;
- for (i = 0; i < len - 1; i++)
- total += pure_sizeof (ptr->contents[i], 1);
- }
- if (len > 0)
- {
- obj = ptr->contents[len - 1];
- goto tail_recurse;
- }
-#endif /* unused */
- }
- break;
-#endif /* !LRECORD_VECTOR */
+ /* Checks we used to perform */
+ /* if (EQ (obj, Qnull_pointer)) return; */
+ /* if (!POINTER_TYPE_P (XGCTYPE (obj))) return; */
+ /* if (PURIFIED (XPNTR (obj))) return; */
- case Lisp_Type_Record:
- {
- struct lrecord_header *lheader = XRECORD_LHEADER (obj);
- CONST struct lrecord_implementation *implementation
- = LHEADER_IMPLEMENTATION (lheader);
+ if (XTYPE (obj) == Lisp_Type_Record)
+ {
+ struct lrecord_header *lheader = XRECORD_LHEADER (obj);
-#ifdef LRECORD_STRING
- if (STRINGP (obj))
- total += pure_string_sizeof (obj);
- else
-#endif
- if (implementation->size_in_bytes_method)
- total += ((implementation->size_in_bytes_method) (lheader));
- else
- total += implementation->static_size;
+ GC_CHECK_LHEADER_INVARIANTS (lheader);
-#if 0 /* unused */
- if (!recurse)
- break;
+ gc_checking_assert (LHEADER_IMPLEMENTATION (lheader)->basic_p ||
+ ! ((struct lcrecord_header *) lheader)->free);
- if (implementation->marker != 0)
- {
- int old = idiot_c_doesnt_have_closures;
+ /* All c_readonly objects have their mark bit set,
+ so that we only need to check the mark bit here. */
+ if (! MARKED_RECORD_HEADER_P (lheader))
+ {
+ MARK_RECORD_HEADER (lheader);
- idiot_c_doesnt_have_closures = 0;
- obj = ((implementation->marker) (obj, idiot_c));
- total += idiot_c_doesnt_have_closures;
- idiot_c_doesnt_have_closures = old;
+ if (RECORD_MARKER (lheader))
+ {
+ obj = RECORD_MARKER (lheader) (obj);
+ if (!NILP (obj)) goto tail_recurse;
+ }
+ }
+ }
+}
- if (!NILP (obj)) goto tail_recurse;
- }
-#endif /* unused */
- }
- break;
+/* mark all of the conses in a list and mark the final cdr; but
+ DO NOT mark the cars.
-#ifndef LRECORD_CONS
- case Lisp_Type_Cons:
- {
- struct Lisp_Cons *ptr = XCONS (obj);
- total += sizeof (*ptr);
-#if 0 /* unused */
- if (!recurse)
- break;
- /* If the cdr is nil, tail-recurse on the car. */
- if (NILP (ptr->cdr))
- {
- obj = ptr->car;
- }
- else
- {
- total += pure_sizeof (ptr->car, 1);
- obj = ptr->cdr;
- }
- goto tail_recurse;
-#endif /* unused */
- }
- break;
-#endif
+ Use only for internal lists! There should never be other pointers
+ to the cons cells, because if so, the cars will remain unmarked
+ even when they maybe should be marked. */
+void
+mark_conses_in_list (Lisp_Object obj)
+{
+ Lisp_Object rest;
- /* Others can't be purified */
- default:
- abort ();
+ for (rest = obj; CONSP (rest); rest = XCDR (rest))
+ {
+ if (CONS_MARKED_P (XCONS (rest)))
+ return;
+ MARK_CONS (XCONS (rest));
}
- return total;
-}
-#endif /* PURESTAT */
-
+ mark_object (rest);
+}
\f
/* Find all structures not marked, and free them. */
-#ifndef LRECORD_VECTOR
-static int gc_count_num_vector_used, gc_count_vector_total_size;
-static int gc_count_vector_storage;
-#endif
static int gc_count_num_bit_vector_used, gc_count_bit_vector_total_size;
static int gc_count_bit_vector_storage;
static int gc_count_num_short_string_in_use;
/* static int gc_count_total_records_used, gc_count_records_total_size; */
\f
-/* This will be used more extensively In The Future */
-static int last_lrecord_type_index_assigned;
-
-CONST struct lrecord_implementation *lrecord_implementations_table[128];
-#define max_lrecord_type (countof (lrecord_implementations_table) - 1)
-
-int
-lrecord_type_index (CONST struct lrecord_implementation *implementation)
-{
- int type_index = *(implementation->lrecord_type_index);
- /* Have to do this circuitous validation test because of problems
- dumping out initialized variables (ie can't set xxx_type_index to -1
- because that would make xxx_type_index read-only in a dumped emacs. */
- if (type_index < 0 || type_index > max_lrecord_type
- || lrecord_implementations_table[type_index] != implementation)
- {
- if (last_lrecord_type_index_assigned == max_lrecord_type)
- abort ();
- type_index = ++last_lrecord_type_index_assigned;
- lrecord_implementations_table[type_index] = implementation;
- *(implementation->lrecord_type_index) = type_index;
- }
- return type_index;
-}
-
/* stats on lcrecords in use - kinda kludgy */
static struct
int instances_freed;
int bytes_freed;
int instances_on_free_list;
-} lcrecord_stats [countof (lrecord_implementations_table)];
-
-
-static void
-reset_lcrecord_stats (void)
-{
- int i;
- for (i = 0; i < countof (lcrecord_stats); i++)
- {
- lcrecord_stats[i].instances_in_use = 0;
- lcrecord_stats[i].bytes_in_use = 0;
- lcrecord_stats[i].instances_freed = 0;
- lcrecord_stats[i].bytes_freed = 0;
- lcrecord_stats[i].instances_on_free_list = 0;
- }
-}
+} lcrecord_stats [countof (lrecord_implementations_table)
+ + MODULE_DEFINABLE_TYPE_COUNT];
static void
-tick_lcrecord_stats (CONST struct lrecord_header *h, int free_p)
+tick_lcrecord_stats (const struct lrecord_header *h, int free_p)
{
- CONST struct lrecord_implementation *implementation =
- LHEADER_IMPLEMENTATION (h);
- int type_index = lrecord_type_index (implementation);
+ unsigned int type_index = h->type;
if (((struct lcrecord_header *) h)->free)
{
- assert (!free_p);
+ gc_checking_assert (!free_p);
lcrecord_stats[type_index].instances_on_free_list++;
}
else
{
- size_t sz = (implementation->size_in_bytes_method
- ? ((implementation->size_in_bytes_method) (h))
- : implementation->static_size);
+ const struct lrecord_implementation *implementation =
+ LHEADER_IMPLEMENTATION (h);
+ size_t sz = (implementation->size_in_bytes_method ?
+ implementation->size_in_bytes_method (h) :
+ implementation->static_size);
if (free_p)
{
lcrecord_stats[type_index].instances_freed++;
struct lcrecord_header *header;
int num_used = 0;
/* int total_size = 0; */
- reset_lcrecord_stats ();
+
+ xzero (lcrecord_stats); /* Reset all statistics to 0. */
/* First go through and call all the finalize methods.
Then go through and free the objects. There used to
for (header = *prev; header; header = header->next)
{
struct lrecord_header *h = &(header->lheader);
- if (!MARKED_RECORD_HEADER_P (h) && ! (header->free))
+
+ GC_CHECK_LHEADER_INVARIANTS (h);
+
+ if (! MARKED_RECORD_HEADER_P (h) && ! header->free)
{
if (LHEADER_IMPLEMENTATION (h)->finalizer)
- ((LHEADER_IMPLEMENTATION (h)->finalizer) (h, 0));
+ LHEADER_IMPLEMENTATION (h)->finalizer (h, 0);
}
}
struct lrecord_header *h = &(header->lheader);
if (MARKED_RECORD_HEADER_P (h))
{
- UNMARK_RECORD_HEADER (h);
+ if (! C_READONLY_RECORD_HEADER_P (h))
+ UNMARK_RECORD_HEADER (h);
num_used++;
- /* total_size += ((n->implementation->size_in_bytes) (h));*/
+ /* total_size += n->implementation->size_in_bytes (h);*/
+ /* #### May modify header->next on a C_READONLY lcrecord */
prev = &(header->next);
header = *prev;
tick_lcrecord_stats (h, 0);
/* *total = total_size; */
}
-#ifndef LRECORD_VECTOR
-
-static void
-sweep_vectors_1 (Lisp_Object *prev,
- int *used, int *total, int *storage)
-{
- Lisp_Object vector;
- int num_used = 0;
- int total_size = 0;
- int total_storage = 0;
-
- for (vector = *prev; VECTORP (vector); )
- {
- struct Lisp_Vector *v = XVECTOR (vector);
- int len = v->size;
- if (len < 0) /* marked */
- {
- len = - (len + 1);
- v->size = len;
- total_size += len;
- total_storage += (MALLOC_OVERHEAD
- + sizeof (struct Lisp_Vector)
- + (len - 1 + 1) * sizeof (Lisp_Object));
- num_used++;
- prev = &(vector_next (v));
- vector = *prev;
- }
- else
- {
- Lisp_Object next = vector_next (v);
- *prev = next;
- xfree (v);
- vector = next;
- }
- }
- *used = num_used;
- *total = total_size;
- *storage = total_storage;
-}
-
-#endif /* ! LRECORD_VECTOR */
static void
sweep_bit_vectors_1 (Lisp_Object *prev,
their implementation */
for (bit_vector = *prev; !EQ (bit_vector, Qzero); )
{
- struct Lisp_Bit_Vector *v = XBIT_VECTOR (bit_vector);
+ Lisp_Bit_Vector *v = XBIT_VECTOR (bit_vector);
int len = v->size;
if (MARKED_RECORD_P (bit_vector))
{
- UNMARK_RECORD_HEADER (&(v->lheader));
+ if (! C_READONLY_RECORD_HEADER_P(&(v->lheader)))
+ UNMARK_RECORD_HEADER (&(v->lheader));
total_size += len;
- total_storage += (MALLOC_OVERHEAD
- + sizeof (struct Lisp_Bit_Vector)
- + (BIT_VECTOR_LONG_STORAGE (len) - 1)
- * sizeof (long));
+ total_storage +=
+ MALLOC_OVERHEAD +
+ FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, unsigned long,
+ bits, BIT_VECTOR_LONG_STORAGE (len));
num_used++;
+ /* #### May modify next on a C_READONLY bitvector */
prev = &(bit_vector_next (v));
bit_vector = *prev;
}
#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
do { \
- struct typename##_block *_frob_current; \
- struct typename##_block **_frob_prev; \
- int _frob_limit; \
+ struct typename##_block *SFTB_current; \
+ int SFTB_limit; \
int num_free = 0, num_used = 0; \
\
- for (_frob_prev = ¤t_##typename##_block, \
- _frob_current = current_##typename##_block, \
- _frob_limit = current_##typename##_block_index; \
- _frob_current; \
+ for (SFTB_current = current_##typename##_block, \
+ SFTB_limit = current_##typename##_block_index; \
+ SFTB_current; \
) \
{ \
- int _frob_iii; \
+ int SFTB_iii; \
\
- for (_frob_iii = 0; _frob_iii < _frob_limit; _frob_iii++) \
+ for (SFTB_iii = 0; SFTB_iii < SFTB_limit; SFTB_iii++) \
{ \
- obj_type *_frob_victim = &(_frob_current->block[_frob_iii]); \
+ obj_type *SFTB_victim = &(SFTB_current->block[SFTB_iii]); \
\
- if (FREE_STRUCT_P (_frob_victim)) \
+ if (LRECORD_FREE_P (SFTB_victim)) \
{ \
num_free++; \
} \
- else if (!MARKED_##typename##_P (_frob_victim)) \
+ else if (C_READONLY_RECORD_HEADER_P (&SFTB_victim->lheader)) \
+ { \
+ num_used++; \
+ } \
+ else if (! MARKED_RECORD_HEADER_P (&SFTB_victim->lheader)) \
{ \
num_free++; \
- FREE_FIXED_TYPE (typename, obj_type, _frob_victim); \
+ FREE_FIXED_TYPE (typename, obj_type, SFTB_victim); \
} \
else \
{ \
num_used++; \
- UNMARK_##typename (_frob_victim); \
+ UNMARK_##typename (SFTB_victim); \
} \
} \
- _frob_prev = &(_frob_current->prev); \
- _frob_current = _frob_current->prev; \
- _frob_limit = countof (current_##typename##_block->block); \
+ SFTB_current = SFTB_current->prev; \
+ SFTB_limit = countof (current_##typename##_block->block); \
} \
\
gc_count_num_##typename##_in_use = num_used; \
#else /* !ERROR_CHECK_GC */
-#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
-do { \
- struct typename##_block *_frob_current; \
- struct typename##_block **_frob_prev; \
- int _frob_limit; \
- int num_free = 0, num_used = 0; \
- \
- typename##_free_list = 0; \
- \
- for (_frob_prev = ¤t_##typename##_block, \
- _frob_current = current_##typename##_block, \
- _frob_limit = current_##typename##_block_index; \
- _frob_current; \
- ) \
- { \
- int _frob_iii; \
- int _frob_empty = 1; \
- obj_type *_frob_old_free_list = typename##_free_list; \
- \
- for (_frob_iii = 0; _frob_iii < _frob_limit; _frob_iii++) \
- { \
- obj_type *_frob_victim = &(_frob_current->block[_frob_iii]); \
- \
- if (FREE_STRUCT_P (_frob_victim)) \
- { \
- num_free++; \
- PUT_FIXED_TYPE_ON_FREE_LIST (typename, obj_type, _frob_victim); \
- } \
- else if (!MARKED_##typename##_P (_frob_victim)) \
- { \
- num_free++; \
- FREE_FIXED_TYPE (typename, obj_type, _frob_victim); \
- } \
- else \
- { \
- _frob_empty = 0; \
- num_used++; \
- UNMARK_##typename (_frob_victim); \
- } \
- } \
- if (!_frob_empty) \
- { \
- _frob_prev = &(_frob_current->prev); \
- _frob_current = _frob_current->prev; \
- } \
- else if (_frob_current == current_##typename##_block \
- && !_frob_current->prev) \
- { \
- /* No real point in freeing sole allocation block */ \
- break; \
- } \
- else \
- { \
- struct typename##_block *_frob_victim_block = _frob_current; \
- if (_frob_victim_block == current_##typename##_block) \
- current_##typename##_block_index \
- = countof (current_##typename##_block->block); \
- _frob_current = _frob_current->prev; \
- { \
- *_frob_prev = _frob_current; \
- xfree (_frob_victim_block); \
- /* Restore free list to what it was before victim was swept */ \
- typename##_free_list = _frob_old_free_list; \
- num_free -= _frob_limit; \
- } \
- } \
- _frob_limit = countof (current_##typename##_block->block); \
- } \
- \
- gc_count_num_##typename##_in_use = num_used; \
- gc_count_num_##typename##_freelist = num_free; \
+#define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
+do { \
+ struct typename##_block *SFTB_current; \
+ struct typename##_block **SFTB_prev; \
+ int SFTB_limit; \
+ int num_free = 0, num_used = 0; \
+ \
+ typename##_free_list = 0; \
+ \
+ for (SFTB_prev = ¤t_##typename##_block, \
+ SFTB_current = current_##typename##_block, \
+ SFTB_limit = current_##typename##_block_index; \
+ SFTB_current; \
+ ) \
+ { \
+ int SFTB_iii; \
+ int SFTB_empty = 1; \
+ Lisp_Free *SFTB_old_free_list = typename##_free_list; \
+ \
+ for (SFTB_iii = 0; SFTB_iii < SFTB_limit; SFTB_iii++) \
+ { \
+ obj_type *SFTB_victim = &(SFTB_current->block[SFTB_iii]); \
+ \
+ if (LRECORD_FREE_P (SFTB_victim)) \
+ { \
+ num_free++; \
+ PUT_FIXED_TYPE_ON_FREE_LIST (typename, obj_type, SFTB_victim); \
+ } \
+ else if (C_READONLY_RECORD_HEADER_P (&SFTB_victim->lheader)) \
+ { \
+ SFTB_empty = 0; \
+ num_used++; \
+ } \
+ else if (! MARKED_RECORD_HEADER_P (&SFTB_victim->lheader)) \
+ { \
+ num_free++; \
+ FREE_FIXED_TYPE (typename, obj_type, SFTB_victim); \
+ } \
+ else \
+ { \
+ SFTB_empty = 0; \
+ num_used++; \
+ UNMARK_##typename (SFTB_victim); \
+ } \
+ } \
+ if (!SFTB_empty) \
+ { \
+ SFTB_prev = &(SFTB_current->prev); \
+ SFTB_current = SFTB_current->prev; \
+ } \
+ else if (SFTB_current == current_##typename##_block \
+ && !SFTB_current->prev) \
+ { \
+ /* No real point in freeing sole allocation block */ \
+ break; \
+ } \
+ else \
+ { \
+ struct typename##_block *SFTB_victim_block = SFTB_current; \
+ if (SFTB_victim_block == current_##typename##_block) \
+ current_##typename##_block_index \
+ = countof (current_##typename##_block->block); \
+ SFTB_current = SFTB_current->prev; \
+ { \
+ *SFTB_prev = SFTB_current; \
+ xfree (SFTB_victim_block); \
+ /* Restore free list to what it was before victim was swept */ \
+ typename##_free_list = SFTB_old_free_list; \
+ num_free -= SFTB_limit; \
+ } \
+ } \
+ SFTB_limit = countof (current_##typename##_block->block); \
+ } \
+ \
+ gc_count_num_##typename##_in_use = num_used; \
+ gc_count_num_##typename##_freelist = num_free; \
} while (0)
#endif /* !ERROR_CHECK_GC */
static void
sweep_conses (void)
{
-#ifndef LRECORD_CONS
-# define MARKED_cons_P(ptr) XMARKBIT ((ptr)->car)
-# define UNMARK_cons(ptr) do { XUNMARK ((ptr)->car); } while (0)
-#else /* LRECORD_CONS */
-# define MARKED_cons_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
-# define UNMARK_cons(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#endif /* LRECORD_CONS */
+#define UNMARK_cons(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_cons(ptr)
- SWEEP_FIXED_TYPE_BLOCK (cons, struct Lisp_Cons);
+ SWEEP_FIXED_TYPE_BLOCK (cons, Lisp_Cons);
}
/* Explicitly free a cons cell. */
void
-free_cons (struct Lisp_Cons *ptr)
+free_cons (Lisp_Cons *ptr)
{
#ifdef ERROR_CHECK_GC
/* If the CAR is not an int, then it will be a pointer, which will
#endif /* ERROR_CHECK_GC */
#ifndef ALLOC_NO_POOLS
- FREE_FIXED_TYPE_WHEN_NOT_IN_GC (cons, struct Lisp_Cons, ptr);
+ FREE_FIXED_TYPE_WHEN_NOT_IN_GC (cons, Lisp_Cons, ptr);
#endif /* ALLOC_NO_POOLS */
}
static void
sweep_compiled_functions (void)
{
-#define MARKED_compiled_function_P(ptr) \
- MARKED_RECORD_HEADER_P (&((ptr)->lheader))
#define UNMARK_compiled_function(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_compiled_function(ptr)
- SWEEP_FIXED_TYPE_BLOCK (compiled_function, struct Lisp_Compiled_Function);
+ SWEEP_FIXED_TYPE_BLOCK (compiled_function, Lisp_Compiled_Function);
}
static void
sweep_floats (void)
{
-#define MARKED_float_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
#define UNMARK_float(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_float(ptr)
- SWEEP_FIXED_TYPE_BLOCK (float, struct Lisp_Float);
+ SWEEP_FIXED_TYPE_BLOCK (float, Lisp_Float);
}
#endif /* LISP_FLOAT_TYPE */
static void
sweep_symbols (void)
{
-#ifndef LRECORD_SYMBOL
-# define MARKED_symbol_P(ptr) XMARKBIT ((ptr)->plist)
-# define UNMARK_symbol(ptr) do { XUNMARK ((ptr)->plist); } while (0)
-#else
-# define MARKED_symbol_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
-# define UNMARK_symbol(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
-#endif /* !LRECORD_SYMBOL */
+#define UNMARK_symbol(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_symbol(ptr)
- SWEEP_FIXED_TYPE_BLOCK (symbol, struct Lisp_Symbol);
+ SWEEP_FIXED_TYPE_BLOCK (symbol, Lisp_Symbol);
}
static void
sweep_extents (void)
{
-#define MARKED_extent_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
#define UNMARK_extent(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_extent(ptr)
static void
sweep_events (void)
{
-#define MARKED_event_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
#define UNMARK_event(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_event(ptr)
- SWEEP_FIXED_TYPE_BLOCK (event, struct Lisp_Event);
+ SWEEP_FIXED_TYPE_BLOCK (event, Lisp_Event);
}
static void
sweep_markers (void)
{
-#define MARKED_marker_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
#define UNMARK_marker(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
#define ADDITIONAL_FREE_marker(ptr) \
do { Lisp_Object tem; \
unchain_marker (tem); \
} while (0)
- SWEEP_FIXED_TYPE_BLOCK (marker, struct Lisp_Marker);
+ SWEEP_FIXED_TYPE_BLOCK (marker, Lisp_Marker);
}
/* Explicitly free a marker. */
void
-free_marker (struct Lisp_Marker *ptr)
+free_marker (Lisp_Marker *ptr)
{
-#ifdef ERROR_CHECK_GC
/* Perhaps this will catch freeing an already-freed marker. */
- Lisp_Object temmy;
- XSETMARKER (temmy, ptr);
- assert (GC_MARKERP (temmy));
-#endif /* ERROR_CHECK_GC */
+ gc_checking_assert (ptr->lheader.type == lrecord_type_marker);
#ifndef ALLOC_NO_POOLS
- FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, struct Lisp_Marker, ptr);
+ FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, Lisp_Marker, ptr);
#endif /* ALLOC_NO_POOLS */
}
\f
{
struct string_chars *s_chars =
(struct string_chars *) &(sb->string_chars[pos]);
- struct Lisp_String *string;
+ Lisp_String *string;
int size;
int fullsize;
- /* If the string_chars struct is marked as free (i.e. the STRING
- pointer is 0xFFFFFFFF) then this is an unused chunk of string
- storage. (See below.) */
+ /* If the string_chars struct is marked as free (i.e. the
+ STRING pointer is NULL) then this is an unused chunk of
+ string storage. (See below.) */
- if (FREE_STRUCT_P (s_chars))
+ if (STRING_CHARS_FREE_P (s_chars))
{
fullsize = ((struct unused_string_chars *) s_chars)->fullsize;
pos += fullsize;
struct string_chars *from_s_chars =
(struct string_chars *) &(from_sb->string_chars[from_pos]);
struct string_chars *to_s_chars;
- struct Lisp_String *string;
+ Lisp_String *string;
int size;
int fullsize;
- /* If the string_chars struct is marked as free (i.e. the STRING
- pointer is 0xFFFFFFFF) then this is an unused chunk of string
- storage. This happens under Mule when a string's size changes
- in such a way that its fullsize changes. (Strings can change
- size because a different-length character can be substituted
- for another character.) In this case, after the bogus string
- pointer is the "fullsize" of this entry, i.e. how many bytes
- to skip. */
+ /* If the string_chars struct is marked as free (i.e. the
+ STRING pointer is NULL) then this is an unused chunk of
+ string storage. This happens under Mule when a string's
+ size changes in such a way that its fullsize changes.
+ (Strings can change size because a different-length
+ character can be substituted for another character.)
+ In this case, after the bogus string pointer is the
+ "fullsize" of this entry, i.e. how many bytes to skip. */
- if (FREE_STRUCT_P (from_s_chars))
+ if (STRING_CHARS_FREE_P (from_s_chars))
{
fullsize = ((struct unused_string_chars *) from_s_chars)->fullsize;
from_pos += fullsize;
}
string = from_s_chars->string;
- assert (!(FREE_STRUCT_P (string)));
+ assert (!(LRECORD_FREE_P (string)));
size = string_length (string);
fullsize = STRING_FULLSIZE (size);
- if (BIG_STRING_FULLSIZE_P (fullsize))
- abort ();
+ gc_checking_assert (! BIG_STRING_FULLSIZE_P (fullsize));
/* Just skip it if it isn't marked. */
-#ifdef LRECORD_STRING
if (! MARKED_RECORD_HEADER_P (&(string->lheader)))
-#else
- if (!XMARKBIT (string->plist))
-#endif
{
from_pos += fullsize;
continue;
static int debug_string_purity;
static void
-debug_string_purity_print (struct Lisp_String *p)
+debug_string_purity_print (Lisp_String *p)
{
Charcount i;
Charcount s = string_char_length (p);
- putc ('\"', stderr);
+ stderr_out ("\"");
for (i = 0; i < s; i++)
{
Emchar ch = string_char (p, i);
int num_small_used = 0, num_small_bytes = 0, num_bytes = 0;
int debug = debug_string_purity;
-#ifdef LRECORD_STRING
-
-# define MARKED_string_P(ptr) MARKED_RECORD_HEADER_P (&((ptr)->lheader))
-# define UNMARK_string(ptr) \
- do { struct Lisp_String *p = (ptr); \
- int size = string_length (p); \
- UNMARK_RECORD_HEADER (&(p->lheader)); \
- num_bytes += size; \
- if (!BIG_STRING_SIZE_P (size)) \
- { num_small_bytes += size; \
- num_small_used++; \
- } \
- if (debug) debug_string_purity_print (p); \
- } while (0)
-# define ADDITIONAL_FREE_string(p) \
- do { int size = string_length (p); \
- if (BIG_STRING_SIZE_P (size)) \
- xfree_1 (CHARS_TO_STRING_CHAR (string_data (p))); \
- } while (0)
-
-#else
-
-# define MARKED_string_P(ptr) XMARKBIT ((ptr)->plist)
-# define UNMARK_string(ptr) \
- do { struct Lisp_String *p = (ptr); \
- int size = string_length (p); \
- XUNMARK (p->plist); \
- num_bytes += size; \
- if (!BIG_STRING_SIZE_P (size)) \
- { num_small_bytes += size; \
- num_small_used++; \
- } \
- if (debug) debug_string_purity_print (p); \
- } while (0)
-# define ADDITIONAL_FREE_string(p) \
- do { int size = string_length (p); \
- if (BIG_STRING_SIZE_P (size)) \
- xfree_1 (CHARS_TO_STRING_CHAR (string_data (p))); \
- } while (0)
-
-#endif /* ! LRECORD_STRING */
+#define UNMARK_string(ptr) do { \
+ Lisp_String *p = (ptr); \
+ size_t size = string_length (p); \
+ UNMARK_RECORD_HEADER (&(p->lheader)); \
+ num_bytes += size; \
+ if (!BIG_STRING_SIZE_P (size)) \
+ { \
+ num_small_bytes += size; \
+ num_small_used++; \
+ } \
+ if (debug) \
+ debug_string_purity_print (p); \
+ } while (0)
+#define ADDITIONAL_FREE_string(ptr) do { \
+ size_t size = string_length (ptr); \
+ if (BIG_STRING_SIZE_P (size)) \
+ xfree (ptr->data); \
+ } while (0)
- SWEEP_FIXED_TYPE_BLOCK (string, struct Lisp_String);
+ SWEEP_FIXED_TYPE_BLOCK (string, Lisp_String);
gc_count_num_short_string_in_use = num_small_used;
gc_count_string_total_size = num_bytes;
/* I hate duplicating all this crap! */
-static int
+int
marked_p (Lisp_Object obj)
{
- if (EQ (obj, Qnull_pointer)) return 1;
- if (!POINTER_TYPE_P (XGCTYPE (obj))) return 1;
- if (PURIFIED (XPNTR (obj))) return 1;
- switch (XGCTYPE (obj))
+ /* Checks we used to perform. */
+ /* if (EQ (obj, Qnull_pointer)) return 1; */
+ /* if (!POINTER_TYPE_P (XGCTYPE (obj))) return 1; */
+ /* if (PURIFIED (XPNTR (obj))) return 1; */
+
+ if (XTYPE (obj) == Lisp_Type_Record)
{
-#ifndef LRECORD_CONS
- case Lisp_Type_Cons:
- return XMARKBIT (XCAR (obj));
-#endif
- case Lisp_Type_Record:
- return MARKED_RECORD_HEADER_P (XRECORD_LHEADER (obj));
-#ifndef LRECORD_STRING
- case Lisp_Type_String:
- return XMARKBIT (XSTRING (obj)->plist);
-#endif /* ! LRECORD_STRING */
-#ifndef LRECORD_VECTOR
- case Lisp_Type_Vector:
- return XVECTOR_LENGTH (obj) < 0;
-#endif /* !LRECORD_VECTOR */
-#ifndef LRECORD_SYMBOL
- case Lisp_Type_Symbol:
- return XMARKBIT (XSYMBOL (obj)->plist);
-#endif
- default:
- abort ();
+ struct lrecord_header *lheader = XRECORD_LHEADER (obj);
+
+ GC_CHECK_LHEADER_INVARIANTS (lheader);
+
+ return MARKED_RECORD_HEADER_P (lheader);
}
- return 0; /* suppress compiler warning */
+ return 1;
}
static void
/* Put all unmarked conses on free list */
sweep_conses ();
-#ifndef LRECORD_VECTOR
- /* Free all unmarked vectors */
- sweep_vectors_1 (&all_vectors,
- &gc_count_num_vector_used, &gc_count_vector_total_size,
- &gc_count_vector_storage);
-#endif
-
/* Free all unmarked bit vectors */
sweep_bit_vectors_1 (&all_bit_vectors,
&gc_count_num_bit_vector_used,
sweep_events ();
+#ifdef PDUMP
+ pdump_objects_unmark ();
+#endif
}
\f
/* Clearing for disksave. */
{
/* It's important that certain information from the environment not get
dumped with the executable (pathnames, environment variables, etc.).
- To make it easier to tell when this has happend with strings(1) we
+ To make it easier to tell when this has happened with strings(1) we
clear some known-to-be-garbage blocks of memory, so that leftover
results of old evaluation don't look like potential problems.
But first we set some notable variables to nil and do one more GC,
to turn those strings into garbage.
- */
+ */
/* Yeah, this list is pretty ad-hoc... */
Vprocess_environment = Qnil;
Vexec_path = Qnil;
Vload_path = Qnil;
/* Vdump_load_path = Qnil; */
+ /* Release hash tables for locate_file */
+ Flocate_file_clear_hashing (Qt);
uncache_home_directory();
#if defined(LOADHIST) && !(defined(LOADHIST_DUMPED) || \
/* Run the disksave finalization methods of all live objects. */
disksave_object_finalization_1 ();
-#if 0 /* I don't see any point in this. The purespace starts out all 0's */
- /* Zero out the unused portion of purespace */
- if (!pure_lossage)
- memset ( (char *) (PUREBEG + pure_bytes_used), 0,
- (((char *) (PUREBEG + get_PURESIZE())) -
- ((char *) (PUREBEG + pure_bytes_used))));
-#endif
-
/* Zero out the uninitialized (really, unused) part of the containers
for the live strings. */
{
int count = sizeof (scb->string_chars) - scb->pos;
assert (count >= 0 && count < STRING_CHARS_BLOCK_SIZE);
- if (count != 0) {
- /* from the block's fill ptr to the end */
- memset ((scb->string_chars + scb->pos), 0, count);
- }
+ if (count != 0)
+ {
+ /* from the block's fill ptr to the end */
+ memset ((scb->string_chars + scb->pos), 0, count);
+ }
}
}
/* Maybe we want to use this when doing a "panic" gc after memory_full()? */
static int gc_hooks_inhibited;
+struct post_gc_action
+{
+ void (*fun) (void *);
+ void *arg;
+};
+
+typedef struct post_gc_action post_gc_action;
+
+typedef struct
+{
+ Dynarr_declare (post_gc_action);
+} post_gc_action_dynarr;
+
+static post_gc_action_dynarr *post_gc_actions;
+
+/* Register an action to be called at the end of GC.
+ gc_in_progress is 0 when this is called.
+ This is used when it is discovered that an action needs to be taken,
+ but it's during GC, so it's not safe. (e.g. in a finalize method.)
+
+ As a general rule, do not use Lisp objects here.
+ And NEVER signal an error.
+*/
+
+void
+register_post_gc_action (void (*fun) (void *), void *arg)
+{
+ post_gc_action action;
+
+ if (!post_gc_actions)
+ post_gc_actions = Dynarr_new (post_gc_action);
+
+ action.fun = fun;
+ action.arg = arg;
+
+ Dynarr_add (post_gc_actions, action);
+}
+
+static void
+run_post_gc_actions (void)
+{
+ int i;
+
+ if (post_gc_actions)
+ {
+ for (i = 0; i < Dynarr_length (post_gc_actions); i++)
+ {
+ post_gc_action action = Dynarr_at (post_gc_actions, i);
+ (action.fun) (action.arg);
+ }
+
+ Dynarr_reset (post_gc_actions);
+ }
+}
+
\f
void
garbage_collect_1 (void)
{
+#if MAX_SAVE_STACK > 0
char stack_top_variable;
extern char *stack_bottom;
- int i;
+#endif
struct frame *f;
int speccount;
int cursor_changed;
|| preparing_for_armageddon)
return;
+ /* We used to call selected_frame() here.
+
+ The following functions cannot be called inside GC
+ so we move to after the above tests. */
+ {
+ Lisp_Object frame;
+ Lisp_Object device = Fselected_device (Qnil);
+ if (NILP (device)) /* Could happen during startup, eg. if always_gc */
+ return;
+ frame = DEVICE_SELECTED_FRAME (XDEVICE (device));
+ if (NILP (frame))
+ signal_simple_error ("No frames exist on device", device);
+ f = XFRAME (frame);
+ }
+
pre_gc_cursor = Qnil;
cursor_changed = 0;
- /* This function cannot be called inside GC so we move to after the */
- /* above tests */
- f = selected_frame ();
-
GCPRO1 (pre_gc_cursor);
/* Very important to prevent GC during any of the following
: 0);
Lisp_Object args[2], whole_msg;
args[0] = build_string (msg ? msg :
- GETTEXT ((CONST char *) gc_default_message));
+ GETTEXT ((const char *) gc_default_message));
args[1] = build_string ("...");
whole_msg = Fconcat (2, args);
echo_area_message (f, (Bufbyte *) 0, whole_msg, 0, -1,
/***** Now we actually start the garbage collection. */
gc_in_progress = 1;
+ inhibit_non_essential_printing_operations = 1;
gc_generation_number[0]++;
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;
- for (i = 0; i < staticidx; i++)
- {
-#ifdef GDB_SUCKS
- printf ("%d\n", i);
- debug_print (*staticvec[i]);
-#endif
- mark_object (*(staticvec[i]));
- }
+ { /* staticpro() */
+ Lisp_Object **p = Dynarr_begin (staticpros);
+ size_t count;
+ for (count = Dynarr_length (staticpros); count; count--)
+ mark_object (**p++);
+ }
+
+ { /* staticpro_nodump() */
+ Lisp_Object **p = Dynarr_begin (staticpros_nodump);
+ size_t count;
+ for (count = Dynarr_length (staticpros_nodump); count; count--)
+ mark_object (**p++);
+ }
+ { /* 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)
+ if (nargs < 0 /* nargs == UNEVALLED || nargs == MANY */)
mark_object (backlist->args[0]);
else
for (i = 0; i < nargs; i++)
mark_object (backlist->args[i]);
}
-
- mark_redisplay (mark_object);
- mark_profiling_info (mark_object);
}
+ mark_redisplay ();
+ mark_profiling_info ();
+
/* OK, now do the after-mark stuff. This is for things that
- are only marked when something else is marked (e.g. weak hashtables).
+ are only marked when something else is marked (e.g. weak hash tables).
There may be complex dependencies between such objects -- e.g.
- a weak hashtable might be unmarked, but after processing a later
- weak hashtable, the former one might get marked. So we have to
+ a weak hash table might be unmarked, but after processing a later
+ weak hash table, the former one might get marked. So we have to
iterate until nothing more gets marked. */
- {
- int did_mark;
- /* Need to iterate until there's nothing more to mark, in case
- of chains of mark dependencies. */
- do
- {
- did_mark = 0;
- did_mark += !!finish_marking_weak_hashtables (marked_p, mark_object);
- did_mark += !!finish_marking_weak_lists (marked_p, mark_object);
- }
- while (did_mark);
- }
+
+ while (finish_marking_weak_hash_tables () > 0 ||
+ finish_marking_weak_lists () > 0)
+ ;
/* And prune (this needs to be called after everything else has been
marked and before we do any sweeping). */
/* #### this is somewhat ad-hoc and should probably be an object
method */
- prune_weak_hashtables (marked_p);
- prune_weak_lists (marked_p);
- prune_specifiers (marked_p);
- prune_syntax_tables (marked_p);
+ prune_weak_hash_tables ();
+ prune_weak_lists ();
+ prune_specifiers ();
+ prune_syntax_tables ();
gc_sweep ();
gc_cons_threshold = 10000;
#endif
+ inhibit_non_essential_printing_operations = 0;
gc_in_progress = 0;
+ run_post_gc_actions ();
+
/******* End of garbage collection ********/
run_hook_trapping_errors ("Error in post-gc-hook", Qpost_gc_hook);
{
Lisp_Object args[2], whole_msg;
args[0] = build_string (msg ? msg :
- GETTEXT ((CONST char *)
+ GETTEXT ((const char *)
gc_default_message));
args[1] = build_string ("... done");
whole_msg = Fconcat (2, args);
return;
}
-#ifdef EMACS_BTL
- /* This isn't actually called. BTL recognizes the stack frame of the top
- of the garbage collector by noting that PC is between &garbage_collect_1
- and &BTL_after_garbage_collect_1_stub. So this fn must be right here.
- There's not any other way to know the address of the end of a function.
- */
-void BTL_after_garbage_collect_1_stub () { abort (); }
-#endif /* EMACS_BTL */
-
/* Debugging aids. */
static Lisp_Object
-gc_plist_hack (CONST char *name, int value, Lisp_Object tail)
+gc_plist_hack (const char *name, int value, Lisp_Object tail)
{
/* C doesn't have local functions (or closures, or GC, or readable syntax,
or portable numeric datatypes, or bit-vectors, or characters, or
return cons3 (intern (name), make_int (value), tail);
}
-#define HACK_O_MATIC(type, name, pl) \
- { \
- int s = 0; \
- struct type##_block *x = current_##type##_block; \
- while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; } \
- (pl) = gc_plist_hack ((name), s, (pl)); \
- }
+#define HACK_O_MATIC(type, name, pl) do { \
+ int s = 0; \
+ struct type##_block *x = current_##type##_block; \
+ while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; } \
+ (pl) = gc_plist_hack ((name), s, (pl)); \
+} while (0)
DEFUN ("garbage-collect", Fgarbage_collect, 0, 0, "", /*
Reclaim storage for Lisp objects no longer needed.
())
{
Lisp_Object pl = Qnil;
- int i;
-#ifdef LRECORD_VECTOR
+ unsigned int i;
int gc_count_vector_total_size = 0;
-#endif
-
- if (purify_flag && pure_lossage)
- return Qnil;
garbage_collect_1 ();
- for (i = 0; i < last_lrecord_type_index_assigned; i++)
+ for (i = 0; i < lrecord_type_count; i++)
{
if (lcrecord_stats[i].bytes_in_use != 0
|| lcrecord_stats[i].bytes_freed != 0
|| lcrecord_stats[i].instances_on_free_list != 0)
{
char buf [255];
- CONST char *name = lrecord_implementations_table[i]->name;
+ const char *name = lrecord_implementations_table[i]->name;
int len = strlen (name);
-#ifdef LRECORD_VECTOR
/* save this for the FSFmacs-compatible part of the summary */
- if (i == *lrecord_vector[0].lrecord_type_index)
+ if (i == lrecord_type_vector)
gc_count_vector_total_size =
lcrecord_stats[i].bytes_in_use + lcrecord_stats[i].bytes_freed;
-#endif
+
sprintf (buf, "%s-storage", name);
pl = gc_plist_hack (buf, lcrecord_stats[i].bytes_in_use, pl);
/* Okay, simple pluralization check for `symbol-value-varalias' */
pl = gc_plist_hack ("compiled-functions-used",
gc_count_num_compiled_function_in_use, pl);
-#ifndef LRECORD_VECTOR
- pl = gc_plist_hack ("vector-storage", gc_count_vector_storage, pl);
- pl = gc_plist_hack ("vectors-total-length",
- gc_count_vector_total_size, pl);
- pl = gc_plist_hack ("vectors-used", gc_count_num_vector_used, pl);
-#endif
-
pl = gc_plist_hack ("bit-vector-storage", gc_count_bit_vector_storage, pl);
pl = gc_plist_hack ("bit-vectors-total-length",
gc_count_bit_vector_total_size, pl);
return make_int (consing_since_gc);
}
-DEFUN ("memory-limit", Fmemory_limit, 0, 0, "", /*
+#if 0
+DEFUN ("memory-limit", Fmemory_limit, 0, 0, 0, /*
Return the address of the last byte Emacs has allocated, divided by 1024.
This may be helpful in debugging Emacs's memory usage.
The value is divided by 1024 to make sure it will fit in a lisp integer.
{
return make_int ((EMACS_INT) sbrk (0) / 1024);
}
-
+#endif
\f
int
\f
/* Initialization */
void
-init_alloc_once_early (void)
+reinit_alloc_once_early (void)
{
- int iii;
-
-#ifdef PURESTAT
- for (iii = 0; iii < countof (purestats); iii++)
- {
- if (! purestats[iii]) continue;
- purestats[iii]->nobjects = 0;
- purestats[iii]->nbytes = 0;
- }
- purecopying_for_bytecode = 0;
-#endif /* PURESTAT */
-
- last_lrecord_type_index_assigned = -1;
- for (iii = 0; iii < countof (lrecord_implementations_table); iii++)
- {
- lrecord_implementations_table[iii] = 0;
- }
-
-#ifdef USE_INDEXED_LRECORD_IMPLEMENTATION
- /*
- * If USE_INDEXED_LRECORD_IMPLEMENTATION is defined, all the staticly
- * defined subr lrecords were initialized with lheader->type == 0.
- * See subr_lheader_initializer in lisp.h. Force type index 0 to be
- * assigned to lrecord_subr so that those predefined indexes match
- * reality.
- */
- lrecord_type_index (lrecord_subr);
- assert (*(lrecord_subr[0].lrecord_type_index) == 0);
- /*
- * The same is true for symbol_value_forward objects, except the
- * type is 1.
- */
- lrecord_type_index (lrecord_symbol_value_forward);
- assert (*(lrecord_symbol_value_forward[0].lrecord_type_index) == 1);
-#endif /* USE_INDEXED_LRECORD_IMPLEMENTATION */
-
- symbols_initialized = 0;
-
gc_generation_number[0] = 0;
- /* purify_flag 1 is correct even if CANNOT_DUMP.
- * loadup.el will set to nil at end. */
- purify_flag = 1;
- pure_bytes_used = 0;
- pure_lossage = 0;
breathing_space = 0;
-#ifndef LRECORD_VECTOR
- XSETINT (all_vectors, 0); /* Qzero may not be set yet. */
-#endif
XSETINT (all_bit_vectors, 0); /* Qzero may not be set yet. */
XSETINT (Vgc_message, 0);
all_lcrecords = 0;
#ifdef DOUG_LEA_MALLOC
mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
mallopt (M_MMAP_THRESHOLD, 64*1024); /* mmap threshold */
-#if 0 /* Moved to emacs.c */
- mallopt (M_MMAP_MAX, 64); /* max. number of mmap'ed areas */
+#if 1 /* Moved to emacs.c */
+ mallopt (M_MMAP_MAX, 0); /* max. number of mmap'ed areas */
#endif
#endif
init_string_alloc ();
init_event_alloc ();
ignore_malloc_warnings = 0;
- staticidx = 0;
+
+ if (staticpros_nodump)
+ Dynarr_free (staticpros_nodump);
+ staticpros_nodump = Dynarr_new2 (Lisp_Object_ptr_dynarr, Lisp_Object *);
+ Dynarr_resize (staticpros_nodump, 100); /* merely a small optimization */
+
consing_since_gc = 0;
#if 1
gc_cons_threshold = 500000; /* XEmacs change */
#else
gc_cons_threshold = 15000; /* debugging */
#endif
-#ifdef VIRT_ADDR_VARIES
- malloc_sbrk_unused = 1<<22; /* A large number */
- malloc_sbrk_used = 100000; /* as reasonable as any number */
-#endif /* VIRT_ADDR_VARIES */
lrecord_uid_counter = 259;
debug_string_purity = 0;
gcprolist = 0;
}
void
+init_alloc_once_early (void)
+{
+ reinit_alloc_once_early ();
+
+ {
+ int i;
+ for (i = 0; i < countof (lrecord_implementations_table); i++)
+ lrecord_implementations_table[i] = 0;
+ }
+
+ INIT_LRECORD_IMPLEMENTATION (cons);
+ INIT_LRECORD_IMPLEMENTATION (vector);
+ INIT_LRECORD_IMPLEMENTATION (string);
+ INIT_LRECORD_IMPLEMENTATION (lcrecord_list);
+
+ staticpros = Dynarr_new2 (Lisp_Object_ptr_dynarr, Lisp_Object *);
+ Dynarr_resize (staticpros, 1410); /* merely a small optimization */
+ dump_add_root_struct_ptr (&staticpros, &staticpros_description);
+}
+
+void
reinit_alloc (void)
{
gcprolist = 0;
void
syms_of_alloc (void)
{
- defsymbol (&Qpre_gc_hook, "pre-gc-hook");
- defsymbol (&Qpost_gc_hook, "post-gc-hook");
- defsymbol (&Qgarbage_collecting, "garbage-collecting");
+ DEFSYMBOL (Qpre_gc_hook);
+ DEFSYMBOL (Qpost_gc_hook);
+ DEFSYMBOL (Qgarbage_collecting);
DEFSUBR (Fcons);
DEFSUBR (Flist);
DEFSUBR (Fmake_marker);
DEFSUBR (Fpurecopy);
DEFSUBR (Fgarbage_collect);
+#if 0
DEFSUBR (Fmemory_limit);
+#endif
DEFSUBR (Fconsing_since_gc);
}
See also `consing-since-gc'.
*/ );
- DEFVAR_INT ("pure-bytes-used", &pure_bytes_used /*
-Number of bytes of sharable Lisp data allocated so far.
-*/ );
-
-#if 0
- DEFVAR_INT ("data-bytes-used", &malloc_sbrk_used /*
-Number of bytes of unshared memory allocated in this session.
-*/ );
-
- DEFVAR_INT ("data-bytes-free", &malloc_sbrk_unused /*
-Number of bytes of unshared memory remaining available in this session.
-*/ );
-#endif
-
#ifdef DEBUG_XEMACS
DEFVAR_INT ("debug-allocation", &debug_allocation /*
If non-zero, print out information to stderr about all objects allocated.
DEFVAR_BOOL ("purify-flag", &purify_flag /*
Non-nil means loading Lisp code in order to dump an executable.
-This means that certain objects should be allocated in shared (pure) space.
+This means that certain objects should be allocated in readonly space.
*/ );
DEFVAR_LISP ("pre-gc-hook", &Vpre_gc_hook /*
image instance) in the domain of the selected frame, the mouse pointer
will change instead of this message being printed.
*/ );
- Vgc_message = make_pure_string ((CONST Bufbyte *) gc_default_message,
- countof (gc_default_message) - 1,
- Qnil, 1);
+ Vgc_message = build_string (gc_default_message);
DEFVAR_LISP ("gc-pointer-glyph", &Vgc_pointer_glyph /*
Pointer glyph used to indicate that a garbage collection is in progress.
projects / chise / xemacs-chise.git.1 / blobdiff