Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting

with lisp system changes.

29 files changed, 348 insertions, 191 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 9eb34feec54..6667b6054fe 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,81 @@
+2001-10-16  Ken Raeburn  <raeburn@gnu.org>
+
+        Avoid the assumption that car and cdr slots of cons cells are
+        addressable lvalues; this allows for easier experimentation with
+        other lisp implementations that may not permit such accesses for
+        various reasons.  Not quite complete -- buffer.c still needs some
+        work, and w32/mac files need rechecking -- so compile-time
+        enforcement is left disabled for now.
+
+        * lisp.h (LISP_MAKE_RVALUE): New macro, or function in the case of
+        gcc with a union-based Lisp object rep.  Redefine as no-op for
+        now.
+        (XCAR_AS_LVALUE, XCDR_AS_LVALUE): Rename from old XCAR, XCDR.
+        (XCAR, XCDR): Apply LISP_MAKE_RVALUE to the _AS_LVALUE versions.
+        (XSETCAR, XSETCDR): New macros.
+        (XSETCARFASTINT, XSETCDRFASTINT): New macros.
+        (CHECK_NUMBER_CAR, CHECK_NUMBER_CDR): New macros.
+        * keyboard.h (POSN_BUFFER_SET_POSN): New macro.
+        * alloc.c (Fcons, pure_cons, Fgarbage_collect): Use XSETCAR and
+        XSETCDR.
+        (mark_buffer): Use XCAR_AS_LVALUE, XCDR_AS_LVALUE.
+        * buffer.c (record_buffer, Fbury_buffer,
+        swap_out_buffer_local_variables, recenter_overlay_lists,
+        Foverlay_put): Use XSETCAR and XSETCDR to set the car and cdr
+        fields of a cons cell respectively.
+        * callint.c (quotify_args, Fcall_interactively): Likewise.
+        * ccl.c (Fregister_code_conversion_map): Likewise.
+        * coding.c (detect_coding_system): Likewise.
+        * composite.c (get_composition_id, make_composition_value_copy):
+        Likewise.
+        * data.c (Fsetcar, Fsetcdr, swap_in_global_binding,
+        swap_in_symval_forwarding, set_internal, Fset_default,
+        Fmake_variable_buffer_local, Fmake_local_variable,
+        Fmake_variable_frame_local): Likewise.
+        * fns.c (concat, Fcopy_alist, Fwidget_put): Likewise.
+        * keymap.c (Fset_keymap_parent, store_in_keymap,
+        accessible_keymaps_1, where_is_internal_2, Fcopy_keymap):
+        Likewise.
+        * minibuf.c (get_minibuffer): Likewise.
+        * search.c (Fmatch_data): Likewise.
+        * textprop.c (extend_property_ranges): Likewise.
+        * undo.c (record_insert, Fundo_boundary, truncate_undo_list):
+        Likewise.
+        * w32fns.c (w32_msg_pump, Fw32_register_hot_key, w32_list_fonts):
+        Likewise.
+        * w32term.c (x_delete_display): Likewise.
+        * xfaces.c (remove_duplicates, Finternal_set_lisp_face_attribute):
+        Likewise.
+        * xterm.c (x_list_fonts, x_load_font, x_delete_display):
+        Likewise.
+        * doc.c (store_function_docstring): Use XSETCARFASTINT.
+        * fileio.c (Fdo_auto_save): Use XSETCARFASTINT and
+        XSETCDRFASTINT.
+        (Fread_file_name): Use XSETCAR.
+        * fontset.c (Fset_fontset_font): Use CHECK_NUMBER_CAR and
+        CHECK_NUMBER_CDR.
+        (accumulate_font_info, Ffontset_info): Use XSETCAR and XSETCDR.
+        * frame.c (Fmake_terminal_frame): Use XSETCDR.
+        * indent.c (Fcompute_motion): Use CHECK_NUMBER_CAR and
+        CHECK_NUMBER_CDR.
+        * keyboard.c (read_char): Alter list traversal to avoid taking the
+        address of cons cell slots.  Use POSN_BUFFER_SET_POSN.
+        (parse_menu_item): Use XSETCAR and XSETCDR.
+        (reach_char_x_menu_prompt): Use XSETCAR.
+        (read_key_sequence): Use POSN_BUFFER_SET_POSN.
+        (Fcommand_execute): Use XSETCDR.
+        * lread.c (Fload): Use XSETCARFASTINT and XSETCDRFASTINT.
+        (openp): Change list traversal to avoid using XCAR as lvalue.
+        (read_list): Use XSETCDR.
+        * process.c (wait_reading_process_input): Change wait_for_cell
+        handling to avoid taking addresses of cons cell slots.
+        * xselect.c (x_own_selection, x_handle_selection_clear,
+        x_clear_frame_selections): Use XSETCDR.
+        (wait_for_property_change): Use XSETCARFASTINT and
+        XSETCDRFASTINT.
+        (x_handle_property_notify, x_get_foreign_selection,
+        x_handle_selection_notify): Use XSETCAR.
+
 2001-10-15  Pavel Jan,Bm(Bk  <Pavel@Janik.cz>
 
         * buffer.c: Put doc strings in comments.
diff --git a/src/alloc.c b/src/alloc.c
index 3a9dcc3c59d..a7780e9ad91 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2087,8 +2087,8 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
       XSETCONS (val, &cons_block->conses[cons_block_index++]);
     }
   
-  XCAR (val) = car;
-  XCDR (val) = cdr;
+  XSETCAR (val, car);
+  XSETCDR (val, cdr);
   consing_since_gc += sizeof (struct Lisp_Cons);
   cons_cells_consed++;
   return val;
@@ -3878,8 +3878,8 @@ pure_cons (car, cdr)
 
   p = (struct Lisp_Cons *) pure_alloc (sizeof *p, Lisp_Cons);
   XSETCONS (new, p);
-  XCAR (new) = Fpurecopy (car);
-  XCDR (new) = Fpurecopy (cdr);
+  XSETCAR (new, Fpurecopy (car));
+  XSETCDR (new, Fpurecopy (cdr));
   return new;
 }
 
@@ -4189,7 +4189,10 @@ Garbage collection happens automatically if you cons more than
                     if (NILP (prev))
                       nextb->undo_list = tail = XCDR (tail);
                     else
-                      tail = XCDR (prev) = XCDR (tail);
+                      {
+                        tail = XCDR (tail);
+                        XSETCDR (prev, tail);
+                      }
                   }
                 else
                   {
@@ -4800,8 +4803,8 @@ mark_buffer (buf)
               && ! XMARKBIT (XCAR (ptr->car))
               && GC_MARKERP (XCAR (ptr->car)))
             {
-              XMARK (XCAR (ptr->car));
-              mark_object (&XCDR (ptr->car));
+              XMARK (XCAR_AS_LVALUE (ptr->car));
+              mark_object (&XCDR_AS_LVALUE (ptr->car));
             }
           else
             mark_object (&ptr->car);
@@ -4812,7 +4815,7 @@ mark_buffer (buf)
             break;
         }
 
-      mark_object (&XCDR (tail));
+      mark_object (&XCDR_AS_LVALUE (tail));
     }
   else
     mark_object (&buffer->undo_list);
diff --git a/src/buffer.c b/src/buffer.c
index e3c3c4c4524..5fd52c8cbaa 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1415,9 +1415,9 @@ record_buffer (buf)
   if (NILP (prev))
     Vbuffer_alist = XCDR (Vbuffer_alist);
   else
