local_var_alist_ is shared by threads.

- buffer local values per-thread cleanup.
- any binding-testsuite.el test is completed successfully.

diff --git a/src/buffer.h b/src/buffer.h
index a61a349a05547a830ee55cbeab787d573d1935c4..8f4fbfcd2e8ab738d8b6337c81d61b518613c75e 100644 (file)
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -862,7 +862,7 @@ struct buffer
 #define BUF_MODE_LINE_FORMAT(BUF) *find_variable_location (&((BUF)->mode_line_format_))
 #define BUF_MODE_NAME(BUF) *find_variable_location (&((BUF)->mode_name_))
 #define BUF_MAJOR_MODE(BUF) *find_variable_location (&((BUF)->major_mode_))
-#define BUF_LOCAL_VAR_ALIST(BUF) *find_variable_location (&((BUF)->local_var_alist_))
+#define BUF_LOCAL_VAR_ALIST(BUF) (((BUF)->local_var_alist_))
 #define BUF_MARK(BUF) *find_variable_location (&((BUF)->mark_))
 #define BUF_READ_ONLY(BUF) *find_variable_location (&((BUF)->read_only_))
 #define BUF_AUTO_SAVE_FILE_NAME(BUF) *find_variable_location (&((BUF)->auto_save_file_name_))

diff --git a/src/data.c b/src/data.c
index a347b87bfe527c58d75199797a539f52ae5b807b..abb277e8d931bdad0cc35deecfce2941d7f128e5 100644 (file)
--- a/src/data.c
+++ b/src/data.c
@@ -814,49 +814,43 @@ blocal_getrealvalue (struct Lisp_Buffer_Local_Value *blv)
 }
 
 Lisp_Object *
-blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l)
+blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object symbol)
 {
   Lisp_Object ret = assq_no_quit (get_current_thread (), l->thread_data);
   if (NILP (ret))
     {
-      Lisp_Object tem, val = Qnil, len, it, parent = Qnil;
+      Lisp_Object tem, val, len;
 
-      for (it = l->thread_data; !NILP (it); it = XCDR (it))
-        {
-          Lisp_Object thread_data = XCDR (XCAR (it));
-          if ((EQ (Fcurrent_buffer (), BLOCAL_BUFFER_VEC (thread_data)))
-              && (! l->check_frame
-                  || EQ (selected_frame, BLOCAL_FRAME_VEC (thread_data))))
-            {
-              Lisp_Object cdr = BLOCAL_CDR_VEC (thread_data);
-              parent = thread_data;
-              VECTORP (thread_data) || (abort (), 1);
-              if (EQ (XCAR (cdr), XCAR (XCAR (cdr))))
-                val = XCDR (assq_no_quit (XCAR (XCAR (it)),
-                                   XTHREADLOCAL (l->realvalue)->thread_alist));
-              else
-                val = XCDR (BLOCAL_CDR_VEC (thread_data));
-
-              break;
-            }
-        }
-
-      if (EQ (parent, Qnil))
-        val = XTHREADLOCAL (l->realvalue)->global;
+      if (NILP (symbol))
+        abort ();
 
       XSETFASTINT (len, 4);
       ret = Fmake_vector (len, Qnil);
 
-      if (NILP (parent))
-        XSETFASTINT (AREF (ret, 0), 0);
+      BLOCAL_CLEAR_FLAGS_VEC (ret);
+      tem = Fcons (Qnil, Qnil);
+      val = assq_no_quit (symbol, BUF_LOCAL_VAR_ALIST (current_buffer));
+      if (NILP (val) || (l->check_frame && ! EQ (selected_frame, Qnil)))
+        {
+          val = assq_no_quit (symbol, XFRAME (selected_frame)->param_alist);
+         if (! NILP (val))
+           BLOCAL_SET_FOUND_FOR_FRAME_VEC (ret);
+         else
+            {
+              val = XTHREADLOCAL (l->realvalue)->global;
+              XSETCAR (tem, tem);
+            }
+       }
       else
-        XSETFASTINT (AREF (ret, 0), AREF (parent, 0));
+        {
+          XSETCAR (tem, val);
+          val = XCDR (val);
+          XSETCDR (tem, XTHREADLOCAL (l->realvalue)->global);
+          BLOCAL_SET_FOUND_FOR_BUFFER_VEC (ret);
+        }
 
       BLOCAL_BUFFER_VEC (ret) = Fcurrent_buffer ();
       BLOCAL_FRAME_VEC (ret) = Qnil;
-
-      tem = Fcons (Qnil, val);
-      XSETCAR (tem, tem);
       BLOCAL_CDR_VEC (ret) = tem;
 
       ret = Fcons (get_current_thread (), ret);
@@ -1184,35 +1178,7 @@ store_symval_forwarding (symbol, valcontents, newval, buf)
     def:
       valcontents = SYMBOL_VALUE (symbol);
       if (BUFFER_LOCAL_VALUEP (valcontents))
-        {
-          Lisp_Object cdr = BLOCAL_CDR (XBUFFER_LOCAL_VALUE (valcontents));
-          if (EQ (XCAR (cdr), XCAR (XCAR (cdr))))
-            {
-              Lisp_Object it;
-              for (it = XBUFFER_LOCAL_VALUE (valcontents)->thread_data;
-                   !NILP (it); it = XCDR (it))
-                {
-                  Lisp_Object head = XCDR (XCAR (it));
-                  if (EQ (BLOCAL_BUFFER (XBUFFER_LOCAL_VALUE (valcontents)),
-                          BLOCAL_BUFFER_VEC (head))
-                      && (! XBUFFER_LOCAL_VALUE (valcontents)->check_frame
-                          || EQ (selected_frame, BLOCAL_FRAME_VEC (head))))
-                    {
-                      Lisp_Object rv
-                        = XBUFFER_LOCAL_VALUE (valcontents)->realvalue;
-
-                      if (EQ (XCAR (BLOCAL_CDR_VEC (head)),
-                              XCAR (XCAR (BLOCAL_CDR_VEC (head)))))
-                        Fsetcdr (assq_no_quit (XCAR (XCAR (it)),
-                                               XTHREADLOCAL (rv)->thread_alist),
-                                 newval);
-
-                      XSETCDR (XCAR (BLOCAL_CDR_VEC (head)), newval);
-                    }
-                }
-            }
-          BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)) = newval;
-        }
+        BLOCAL_REALVALUE (XBUFFER_LOCAL_VALUE (valcontents)) = newval;
       else if (THREADLOCALP (valcontents))
         {
           Lisp_Object val = indirect_variable (XSYMBOL (symbol))->value;
@@ -1262,7 +1228,9 @@ swap_in_symval_forwarding (symbol, valcontents)
 {
   register Lisp_Object tem1;
 
-  tem1 = BLOCAL_BUFFER (XBUFFER_LOCAL_VALUE (valcontents));
+  struct Lisp_Buffer_Local_Value *local = XBUFFER_LOCAL_VALUE (valcontents);
+  blocal_get_thread_data (local, symbol);
+  tem1 = BLOCAL_BUFFER (local);
 
   if (NILP (tem1)
       || current_buffer != XBUFFER (tem1)

diff --git a/src/lisp.h b/src/lisp.h
index b566a2920ecba45310811a42f03850ee1eb53a72..e459160c52a063fbebddfae0448ab0127aadd8ec 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1366,7 +1366,8 @@ struct Lisp_Buffer_Local_Value
   };
 
 void blocal_unbind_thread (Lisp_Object thread);
-Lisp_Object *blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l);
+Lisp_Object *blocal_get_thread_data (struct Lisp_Buffer_Local_Value *l,
+                                     Lisp_Object sym);
 void blocal_set_thread_data (struct Lisp_Buffer_Local_Value *l, Lisp_Object o);
 Lisp_Object *blocal_getrealvalue (struct Lisp_Buffer_Local_Value *l);
 
@@ -1378,7 +1379,7 @@ Lisp_Object *blocal_getrealvalue (struct Lisp_Buffer_Local_Value *l);
 #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_THREAD_DATA(A) (*blocal_get_thread_data (A, Qnil))
 #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)))