Move realvalue to thread_data.

diff --git a/src/alloc.c b/src/alloc.c
index 01317dae23b890025e4140bb307df0a619c05a30..0299e1865ec35e4db6df683699089a2e8efe3e5a 100644 (file)
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5577,7 +5577,6 @@ mark_object (arg)
          {
            register struct Lisp_Buffer_Local_Value *ptr
              = XBUFFER_LOCAL_VALUE (obj);
-           mark_object (ptr->realvalue);
            mark_object (ptr->thread_data);
            obj = BLOCAL_THREAD_DATA (ptr);
            goto loop;

diff --git a/src/buffer.c b/src/buffer.c
index 3c79c89262ae9e908562a5520fa0b7a89afeef25..e1bf4f7933d50647be7e9f0d9fb9289ba1416b32 100644 (file)
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -988,7 +988,7 @@ is the default binding of the variable. */)
         in case that is the one we are about to use.  */
 
       Fsetcdr (current_alist_element,
-              do_symval_forwarding (BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
+              do_symval_forwarding (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
 
       /* Now get the (perhaps updated) value out of the binding.  */
       result = XCDR (result);
@@ -1937,7 +1937,7 @@ set_buffer_internal_1 (b)
          && SYMBOLP (XCAR (XCAR (tail)))
          && (valcontents = SYMBOL_VALUE (XCAR (XCAR (tail))),
              (BUFFER_LOCAL_VALUEP (valcontents)))
-         && (tem = BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
+         && (tem = BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
              (BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
        /* Just reference the variable to cause it to become set for
           this buffer.  */
@@ -1953,7 +1953,7 @@ set_buffer_internal_1 (b)
            && SYMBOLP (XCAR (XCAR (tail)))
            && (valcontents = SYMBOL_VALUE (XCAR (XCAR (tail))),
                (BUFFER_LOCAL_VALUEP (valcontents)))
-           && (tem = BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
+           && (tem = BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
                (BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
          /* Just reference the variable to cause it to become set for
             this buffer.  */

diff --git a/src/data.c b/src/data.c
index 11e192680e9fd41b35c650f3cf395c72a7413ab6..f0b988b8446e5971fa28c3171dd6b908f5191e0c 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -95,30 +95,35 @@ static Lisp_Object swap_in_symval_forwarding P_ ((Lisp_Object, Lisp_Object));
 
 Lisp_Object impl_Vmost_positive_fixnum, impl_Vmost_negative_fixnum;
 
-Lisp_Object
+Lisp_Object *
 blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l)
 {
   Lisp_Object ret = assq_no_quit (get_current_thread (), l->thread_data);
   if (NILP (ret))
     {
-      /* FIXME: use the parent, not the first element. (or not?)  */
-      Lisp_Object tem, len, parent = XCDR (XCAR (l->thread_data));
-
-      XSETFASTINT (len, 4);
+      Lisp_Object len;
+      XSETFASTINT (len, 5);
       ret = Fmake_vector (len, Qnil);
       BLOCAL_CLEAR_FLAGS_VEC (ret);
-      XSETFASTINT (AREF (ret, 0), AREF (parent, 0));
-      BLOCAL_BUFFER_VEC (ret) = BLOCAL_BUFFER_VEC (parent);
-      BLOCAL_FRAME_VEC (ret) = BLOCAL_FRAME_VEC (parent);
-
-      tem = Fcons (Qnil, Qnil);
-      XSETCAR (tem, tem);
 
-      BLOCAL_CDR_VEC (ret) = tem;
-      l->thread_data = Fcons (Fcons (get_current_thread (), ret), l->thread_data);
+      if (!NILP (l->thread_data))
+        {
+          /* FIXME: use the parent, not the first element. (or not?)  */
+          Lisp_Object tem, parent = XCDR (XCAR (l->thread_data));
+          XSETFASTINT (AREF (ret, 0), AREF (parent, 0));
+          BLOCAL_BUFFER_VEC (ret) = BLOCAL_BUFFER_VEC (parent);
+          BLOCAL_FRAME_VEC (ret) = BLOCAL_FRAME_VEC (parent);
+          tem = Fcons (Qnil, Qnil);
+          XSETCAR (tem, tem);
+
+          BLOCAL_CDR_VEC (ret) = tem;
+        }
+
+      l->thread_data = Fcons (Fcons (get_current_thread (), ret),
+                              l->thread_data);
     }
 
-  return XCDR (ret);
+  return &XCDR_AS_LVALUE (ret);
 }
 
 void
@@ -127,20 +132,6 @@ blocal_set_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object obj)
   l->thread_data = Fcons (Fcons (get_current_thread (), obj), Qnil);
 }
 
-Lisp_Object *
-blocal_get_realvalue (struct Lisp_Buffer_Local_Value *l)
-{
-  Lisp_Object current_thread = get_current_thread ();
-  Lisp_Object ret = assq_no_quit (current_thread, l->realvalue);
-  if (NILP (ret))
-    {
-      ret = Fcons (current_thread, Qnil);
-      l->realvalue = Fcons (ret, l->realvalue);
-    }
-
-  return &XCDR_AS_LVALUE (ret);
-}
-
 void
 circular_list_error (list)
      Lisp_Object list;
@@ -1117,7 +1108,7 @@ store_symval_forwarding (symbol, valcontents, newval, buf)
     def:
       valcontents = SYMBOL_VALUE (symbol);
       if (BUFFER_LOCAL_VALUEP (valcontents))
-       BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)) = newval;
+       BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)) = newval;
       else if (THREADLOCALP (valcontents))
        *find_variable_location (&indirect_variable (XSYMBOL (symbol))->value) = newval;
       else
@@ -1138,11 +1129,11 @@ swap_in_global_binding (symbol)
 
   /* Unload the previously loaded binding.  */
   Fsetcdr (XCAR (cdr),
-          do_symval_forwarding (BLOCAL_GET_REALVALUE (blv)));
+          do_symval_forwarding (BLOCAL_REALVALUE (blv)));
 
   /* Select the global binding in the symbol.  */
   XSETCAR (cdr, cdr);
-  store_symval_forwarding (symbol, BLOCAL_GET_REALVALUE (blv), XCDR (cdr), NULL);
+  store_symval_forwarding (symbol, BLOCAL_REALVALUE (blv), XCDR (cdr), NULL);
 
   /* Indicate that the global binding is set up now.  */
   BLOCAL_FRAME (blv) = Qnil;
@@ -1180,7 +1171,7 @@ swap_in_symval_forwarding (symbol, valcontents)
       /* Unload the previously loaded binding.  */
       tem1 = XCAR (BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents)));
       Fsetcdr (tem1,
-              do_symval_forwarding (BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
+              do_symval_forwarding (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
       /* Choose the new binding.  */
       tem1 = assq_no_quit (symbol, BUF_LOCAL_VAR_ALIST (current_buffer));
       BLOCAL_CLEAR_FLAGS (XBUFFER_LOCAL_VALUE (valcontents));
@@ -1201,10 +1192,10 @@ swap_in_symval_forwarding (symbol, valcontents)
       XSETBUFFER (BLOCAL_BUFFER (XBUFFER_LOCAL_VALUE (valcontents)), current_buffer);
       BLOCAL_FRAME (XBUFFER_LOCAL_VALUE (valcontents)) = selected_frame;
       store_symval_forwarding (symbol,
-                              BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
+                              BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
                               Fcdr (tem1), NULL);
     }
-  return BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents));
+  return BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents));
 }
 \f
 /* Find the value of a symbol, returning Qunbound if it's not bound.
@@ -1345,7 +1336,7 @@ set_internal (symbol, newval, buf, bindflag)
 
          /* Write out `realvalue' to the old loaded binding.  */
           Fsetcdr (current_alist_element,
-                  do_symval_forwarding (BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
+                  do_symval_forwarding (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents))));
 
          /* Find the new binding.  */
          tem1 = Fassq (symbol, BUF_LOCAL_VAR_ALIST (buf));