-    XCDR (prev) = XCDR (XCDR (prev));
+    XSETCDR (prev, XCDR (XCDR (prev)));
         
-  XCDR (link) = Vbuffer_alist;
+  XSETCDR (link, Vbuffer_alist);
   Vbuffer_alist = link;
 
   /* Now move this buffer to the front of frame_buffer_list also.  */
@@ -1439,9 +1439,9 @@ record_buffer (buf)
         set_frame_buffer_list (frame,
                                XCDR (frame_buffer_list (frame)));
       else
-        XCDR (prev) = XCDR (XCDR (prev));
+        XSETCDR (prev, XCDR (XCDR (prev)));
         
-      XCDR (link) = frame_buffer_list (frame);
+      XSETCDR (link, frame_buffer_list (frame));
       set_frame_buffer_list (frame, link);
     }
   else
@@ -1863,7 +1863,7 @@ selected window if it is displayed there.  */
       aelt = Frassq (buffer, Vbuffer_alist);
       link = Fmemq (aelt, Vbuffer_alist);
       Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
-      XCDR (link) = Qnil;
+      XSETCDR (link, Qnil);
       Vbuffer_alist = nconc2 (Vbuffer_alist, link);
 
       frames_bury_buffer (buffer);
@@ -2286,10 +2286,10 @@ swap_out_buffer_local_variables (b)
              it is currently set up for.  This is so that, if the
              local is marked permanent, and we make it local again
              later in Fkill_all_local_variables, we don't lose the value.  */
-          XCDR (XCAR (tem))
-            = do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue);
+          XSETCDR (XCAR (tem),
+                   do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue));
           /* Switch to the symbol's default-value alist entry.  */
-          XCAR (tem) = tem;
+          XSETCAR (tem, tem);
           /* Mark it as current for buffer B.  */
           XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->buffer = buffer;
           /* Store the current value into any forwarding in the symbol.  */
@@ -3008,7 +3008,7 @@ recenter_overlay_lists (buf, pos)
 
           /* Splice the cons cell TAIL out of overlays_before.  */
           if (!NILP (prev))
-            XCDR (prev) = next;
+            XSETCDR (prev, next);
           else
             buf->overlays_before = next;
 
@@ -3030,9 +3030,9 @@ recenter_overlay_lists (buf, pos)
             }
 
           /* Add TAIL to overlays_after before OTHER.  */
-          XCDR (tail) = other;
+          XSETCDR (tail, other);
           if (!NILP (other_prev))
-            XCDR (other_prev) = tail;
+            XSETCDR (other_prev, tail);
           else
             buf->overlays_after = tail;
           tail = prev;
@@ -3085,7 +3085,7 @@ recenter_overlay_lists (buf, pos)
 
           /* Splice the cons cell TAIL out of overlays_after.  */
           if (!NILP (prev))
-            XCDR (prev) = next;
+            XSETCDR (prev, next);
           else
             buf->overlays_after = next;
 
@@ -3107,9 +3107,9 @@ recenter_overlay_lists (buf, pos)
             }
 
           /* Add TAIL to overlays_before before OTHER.  */
-          XCDR (tail) = other;
+          XSETCDR (tail, other);
           if (!NILP (other_prev))
-            XCDR (other_prev) = tail;
+            XSETCDR (other_prev, tail);
           else
             buf->overlays_before = tail;
           tail = prev;
@@ -3841,7 +3841,7 @@ DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
     if (EQ (XCAR (tail), prop))
       {
         changed = !EQ (XCAR (XCDR (tail)), value);
-        XCAR (XCDR (tail)) = value;
+        XSETCAR (XCDR (tail), value);
         goto found;
       }
   /* It wasn't in the list, so add it to the front.  */
diff --git a/src/callint.c b/src/callint.c
index 54ad0c2cf7e..329911cda6e 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -156,7 +156,7 @@ quotify_args (exp)
   for (tail = exp; CONSP (tail); tail = next)
     {
       next = XCDR (tail);
-      XCAR (tail) = quotify_arg (XCAR (tail));
+      XSETCAR (tail, quotify_arg (XCAR (tail)));
     }
   return exp;
 }
@@ -358,7 +358,7 @@ supply if the command inquires which events were used to invoke it.")
             {
               teml = Fnthcdr (Vhistory_length, Vcommand_history);
               if (CONSP (teml))
-                XCDR (teml) = Qnil;
+                XSETCDR (teml, Qnil);
             }
         }
       single_kboard_state ();
@@ -776,7 +776,7 @@ supply if the command inquires which events were used to invoke it.")
         {
           teml = Fnthcdr (Vhistory_length, Vcommand_history);
           if (CONSP (teml))
-            XCDR (teml) = Qnil;
+            XSETCDR (teml, Qnil);
         }
     }
 
diff --git a/src/ccl.c b/src/ccl.c
index d3879abae6b..52a4ff3c388 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2274,7 +2274,7 @@ Return index number of the registered map.")
       if (EQ (symbol, XCAR (slot)))
         {
           index = make_number (i);
-          XCDR (slot) = map;
+          XSETCDR (slot, map);
           Fput (symbol, Qcode_conversion_map, map);
           Fput (symbol, Qcode_conversion_map_id, index);
           return index;
diff --git a/src/coding.c b/src/coding.c
index 43f1867d9f8..08da1ae3dbb 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -6212,7 +6212,7 @@ detect_coding_system (src, src_bytes, highest, multibytep)
           Lisp_Object eol;
           eol = Fget (XCAR (tmp), Qeol_type);
           if (VECTORP (eol))
-            XCAR (tmp) = XVECTOR (eol)->contents[eol_type];
+            XSETCAR (tmp, XVECTOR (eol)->contents[eol_type]);
         }
     }
   return (highest ? XCAR (val) : val);
diff --git a/src/composite.c b/src/composite.c
index c3bf6878ce3..ff6d1a5ba34 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -249,8 +249,8 @@ get_composition_id (charpos, bytepos, nchars, prop, string)
          modify the cons cell of PROP because it is not shared.  */
       key = HASH_KEY (hash_table, hash_index);
       id = HASH_VALUE (hash_table, hash_index);
-      XCAR (prop) = id;
-      XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
+      XSETCAR (prop, id);
+      XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
       return XINT (id);
     }
 
@@ -297,8 +297,8 @@ get_composition_id (charpos, bytepos, nchars, prop, string)
   /* Change PROP from Form-A above to Form-B.  We can directly modify
      the cons cell of PROP because it is not shared.  */
   XSETFASTINT (id, n_compositions);
-  XCAR (prop) = id;
-  XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
+  XSETCAR (prop, id);
+  XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
 
   /* Register the composition in composition_hash_table.  */
   hash_index = hash_put (hash_table, key, id, hash_code);
@@ -569,7 +569,7 @@ make_composition_value_copy (list)
         {
           if (EQ (XCAR (plist), Qcomposition)
               && (val = XCAR (XCDR (plist)), CONSP (val)))
-            XCAR (XCDR (plist)) = Fcons (XCAR (val), XCDR (val));
+            XSETCAR (XCDR (plist), Fcons (XCAR (val), XCDR (val)));
           plist = XCDR (XCDR (plist));
         }
     }
diff --git a/src/data.c b/src/data.c
index 336afa98d8c..e56512370e0 100644
--- a/src/data.c
+++ b/src/data.c
@@ -582,7 +582,7 @@ DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
     cell = wrong_type_argument (Qconsp, cell);
 
   CHECK_IMPURE (cell);
