emacs: src/alloc.c comparison

comparison src/alloc.c @ 83400:03934708f1e9

Merged from miles@gnu.org--gnu-2005 (patch 152-156, 642-654) Patches applied: * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-642 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-643 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-644 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-645 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-646 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-647 lisp/gnus/ChangeLog: Remove duplicate entry * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-648 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-649 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-650 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-651 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-652 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-653 Update from CVS * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-654 Update from CVS * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-152 Update from CVS: lisp/mml.el (mml-preview): Doc fix. * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-153 Update from CVS * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-154 Update from CVS * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-155 Update from CVS * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-156 Update from CVS git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-440

author	Karoly Lorentey <lorentey@elte.hu>
date	Fri, 18 Nov 2005 13:13:34 +0000
parents	693e794b57bf e485868e3caf
children	1955a4462bf9

comparison

equal deleted inserted replaced

-:2988c5a31dc1
+:03934708f1e9
 void
 free_float (ptr)
 struct Lisp_Float *ptr;
 {
-*(struct Lisp_Float **)&ptr->data = float_free_list;
+ptr->u.chain = float_free_list;
 float_free_list = ptr;
 }
 /* Return a new float object with value FLOAT_VALUE.  */
 if (float_free_list)
 {
 /* We use the data field for chaining the free list
 	 so that we won't use the same field that has the mark bit.  */
 XSETFLOAT (val, float_free_list);
-float_free_list = *(struct Lisp_Float **)&float_free_list->data;
+float_free_list = float_free_list->u.chain;
 }
 else
 {
 if (float_block_index == FLOAT_BLOCK_SIZE)
 	{
 void
 free_cons (ptr)
 struct Lisp_Cons *ptr;
 {
-*(struct Lisp_Cons **)&ptr->cdr = cons_free_list;
+ptr->u.chain = cons_free_list;
 #if GC_MARK_STACK
 ptr->car = Vdead;
 #endif
 cons_free_list = ptr;
 }
 if (cons_free_list)
 {
 /* We use the cdr for chaining the free list
 	 so that we won't use the same field that has the mark bit.  */
 XSETCONS (val, cons_free_list);
-cons_free_list = *(struct Lisp_Cons **)&cons_free_list->cdr;
+cons_free_list = cons_free_list->u.chain;
 }
 else
 {
 if (cons_block_index == CONS_BLOCK_SIZE)
 	{
 {
 #ifdef GC_CHECK_CONS_LIST
 struct Lisp_Cons *tail = cons_free_list;
 while (tail)
-tail = *(struct Lisp_Cons **)&tail->cdr;
+tail = tail->u.chain;
 #endif
 }
 /* Make a list of 2, 3, 4 or 5 specified objects.  */
 CHECK_STRING (name);
 if (symbol_free_list)
 {
 XSETSYMBOL (val, symbol_free_list);
-symbol_free_list = *(struct Lisp_Symbol **)&symbol_free_list->value;
+symbol_free_list = symbol_free_list->next;
 }
 else
 {
 if (symbol_block_index == SYMBOL_BLOCK_SIZE)
 	{
 #if GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS
 check_gcpros ();
 #endif
 }
 #endif /* GC_MARK_STACK != 0 */
+/* Return 1 if OBJ is a valid lisp object.
+Return 0 if OBJ is NOT a valid lisp object.
+Return -1 if we cannot validate OBJ.
+*/
+int
+valid_lisp_object_p (obj)
+Lisp_Object obj;
+{
+#if !GC_MARK_STACK
+/* Cannot determine this.  */
+return -1;
+#else
+void *p;
+struct mem_node *m;
+if (INTEGERP (obj))
+return 1;
+p = (void *) XPNTR (obj);
+if (PURE_POINTER_P (p))
+return 1;
+m = mem_find (p);
+if (m == MEM_NIL)
+return 0;
+switch (m->type)
+{
+case MEM_TYPE_NON_LISP:
+return 0;
+case MEM_TYPE_BUFFER:
+return live_buffer_p (m, p);
+case MEM_TYPE_CONS:
+return live_cons_p (m, p);
+case MEM_TYPE_STRING:
+return live_string_p (m, p);
+case MEM_TYPE_MISC:
+return live_misc_p (m, p);
+case MEM_TYPE_SYMBOL:
+return live_symbol_p (m, p);
+case MEM_TYPE_FLOAT:
+return live_float_p (m, p);
+case MEM_TYPE_VECTOR:
+case MEM_TYPE_PROCESS:
+case MEM_TYPE_HASH_TABLE:
+case MEM_TYPE_FRAME:
+case MEM_TYPE_WINDOW:
+return live_vector_p (m, p);
+default:
+break;
+}
+return 0;
+#endif
+}
 /***********************************************************************
 		       Pure Storage Management
 total += total_string_size;
 total += total_vector_size * sizeof (Lisp_Object);
 total += total_floats  * sizeof (struct Lisp_Float);
 total += total_intervals * sizeof (struct interval);
 total += total_strings * sizeof (struct Lisp_String);
 gc_relative_threshold = total * XFLOAT_DATA (Vgc_cons_percentage);
 }
 else
 gc_relative_threshold = 0;
 	register struct Lisp_Cons *ptr = XCONS (obj);
 	if (CONS_MARKED_P (ptr)) break;
 	CHECK_ALLOCATED_AND_LIVE (live_cons_p);
 	CONS_MARK (ptr);
 	/* If the cdr is nil, avoid recursion for the car.  */
-	if (EQ (ptr->cdr, Qnil))
+	if (EQ (ptr->u.cdr, Qnil))
 	  {
 	    obj = ptr->car;
 	    cdr_count = 0;
 	    goto loop;
 	  }
 	mark_object (ptr->car);
-	obj = ptr->cdr;
+	obj = ptr->u.cdr;
 	cdr_count++;
 	if (cdr_count == mark_object_loop_halt)
 	  abort ();
 	goto loop;
 }
 	int this_free = 0;
 	for (i = 0; i < lim; i++)
 	  if (!CONS_MARKED_P (&cblk->conses[i]))
 	    {
 	      this_free++;
-	      *(struct Lisp_Cons **)&cblk->conses[i].cdr = cons_free_list;
+	      cblk->conses[i].u.chain = cons_free_list;
 	      cons_free_list = &cblk->conses[i];
 #if GC_MARK_STACK
 	      cons_free_list->car = Vdead;
 #endif
 	    }
 	   this block.  */
 	if (this_free == CONS_BLOCK_SIZE && num_free > CONS_BLOCK_SIZE)
 	  {
 	    *cprev = cblk->next;
 	    /* Unhook from the free list.  */
-	    cons_free_list = *(struct Lisp_Cons **) &cblk->conses[0].cdr;
+	    cons_free_list = cblk->conses[0].u.chain;
 	    lisp_align_free (cblk);
 	    n_cons_blocks--;
 	  }
 	else
 	  {
 	int this_free = 0;
 	for (i = 0; i < lim; i++)
 	  if (!FLOAT_MARKED_P (&fblk->floats[i]))
 	    {
 	      this_free++;
-	      *(struct Lisp_Float **)&fblk->floats[i].data = float_free_list;
+	      fblk->floats[i].u.chain = float_free_list;
 	      float_free_list = &fblk->floats[i];
 	    }
 	  else
 	    {
 	      num_used++;
 	   this block.  */
 	if (this_free == FLOAT_BLOCK_SIZE && num_free > FLOAT_BLOCK_SIZE)
 	  {
 	    *fprev = fblk->next;
 	    /* Unhook from the free list.  */
-	    float_free_list = *(struct Lisp_Float **) &fblk->floats[0].data;
+	    float_free_list = fblk->floats[0].u.chain;
 	    lisp_align_free (fblk);
 	    n_float_blocks--;
 	  }
 	else
 	  {
 	       so we conservatively assume that it is live.  */
 	    int pure_p = PURE_POINTER_P (XSTRING (sym->xname));
 	    if (!sym->gcmarkbit && !pure_p)
 	      {
-		*(struct Lisp_Symbol **) &sym->value = symbol_free_list;
+		sym->next = symbol_free_list;
 		symbol_free_list = sym;
 #if GC_MARK_STACK
 		symbol_free_list->function = Vdead;
 #endif
 		++this_free;
 	   this block.  */
 	if (this_free == SYMBOL_BLOCK_SIZE && num_free > SYMBOL_BLOCK_SIZE)
 	  {
 	    *sprev = sblk->next;
 	    /* Unhook from the free list.  */
-	    symbol_free_list = *(struct Lisp_Symbol **)&sblk->symbols[0].value;
+	    symbol_free_list = sblk->symbols[0].next;
 	    lisp_free (sblk);
 	    n_symbol_blocks--;
 	  }
 	else
 	  {

Mercurial > emacs

comparison src/alloc.c @ 83400:03934708f1e9