@@ -1395,7 +1386,7 @@ set_internal (symbol, newval, buf, bindflag)
          XSETBUFFER (BLOCAL_BUFFER (XBUFFER_LOCAL_VALUE (valcontents)), buf);
          BLOCAL_FRAME (XBUFFER_LOCAL_VALUE (valcontents)) = selected_frame;
        }
-      innercontents = BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents));
+      innercontents = BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents));
 
       /* Store the new value in the cons-cell.  */
       XSETCDR (XCAR (BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents))), newval);
@@ -1446,7 +1437,7 @@ default_value (symbol)
        = XCAR (BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents)));
       alist_element_car = XCAR (current_alist_element);
       if (EQ (alist_element_car, current_alist_element))
-       return do_symval_forwarding (BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)));
+       return do_symval_forwarding (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)));
       else
        return XCDR (BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents)));
     }
@@ -1531,7 +1522,7 @@ for this variable.  */)
   alist_element_buffer = Fcar (current_alist_element);
   if (EQ (alist_element_buffer, current_alist_element))
     store_symval_forwarding (symbol,
-                            BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
+                            BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)),
                             value, NULL);
 
   return value;
@@ -1616,7 +1607,7 @@ The function `default-value' gets the default value and `set-default' sets it.
   else
     {
       Lisp_Object len, val_vec;
-      XSETFASTINT (len, 4);
+      XSETFASTINT (len, 5);
       val_vec = Fmake_vector (len, Qnil);
       if (EQ (valcontents, Qunbound))
        sym->value = Qnil;
@@ -1624,8 +1615,8 @@ The function `default-value' gets the default value and `set-default' sets it.
       XSETCAR (tem, tem);
       newval = allocate_misc ();
       XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
-      XBUFFER_LOCAL_VALUE (newval)->realvalue = Qnil;
-      BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
+      XBUFFER_LOCAL_VALUE (newval)->thread_data = Qnil;
+      BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
       BLOCAL_CLEAR_FLAGS_VEC (val_vec);
       BLOCAL_BUFFER_VEC (val_vec) = Fcurrent_buffer ();
       BLOCAL_FRAME_VEC (val_vec) = Qnil;
@@ -1688,17 +1679,18 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
   if (!BUFFER_LOCAL_VALUEP (valcontents))
     {
       Lisp_Object newval, len, val_vec;
-      XSETFASTINT (len, 4);
+      XSETFASTINT (len, 5);
       val_vec = Fmake_vector (len, Qnil);
       tem = Fcons (Qnil, do_symval_forwarding (valcontents));
       XSETCAR (tem, tem);
       newval = allocate_misc ();
       XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
-      XBUFFER_LOCAL_VALUE (newval)->realvalue = Qnil;
-      BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
+      XBUFFER_LOCAL_VALUE (newval)->thread_data = Qnil;
+      BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
       BLOCAL_CDR_VEC (val_vec);
       BLOCAL_BUFFER_VEC (val_vec) = Qnil;
       BLOCAL_FRAME_VEC (val_vec) = Qnil;
+      BLOCAL_REALVALUE_VEC (val_vec) = Qnil;
       BLOCAL_CDR_VEC (val_vec) = tem;
       XBUFFER_LOCAL_VALUE (newval)->local_if_set = 0;
       XBUFFER_LOCAL_VALUE (newval)->check_frame = 0;
@@ -1737,7 +1729,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
      for this buffer now.  If C code modifies the variable before we
      load the binding in, then that new value will clobber the default
      binding the next time we unload it.  */
-  valcontents = BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (sym->value));
+  valcontents = BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (sym->value));
   if (INTFWDP (valcontents) || BOOLFWDP (valcontents) || OBJFWDP (valcontents))
     swap_in_symval_forwarding (variable, sym->value);
 
