Changeset 3670

Show
Ignore:
Timestamp:
04/07/05 08:55:40 (4 years ago)
Author:
miyoshi
Message:

* alloc.c (struct backtrace): Removed.
(Fgarbage_collect): Sync up with Emacs CVS HEAD.
(mark_object): Ditto.
(mark_buffer): Ditto.
(survives_gc_p): Ditto.
(gc_sweep): Ditto.

* bytecode.c (mark_byte_stack): Ditto.
(unmark_byte_stack): Ditto.

* eval.c (mark_backtrace): Ditto.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/2.2/src/ChangeLog.Meadow

    r3669 r3670  
     12005-04-07  MIYOSHI Masanori  <miyoshi@meadowy.org> 
     2 
     3        * alloc.c (struct backtrace): Removed. 
     4        (Fgarbage_collect): Sync up with Emacs CVS HEAD. 
     5        (mark_object): Ditto. 
     6        (mark_buffer): Ditto. 
     7        (survives_gc_p): Ditto. 
     8        (gc_sweep): Ditto. 
     9 
     10        * bytecode.c (mark_byte_stack): Ditto. 
     11        (unmark_byte_stack): Ditto. 
     12 
     13        * eval.c (mark_backtrace): Ditto. 
     14 
    1152005-04-07  MIYOSHI Masanori  <miyoshi@meadowy.org> 
    216 

  • branches/2.2/src/alloc.c

    r3669 r3670  
    46594659}; 
    46604660 
    4661 struct backtrace 
    4662 { 
    4663   struct backtrace *next; 
    4664   Lisp_Object *function; 
    4665   Lisp_Object *args;    /* Points to vector of args.  */ 
    4666   int nargs;            /* Length of vector.  */ 
    4667   /* If nargs is UNEVALLED, args points to slot holding list of 
    4668      unevalled args.  */ 
    4669   char evalargs; 
    4670 }; 
    4671  
    4672  
    46734661  
    46744662/*********************************************************************** 
    …… 
    47024690     () 
    47034691{ 
    4704   register struct gcpro *tail; 
    47054692  register struct specbinding *bind; 
    47064693  struct catchtag *catch; 
    47074694  struct handler *handler; 
    4708   register struct backtrace *backlist; 
    47094695  char stack_top_variable; 
    47104696  register int i; 
    …… 
    48284814  mark_stack (); 
    48294815#else 
    4830   for (tail = gcprolist; tail; tail = tail->next) 
    4831     for (i = 0; i < tail->nvars; i++) 
    4832       if (!XMARKBIT (tail->var[i])) 
    4833         { 
    4834           /* Explicit casting prevents compiler warning about 
    4835              discarding the `volatile' qualifier.  */ 
    4836           mark_object (tail->var[i]); 
    4837           XMARK (tail->var[i]); 
    4838         } 
     4816  { 
     4817    register struct gcpro *tail; 
     4818    for (tail = gcprolist; tail; tail = tail->next) 
     4819      for (i = 0; i < tail->nvars; i++) 
     4820        mark_object (tail->var[i]); 
     4821  } 
    48394822#endif 
    48404823 
    …… 
    49124895  /* Clear the mark bits that we set in certain root slots.  */ 
    49134896 
    4914 #if (GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE \ 
    4915      || GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES) 
    4916   for (tail = gcprolist; tail; tail = tail->next) 
    4917     for (i = 0; i < tail->nvars; i++) 
    4918       XUNMARK (tail->var[i]); 
    4919 #endif 
    4920  
    49214897  unmark_byte_stack (); 
    4922   for (backlist = backtrace_list; backlist; backlist = backlist->next) 
    4923     { 
    4924       XUNMARK (*backlist->function); 
    4925       if (backlist->nargs == UNEVALLED || backlist->nargs == MANY) 
    4926         i = 0; 
    4927       else 
    4928         i = backlist->nargs - 1; 
    4929       for (; i >= 0; i--) 
    4930         XUNMARK (backlist->args[i]); 
    4931     } 
    4932   XUNMARK (buffer_defaults.name); 
    4933   XUNMARK (buffer_local_symbols.name); 
     4898  VECTOR_UNMARK (&buffer_defaults); 
     4899  VECTOR_UNMARK (&buffer_local_symbols); 
    49344900 
    49354901#if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES && 0 
    …… 
    51825148    case Lisp_Misc: 
    51835149    case Lisp_Float: 
     5150    case Lisp_Vectorlike: 
     5151    case Lisp_Symbol: 
     5152    case Lisp_String: 
    51845153      break; 
    51855154       
    5186     case Lisp_Symbol: 
    5187     case Lisp_String: 
    5188     case Lisp_Vectorlike: 
    51895155    case Lisp_Cons: 
    51905156      XUNMARK (obj); 
    …… 
    52225188      if (GC_BUFFERP (obj)) 
    52235189        { 
    5224           if (!XMARKBIT (XBUFFER (obj)->name)) 
     5190          if (!VECTOR_MARKED_P (XBUFFER (obj))) 
    52255191            { 
    52265192#ifdef GC_CHECK_MARKED_OBJECTS 
    …… 
    55425508  Lisp_Object base_buffer; 
    55435509 
    5544   /* This is the buffer's markbit */ 
    5545   mark_object (buffer->name); 
    5546   XMARK (buffer->name); 
     5510  VECTOR_MARK (buffer); 
    55475511 
    55485512  MARK_INTERVAL_TREE (BUF_INTERVALS (buffer)); 
    …… 
    55635527    } 
    55645528 
    5565   for (ptr = &buffer->name + 1; 
     5529  for (ptr = &buffer->name; 
    55665530       (char *)ptr < (char *)buffer + sizeof (struct buffer); 
    55675531       ptr++) 
    …… 
    55695533 
    55705534  /* If this is an indirect buffer, mark its base buffer.  */ 
    5571   if (buffer->base_buffer && !XMARKBIT (buffer->base_buffer->name)) 
     5535  if (buffer->base_buffer && !VECTOR_MARKED_P (buffer->base_buffer)) 
    55725536    { 
    55735537      XSETBUFFER (base_buffer, buffer->base_buffer); 
    …… 
    56055569 
    56065570    case Lisp_Vectorlike: 
    5607       if (GC_BUFFERP (obj)) 
    5608         survives_p = XMARKBIT (XBUFFER (obj)->name); 
    5609       else if (GC_SUBRP (obj)) 
    5610         survives_p = 1; 
    5611       else 
    5612         survives_p = VECTOR_MARKED_P (XVECTOR (obj)); 
     5571      survives_p = GC_SUBRP (obj) || VECTOR_MARKED_P (XVECTOR (obj)); 
    56135572      break; 
    56145573 
    …… 
    59175876 
    59185877    while (buffer) 
    5919       if (!XMARKBIT (buffer->name)) 
     5878      if (!VECTOR_MARKED_P (buffer)) 
    59205879        { 
    59215880          if (prev) 
    …… 
    59295888      else 
    59305889        { 
    5931           XUNMARK (buffer->name); 
     5890          VECTOR_UNMARK (buffer); 
    59325891          UNMARK_BALANCE_INTERVALS (BUF_INTERVALS (buffer)); 
    59335892          prev = buffer, buffer = buffer->next; 

  • branches/2.2/src/bytecode.c

    r3665 r3670  
    290290 
    291291      for (obj = stack->bottom; obj <= stack->top; ++obj) 
    292         if (!XMARKBIT (*obj)) 
    293           { 
    294             mark_object (*obj); 
    295             XMARK (*obj); 
    296           } 
    297  
    298       if (!XMARKBIT (stack->byte_string)) 
    299         { 
    300           mark_object (stack->byte_string); 
    301           XMARK (stack->byte_string); 
    302         } 
    303  
    304       if (!XMARKBIT (stack->constants)) 
    305         { 
    306           mark_object (stack->constants); 
    307           XMARK (stack->constants); 
    308         } 
     292        mark_object (*obj); 
     293 
     294      mark_object (stack->byte_string); 
     295      mark_object (stack->constants); 
    309296    } 
    310297} 
    …… 
    318305{ 
    319306  struct byte_stack *stack; 
    320   Lisp_Object *obj; 
    321307 
    322308  for (stack = byte_stack_list; stack; stack = stack->next) 
    323309    { 
    324       for (obj = stack->bottom; obj <= stack->top; ++obj) 
    325         XUNMARK (*obj); 
    326  
    327       XUNMARK (stack->byte_string); 
    328       XUNMARK (stack->constants); 
    329310      if (stack->byte_string_start != SDATA (stack->byte_string)) 
    330311        { 

  • branches/2.2/src/eval.c

    r3665 r3670  
    33203320  for (backlist = backtrace_list; backlist; backlist = backlist->next) 
    33213321    { 
    3322       if (!XMARKBIT (*backlist->function)) 
    3323         { 
    3324           mark_object (*backlist->function); 
    3325           XMARK (*backlist->function); 
    3326         } 
     3322      mark_object (*backlist->function); 
     3323 
    33273324      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY) 
    33283325        i = 0; 
    …… 
    33303327        i = backlist->nargs - 1; 
    33313328      for (; i >= 0; i--) 
    3332         if (!XMARKBIT (backlist->args[i])) 
    3333           { 
    3334             mark_object (backlist->args[i]); 
    3335             XMARK (backlist->args[i]); 
    3336           } 
     3329        mark_object (backlist->args[i]); 
    33373330    } 
    33383331}