-  XCAR (cell) = newcar;
+  XSETCAR (cell, newcar);
   return newcar;
 }
 
@@ -595,7 +595,7 @@ DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
     cell = wrong_type_argument (Qconsp, cell);
 
   CHECK_IMPURE (cell);
-  XCDR (cell) = newcdr;
+  XSETCDR (cell, newcdr);
   return newcdr;
 }
 
@@ -937,7 +937,7 @@ swap_in_global_binding (symbol)
            do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
   
   /* Select the global binding in the symbol.  */
-  XCAR (cdr) = cdr;
+  XSETCAR (cdr, cdr);
   store_symval_forwarding (symbol, valcontents, XCDR (cdr), NULL);
 
   /* Indicate that the global binding is set up now.  */
@@ -991,7 +991,7 @@ swap_in_symval_forwarding (symbol, valcontents)
         XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 1;
 
       /* Load the new binding.  */
-      XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = tem1;
+      XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, tem1);
       XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, current_buffer);
       XBUFFER_LOCAL_VALUE (valcontents)->frame = selected_frame;
       store_symval_forwarding (symbol,
@@ -1210,8 +1210,8 @@ set_internal (symbol, newval, buf, bindflag)
             }
 
           /* Record which binding is now loaded.  */
-          XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr)
-            = tem1;
+          XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr,
+                   tem1);
 
           /* Set `buffer' and `frame' slots for thebinding now loaded.  */
           XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, buf);
@@ -1243,7 +1243,7 @@ set_internal (symbol, newval, buf, bindflag)
          the default binding is loaded, the loaded binding may be the
          wrong one.  */
       if (XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame)
-        XCDR (current_alist_element) = newval;
+        XSETCDR (current_alist_element, newval);
     }
 
   return newval;
@@ -1362,7 +1362,7 @@ for this variable.")
     return Fset (symbol, value);
 
   /* Store new value into the DEFAULT-VALUE slot.  */
-  XCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = value;
+  XSETCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, value);
 
   /* If the default binding is now loaded, set the REALVALUE slot too.  */
   current_alist_element
@@ -1448,7 +1448,7 @@ The function `default-value' gets the default value and `set-default' sets it.")
   if (EQ (valcontents, Qunbound))
     SET_SYMBOL_VALUE (variable, Qnil);
   tem = Fcons (Qnil, Fsymbol_value (variable));
-  XCAR (tem) = tem;
+  XSETCAR (tem, tem);
   newval = allocate_misc ();
   XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
   XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@@ -1505,7 +1505,7 @@ Use `make-local-hook' instead.")
     {
       Lisp_Object newval;
       tem = Fcons (Qnil, do_symval_forwarding (valcontents));
-      XCAR (tem) = tem;
+      XSETCAR (tem, tem);
       newval = allocate_misc ();
       XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
       XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@@ -1644,7 +1644,7 @@ See `modify-frame-parameters'.")
   if (EQ (valcontents, Qunbound))
     SET_SYMBOL_VALUE (variable, Qnil);
   tem = Fcons (Qnil, Fsymbol_value (variable));
-  XCAR (tem) = tem;
+  XSETCAR (tem, tem);
   newval = allocate_misc ();
   XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
   XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
diff --git a/src/doc.c b/src/doc.c
index 09f377bb1af..39cffee19cb 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -445,7 +445,7 @@ store_function_docstring (fun, offset)
         {
           tem = Fcdr (Fcdr (fun));
           if (CONSP (tem) && INTEGERP (XCAR (tem)))
-            XSETFASTINT (XCAR (tem), offset);
+            XSETCARFASTINT (tem, offset);
         }
       else if (EQ (tem, Qmacro))
         store_function_docstring (XCDR (fun), offset);
diff --git a/src/fileio.c b/src/fileio.c
index 0a726a4a01a..e7b9b0aa3db 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5499,8 +5499,8 @@ A non-nil CURRENT-ONLY argument means save only current buffer.")
           /* Arrange to close that file whether or not we get an error.
              Also reset auto_saving to 0.  */
           lispstream = Fcons (Qnil, Qnil);
-          XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
-          XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
+          XSETCARFASTINT (lispstream, (EMACS_UINT)stream >> 16);
+          XSETCDRFASTINT (lispstream, (EMACS_UINT)stream & 0xffff);
         }
       else
         lispstream = Qnil;
@@ -5939,7 +5939,7 @@ provides a file dialog box..")
   if (replace_in_history)
     /* Replace what Fcompleting_read added to the history
        with what we will actually return.  */
-    XCAR (Fsymbol_value (Qfile_name_history)) = double_dollars (val);
+    XSETCAR (Fsymbol_value (Qfile_name_history), double_dollars (val));
   else if (add_to_history)
     {
       /* Add the value to the history--but not if it matches
diff --git a/src/fns.c b/src/fns.c
index 7a43057ae72..e293d446511 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -782,7 +782,7 @@ concat (nargs, args, target_type, last_special)
             /* Store this element into the result.  */
             if (toindex < 0)
               {
-                XCAR (tail) = elt;
+                XSETCAR (tail, elt);
                 prev = tail;
                 tail = XCDR (tail);
               }
@@ -823,7 +823,7 @@ concat (nargs, args, target_type, last_special)
           }
     }
   if (!NILP (prev))
-    XCDR (prev) = last_tail;
+    XSETCDR (prev, last_tail);
 
   if (num_textprops > 0)
     {
@@ -1159,7 +1159,7 @@ Elements of ALIST that are not conses are also shared.  */
       car = XCAR (tem);
 
       if (CONSP (car))
-        XCAR (tem) = Fcons (XCAR (car), XCDR (car));
+        XSETCAR (tem, Fcons (XCAR (car), XCDR (car)));
     }
   return alist;
 }