@@ -1852,15 +1844,16 @@ frame-local bindings).  */)
   tem = Fcons (Qnil, Fsymbol_value (variable));
   XSETCAR (tem, tem);
   newval = allocate_misc ();
-  XSETFASTINT (len, 4);
+  XSETFASTINT (len, 5);
   val_vec = Fmake_vector (len, Qnil);
   XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
-  XBUFFER_LOCAL_VALUE (newval)->realvalue = Qnil;
-  BLOCAL_GET_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
+  XBUFFER_LOCAL_VALUE (newval)->thread_data = Qnil;
+  BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (newval)) = sym->value;
   BLOCAL_CLEAR_FLAGS_VEC (val_vec);
   BLOCAL_BUFFER_VEC (val_vec) = Qnil;
   BLOCAL_FRAME_VEC (val_vec) = Qnil;
   BLOCAL_CDR_VEC (val_vec) = tem;
+  BLOCAL_REALVALUE_VEC (val_vec) = Qnil;
   XBUFFER_LOCAL_VALUE (newval)->local_if_set = 0;
   XBUFFER_LOCAL_VALUE (newval)->check_frame = 1;
   BLOCAL_SET_THREAD_DATA (XBUFFER_LOCAL_VALUE (newval), val_vec);

diff --git a/src/lisp.h b/src/lisp.h
index 69e64a4469a6f8a867e73e82eab94b4403983a14..65bc5d857a453599d1f947cee53bf4d30e0fd86f 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1339,7 +1339,8 @@ struct Lisp_Buffer_Local_Value
     /* 1 means that the binding now loaded was found
        as a local binding for the frame in the `frame' slot.  */
     /* unsigned int found_for_frame : 1; */