@@ -3153,7 +3153,7 @@ The value can later be retrieved with `widget-get'.  */
      Lisp_Object widget, property, value;
 {
   CHECK_CONS (widget, 1);
-  XCDR (widget) = Fplist_put (XCDR (widget), property, value);
+  XSETCDR (widget, Fplist_put (XCDR (widget), property, value));
   return value;
 }
 
diff --git a/src/fontset.c b/src/fontset.c
index 5e359ddef8f..983222f4bb7 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -994,8 +994,8 @@ name of a font, REGSITRY is a registry name of a font.")
     {
       /* CH should be (FROM . TO) where FROM and TO are non-generic
          characters.  */
-      CHECK_NUMBER (XCAR (character), 1);
-      CHECK_NUMBER (XCDR (character), 1);
+      CHECK_NUMBER_CAR (character, 1);
+      CHECK_NUMBER_CDR (character, 1);
       from = XINT (XCAR (character));
       to = XINT (XCDR (character));
       if (!char_valid_p (from, 0) || !char_valid_p (to, 0))
@@ -1214,7 +1214,7 @@ accumulate_font_info (arg, character, elt)
         {
           if (this_charset == CHAR_CHARSET (XINT (XCAR (last_char))))
             {
-              XCDR (last_char) = character;
+              XSETCDR (last_char, character);
               return;
             }
         }
@@ -1222,12 +1222,12 @@ accumulate_font_info (arg, character, elt)
         return;
       else if (this_charset == CHAR_CHARSET (XINT (last_char)))
         {
-          XCAR (XCAR (last)) = Fcons (last_char, character);
+          XSETCAR (XCAR (last), Fcons (last_char, character));
           return;
         }
     }
-  XCDR (last) = Fcons (Fcons (character, Fcons (elt, Qnil)), Qnil);
-  XCAR (arg) = XCDR (last);
+  XSETCDR (last, Fcons (Fcons (character, Fcons (elt, Qnil)), Qnil));
+  XSETCAR (arg, XCDR (last));
 }
 
 
@@ -1306,7 +1306,7 @@ If FRAME is omitted, it defaults to the currently selected frame.")
           c = XINT (XCAR (elt));
           SPLIT_CHAR (c, charset, c1, c2);
           if (c1 == 0)
-            XCAR (elt) = CHARSET_SYMBOL (charset);
+            XSETCAR (elt, CHARSET_SYMBOL (charset));
         }
       else
         c = XINT (XCAR (XCAR (elt)));
@@ -1323,7 +1323,7 @@ If FRAME is omitted, it defaults to the currently selected frame.")
                 {
                   font = build_string (face->font_name);
                   if (NILP (Fmember (font, XCDR (XCDR (elt)))))
-                    XCDR (XCDR (elt)) = Fcons (font, XCDR (XCDR (elt)));
+                    XSETCDR (XCDR (elt), Fcons (font, XCDR (XCDR (elt))));
                 }
             }
         }
diff --git a/src/frame.c b/src/frame.c
index f6a4ee8e2cf..2bed16b9503 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -543,7 +543,7 @@ Note that changing the size of one terminal frame automatically affects all.")
      the vectors which are the CDRs of associations in face_alist to
      be copied as well.  */
   for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
-    XCDR (XCAR (tem)) = Fcopy_sequence (XCDR (XCAR (tem)));
+    XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
   return frame;
 }
 
diff --git a/src/indent.c b/src/indent.c
index d8ede2ad0e8..95e16d1fa56 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1755,18 +1755,18 @@ DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
 
   CHECK_NUMBER_COERCE_MARKER (from, 0);
   CHECK_CONS (frompos, 0);
-  CHECK_NUMBER (XCAR (frompos), 0);
-  CHECK_NUMBER (XCDR (frompos), 0);
+  CHECK_NUMBER_CAR (frompos, 0);
+  CHECK_NUMBER_CDR (frompos, 0);
   CHECK_NUMBER_COERCE_MARKER (to, 0);
   CHECK_CONS (topos, 0);
-  CHECK_NUMBER (XCAR (topos), 0);
-  CHECK_NUMBER (XCDR (topos), 0);
+  CHECK_NUMBER_CAR (topos, 0);
+  CHECK_NUMBER_CDR (topos, 0);
   CHECK_NUMBER (width, 0);
   if (!NILP (offsets))
     {
       CHECK_CONS (offsets, 0);
-      CHECK_NUMBER (XCAR (offsets), 0);
-      CHECK_NUMBER (XCDR (offsets), 0);
+      CHECK_NUMBER_CAR (offsets, 0);
+      CHECK_NUMBER_CDR (offsets, 0);
       hscroll = XINT (XCAR (offsets));
       tab_offset = XINT (XCDR (offsets));
     }
diff --git a/src/keyboard.c b/src/keyboard.c
index 414f72b971f..23b1f0d5b57 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2358,15 +2358,21 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
         KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
         if (kb != current_kboard)
           {
-            Lisp_Object *tailp = &kb->kbd_queue;
+            Lisp_Object link = kb->kbd_queue;
             /* We shouldn't get here if we were in single-kboard mode!  */
             if (single_kboard)
               abort ();
-            while (CONSP (*tailp))
-              tailp = &XCDR (*tailp);
-            if (!NILP (*tailp))
-              abort ();
-            *tailp = Fcons (c, Qnil);
+            if (CONSP (link))
+              {
+                while (CONSP (XCDR (link)))
+                  link = XCDR (link);
+                if (!NILP (XCDR (link)))
+                  abort ();
+              }
+            if (!CONSP (link))
+              kb->kbd_queue = Fcons (c, Qnil);
+            else
+              XSETCDR (link, Fcons (c, Qnil));
             kb->kbd_queue_has_data = 1;
             current_kboard = kb;
             /* This is going to exit from read_char
@@ -2581,12 +2587,18 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 #ifdef MULTI_KBOARD
       if (! NILP (c) && (kb != current_kboard))
         {
-          Lisp_Object *tailp = &kb->kbd_queue;
-          while (CONSP (*tailp))
-            tailp = &XCDR (*tailp);
-          if (!NILP (*tailp))
-            abort ();
-          *tailp = Fcons (c, Qnil);
+          Lisp_Object link = kb->kbd_queue;
+          if (CONSP (link))
+            {
+              while (CONSP (XCDR (link)))
+                link = XCDR (link);
+              if (!NILP (XCDR (link)))
+                abort ();
+            }
+          if (!CONSP (link))
+            kb->kbd_queue = Fcons (c, Qnil);
+          else
+            XSETCDR (link, Fcons (c, Qnil));
           kb->kbd_queue_has_data = 1;
           c = Qnil;
           if (single_kboard)
@@ -2702,7 +2714,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
         {
           /* Change menu-bar to (menu-bar) as the event "position".  */
-          POSN_BUFFER_POSN (EVENT_START (c)) = Fcons (posn, Qnil);
+          POSN_BUFFER_SET_POSN (EVENT_START (c), Fcons (posn, Qnil));
 
           also_record = c;
           Vunread_command_events = Fcons (c, Vunread_command_events);
@@ -6854,19 +6866,19 @@ parse_menu_item (item, notreal, inmenubar)
     {
       /* We have to create a cachelist.  */
       CHECK_IMPURE (start);
-      XCDR (start) = Fcons (Fcons (Qnil, Qnil), XCDR (start));
+      XSETCDR (start, Fcons (Fcons (Qnil, Qnil), XCDR (start)));
       cachelist = XCAR (XCDR (start));
       newcache = 1;
       tem = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
       if (!NILP (keyhint))
         {
-          XCAR (cachelist) = XCAR (keyhint);
+          XSETCAR (cachelist, XCAR (keyhint));
           newcache = 0;
         }
       else if (STRINGP (tem))
         {
-          XCDR (cachelist) = Fsubstitute_command_keys (tem);
-          XCAR (cachelist) = Qt;
+          XSETCDR (cachelist, Fsubstitute_command_keys (tem));
+          XSETCAR (cachelist, Qt);
         }
     }
   
@@ -6924,10 +6936,10 @@ parse_menu_item (item, notreal, inmenubar)
               && ! NILP (Fget (def, Qmenu_alias)))
             def = XSYMBOL (def)->function;
           tem = Fwhere_is_internal (def, Qnil, Qt, Qnil);
-          XCAR (cachelist) = tem;
+          XSETCAR (cachelist, tem);
           if (NILP (tem))
             {
-              XCDR (cachelist) = Qnil;
+              XSETCDR (cachelist, Qnil);
               chkcache = 0;
             }
         }
@@ -6948,7 +6960,7 @@ parse_menu_item (item, notreal, inmenubar)
               if (STRINGP (XCDR (prefix)))
                 tem = concat2 (tem, XCDR (prefix));
             }
-          XCDR (cachelist) = tem;
+          XSETCDR (cachelist, tem);
         }
     }
 
@@ -6956,7 +6968,7 @@ parse_menu_item (item, notreal, inmenubar)
   if (newcache && !NILP (tem))
     {
       tem = concat3 (build_string ("  ("), tem, build_string (")"));
-      XCDR (cachelist) = tem;
+      XSETCDR (cachelist, tem);
     }
 
   /* If we only want to precompute equivalent key bindings, stop here. */
@@ -7474,7 +7486,7 @@ read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
               record_menu_key (XCAR (tem));
               if (SYMBOLP (XCAR (tem))
                   || INTEGERP (XCAR (tem)))
-                XCAR (tem) = Fcons (XCAR (tem), Qdisabled);
+                XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
             }
 
           /* If we got more than one event, put all but the first
@@ -8466,8 +8478,8 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
 
                   /* Zap the position in key, so we know that we've
                      expanded it, and don't try to do so again.  */
-                  POSN_BUFFER_POSN (EVENT_START (key))
-                    = Fcons (posn, Qnil);
+                  POSN_BUFFER_SET_POSN (EVENT_START (key),
+                                        Fcons (posn, Qnil));
 
                   mock_input = t + 2;
                   goto replay_sequence;
@@ -9203,7 +9215,7 @@ a special event, so ignore the prefix argument and don't clear it.")
             {
               tem = Fnthcdr (Vhistory_length, Vcommand_history);
               if (CONSP (tem))
-                XCDR (tem) = Qnil;
+                XSETCDR (tem, Qnil);
             }
         }
 
diff --git a/src/keyboard.h b/src/keyboard.h
index ff867f0c268..625f40c94d7 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -260,6 +260,7 @@ extern Lisp_Object item_properties;
 /* Extract the fields of a position.  */
 #define POSN_WINDOW(posn) (XCAR (posn))
 #define POSN_BUFFER_POSN(posn) (XCAR (XCDR (posn)))
+#define POSN_BUFFER_SET_POSN(posn,x) (XSETCAR (XCDR (posn), (x)))
 #define POSN_WINDOW_POSN(posn) (XCAR (XCDR (XCDR (posn))))
 #define POSN_TIMESTAMP(posn) \
   (XCAR (XCDR (XCDR (XCDR (posn)))))
diff --git a/src/keymap.c b/src/keymap.c
index 75a12ead3ca..eb4d3ab375c 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -363,7 +363,7 @@ PARENT should be nil or another keymap.")
           if (EQ (XCDR (prev), parent))
             RETURN_UNGCPRO (parent);
 
-          XCDR (prev) = parent;
+          XSETCDR (prev, parent);
           break;
         }
       prev = list;
@@ -769,7 +769,7 @@ store_in_keymap (keymap, idx, def)
           {
             if (EQ (idx, XCAR (elt)))
               {
-                XCDR (elt) = def;
+                XSETCDR (elt, def);
                 return def;
               }
           }
@@ -786,8 +786,8 @@ store_in_keymap (keymap, idx, def)
   keymap_end:
     /* We have scanned the entire keymap, and not found a binding for
        IDX.  Let's add one.  */
-    XCDR (insertion_point)
-      = Fcons (Fcons (idx, def), XCDR (insertion_point));
+    XSETCDR (insertion_point,
+             Fcons (Fcons (idx, def), XCDR (insertion_point)));
   }
   
   return def;
@@ -830,7 +830,7 @@ is not copied.")
           Lisp_Object indices[3];
 
           elt = Fcopy_sequence (elt);
-          XCAR (tail) = elt;
+          XSETCAR (tail, elt);
 
           map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
         }
@@ -839,7 +839,7 @@ is not copied.")
           int i;
 
           elt = Fcopy_sequence (elt);
-          XCAR (tail) = elt;
+          XSETCAR (tail, elt);
 
           for (i = 0; i < ASIZE (elt); i++)
             if (CONSP (AREF (elt, i)) && EQ (XCAR (AREF (elt, i)), Qkeymap))
@@ -854,15 +854,15 @@ is not copied.")
           if (EQ (XCAR (tem),Qmenu_item))
             {
               /* Copy cell with menu-item marker.  */
-              XCDR (elt)
-                = Fcons (XCAR (tem), XCDR (tem));
+              XSETCDR (elt,
+                       Fcons (XCAR (tem), XCDR (tem)));
               elt = XCDR (elt);
               tem = XCDR (elt);
               if (CONSP (tem))
                 {
                   /* Copy cell with menu-item name.  */
-                  XCDR (elt)
-                    = Fcons (XCAR (tem), XCDR (tem));
+                  XSETCDR (elt,
+                           Fcons (XCAR (tem), XCDR (tem)));
                   elt = XCDR (elt);
                   tem = XCDR (elt);
                 };
@@ -870,16 +870,16 @@ is not copied.")
                 {
                   /* Copy cell with binding and if the binding is a keymap,
                      copy that.  */
-                  XCDR (elt)
-                    = Fcons (XCAR (tem), XCDR (tem));
+                  XSETCDR (elt,
+                           Fcons (XCAR (tem), XCDR (tem)));
                   elt = XCDR (elt);
                   tem = XCAR (elt);
                   if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
-                    XCAR (elt) = Fcopy_keymap (tem);
+                    XSETCAR (elt, Fcopy_keymap (tem));
                   tem = XCDR (elt);
                   if (CONSP (tem) && CONSP (XCAR (tem)))
                     /* Delete cache for key equivalences.  */
-                    XCDR (elt) = XCDR (tem);
+                    XSETCDR (elt, XCDR (tem));
                 }
             }
           else
@@ -890,15 +890,15 @@ is not copied.")
               if (STRINGP (XCAR (tem)))
                 {
                   /* Copy the cell, since copy-alist didn't go this deep.  */
-                  XCDR (elt)
-                    = Fcons (XCAR (tem), XCDR (tem));
+                  XSETCDR (elt,
+                           Fcons (XCAR (tem), XCDR (tem)));
                   elt = XCDR (elt);
                   tem = XCDR (elt);
                   /* Also skip the optional menu help string.  */
                   if (CONSP (tem) && STRINGP (XCAR (tem)))
                     {
-                      XCDR (elt)
-                        = Fcons (XCAR (tem), XCDR (tem));
+                      XSETCDR (elt,
+                               Fcons (XCAR (tem), XCDR (tem)));
                       elt = XCDR (elt);
                       tem = XCDR (elt);
                     }
@@ -908,12 +908,12 @@ is not copied.")
                       && CONSP (XCAR (tem))
                       && (NILP (XCAR (XCAR (tem)))
                           || VECTORP (XCAR (XCAR (tem)))))
-                    XCDR (elt) = XCDR (tem);
+                    XSETCDR (elt, XCDR (tem));
                 }
               if (CONSP (elt)
                   && CONSP (XCDR (elt))
                   && EQ (XCAR (XCDR (elt)), Qkeymap))
-                XCDR (elt) = Fcopy_keymap (XCDR (elt));
+                XSETCDR (elt, Fcopy_keymap (XCDR (elt)));
             }
 
         }
@@ -1548,8 +1548,8 @@ accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized)
               /* This new sequence is the same length as
                  thisseq, so stick it in the list right
                  after this one.  */
-              XCDR (tail)
-                = Fcons (Fcons (tem, cmd), XCDR (tail));
+              XSETCDR (tail,
+                       Fcons (Fcons (tem, cmd), XCDR (tail)));
             }
           else
             {
@@ -2396,7 +2396,7 @@ where_is_internal_2 (args, key, binding)
                                   this, last, nomenus, last_is_meta);
 
   if (!NILP (sequence))
-    XCDR (XCAR (args)) = Fcons (sequence, result);
+    XSETCDR (XCAR (args), Fcons (sequence, result));
 
   UNGCPRO;
 }
diff --git a/src/lisp.h b/src/lisp.h
index add5312578b..2cb7a1fcc7f 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -248,6 +248,16 @@ Lisp_Object;
 
 #endif /* WORDS_BIG_ENDIAN */
 
+#ifdef __GNUC__
+static __inline__ Lisp_Object
+LISP_MAKE_RVALUE (Lisp_Object o)
+{
+    return o;
+}
+#else
+#define LISP_MAKE_RVALUE(o) (o) /* XXX - keeps arg as rvalue.  */
+#endif
+
 #endif /* NO_UNION_TYPE */
 
 
@@ -255,6 +265,7 @@ Lisp_Object;
 
 #ifdef NO_UNION_TYPE
 #define Lisp_Object EMACS_INT
+#define LISP_MAKE_RVALUE(o) (0+(o))
 #endif /* NO_UNION_TYPE */
 
 #ifndef VALMASK
@@ -616,14 +627,43 @@ struct Lisp_Cons
   };
 
 /* Take the car or cdr of something known to be a cons cell.  */
+/* The _AS_LVALUE macros shouldn't be used outside of the minimal set
+   of code that has to know what a cons cell looks like.  Other code not
+   part of the basic lisp implementation should assume that the car and cdr
+   fields are not accessible as lvalues.  (What if we want to switch to
+   a copying collector someday?  Cached cons cell field addresses may be
+   invalidated at arbitrary points.)  */
 #ifdef HIDE_LISP_IMPLEMENTATION
-#define XCAR(c) (XCONS ((c))->car_)
-#define XCDR(c) (XCONS ((c))->cdr_)
+#define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
+#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr_)
 #else
-#define XCAR(c) (XCONS ((c))->car)
-#define XCDR(c) (XCONS ((c))->cdr)
+#define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
+#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr)
 #endif
 
+/* Okay, we're not quite ready to turn this on yet.  A few files still
+   need to be updated and tested.  */
+#undef LISP_MAKE_RVALUE
+#define LISP_MAKE_RVALUE(x) (x)
+
+/* Use these from normal code.  */
+#define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
+#define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
+
+/* Use these to set the fields of a cons cell.
+
+   Note that both arguments may refer to the same object, so 'n'
+   should not be read after 'c' is first modified.  Also, neither
+   argument should be evaluated more than once; side effects are
+   especially common in the second argument.  */
+#define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
+#define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
+
+/* For performance: Fast storage of positive integers into the
+   fields of a cons cell.  See above caveats.  */
+#define XSETCARFASTINT(c,n)  XSETFASTINT(XCAR_AS_LVALUE(c),(n))
+#define XSETCDRFASTINT(c,n)  XSETFASTINT(XCDR_AS_LVALUE(c),(n))
+
 /* Take the car or cdr of something whose type is not known.  */
 #define CAR(c)                                  \
  (CONSP ((c)) ? XCAR ((c))                      \
@@ -1474,6 +1514,22 @@ typedef unsigned char UCHAR;
 #define CHECK_OVERLAY(x, i) \
   do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
 
+/* Since we can't assign directly to the CAR or CDR fields of a cons
+   cell, use these when checking that those fields contain numbers.  */
+#define CHECK_NUMBER_CAR(x, i) \
+  do {                                  \
+    Lisp_Object tmp = XCAR (x);         \
+    CHECK_NUMBER (tmp, (i));            \
+    XSETCAR ((x), tmp);                 \
+  } while (0)
+
+#define CHECK_NUMBER_CDR(x, i) \
+  do {                                  \
+    Lisp_Object tmp = XCDR (x);         \
+    CHECK_NUMBER (tmp, (i));            \
+    XSETCDR ((x), tmp);                 \
+  } while (0)
+
 /* Cast pointers to this type to compare them.  Some machines want int.  */
 #ifndef PNTR_COMPARISON_TYPE
 #define PNTR_COMPARISON_TYPE EMACS_UINT
diff --git a/src/lread.c b/src/lread.c
index 671305c6f93..6968c5394fb 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -832,8 +832,8 @@ Return t if file exists.")
 
   GCPRO1 (file);
   lispstream = Fcons (Qnil, Qnil);
-  XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
-  XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
+  XSETCARFASTINT (lispstream, (EMACS_UINT)stream >> 16);
+  XSETCDRFASTINT (lispstream, (EMACS_UINT)stream & 0xffff);
   record_unwind_protect (load_unwind, lispstream);
   record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
   specbind (Qload_file_name, found);
@@ -963,16 +963,19 @@ openp (path, str, suffixes, storeptr, exec_only)
   Lisp_Object string, tail;
   int max_suffix_len = 0;
 
+  string = filename = Qnil;
+  GCPRO5 (str, string, filename, path, suffixes);
+  
   for (tail = suffixes; CONSP (tail); tail = XCDR (tail))
     {
-      CHECK_STRING (XCAR (tail), 0);
+      string = XCAR (tail);
+      CHECK_STRING (string, 0);
+      if (! EQ (string, XCAR (tail)))
+        XSETCAR (tail, string);
       max_suffix_len = max (max_suffix_len,
-                            STRING_BYTES (XSTRING (XCAR (tail))));
+                            STRING_BYTES (XSTRING (string)));
     }
 
-  string = filename = Qnil;
-  GCPRO5 (str, string, filename, path, suffixes);
-  
   if (storeptr)
     *storeptr = Qnil;
 
@@ -2724,7 +2727,7 @@ read_list (flag, readcharfun)
             {
               GCPRO2 (val, tail);
               if (!NILP (tail))
-                XCDR (tail) = read0 (readcharfun);
+                XSETCDR (tail, read0 (readcharfun));
               else
                 val = read0 (readcharfun);
               read1 (readcharfun, &ch, 0);
@@ -2817,7 +2820,7 @@ read_list (flag, readcharfun)
              ? pure_cons (elt, Qnil)
              : Fcons (elt, Qnil));
       if (!NILP (tail))
-        XCDR (tail) = tem;
+        XSETCDR (tail, tem);
       else
         val = tem;
       tail = tem;
diff --git a/src/minibuf.c b/src/minibuf.c
index 9af0c0b0fe5..655a6061aaa 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -723,7 +723,7 @@ get_minibuffer (depth)
          enabled in it.  */
       Fbuffer_enable_undo (buf);
 
-      XCAR (tail) = buf;
+      XSETCAR (tail, buf);
     }
   else
     {
diff --git a/src/process.c b/src/process.c
index f3407838720..956f2b8fdb3 100644
--- a/src/process.c
+++ b/src/process.c
@@ -2367,7 +2367,9 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   int wait_channel = -1;
   struct Lisp_Process *wait_proc = 0;
   int got_some_input = 0;
-  Lisp_Object *wait_for_cell = 0;
+  /* Either nil or a cons cell, the car of which is of interest and
+     may be changed outside of this routine.  */
+  Lisp_Object wait_for_cell = Qnil;
 
   FD_ZERO (&Available);
 
@@ -2383,7 +2385,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   /* If waiting for non-nil in a cell, record where.  */
   if (CONSP (read_kbd))
     {
-      wait_for_cell = &XCAR (read_kbd);
+      wait_for_cell = read_kbd;
       XSETFASTINT (read_kbd, 0);
     }
 
@@ -2417,7 +2419,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         QUIT;
 
       /* Exit now if the cell we're waiting for became non-nil.  */
-      if (wait_for_cell && ! NILP (*wait_for_cell))
+      if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
       /* Compute time from now till when time limit is up */
@@ -2446,7 +2448,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          But not if wait_for_cell; in those cases,
          the wait is supposed to be short,
          and those callers cannot handle running arbitrary Lisp code here.  */
-      if (! wait_for_cell)
+      if (NILP (wait_for_cell))
         {
           EMACS_TIME timer_delay;
 
@@ -2567,7 +2569,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* Wait till there is something to do */
 
-      if (wait_for_cell)
+      if (!NILP (wait_for_cell))
         Available = non_process_wait_mask;
       else if (! XINT (read_kbd))
         Available = non_keyboard_wait_mask;
@@ -2723,7 +2725,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         }
 
       /* Exit now if the cell we're waiting for became non-nil.  */
-      if (wait_for_cell && ! NILP (*wait_for_cell))
+      if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
 #ifdef SIGIO
@@ -2742,7 +2744,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* If checking input just got us a size-change event from X,
          obey it now if we should.  */
-      if (XINT (read_kbd) || wait_for_cell)
+      if (XINT (read_kbd) || ! NILP (wait_for_cell))
         do_pending_window_change (0);
 
       /* Check for data from a process.  */
@@ -4768,12 +4770,14 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   EMACS_TIME end_time, timeout;
   SELECT_TYPE waitchannels;
   int xerrno;
-  Lisp_Object *wait_for_cell = 0;
+  /* Either nil or a cons cell, the car of which is of interest and
+     may be changed outside of this routine.  */
+  Lisp_Object wait_for_cell = Qnil;
 
   /* If waiting for non-nil in a cell, record where.  */
   if (CONSP (read_kbd))
     {
-      wait_for_cell = &XCAR (read_kbd);
+      wait_for_cell = read_kbd;
       XSETFASTINT (read_kbd, 0);
     }
 
@@ -4800,7 +4804,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         QUIT;
 
       /* Exit now if the cell we're waiting for became non-nil.  */
-      if (wait_for_cell && ! NILP (*wait_for_cell))
+      if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
       /* Compute time from now till when time limit is up */
@@ -4829,7 +4833,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          run timer events directly.
          (Callers that will immediately read keyboard events
          call timer_delay on their own.)  */
-      if (! wait_for_cell)
+      if (NILP (wait_for_cell))
         {
           EMACS_TIME timer_delay;
 
@@ -4870,7 +4874,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* Wait till there is something to do.  */
 
-      if (! XINT (read_kbd) && wait_for_cell == 0)
+      if (! XINT (read_kbd) && NILP (wait_for_cell))
         FD_ZERO (&waitchannels);
       else
         FD_SET (0, &waitchannels);
@@ -4946,7 +4950,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          input at all when wait_for_cell, but the code
          has been this way since July 1994.
          Try changing this after version 19.31.)  */
-      if (wait_for_cell
+      if (! NILP (wait_for_cell)
           && detect_input_pending ())
         {
           swallow_events (do_display);
@@ -4955,7 +4959,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         }
 
       /* Exit now if the cell we're waiting for became non-nil.  */
-      if (wait_for_cell && ! NILP (*wait_for_cell))
+      if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
     }
 
diff --git a/src/search.c b/src/search.c
index f05f2cc0bf3..519a7b48665 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2691,16 +2691,16 @@ to hold all the values, and if INTEGERS is non-nil, no consing is done.")
        i++, tail = XCDR (tail))
     {
       if (i < 2 * len + 2)
-        XCAR (tail) = data[i];
+        XSETCAR (tail, data[i]);
       else
-        XCAR (tail) = Qnil;
+        XSETCAR (tail, Qnil);
       prev = tail;
     }
 
   /* If we couldn't fit all value elements into REUSE,
      cons up the rest of them and add them to the end of REUSE.  */
   if (i < 2 * len + 2)
-    XCDR (prev) = Flist (2 * len + 2 - i, data + i);
+    XSETCDR (prev, Flist (2 * len + 2 - i, data + i));
 
   return reuse;
 }
diff --git a/src/textprop.c b/src/textprop.c
index 0cb09791f5e..b43503dfdb8 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -1738,7 +1738,7 @@ extend_property_ranges (list, old_end, new_end)
       end = XCAR (XCDR (item));
 
       if (EQ (end, old_end))
-        XCAR (XCDR (item)) = new_end;
+        XSETCAR (XCDR (item), new_end);
     }
 }
 
diff --git a/src/undo.c b/src/undo.c
index b664cf3c61f..bf10de6e502 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -73,7 +73,7 @@ record_insert (beg, length)
           && INTEGERP (XCDR (elt))
           && XINT (XCDR (elt)) == beg)
         {
-          XSETINT (XCDR (elt), beg + length);
+          XSETCDR (elt, make_number (beg + length));
           return;
         }
     }
@@ -273,7 +273,7 @@ but another undo command will undo to the previous boundary.")
         {
           /* If we have preallocated the cons cell to use here,
              use that one.  */
-          XCDR (pending_boundary) = current_buffer->undo_list;
+          XSETCDR (pending_boundary, current_buffer->undo_list);
           current_buffer->undo_list = pending_boundary;
           pending_boundary = Qnil;
         }
@@ -378,7 +378,7 @@ truncate_undo_list (list, minsize, maxsize)
   /* Truncate at the boundary where we decided to truncate.  */
   if (!NILP (last_boundary))
     {
-      XCDR (last_boundary) = Qnil;
+      XSETCDR (last_boundary, Qnil);
       return list;
     }
   else
diff --git a/src/w32fns.c b/src/w32fns.c
index f1884e0f4e5..18e40ed09ed 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3784,7 +3784,7 @@ w32_msg_pump (deferred_msg * msg_buf)
                  thread-safe.  The next line is okay because the cons
                  cell is never made into garbage and is not relocated by
                  GC.  */
-              XCAR ((Lisp_Object) msg.lParam) = Qnil;
+              XSETCAR ((Lisp_Object) msg.lParam, Qnil);
               if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
                 abort ();
               break;
@@ -6866,9 +6866,9 @@ w32_list_fonts (f, pattern, size, maxnames)
 
       /* Make a list of the fonts we got back.
          Store that in the font cache for the display. */
-      XCDR (dpyinfo->name_list_element)
-        = Fcons (Fcons (tpat, list),
-                 XCDR (dpyinfo->name_list_element));
+      XSETCDR (dpyinfo->name_list_element,
+               Fcons (Fcons (tpat, list),
+                      XCDR (dpyinfo->name_list_element)));
 
     label_cached:
       if (NILP (list)) continue; /* Try the remaining alternatives.  */
@@ -6915,9 +6915,9 @@ w32_list_fonts (f, pattern, size, maxnames)
               hdc = GetDC (dpyinfo->root_window);
               oldobj = SelectObject (hdc, thisinfo.hfont);
               if (GetTextMetrics (hdc, &thisinfo.tm))
-                XCDR (tem) = make_number (FONT_WIDTH (&thisinfo));
+                XSETCDR (tem, make_number (FONT_WIDTH (&thisinfo)));
               else
-                XCDR (tem) = make_number (0);
+                XSETCDR (tem, make_number (0));
               SelectObject (hdc, oldobj);
               ReleaseDC (dpyinfo->root_window, hdc);
               DeleteObject(thisinfo.hfont);
@@ -13240,7 +13240,7 @@ The return value is the hotkey-id if registered, otherwise nil.")
       if (NILP (item))
         w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
       else
-        XCAR (item) = key;
+        XSETCAR (item, key);
 
       /* Notify input thread about new hot-key definition, so that it
          takes effect without needing to switch focus.  */
diff --git a/src/w32term.c b/src/w32term.c
index 42a8fdd957f..8478f6c8b5e 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -10286,7 +10286,7 @@ x_delete_display (dpyinfo)
         {
           if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
             {
-              XCDR (tail) = XCDR (XCDR (tail));
+              XSETCDR (tail, XCDR (XCDR (tail)));
               break;
             }
           tail = XCDR (tail);
diff --git a/src/xfaces.c b/src/xfaces.c
index 476908e5b15..c9867c4ce1f 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -2684,7 +2684,7 @@ remove_duplicates (list)
     {
       Lisp_Object next = XCDR (tail);
       if (!NILP (Fequal (XCAR (next), XCAR (tail))))
-        XCDR (tail) = XCDR (next);
+        XSETCDR (tail, XCDR (next));
       else
         tail = XCDR (tail);
     }
@@ -4199,8 +4199,8 @@ FRAME 0 means change the face on all frames, and change the default
           {
             Lisp_Object cons;
             cons = XCAR (Vparam_value_alist);
-            XCAR (cons) = param;
-            XCDR (cons) = value;
+            XSETCAR (cons, param);
+            XSETCDR (cons, value);
             Fmodify_frame_parameters (frame, Vparam_value_alist);
           }
     }
diff --git a/src/xselect.c b/src/xselect.c
index 91011589bc4..ad27323d358 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -338,7 +338,7 @@ x_own_selection (selection_name, selection_value)
         for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
           if (EQ (prev_value, Fcar (XCDR (rest))))
             {
-              XCDR (rest) = Fcdr (XCDR (rest));
+              XSETCDR (rest, Fcdr (XCDR (rest)));
               break;
             }
       }
@@ -905,7 +905,7 @@ x_handle_selection_clear (event)
       for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
         if (EQ (local_selection_data, Fcar (XCDR (rest))))
           {
-            XCDR (rest) = Fcdr (XCDR (rest));
+            XSETCDR (rest, Fcdr (XCDR (rest)));
             break;
           }
     }
@@ -982,7 +982,7 @@ x_clear_frame_selections (f)
             redisplay_preserve_echo_area (22);
 #endif
           }
-        XCDR (rest) = Fcdr (XCDR (rest));
+        XSETCDR (rest, Fcdr (XCDR (rest)));
         break;
       }
 }
@@ -1076,13 +1076,13 @@ wait_for_property_change (location)
   Lisp_Object tem;
 
   tem = Fcons (Qnil, Qnil);
-  XSETFASTINT (XCAR (tem), (EMACS_UINT)location >> 16);
-  XSETFASTINT (XCDR (tem), (EMACS_UINT)location & 0xffff);
+  XSETCARFASTINT (tem, (EMACS_UINT)location >> 16);
+  XSETCDRFASTINT (tem, (EMACS_UINT)location & 0xffff);
 
   /* Make sure to do unexpect_property_change if we quit or err.  */
   record_unwind_protect (wait_for_property_change_unwind, tem);
 
-  XCAR (property_change_reply) = Qnil;
+  XSETCAR (property_change_reply, Qnil);
 
   property_change_reply_object = location;
   /* If the event we are waiting for arrives beyond here, it will set
@@ -1128,7 +1128,7 @@ x_handle_property_notify (event)
           /* If this is the one wait_for_property_change is waiting for,
              tell it to wake up.  */
           if (rest == property_change_reply_object)
-            XCAR (property_change_reply) = Qt;
+            XSETCAR (property_change_reply, Qt);
 
           if (prev)
             prev->next = rest->next;
@@ -1239,7 +1239,7 @@ x_get_foreign_selection (selection_symbol, target_type)
   /* Prepare to block until the reply has been read.  */
   reading_selection_window = requestor_window;
   reading_which_selection = selection_atom;
-  XCAR (reading_selection_reply) = Qnil;
+  XSETCAR (reading_selection_reply, Qnil);
 
   frame = some_frame_on_display (dpyinfo);
 
@@ -1942,8 +1942,8 @@ x_handle_selection_notify (event)
     return;
 
   TRACE0 ("Received SelectionNotify");
-  XCAR (reading_selection_reply)
-    = (event->property != 0 ? Qt : Qlambda);
+  XSETCAR (reading_selection_reply,
+           (event->property != 0 ? Qt : Qlambda));
 }
 
 
diff --git a/src/xterm.c b/src/xterm.c
index 1fe78ad6407..492966253de 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -13714,8 +13714,8 @@ x_list_fonts (f, pattern, size, maxnames)
         }
 
       /* Now store the result in the cache.  */
-      XCDR (dpyinfo->name_list_element)
-        = Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element));
+      XSETCDR (dpyinfo->name_list_element,
+               Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element)));
 
     label_cached:
       if (NILP (list)) continue; /* Try the remaining alternatives.  */
@@ -13758,10 +13758,10 @@ x_list_fonts (f, pattern, size, maxnames)
 
               if (thisinfo)
                 {
-                  XCDR (tem)
-                    = (thisinfo->min_bounds.width == 0
-                       ? make_number (0)
-                       : make_number (thisinfo->max_bounds.width));
+                  XSETCDR (tem,
+                           (thisinfo->min_bounds.width == 0
+                            ? make_number (0)
+                            : make_number (thisinfo->max_bounds.width)));
                   BLOCK_INPUT;
                   XFreeFont (dpy, thisinfo);
                   UNBLOCK_INPUT;
@@ -13770,7 +13770,7 @@ x_list_fonts (f, pattern, size, maxnames)
                 /* For unknown reason, the previous call of XListFont had
                   returned a font which can't be opened.  Record the size
                   as 0 not to try to open it again.  */
-                XCDR (tem) = make_number (0);
+                XSETCDR (tem, make_number (0));
             }
 
           found_size = XINT (XCDR (tem));
@@ -14036,22 +14036,22 @@ x_load_font (f, fontname, size)
         Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
                                  Qnil);
 
-        XCDR (dpyinfo->name_list_element)
-          = Fcons (Fcons (key,
-                          Fcons (Fcons (lispy_full_name,
-                                        make_number (fontp->size)),
-                                 Qnil)),
-                   XCDR (dpyinfo->name_list_element));
+        XSETCDR (dpyinfo->name_list_element,
+                 Fcons (Fcons (key,
+                               Fcons (Fcons (lispy_full_name,
+                                             make_number (fontp->size)),
+                                      Qnil)),
+                        XCDR (dpyinfo->name_list_element)));
         if (full_name)
           {
             key = Fcons (Fcons (lispy_full_name, make_number (256)),
                          Qnil);
-            XCDR (dpyinfo->name_list_element)
-              = Fcons (Fcons (key,
-                              Fcons (Fcons (lispy_full_name,
-                                            make_number (fontp->size)),
-                                     Qnil)),
-                       XCDR (dpyinfo->name_list_element));
+            XSETCDR (dpyinfo->name_list_element,
+                     Fcons (Fcons (key,
+                                   Fcons (Fcons (lispy_full_name,
+                                                 make_number (fontp->size)),
+                                          Qnil)),
+                            XCDR (dpyinfo->name_list_element)));
           }
       }
 
@@ -14622,7 +14622,7 @@ x_delete_display (dpyinfo)
         {
           if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
             {
-              XCDR (tail) = XCDR (XCDR (tail));
+              XSETCDR (tail, XCDR (XCDR (tail)));
               break;
             }
           tail = XCDR (tail);