-    Lisp_Object realvalue;
+    /*Lisp_Object realvalue;*/
+
     /* The buffer and frame for which the loaded binding was found.  */
     /* Having both is only needed if we want to allow variables that are
        both buffer local and frame local (in which case, we currently give
@@ -1364,11 +1365,9 @@ struct Lisp_Buffer_Local_Value
     Lisp_Object thread_data;
   };
 
-Lisp_Object blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l);
-Lisp_Object *blocal_get_realvalue (struct Lisp_Buffer_Local_Value *l);
+Lisp_Object *blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l);
 void blocal_set_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object o);
 
-#define BLOCAL_GET_REALVALUE(A) (*blocal_get_realvalue (A))
 #define BLOCAL_CLEAR_FLAGS_VEC(VEC) XSETFASTINT (AREF ((VEC), 0), 0)
 #define BLOCAL_FOUND_FOR_BUFFER_VEC(VEC) ((XFASTINT (AREF ((VEC), 0))) == 1)
 #define BLOCAL_SET_FOUND_FOR_BUFFER_VEC(VEC) XSETFASTINT (AREF ((VEC), 0), 1)
@@ -1377,7 +1376,8 @@ void blocal_set_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object o);
 #define BLOCAL_BUFFER_VEC(VEC) (AREF ((VEC), 1))
 #define BLOCAL_FRAME_VEC(VEC) (AREF ((VEC), 2))
 #define BLOCAL_CDR_VEC(VEC) (AREF ((VEC), 3))
-#define BLOCAL_THREAD_DATA(A) (blocal_get_thread_data (A))
+#define BLOCAL_REALVALUE_VEC(VEC) (AREF ((VEC), 4))
+#define BLOCAL_THREAD_DATA(A) (*blocal_get_thread_data (A))
 #define BLOCAL_SET_THREAD_DATA(A, B) (blocal_set_thread_data (A, B))
 #define BLOCAL_CLEAR_FLAGS(A) (BLOCAL_CLEAR_FLAGS_VEC (BLOCAL_THREAD_DATA (A)))
 #define BLOCAL_FOUND_FOR_BUFFER(A) (BLOCAL_FOUND_FOR_BUFFER_VEC (BLOCAL_THREAD_DATA (A)))
@@ -1387,6 +1387,7 @@ void blocal_set_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object o);
 #define BLOCAL_BUFFER(A) (BLOCAL_BUFFER_VEC (BLOCAL_THREAD_DATA (A)))
 #define BLOCAL_FRAME(A) (BLOCAL_FRAME_VEC (BLOCAL_THREAD_DATA (A)))
 #define BLOCAL_CDR(A) (BLOCAL_CDR_VEC (BLOCAL_THREAD_DATA (A)))
+#define BLOCAL_REALVALUE(A) (BLOCAL_REALVALUE_VEC (BLOCAL_THREAD_DATA (A)))
 
 
 /* START and END are markers in the overlay's buffer, and

diff --git a/src/print.c b/src/print.c
index c7ab39036e5ce1479aa5908e2c7c601bd28ede99..5c9bd8bfa2b50a859c7ca3a2090bbfbec9d6123c 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -2304,8 +2304,8 @@ print_object (obj, printcharfun, escapeflag)
          strout ("#<buffer_local_value ", -1, -1, printcharfun, 0);
          if (XBUFFER_LOCAL_VALUE (obj)->local_if_set)
            strout ("[local-if-set] ", -1, -1, printcharfun, 0);
-         strout ("[realvalue] ", -1, -1, printcharfun, 0);
-         print_object (XBUFFER_LOCAL_VALUE (obj)->realvalue,
+         strout ("[thread_data] ", -1, -1, printcharfun, 0);
+         print_object (BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (obj)),
                        printcharfun, escapeflag);
          if (BLOCAL_FOUND_FOR_BUFFER (XBUFFER_LOCAL_VALUE (obj)))
            strout ("[local in buffer] ", -1, -1, printcharfun, 0);