Use XCAR, XCDR, and XFLOAT_DATA instead of explicit member access.

11 files changed, 296 insertions, 296 deletions

diff --git a/src/category.c b/src/category.c
index 734634bd6aa..99f8a5a3bf2 100644
--- a/src/category.c
+++ b/src/category.c
@@ -591,15 +591,15 @@ word_boundary_p (c1, c2)
   if (NILP (category_set2))
     return default_result;
 
-  for (; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (; CONSP (tail); tail = XCDR (tail))
     {
-      Lisp_Object elt = XCONS(tail)->car;
+      Lisp_Object elt = XCAR (tail);
 
       if (CONSP (elt)
-	  && CATEGORYP (XCONS (elt)->car)
-	  && CATEGORYP (XCONS (elt)->cdr)
-	  && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->car), category_set1)
-	  && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->cdr), category_set2))
+	  && CATEGORYP (XCAR (elt))
+	  && CATEGORYP (XCDR (elt))
+	  && CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set1)
+	  && CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set2))
 	return !default_result;
     }
   return default_result;
diff --git a/src/ccl.c b/src/ccl.c
index 46c5f0fa7ed..fb9fbf60e4a 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1328,7 +1328,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 
 		    /* Check map varidity.  */
 		    if (!CONSP (map)) continue;
-		    map = XCONS(map)->cdr;
+		    map = XCDR (map);
 		    if (!VECTORP (map)) continue;
 		    size = XVECTOR (map)->size;
 		    if (size <= 1) continue;
@@ -1372,8 +1372,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 		      }
 		    else if (CONSP (content))
 		      {
-			attrib = XCONS (content)->car;
-			value = XCONS (content)->cdr;
+			attrib = XCAR (content);
+			value = XCDR (content);
 			if (!NUMBERP (attrib) || !NUMBERP (value))
 			  continue;
 			reg[RRR] = i;
@@ -1437,7 +1437,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 
 		    /* Check map varidity.  */
 		    if (!CONSP (map)) continue;
-		    map = XCONS (map)->cdr;
+		    map = XCDR (map);
 		    if (!VECTORP (map)) continue;
 		    size = XVECTOR (map)->size;
 		    if (size <= 1) continue;
@@ -1477,8 +1477,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 		      }
 		    else if (CONSP (content))
 		      {
-			attrib = XCONS (content)->car;
-			value = XCONS (content)->cdr;
+			attrib = XCAR (content);
+			value = XCDR (content);
 			if (!NUMBERP (attrib) || !NUMBERP (value))
 			  continue;
 			reg[RRR] = i;
@@ -1522,7 +1522,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 		    reg[RRR] = -1;
 		    break;
 		  }
-		map = XCONS(map)->cdr;
+		map = XCDR (map);
 		if (!VECTORP (map))
 		  {
 		    reg[RRR] = -1;
@@ -1546,8 +1546,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 		      reg[RRR] = i;
 		    else if (CONSP (content))
 		      {
-			attrib = XCONS (content)->car;
-			value = XCONS (content)->cdr;
+			attrib = XCAR (content);
+			value = XCDR (content);
 			if (!NUMBERP (attrib) || !NUMBERP (value))
 			  continue;
 			reg[rrr] = XUINT(value);
@@ -1663,8 +1663,8 @@ resolve_symbol_ccl_program (ccl)
       if (INTEGERP (contents))
 	continue;
       else if (CONSP (contents)
-	       && SYMBOLP (XCONS (contents)->car)
-	       && SYMBOLP (XCONS (contents)->cdr))
+	       && SYMBOLP (XCAR (contents))
+	       && SYMBOLP (XCDR (contents)))
 	{
 	  /* This is the new style for embedding symbols.  The form is
 	     (SYMBOL . PROPERTY).  (get SYMBOL PROPERTY) should give
@@ -1673,7 +1673,7 @@ resolve_symbol_ccl_program (ccl)
 	  if (EQ (result, ccl))
 	    result =  Fcopy_sequence (ccl);
 
-	  val = Fget (XCONS (contents)->car, XCONS (contents)->cdr);
+	  val = Fget (XCAR (contents), XCDR (contents));
 	  if (NATNUMP (val))
 	    XVECTOR (result)->contents[i] = val;
 	  else
@@ -2038,10 +2038,10 @@ Return index number of the registered map.")
       if (!CONSP (slot))
 	break;
 
-      if (EQ (symbol, XCONS (slot)->car))
+      if (EQ (symbol, XCAR (slot)))
 	{
 	  index = make_number (i);
-	  XCONS (slot)->cdr = map;
+	  XCDR (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 ee15e64603c..534a5f75d23 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -2974,9 +2974,9 @@ setup_coding_system (coding_system, coding)
       bzero (coding->safe_charsets, MAX_CHARSET + 1);
       while (CONSP (val))
 	{
-	  if ((i = get_charset_id (XCONS (val)->car)) >= 0)
+	  if ((i = get_charset_id (XCAR (val))) >= 0)
 	    coding->safe_charsets[i] = 1;
-	  val = XCONS (val)->cdr;
+	  val = XCDR (val);
 	}
     }
 
@@ -3042,12 +3042,12 @@ setup_coding_system (coding_system, coding)
 	val = Vcharset_revision_alist;
 	while (CONSP (val))
 	  {
-	    charset = get_charset_id (Fcar_safe (XCONS (val)->car));
+	    charset = get_charset_id (Fcar_safe (XCAR (val)));
 	    if (charset >= 0
-		&& (temp = Fcdr_safe (XCONS (val)->car), INTEGERP (temp))
+		&& (temp = Fcdr_safe (XCAR (val)), INTEGERP (temp))
 		&& (i = XINT (temp), (i >= 0 && (i + '@') < 128)))
 	      CODING_SPEC_ISO_REVISION_NUMBER (coding, charset) = i;
-	    val = XCONS (val)->cdr;
+	    val = XCDR (val);
 	  }
 
 	/* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
@@ -3084,28 +3084,28 @@ setup_coding_system (coding_system, coding)
 		tail = flags[i];
 
 		coding->flags |= CODING_FLAG_ISO_DESIGNATION;
-		if (INTEGERP (XCONS (tail)->car)
-		    && (charset = XINT (XCONS (tail)->car),
+		if (INTEGERP (XCAR (tail))
+		    && (charset = XINT (XCAR (tail)),
 			CHARSET_VALID_P (charset))
-		    || (charset = get_charset_id (XCONS (tail)->car)) >= 0)
+		    || (charset = get_charset_id (XCAR (tail))) >= 0)
 		  {
 		    CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
 		    CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) =i;
 		  }
 		else
 		  CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
-		tail = XCONS (tail)->cdr;
+		tail = XCDR (tail);
 		while (CONSP (tail))
 		  {
-		    if (INTEGERP (XCONS (tail)->car)
-			&& (charset = XINT (XCONS (tail)->car),
+		    if (INTEGERP (XCAR (tail))
+			&& (charset = XINT (XCAR (tail)),
 			    CHARSET_VALID_P (charset))
-			|| (charset = get_charset_id (XCONS (tail)->car)) >= 0)
+			|| (charset = get_charset_id (XCAR (tail))) >= 0)
 		      CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
 			= i;
-		    else if (EQ (XCONS (tail)->car, Qt))
+		    else if (EQ (XCAR (tail), Qt))
 		      reg_bits |= 1 << i;
-		    tail = XCONS (tail)->cdr;
+		    tail = XCDR (tail);
 		  }
 	      }
 	    else
@@ -3168,9 +3168,9 @@ setup_coding_system (coding_system, coding)
 	val = XVECTOR (coding_spec)->contents[4];
 	if (! CONSP (val)
 	    || setup_ccl_program (&(coding->spec.ccl.decoder),
-				  XCONS (val)->car) < 0
+				  XCAR (val)) < 0
 	    || setup_ccl_program (&(coding->spec.ccl.encoder),
-				  XCONS (val)->cdr) < 0)
+				  XCDR (val)) < 0)
 	  goto label_invalid_coding_system;
 
 	bzero (coding->spec.ccl.valid_codes, 256);
@@ -3179,18 +3179,18 @@ setup_coding_system (coding_system, coding)
 	  {
 	    Lisp_Object this;
 
-	    for (; CONSP (val); val = XCONS (val)->cdr)
+	    for (; CONSP (val); val = XCDR (val))
 	      {
-		this = XCONS (val)->car;
+		this = XCAR (val);
 		if (INTEGERP (this)
 		    && XINT (this) >= 0 && XINT (this) < 256)
 		  coding->spec.ccl.valid_codes[XINT (this)] = 1;
 		else if (CONSP (this)
-			 && INTEGERP (XCONS (this)->car)
-			 && INTEGERP (XCONS (this)->cdr))
+			 && INTEGERP (XCAR (this))
+			 && INTEGERP (XCDR (this)))
 		  {
-		    int start = XINT (XCONS (this)->car);
-		    int end = XINT (XCONS (this)->cdr);
+		    int start = XINT (XCAR (this));
+		    int end = XINT (XCDR (this));
 
 		    if (start >= 0 && start <= end && end < 256)
 		      while (start <= end)
@@ -4876,13 +4876,13 @@ detect_coding_system (src, src_bytes, highest)
 
   /* At first, gather possible coding systems in VAL.  */
   val = Qnil;
-  for (tmp = Vcoding_category_list; !NILP (tmp); tmp = XCONS (tmp)->cdr)
+  for (tmp = Vcoding_category_list; !NILP (tmp); tmp = XCDR (tmp))
     {
       int idx
-	= XFASTINT (Fget (XCONS (tmp)->car, Qcoding_category_index));
+	= XFASTINT (Fget (XCAR (tmp), Qcoding_category_index));
       if (coding_mask & (1 << idx))
 	{
-	  val = Fcons (Fsymbol_value (XCONS (tmp)->car), val);
+	  val = Fcons (Fsymbol_value (XCAR (tmp)), val);
 	  if (highest)
 	    break;
 	}
@@ -4891,18 +4891,18 @@ detect_coding_system (src, src_bytes, highest)
     val = Fnreverse (val);
 
   /* Then, replace the elements with subsidiary coding systems.  */
-  for (tmp = val; !NILP (tmp); tmp = XCONS (tmp)->cdr)
+  for (tmp = val; !NILP (tmp); tmp = XCDR (tmp))
     {
       if (eol_type != CODING_EOL_UNDECIDED
 	  && eol_type != CODING_EOL_INCONSISTENT)
 	{
 	  Lisp_Object eol;
-	  eol = Fget (XCONS (tmp)->car, Qeol_type);
+	  eol = Fget (XCAR (tmp), Qeol_type);
 	  if (VECTORP (eol))
-	    XCONS (tmp)->car = XVECTOR (eol)->contents[eol_type];
+	    XCAR (tmp) = XVECTOR (eol)->contents[eol_type];
 	}
     }
-  return (highest ? XCONS (val)->car : val);
+  return (highest ? XCAR (val) : val);
 }  
 
 DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
@@ -5324,18 +5324,18 @@ which is a list of all the arguments given to this function.")
   if (NILP (chain))
     return Qnil;
 
-  for (; CONSP (chain); chain = XCONS (chain)->cdr)
+  for (; CONSP (chain); chain = XCDR (chain))
     {
       Lisp_Object elt;
-      elt = XCONS (chain)->car;
+      elt = XCAR (chain);
 
       if (CONSP (elt)
 	  && ((STRINGP (target)
-	       && STRINGP (XCONS (elt)->car)
-	       && fast_string_match (XCONS (elt)->car, target) >= 0)
-	      || (INTEGERP (target) && EQ (target, XCONS (elt)->car))))
+	       && STRINGP (XCAR (elt))
+	       && fast_string_match (XCAR (elt), target) >= 0)
+	      || (INTEGERP (target) && EQ (target, XCAR (elt)))))
 	{
-	  val = XCONS (elt)->cdr;
+	  val = XCDR (elt);
 	  /* Here, if VAL is both a valid coding system and a valid
              function symbol, we return VAL as a coding system.  */
 	  if (CONSP (val))
@@ -5406,13 +5406,13 @@ This function is internal use only.")
 
   while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
     {
-      if (! SYMBOLP (XCONS (val)->car))
+      if (! SYMBOLP (XCAR (val)))
 	break;
-      idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
+      idx = XFASTINT (Fget (XCAR (val), Qcoding_category_index));
       if (idx >= CODING_CATEGORY_IDX_MAX)
 	break;
       coding_priorities[i++] = (1 << idx);
-      val = XCONS (val)->cdr;
+      val = XCDR (val);
     }
   /* If coding-category-list is valid and contains all coding
      categories, `i' should be CODING_CATEGORY_IDX_MAX now.  If not,
diff --git a/src/doc.c b/src/doc.c
index af7c55e0b20..78b005b852b 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -126,8 +126,8 @@ get_doc_string (filepos, unibyte, definition)
     }
   else if (CONSP (filepos))
     {
-      file = XCONS (filepos)->car;
-      position = XINT (XCONS (filepos)->cdr);
+      file = XCAR (filepos);
+      position = XINT (XCDR (filepos));
       if (position < 0)
 	position = - position;
     }
@@ -353,7 +353,7 @@ string is passed through `substitute-command-keys'.")
 	  /* Handle a doc reference--but these never come last
 	     in the function body, so reject them if they are last.  */
 	  else if ((NATNUMP (tem) || CONSP (tem))
-		   && ! NILP (XCONS (tem1)->cdr))
+		   && ! NILP (XCDR (tem1)))
 	    doc = get_doc_string (tem, 0, 0);
 	  else
 	    return Qnil;
@@ -424,15 +424,15 @@ store_function_docstring (fun, offset)
     {
       Lisp_Object tem;
 
-      tem = XCONS (fun)->car;
+      tem = XCAR (fun);
       if (EQ (tem, Qlambda) || EQ (tem, Qautoload))
 	{
 	  tem = Fcdr (Fcdr (fun));
-	  if (CONSP (tem) && INTEGERP (XCONS (tem)->car))
-	    XSETFASTINT (XCONS (tem)->car, offset);
+	  if (CONSP (tem) && INTEGERP (XCAR (tem)))
+	    XSETFASTINT (XCAR (tem), offset);
 	}
       else if (EQ (tem, Qmacro))
-	store_function_docstring (XCONS (fun)->cdr, offset);
+	store_function_docstring (XCDR (fun), offset);
     }
 
   /* Bytecode objects sometimes have slots for it.  */
diff --git a/src/editfns.c b/src/editfns.c
index 7b5eefc1d0e..c08017ded80 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -2288,13 +2288,13 @@ save_restriction_restore (data)
   register Lisp_Object tem;
   int obegv, ozv;
 
-  buf = XBUFFER (XCONS (data)->car);
+  buf = XBUFFER (XCAR (data));
 
-  data = XCONS (data)->cdr;
+  data = XCDR (data);
 
-  tem = XCONS (data)->car;
+  tem = XCAR (data);
   newhead = XINT (tem);
-  tem = XCONS (data)->cdr;
+  tem = XCDR (data);
   newtail = XINT (tem);
   if (newhead + newtail > BUF_Z (buf) - BUF_BEG (buf))
     {
@@ -2761,7 +2761,7 @@ Use %% to put a single % into the output.")
 	      if (INTEGERP (args[n]))
 		sprintf (p, this_format, XINT (args[n]));
 	      else
-		sprintf (p, this_format, XFLOAT (args[n])->data);
+		sprintf (p, this_format, XFLOAT_DATA (args[n]));
 
 	      if (p > buf
 		  && multibyte
diff --git a/src/eval.c b/src/eval.c
index b7e29f068c9..7052bec2586 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -322,11 +322,11 @@ CONDITION's value if non-nil is returned from the cond-form.")
       val = Feval (Fcar (clause));
       if (!NILP (val))
 	{
-	  if (!EQ (XCONS (clause)->cdr, Qnil))
-	    val = Fprogn (XCONS (clause)->cdr);
+	  if (!EQ (XCDR (clause), Qnil))
+	    val = Fprogn (XCDR (clause));
 	  break;
 	}
-      args = XCONS (args)->cdr;
+      args = XCDR (args);
     }
   UNGCPRO;
 
@@ -670,9 +670,9 @@ for the variable is `*'.")
     return Qt;
   /* If it is (STRING . INTEGER), a negative integer means a user variable.  */
   if (CONSP (documentation)
-      && STRINGP (XCONS (documentation)->car)
-      && INTEGERP (XCONS (documentation)->cdr)
-      && XINT (XCONS (documentation)->cdr) < 0)
+      && STRINGP (XCAR (documentation))
+      && INTEGERP (XCDR (documentation))
+      && XINT (XCDR (documentation)) < 0)
     return Qt;
   return Qnil;
 }  
@@ -818,7 +818,7 @@ definitions to shadow the loaded ones for use in file byte-compilation.")
       if (!CONSP (form))
 	break;
       /* Set SYM, give DEF and TEM right values in case SYM is not a symbol. */
-      def = sym = XCONS (form)->car;
+      def = sym = XCAR (form);
       tem = Qnil;
       /* Trace symbols aliases to other symbols
 	 until we get a symbol that is not an alias.  */
@@ -844,7 +844,7 @@ definitions to shadow the loaded ones for use in file byte-compilation.")
 	  if (EQ (def, Qunbound) || !CONSP (def))
 	    /* Not defined or definition not suitable */
 	    break;
-	  if (EQ (XCONS (def)->car, Qautoload))
+	  if (EQ (XCAR (def), Qautoload))
 	    {
 	      /* Autoloading function: will it be a macro when loaded?  */
 	      tem = Fnth (make_number (4), def);
@@ -860,17 +860,17 @@ definitions to shadow the loaded ones for use in file byte-compilation.")
 	      else
 		break;
 	    }
-	  else if (!EQ (XCONS (def)->car, Qmacro))
+	  else if (!EQ (XCAR (def), Qmacro))
 	    break;
-	  else expander = XCONS (def)->cdr;
+	  else expander = XCDR (def);
 	}
       else
 	{
-	  expander = XCONS (tem)->cdr;
+	  expander = XCDR (tem);
 	  if (NILP (expander))
 	    break;
 	}
-      form = apply1 (expander, XCONS (form)->cdr);
+      form = apply1 (expander, XCDR (form));
     }
   return form;
 }
@@ -1062,8 +1062,8 @@ See also the function `signal' for more info.")
       tem = Fcar (val);
       if (! (NILP (tem)
 	     || (CONSP (tem)
-		 && (SYMBOLP (XCONS (tem)->car)
-		     || CONSP (XCONS (tem)->car)))))
+		 && (SYMBOLP (XCAR (tem))
+		     || CONSP (XCAR (tem))))))
 	error ("Invalid condition handler", tem);
     }
 
@@ -1311,11 +1311,11 @@ wants_debugger (list, conditions)
   while (CONSP (conditions))
     {
       Lisp_Object this, tail;
-      this = XCONS (conditions)->car;
-      for (tail = list; CONSP (tail); tail = XCONS (tail)->cdr)
-	if (EQ (XCONS (tail)->car, this))
+      this = XCAR (conditions);
+      for (tail = list; CONSP (tail); tail = XCDR (tail))
+	if (EQ (XCAR (tail), this))
 	  return 1;
-      conditions = XCONS (conditions)->cdr;
+      conditions = XCDR (conditions);
     }
   return 0;
 }
@@ -1333,16 +1333,16 @@ skip_debugger (conditions, data)
   Lisp_Object error_message;
 
   for (tail = Vdebug_ignored_errors; CONSP (tail);
-       tail = XCONS (tail)->cdr)
+       tail = XCDR (tail))
     {
-      if (STRINGP (XCONS (tail)->car))
+      if (STRINGP (XCAR (tail)))
 	{
 	  if (first_string)
 	    {
 	      error_message = Ferror_message_string (data);
 	      first_string = 0;
 	    }
-	  if (fast_string_match (XCONS (tail)->car, error_message) >= 0)
+	  if (fast_string_match (XCAR (tail), error_message) >= 0)
 	    return 1;
 	}
       else
@@ -1350,8 +1350,8 @@ skip_debugger (conditions, data)
 	  Lisp_Object contail;
 
 	  for (contail = conditions; CONSP (contail);
-	       contail = XCONS (contail)->cdr)
-	    if (EQ (XCONS (tail)->car, XCONS (contail)->car))
+	       contail = XCDR (contail))
+	    if (EQ (XCAR (tail), XCAR (contail)))
 	      return 1;
 	}
     }
@@ -1458,7 +1458,7 @@ find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
 	      tem = Fmemq (Fcar (condit), conditions);
 	      if (!NILP (tem))
 		return handler;
-	      condit = XCONS (condit)->cdr;
+	      condit = XCDR (condit);
 	    }
 	}
     }
@@ -1599,7 +1599,7 @@ this does nothing and returns nil.")
   /* If function is defined and not as an autoload, don't override */
   if (!EQ (XSYMBOL (function)->function, Qunbound)
       && !(CONSP (XSYMBOL (function)->function)
-	   && EQ (XCONS (XSYMBOL (function)->function)->car, Qautoload)))
+	   && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
     return Qnil;
 
 #ifdef NO_ARG_ARRAY
@@ -1929,7 +1929,7 @@ Thus, (apply '+ 1 2 '(3 4)) returns 10.")
     return Ffuncall (nargs - 1, args);
   else if (numargs == 1)
     {
-      args [nargs - 1] = XCONS (spread_arg)->car;
+      args [nargs - 1] = XCAR (spread_arg);
       return Ffuncall (nargs, args);
     }
 
@@ -1977,8 +1977,8 @@ Thus, (apply '+ 1 2 '(3 4)) returns 10.")
   i = nargs - 1;
   while (!NILP (spread_arg))
     {
-      funcall_args [i++] = XCONS (spread_arg)->car;
-      spread_arg = XCONS (spread_arg)->cdr;
+      funcall_args [i++] = XCAR (spread_arg);
+      spread_arg = XCDR (spread_arg);
     }
 
   RETURN_UNGCPRO (Ffuncall (gcpro1.nvars, funcall_args));
@@ -2101,7 +2101,7 @@ run_hook_with_args (nargs, args, cond)
 
   if (EQ (val, Qunbound) || NILP (val))
     return ret;
-  else if (!CONSP (val) || EQ (XCONS (val)->car, Qlambda))
+  else if (!CONSP (val) || EQ (XCAR (val), Qlambda))
     {
       args[0] = val;
       return Ffuncall (nargs, args);
@@ -2115,9 +2115,9 @@ run_hook_with_args (nargs, args, cond)
 	   CONSP (val) && ((cond == to_completion)
 			   || (cond == until_success ? NILP (ret)
 			       : !NILP (ret)));
-	   val = XCONS (val)->cdr)
+	   val = XCDR (val))
 	{
-	  if (EQ (XCONS (val)->car, Qt))
+	  if (EQ (XCAR (val), Qt))
 	    {
 	      /* t indicates this hook has a local binding;
 		 it means to run the global binding too.  */
@@ -2126,9 +2126,9 @@ run_hook_with_args (nargs, args, cond)
 		   CONSP (globals) && ((cond == to_completion)
 				       || (cond == until_success ? NILP (ret)
 					   : !NILP (ret)));
-		   globals = XCONS (globals)->cdr)
+		   globals = XCDR (globals))
 		{
-		  args[0] = XCONS (globals)->car;
+		  args[0] = XCAR (globals);
 		  /* In a global value, t should not occur.  If it does, we
 		     must ignore it to avoid an endless loop.  */
 		  if (!EQ (args[0], Qt))
@@ -2137,7 +2137,7 @@ run_hook_with_args (nargs, args, cond)
 	    }
 	  else
 	    {
-	      args[0] = XCONS (val)->car;
+	      args[0] = XCAR (val);
 	      ret = Ffuncall (nargs, args);
 	    }
 	}
@@ -2169,18 +2169,18 @@ run_hook_list_with_args (funlist, nargs, args)
   globals = Qnil;
   GCPRO3 (sym, val, globals);
 
-  for (val = funlist; CONSP (val); val = XCONS (val)->cdr)
+  for (val = funlist; CONSP (val); val = XCDR (val))
     {
-      if (EQ (XCONS (val)->car, Qt))
+      if (EQ (XCAR (val), Qt))
 	{
 	  /* t indicates this hook has a local binding;
 	     it means to run the global binding too.  */
 
 	  for (globals = Fdefault_value (sym);
 	       CONSP (globals);
-	       globals = XCONS (globals)->cdr)
+	       globals = XCDR (globals))
 	    {
-	      args[0] = XCONS (globals)->car;
+	      args[0] = XCAR (globals);
 	      /* In a global value, t should not occur.  If it does, we
 		 must ignore it to avoid an endless loop.  */
 	      if (!EQ (args[0], Qt))
@@ -2189,7 +2189,7 @@ run_hook_list_with_args (funlist, nargs, args)
 	}
       else
 	{
-	  args[0] = XCONS (val)->car;
+	  args[0] = XCAR (val);
 	  Ffuncall (nargs, args);
 	}
     }
@@ -2675,8 +2675,8 @@ DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
       tem = read_doc_string (XVECTOR (object)->contents[COMPILED_BYTECODE]);
       if (!CONSP (tem))
 	error ("invalid byte code");
-      XVECTOR (object)->contents[COMPILED_BYTECODE] = XCONS (tem)->car;
-      XVECTOR (object)->contents[COMPILED_CONSTANTS] = XCONS (tem)->cdr;
+      XVECTOR (object)->contents[COMPILED_BYTECODE] = XCAR (tem);
+      XVECTOR (object)->contents[COMPILED_CONSTANTS] = XCDR (tem);
     }
   return object;
 }
diff --git a/src/fileio.c b/src/fileio.c
index efe7f432e2a..8d5e32eb426 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -344,19 +344,19 @@ use the standard functions without calling themselves recursively.")
     inhibited_handlers = Qnil;
 
   for (chain = Vfile_name_handler_alist; CONSP (chain);
-       chain = XCONS (chain)->cdr)
+       chain = XCDR (chain))
     {
       Lisp_Object elt;
-      elt = XCONS (chain)->car;
+      elt = XCAR (chain);
       if (CONSP (elt))
 	{
 	  Lisp_Object string;
-	  string = XCONS (elt)->car;
+	  string = XCAR (elt);
 	  if (STRINGP (string) && fast_string_match (string, filename) >= 0)
 	    {
 	      Lisp_Object handler, tem;
 
-	      handler = XCONS (elt)->cdr;
+	      handler = XCDR (elt);
 	      tem = Fmemq (handler, inhibited_handlers);
 	      if (NILP (tem))
 		return handler;
@@ -3375,8 +3375,8 @@ actually used.")
     {
       val = call6 (handler, Qinsert_file_contents, filename,
 		   visit, beg, end, replace);
-      if (CONSP (val) && CONSP (XCONS (val)->cdr))
-	inserted = XINT (XCONS (XCONS (val)->cdr)->car);
+      if (CONSP (val) && CONSP (XCDR (val)))
+	inserted = XINT (XCAR (XCDR (val)));
       goto handled;
     }
 
@@ -3550,7 +3550,7 @@ actually used.")
 	      args[2] = visit, args[3] = beg, args[4] = end, args[5] = replace;
 	      coding_systems = Ffind_operation_coding_system (6, args);
 	      if (CONSP (coding_systems))
-		val = XCONS (coding_systems)->car;
+		val = XCAR (coding_systems);
 	    }
 	}
 
@@ -4083,7 +4083,7 @@ actually used.")
 	      args[2] = visit, args[3] = beg, args[4] = end, args[5] = Qnil;
 	      coding_systems = Ffind_operation_coding_system (6, args);
 	      if (CONSP (coding_systems))
-		val = XCONS (coding_systems)->car;
+		val = XCAR (coding_systems);
 	    }
 	}
 
@@ -4357,8 +4357,8 @@ This does code conversion according to the value of\n\
 	    args[3] = filename; args[4] = append; args[5] = visit;
 	    args[6] = lockname;
 	    coding_systems = Ffind_operation_coding_system (7, args);
-	    if (CONSP (coding_systems) && !NILP (XCONS (coding_systems)->cdr))
-	      val = XCONS (coding_systems)->cdr;
+	    if (CONSP (coding_systems) && !NILP (XCDR (coding_systems)))
+	      val = XCDR (coding_systems);
 	  }
 
 	if (NILP (val)
@@ -5079,8 +5079,8 @@ do_auto_save_unwind (stream)  /* used as unwind-protect function */
 {
   auto_saving = 0;
   if (!NILP (stream))
-    fclose ((FILE *) (XFASTINT (XCONS (stream)->car) << 16
-		      | XFASTINT (XCONS (stream)->cdr)));
+    fclose ((FILE *) (XFASTINT (XCAR (stream)) << 16
+		      | XFASTINT (XCDR (stream))));
   return Qnil;
 }
 
@@ -5141,8 +5141,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 (XCONS (lispstream)->car, (EMACS_UINT)stream >> 16);
-	  XSETFASTINT (XCONS (lispstream)->cdr, (EMACS_UINT)stream & 0xffff);
+	  XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
+	  XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
 	}
       else
 	lispstream = Qnil;
@@ -5165,9 +5165,9 @@ A non-nil CURRENT-ONLY argument means save only current buffer.")
      autosave perfectly ordinary files because it couldn't handle some
      ange-ftp'd file.  */
   for (do_handled_files = 0; do_handled_files < 2; do_handled_files++)
-    for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
+    for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCDR (tail))
       {
-	buf = XCONS (XCONS (tail)->car)->cdr;
+	buf = XCDR (XCAR (tail));
 	b = XBUFFER (buf);
 
 	/* Record all the buffers that have auto save mode
@@ -5524,7 +5524,7 @@ DIR defaults to current buffer's directory default.")
 			    Qfile_name_history, default_filename, Qnil);
 
   tem = Fsymbol_value (Qfile_name_history);
-  if (CONSP (tem) && EQ (XCONS (tem)->car, val))
+  if (CONSP (tem) && EQ (XCAR (tem), val))
     replace_in_history = 1;
 
   /* If Fcompleting_read returned the inserted default string itself
@@ -5563,14 +5563,14 @@ DIR defaults to current buffer's directory default.")
   if (replace_in_history)
     /* Replace what Fcompleting_read added to the history
        with what we will actually return.  */
-    XCONS (Fsymbol_value (Qfile_name_history))->car = double_dollars (val);
+    XCAR (Fsymbol_value (Qfile_name_history)) = double_dollars (val);
   else if (add_to_history)
     {
       /* Add the value to the history--but not if it matches
 	 the last value already there.  */
       Lisp_Object val1 = double_dollars (val);
       tem = Fsymbol_value (Qfile_name_history);
-      if (! CONSP (tem) || NILP (Fequal (XCONS (tem)->car, val1)))
+      if (! CONSP (tem) || NILP (Fequal (XCAR (tem), val1)))
 	Fset (Qfile_name_history,
 	      Fcons (val1, tem));
     }
diff --git a/src/filelock.c b/src/filelock.c
index f1f9955f8f5..241835221d1 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -623,9 +623,9 @@ unlock_all_files ()
   register Lisp_Object tail;
   register struct buffer *b;
 
-  for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCDR (tail))
     {
-      b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
+      b = XBUFFER (XCDR (XCAR (tail)));
       if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 	{
 	  register char *lfname;
diff --git a/src/insdel.c b/src/insdel.c
index c0157772f13..83424a019bc 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -2660,26 +2660,26 @@ DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
   /* Scan the various individual changes,
      accumulating the range info in BEG, END and CHANGE.  */
   for (tail = combine_after_change_list; CONSP (tail);
-       tail = XCONS (tail)->cdr)
+       tail = XCDR (tail))
     {
       Lisp_Object elt;
       int thisbeg, thisend, thischange;
 
       /* Extract the info from the next element.  */
-      elt = XCONS (tail)->car;
+      elt = XCAR (tail);
       if (! CONSP (elt))
 	continue;
-      thisbeg = XINT (XCONS (elt)->car);
+      thisbeg = XINT (XCAR (elt));
 
-      elt = XCONS (elt)->cdr;
+      elt = XCDR (elt);
       if (! CONSP (elt))
 	continue;
-      thisend = XINT (XCONS (elt)->car);
+      thisend = XINT (XCAR (elt));
 
-      elt = XCONS (elt)->cdr;
+      elt = XCDR (elt);
       if (! CONSP (elt))
 	continue;
-      thischange = XINT (XCONS (elt)->car);
+      thischange = XINT (XCAR (elt));
 
       /* Merge this range into the accumulated range.  */
       change += thischange;
diff --git a/src/intervals.c b/src/intervals.c
index 159cc3693ac..73e2e675568 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -867,7 +867,7 @@ adjust_intervals_for_insertion (tree, position, length)
       for (tail = i->plist; ! NILP (tail); tail = Fcdr (Fcdr (tail)))
 	{
 	  Lisp_Object prop;
-	  prop = XCONS (tail)->car;
+	  prop = XCAR (tail);
 
 	  /* Is this particular property rear-sticky?
 	     Note, if REAR isn't a cons, it must be non-nil,
diff --git a/src/keymap.c b/src/keymap.c
index c209a690226..aa1ec28c284 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -231,7 +231,7 @@ get_keymap_1 (object, error, autoload)
   else
     {
       tem = indirect_function (object);
-      if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
+      if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
 	return tem;
     }
 
@@ -240,7 +240,7 @@ get_keymap_1 (object, error, autoload)
   if (autoload
       && SYMBOLP (object)
       && CONSP (tem)
-      && EQ (XCONS (tem)->car, Qautoload))
+      && EQ (XCAR (tem), Qautoload))
     {
       Lisp_Object tail;
 
@@ -287,11 +287,11 @@ DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
   keymap = get_keymap_1 (keymap, 1, 1);
 
   /* Skip past the initial element `keymap'.  */
-  list = XCONS (keymap)->cdr;
-  for (; CONSP (list); list = XCONS (list)->cdr)
+  list = XCDR (keymap);
+  for (; CONSP (list); list = XCDR (list))
     {
       /* See if there is another `keymap'.  */
-      if (EQ (Qkeymap, XCONS (list)->car))
+      if (EQ (Qkeymap, XCAR (list)))
 	return list;
     }
 
@@ -317,17 +317,17 @@ PARENT should be nil or another keymap.")
   prev = keymap;
   while (1)
     {
-      list = XCONS (prev)->cdr;
+      list = XCDR (prev);
       /* If there is a parent keymap here, replace it.
 	 If we came to the end, add the parent in PREV.  */
-      if (! CONSP (list) || EQ (Qkeymap, XCONS (list)->car))
+      if (! CONSP (list) || EQ (Qkeymap, XCAR (list)))
 	{
 	  /* If we already have the right parent, return now
 	     so that we avoid the loops below.  */
-	  if (EQ (XCONS (prev)->cdr, parent))
+	  if (EQ (XCDR (prev), parent))
 	    return parent;
 
-	  XCONS (prev)->cdr = parent;
+	  XCDR (prev) = parent;
 	  break;
 	}
       prev = list;
@@ -335,29 +335,29 @@ PARENT should be nil or another keymap.")
 
   /* Scan through for submaps, and set their parents too.  */
 
-  for (list = XCONS (keymap)->cdr; CONSP (list); list = XCONS (list)->cdr)
+  for (list = XCDR (keymap); CONSP (list); list = XCDR (list))
     {
       /* Stop the scan when we come to the parent.  */
-      if (EQ (XCONS (list)->car, Qkeymap))
+      if (EQ (XCAR (list), Qkeymap))
 	break;
 
       /* If this element holds a prefix map, deal with it.  */
-      if (CONSP (XCONS (list)->car)
-	  && CONSP (XCONS (XCONS (list)->car)->cdr))
-	fix_submap_inheritance (keymap, XCONS (XCONS (list)->car)->car,
-				XCONS (XCONS (list)->car)->cdr);
-
-      if (VECTORP (XCONS (list)->car))
-	for (i = 0; i < XVECTOR (XCONS (list)->car)->size; i++)
-	  if (CONSP (XVECTOR (XCONS (list)->car)->contents[i]))
+      if (CONSP (XCAR (list))
+	  && CONSP (XCDR (XCAR (list))))
+	fix_submap_inheritance (keymap, XCAR (XCAR (list)),
+				XCDR (XCAR (list)));
+
+      if (VECTORP (XCAR (list)))
+	for (i = 0; i < XVECTOR (XCAR (list))->size; i++)
+	  if (CONSP (XVECTOR (XCAR (list))->contents[i]))
 	    fix_submap_inheritance (keymap, make_number (i),
-				    XVECTOR (XCONS (list)->car)->contents[i]);
+				    XVECTOR (XCAR (list))->contents[i]);
 
-      if (CHAR_TABLE_P (XCONS (list)->car))
+      if (CHAR_TABLE_P (XCAR (list)))
 	{
 	  Lisp_Object indices[3];
 
-	  map_char_table (fix_submap_inheritance, Qnil, XCONS (list)->car,
+	  map_char_table (fix_submap_inheritance, Qnil, XCAR (list),
 			  keymap, 0, indices);
 	}
     }
@@ -381,37 +381,37 @@ fix_submap_inheritance (map, event, submap)
   if (CONSP (submap))
     {
       /* May be an old format menu item */
-      if (STRINGP (XCONS (submap)->car))
+      if (STRINGP (XCAR (submap)))
 	{
-	  submap = XCONS (submap)->cdr;
+	  submap = XCDR (submap);
 	  /* Also remove a menu help string, if any,
 	     following the menu item name.  */
-	  if (CONSP (submap) && STRINGP (XCONS (submap)->car))
-	    submap = XCONS (submap)->cdr;
+	  if (CONSP (submap) && STRINGP (XCAR (submap)))
+	    submap = XCDR (submap);
 	  /* Also remove the sublist that caches key equivalences, if any.  */
 	  if (CONSP (submap)
-	      && CONSP (XCONS (submap)->car))
+	      && CONSP (XCAR (submap)))
 	    {
 	      Lisp_Object carcar;
-	      carcar = XCONS (XCONS (submap)->car)->car;
+	      carcar = XCAR (XCAR (submap));
 	      if (NILP (carcar) || VECTORP (carcar))
-		submap = XCONS (submap)->cdr;
+		submap = XCDR (submap);
 	    }
 	}
 
       /* Or a new format menu item */
-      else if (EQ (XCONS (submap)->car, Qmenu_item)
-	       && CONSP (XCONS (submap)->cdr))
+      else if (EQ (XCAR (submap), Qmenu_item)
+	       && CONSP (XCDR (submap)))
 	{
-	  submap = XCONS (XCONS (submap)->cdr)->cdr;
+	  submap = XCDR (XCDR (submap));
 	  if (CONSP (submap))
-	    submap = XCONS (submap)->car;
+	    submap = XCAR (submap);
 	}
     }
 
   /* If it isn't a keymap now, there's no work to do.  */
   if (! CONSP (submap)
-      || ! EQ (XCONS (submap)->car, Qkeymap))
+      || ! EQ (XCAR (submap), Qkeymap))
     return;
 
   map_parent = Fkeymap_parent (map);
@@ -422,7 +422,7 @@ fix_submap_inheritance (map, event, submap)
 
   /* If MAP's parent has something other than a keymap,
      our own submap shadows it completely, so use nil as SUBMAP's parent.  */
-  if (! (CONSP (parent_entry) && EQ (XCONS (parent_entry)->car, Qkeymap)))
+  if (! (CONSP (parent_entry) && EQ (XCAR (parent_entry), Qkeymap)))
     parent_entry = Qnil;
 
   if (! EQ (parent_entry, submap))
@@ -436,7 +436,7 @@ fix_submap_inheritance (map, event, submap)
 	  if (EQ (tem, parent_entry))
 	    return;
           if (CONSP (tem)
-	      && EQ (XCONS (tem)->car, Qkeymap))
+	      && EQ (XCAR (tem), Qkeymap))
 	    submap_parent = tem;
 	  else
 	    break;
@@ -486,11 +486,11 @@ access_keymap (map, idx, t_ok, noinherit)
     Lisp_Object t_binding;
 
     t_binding = Qnil;
-    for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+    for (tail = map; CONSP (tail); tail = XCDR (tail))
       {
 	Lisp_Object binding;
 
-	binding = XCONS (tail)->car;
+	binding = XCAR (tail);
 	if (SYMBOLP (binding))
 	  {
 	    /* If NOINHERIT, stop finding prefix definitions
@@ -500,24 +500,24 @@ access_keymap (map, idx, t_ok, noinherit)
 	  }
 	else if (CONSP (binding))
 	  {
-	    if (EQ (XCONS (binding)->car, idx))
+	    if (EQ (XCAR (binding), idx))
 	      {
-		val = XCONS (binding)->cdr;
-		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+		val = XCDR (binding);
+		if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 		  return Qnil;
 		if (CONSP (val))
 		  fix_submap_inheritance (map, idx, val);
 		return val;
 	      }
-	    if (t_ok && EQ (XCONS (binding)->car, Qt))
-	      t_binding = XCONS (binding)->cdr;
+	    if (t_ok && EQ (XCAR (binding), Qt))
+	      t_binding = XCDR (binding);
 	  }
 	else if (VECTORP (binding))
 	  {
 	    if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (binding)->size)
 	      {
 		val = XVECTOR (binding)->contents[XFASTINT (idx)];
-		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+		if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 		  return Qnil;
 		if (CONSP (val))
 		  fix_submap_inheritance (map, idx, val);
@@ -535,7 +535,7 @@ access_keymap (map, idx, t_ok, noinherit)
 			 | CHAR_SHIFT | CHAR_CTL | CHAR_META)))
 	      {
 		val = Faref (binding, idx);
-		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+		if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 		  return Qnil;
 		if (CONSP (val))
 		  fix_submap_inheritance (map, idx, val);
@@ -651,10 +651,10 @@ store_in_keymap (keymap, idx, def)
   /* If we are preparing to dump, and DEF is a menu element
      with a menu item indicator, copy it to ensure it is not pure.  */
   if (CONSP (def) && PURE_P (def)
-      && (EQ (XCONS (def)->car, Qmenu_item) || STRINGP (XCONS (def)->car)))
-    def = Fcons (XCONS (def)->car, XCONS (def)->cdr);
+      && (EQ (XCAR (def), Qmenu_item) || STRINGP (XCAR (def))))
+    def = Fcons (XCAR (def), XCDR (def));
 
-  if (!CONSP (keymap) || ! EQ (XCONS (keymap)->car, Qkeymap))
+  if (!CONSP (keymap) || ! EQ (XCAR (keymap), Qkeymap))
     error ("attempt to define a key in a non-keymap");
 
   /* If idx is a list (some sort of mouse click, perhaps?),
@@ -684,11 +684,11 @@ store_in_keymap (keymap, idx, def)
     Lisp_Object insertion_point;
 
     insertion_point = keymap;
-    for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
+    for (tail = XCDR (keymap); CONSP (tail); tail = XCDR (tail))
       {
 	Lisp_Object elt;
 
-	elt = XCONS (tail)->car;
+	elt = XCAR (tail);
 	if (VECTORP (elt))
 	  {
 	    if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)
@@ -715,9 +715,9 @@ store_in_keymap (keymap, idx, def)
 	  }
 	else if (CONSP (elt))
 	  {
-	    if (EQ (idx, XCONS (elt)->car))
+	    if (EQ (idx, XCAR (elt)))
 	      {
-		XCONS (elt)->cdr = def;
+		XCDR (elt) = def;
 		return def;
 	      }
 	  }
@@ -737,8 +737,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.  */
-    XCONS (insertion_point)->cdr
-      = Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr);
+    XCDR (insertion_point)
+      = Fcons (Fcons (idx, def), XCDR (insertion_point));
   }
 	  
   return def;
@@ -766,17 +766,17 @@ is not copied.")
 
   copy = Fcopy_alist (get_keymap (keymap));
 
-  for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = copy; CONSP (tail); tail = XCDR (tail))
     {
       Lisp_Object elt;
 
-      elt = XCONS (tail)->car;
+      elt = XCAR (tail);
       if (CHAR_TABLE_P (elt))
 	{
 	  Lisp_Object indices[3];
 
 	  elt = Fcopy_sequence (elt);
-	  XCONS (tail)->car = elt;
+	  XCAR (tail) = elt;
 
 	  map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
 	}
@@ -785,7 +785,7 @@ is not copied.")
 	  int i;
 
 	  elt = Fcopy_sequence (elt);
-	  XCONS (tail)->car = elt;
+	  XCAR (tail) = elt;
 
 	  for (i = 0; i < XVECTOR (elt)->size; i++)
 	    if (!SYMBOLP (XVECTOR (elt)->contents[i])
@@ -793,41 +793,41 @@ is not copied.")
 	      XVECTOR (elt)->contents[i]
 		= Fcopy_keymap (XVECTOR (elt)->contents[i]);
 	}
-      else if (CONSP (elt) && CONSP (XCONS (elt)->cdr))
+      else if (CONSP (elt) && CONSP (XCDR (elt)))
 	{
 	  Lisp_Object tem;
-	  tem = XCONS (elt)->cdr;
+	  tem = XCDR (elt);
 
 	  /* Is this a new format menu item.  */
-	  if (EQ (XCONS (tem)->car,Qmenu_item))
+	  if (EQ (XCAR (tem),Qmenu_item))
 	    {
 	      /* Copy cell with menu-item marker.  */
-	      XCONS (elt)->cdr
-		= Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
-	      elt = XCONS (elt)->cdr;
-	      tem = XCONS (elt)->cdr;
+	      XCDR (elt)
+		= Fcons (XCAR (tem), XCDR (tem));
+	      elt = XCDR (elt);
+	      tem = XCDR (elt);
 	      if (CONSP (tem))
 		{
 		  /* Copy cell with menu-item name.  */
-		  XCONS (elt)->cdr
-		    = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
-		  elt = XCONS (elt)->cdr;
-		  tem = XCONS (elt)->cdr;
+		  XCDR (elt)
+		    = Fcons (XCAR (tem), XCDR (tem));
+		  elt = XCDR (elt);
+		  tem = XCDR (elt);
 		};
 	      if (CONSP (tem))
 		{
 		  /* Copy cell with binding and if the binding is a keymap,
 		     copy that.  */
-		  XCONS (elt)->cdr
-		    = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
-		  elt = XCONS (elt)->cdr;
-		  tem = XCONS (elt)->car;
+		  XCDR (elt)
+		    = Fcons (XCAR (tem), XCDR (tem));
+		  elt = XCDR (elt);
+		  tem = XCAR (elt);
 		  if (!(SYMBOLP (tem) || NILP (Fkeymapp (tem))))
-		    XCONS (elt)->car = Fcopy_keymap (tem);
-		  tem = XCONS (elt)->cdr;
-		  if (CONSP (tem) && CONSP (XCONS (tem)->car))
+		    XCAR (elt) = Fcopy_keymap (tem);
+		  tem = XCDR (elt);
+		  if (CONSP (tem) && CONSP (XCAR (tem)))
 		    /* Delete cache for key equivalences.  */
-		    XCONS (elt)->cdr = XCONS (tem)->cdr;
+		    XCDR (elt) = XCDR (tem);
 		}
 	    }
 	  else
@@ -835,33 +835,33 @@ is not copied.")
 	      /* It may be an old fomat menu item.
 		 Skip the optional menu string.
 	      */
-	      if (STRINGP (XCONS (tem)->car))
+	      if (STRINGP (XCAR (tem)))
 		{
 		  /* Copy the cell, since copy-alist didn't go this deep.  */
-		  XCONS (elt)->cdr
-		    = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
-		  elt = XCONS (elt)->cdr;
-		  tem = XCONS (elt)->cdr;
+		  XCDR (elt)
+		    = Fcons (XCAR (tem), XCDR (tem));
+		  elt = XCDR (elt);
+		  tem = XCDR (elt);
 		  /* Also skip the optional menu help string.  */
-		  if (CONSP (tem) && STRINGP (XCONS (tem)->car))
+		  if (CONSP (tem) && STRINGP (XCAR (tem)))
 		    {
-		      XCONS (elt)->cdr
-			= Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
-		      elt = XCONS (elt)->cdr;
-		      tem = XCONS (elt)->cdr;
+		      XCDR (elt)
+			= Fcons (XCAR (tem), XCDR (tem));
+		      elt = XCDR (elt);
+		      tem = XCDR (elt);
 		    }
 		  /* There may also be a list that caches key equivalences.
 		     Just delete it for the new keymap.  */
 		  if (CONSP (tem)
-		      && CONSP (XCONS (tem)->car)
-		      && (NILP (XCONS (XCONS (tem)->car)->car)
-			  || VECTORP (XCONS (XCONS (tem)->car)->car)))
-		    XCONS (elt)->cdr = XCONS (tem)->cdr;
+		      && CONSP (XCAR (tem))
+		      && (NILP (XCAR (XCAR (tem)))
+			  || VECTORP (XCAR (XCAR (tem)))))
+		    XCDR (elt) = XCDR (tem);
 		}
 	      if (CONSP (elt)
-		  && ! SYMBOLP (XCONS (elt)->cdr)
-		  && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
-		XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
+		  && ! SYMBOLP (XCDR (elt))
+		  && ! NILP (Fkeymapp (XCDR (elt))))
+		XCDR (elt) = Fcopy_keymap (XCDR (elt));
 	    }
 
 	}
@@ -1093,8 +1093,8 @@ define_as_prefix (keymap, c)
 	 make it define this key.  */
       Lisp_Object tail;
 
-      for (tail = Fcdr (keymap); CONSP (tail); tail = XCONS (tail)->cdr)
-	if (EQ (XCONS (tail)->car, Qkeymap))
+      for (tail = Fcdr (keymap); CONSP (tail); tail = XCDR (tail))
+	if (EQ (XCAR (tail), Qkeymap))
 	  break;
 
       if (!NILP (tail))
@@ -1169,9 +1169,9 @@ current_minor_maps (modeptr, mapptr)
   for (list_number = 0; list_number < 2; list_number++)
     for (alist = lists[list_number];
 	 CONSP (alist);
-	 alist = XCONS (alist)->cdr)
-      if ((assoc = XCONS (alist)->car, CONSP (assoc))
-	  && (var = XCONS (assoc)->car, SYMBOLP (var))
+	 alist = XCDR (alist))
+      if ((assoc = XCAR (alist), CONSP (assoc))
+	  && (var = XCAR (assoc), SYMBOLP (var))
 	  && (val = find_symbol_value (var), ! EQ (val, Qunbound))
 	  && ! NILP (val))
 	{
@@ -1225,7 +1225,7 @@ current_minor_maps (modeptr, mapptr)
 
 	  /* Get the keymap definition--or nil if it is not defined.  */
 	  temp = internal_condition_case_1 (Findirect_function,
-					    XCONS (assoc)->cdr,
+					    XCDR (assoc),
 					    Qerror, current_minor_maps_error);
 	  if (!NILP (temp))
 	    {
@@ -1536,7 +1536,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
      This is a breadth-first traversal, where tail is the queue of
      nodes, and maps accumulates a list of all nodes visited.  */
 
-  for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = maps; CONSP (tail); tail = XCDR (tail))
     {
       register Lisp_Object thisseq, thismap;
       Lisp_Object last;
@@ -1551,11 +1551,11 @@ then the value includes only maps for prefixes that start with PREFIX.")
 		    && XINT (last) >= prefixlen
 		    && EQ (Faref (thisseq, last), meta_prefix_char));
 
-      for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
+      for (; CONSP (thismap); thismap = XCDR (thismap))
 	{
 	  Lisp_Object elt;
 
-	  elt = XCONS (thismap)->car;
+	  elt = XCAR (thismap);
 
 	  QUIT;
 
@@ -1602,8 +1602,8 @@ then the value includes only maps for prefixes that start with PREFIX.")
 			      /* This new sequence is the same length as
 				 thisseq, so stick it in the list right
 				 after this one.  */
-			      XCONS (tail)->cdr
-				= Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
+			      XCDR (tail)
+				= Fcons (Fcons (tem, cmd), XCDR (tail));
 			    }
 			  else
 			    {
@@ -1618,7 +1618,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
 	    {
 	      register Lisp_Object cmd, tem, filter;
 
-	      cmd = get_keyelt (XCONS (elt)->cdr, 0);
+	      cmd = get_keyelt (XCDR (elt), 0);
 	      /* Ignore definitions that aren't keymaps themselves.  */
 	      tem = Fkeymapp (cmd);
 	      if (!NILP (tem))
@@ -1629,7 +1629,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
 		  if (NILP (tem))
 		    {
 		      /* Let elt be the event defined by this map entry.  */
-		      elt = XCONS (elt)->car;
+		      elt = XCAR (elt);
 
 		      /* If the last key in thisseq is meta-prefix-char, and
 			 this entry is a binding for an ascii keystroke,
@@ -1646,8 +1646,8 @@ then the value includes only maps for prefixes that start with PREFIX.")
 			  /* This new sequence is the same length as
 			     thisseq, so stick it in the list right
 			     after this one.  */
-			  XCONS (tail)->cdr
-			    = Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
+			  XCDR (tail)
+			    = Fcons (Fcons (tem, cmd), XCDR (tail));
 			}
 		      else
 			nconc2 (tail,
@@ -1665,11 +1665,11 @@ then the value includes only maps for prefixes that start with PREFIX.")
   /* Now find just the maps whose access prefixes start with PREFIX.  */
 
   good_maps = Qnil;
-  for (; CONSP (maps); maps = XCONS (maps)->cdr)
+  for (; CONSP (maps); maps = XCDR (maps))
     {
       Lisp_Object elt, thisseq;
-      elt = XCONS (maps)->car;
-      thisseq = XCONS (elt)->car;
+      elt = XCAR (maps);
+      thisseq = XCAR (elt);
       /* The access prefix must be at least as long as PREFIX,
 	 and the first elements must match those of PREFIX.  */
       if (XINT (Flength (thisseq)) >= prefixlen)
@@ -1700,9 +1700,9 @@ accessible_keymaps_char_table (args, index, cmd)
   if (NILP (cmd))
     return;
 
-  maps = XCONS (args)->car;
-  tail = XCONS (XCONS (args)->cdr)->car;
-  thisseq = XCONS (XCONS (args)->cdr)->cdr;
+  maps = XCAR (args);
+  tail = XCAR (XCDR (args));
+  thisseq = XCDR (XCDR (args));
 
   tem = Fkeymapp (cmd);
   if (!NILP (tem))
@@ -1787,9 +1787,9 @@ spaces are put between sequence elements, etc.")
 
       for (i = 0; i < len; i++)
 	{
-	  args[i * 2] = Fsingle_key_description (XCONS (keys)->car);
+	  args[i * 2] = Fsingle_key_description (XCAR (keys));
 	  args[i * 2 + 1] = sep;
-	  keys = XCONS (keys)->cdr;
+	  keys = XCDR (keys);
 	}
     }
   else
@@ -2106,10 +2106,10 @@ indirect definition itself.")
       minors = Fnreverse (Fcurrent_minor_mode_maps ());
       while (!NILP (minors))
 	{
-	  maps = nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors)->car),
+	  maps = nconc2 (Faccessible_keymaps (get_keymap (XCAR (minors)),
 					      Qnil),
 			 maps);
-	  minors = XCONS (minors)->cdr;
+	  minors = XCDR (minors);
 	}
     }
 
@@ -2147,8 +2147,8 @@ indirect definition itself.")
 	     advance map to the next element until i indicates that we
 	     have finished off the vector.  */
 	  Lisp_Object elt, key, binding;
-	  elt = XCONS (map)->car;
-	  map = XCONS (map)->cdr;
+	  elt = XCAR (map);
+	  map = XCDR (map);
 
 	  sequences = Qnil;
 
@@ -2185,14 +2185,14 @@ indirect definition itself.")
 
 	      map_char_table (where_is_internal_2, Qnil, elt, args,
 			      0, indices);
-	      sequences = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
+	      sequences = XCDR (XCDR (XCAR (args)));
 	    }
 	  else if (CONSP (elt))
 	    {
 	      Lisp_Object sequence;
 
-	      key = XCONS (elt)->car;
-	      binding = XCONS (elt)->cdr;
+	      key = XCAR (elt);
+	      binding = XCDR (elt);
 
 	      sequence = where_is_internal_1 (binding, key, definition,
 					      noindirect, keymap, this,
@@ -2202,11 +2202,11 @@ indirect definition itself.")
 	    }
 
 
-	  for (; ! NILP (sequences); sequences = XCONS (sequences)->cdr)
+	  for (; ! NILP (sequences); sequences = XCDR (sequences))
 	    {
 	      Lisp_Object sequence;
 
-	      sequence = XCONS (sequences)->car;
+	      sequence = XCAR (sequences);
 
 	      /* It is a true unshadowed match.  Record it, unless it's already
 		 been seen (as could happen when inheriting keymaps).  */
@@ -2254,20 +2254,20 @@ where_is_internal_2 (args, key, binding)
   Lisp_Object result, sequence;
   int nomenus, last_is_meta;
 
-  result = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
-  definition = XCONS (XCONS (XCONS (args)->car)->car)->car;
-  noindirect = XCONS (XCONS (XCONS (args)->car)->car)->cdr;
-  keymap = XCONS (XCONS (XCONS (args)->car)->cdr)->car;
-  this = XCONS (XCONS (XCONS (args)->cdr)->car)->car;
-  last = XCONS (XCONS (XCONS (args)->cdr)->car)->cdr;
-  nomenus = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->car);
-  last_is_meta = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->cdr);
+  result = XCDR (XCDR (XCAR (args)));
+  definition = XCAR (XCAR (XCAR (args)));
+  noindirect = XCDR (XCAR (XCAR (args)));
+  keymap = XCAR (XCDR (XCAR (args)));
+  this = XCAR (XCAR (XCDR (args)));
+  last = XCDR (XCAR (XCDR (args)));
+  nomenus = XFASTINT (XCAR (XCDR (XCDR (args))));
+  last_is_meta = XFASTINT (XCDR (XCDR (XCDR (args))));
 
   sequence = where_is_internal_1 (binding, key, definition, noindirect, keymap,
 				  this, last, nomenus, last_is_meta);
 
   if (!NILP (sequence))
-    XCONS (XCONS (XCONS (args)->car)->cdr)->cdr
+    XCDR (XCDR (XCAR (args)))
       = Fcons (sequence, result);
 }
 
@@ -2298,8 +2298,8 @@ where_is_internal_1 (binding, key, definition, noindirect, keymap, this, last,
 	    }
 	  /* If the contents are (menu-item ...) or (STRING ...), reject.  */
 	  if (CONSP (definition)
-	      && (EQ (XCONS (definition)->car,Qmenu_item)
-		  || STRINGP (XCONS (definition)->car)))
+	      && (EQ (XCAR (definition),Qmenu_item)
+		  || STRINGP (XCAR (definition))))
 	    return Qnil;
 	}
       else
@@ -2404,11 +2404,11 @@ Keyboard translations:\n\n\
 You type        Translation\n\
 --------        -----------\n";
 
-  descbuf = XCONS (arg)->car;
-  arg = XCONS (arg)->cdr;
-  prefix = XCONS (arg)->car;
-  arg = XCONS (arg)->cdr;
-  nomenu = NILP (XCONS (arg)->car);
+  descbuf = XCAR (arg);
+  arg = XCDR (arg);
+  prefix = XCAR (arg);
+  arg = XCDR (arg);
+  nomenu = NILP (XCAR (arg));
 
   shadow = Qnil;
   GCPRO1 (shadow);
@@ -2566,7 +2566,7 @@ key             binding\n\
       Lisp_Object list;
 
       /* Delete from MAPS each element that is for the menu bar.  */
-      for (list = maps; !NILP (list); list = XCONS (list)->cdr)
+      for (list = maps; !NILP (list); list = XCDR (list))
 	{
 	  Lisp_Object elt, prefix, tem;
 
@@ -2606,11 +2606,11 @@ key             binding\n\
 
       sub_shadows = Qnil;
 
-      for (tail = shadow; CONSP (tail); tail = XCONS (tail)->cdr)
+      for (tail = shadow; CONSP (tail); tail = XCDR (tail))
 	{
 	  Lisp_Object shmap;
 
-	  shmap = XCONS (tail)->car;
+	  shmap = XCAR (tail);
 
 	  /* If the sequence by which we reach this keymap is zero-length,
 	     then the shadow map for this keymap is just SHADOW.  */
@@ -2740,9 +2740,9 @@ shadow_lookup (shadow, key, flag)
 {
   Lisp_Object tail, value;
 
-  for (tail = shadow; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = shadow; CONSP (tail); tail = XCDR (tail))
     {
-      value = Flookup_key (XCONS (tail)->car, key, flag);
+      value = Flookup_key (XCAR (tail), key, flag);
       if (!NILP (value))
 	return value;
     }
@@ -2791,18 +2791,18 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
 
   GCPRO3 (elt_prefix, definition, kludge);
 
-  for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = map; CONSP (tail); tail = XCDR (tail))
     {
       QUIT;
 
-      if (VECTORP (XCONS (tail)->car)
-	  || CHAR_TABLE_P (XCONS (tail)->car))
-	describe_vector (XCONS (tail)->car,
+      if (VECTORP (XCAR (tail))
+	  || CHAR_TABLE_P (XCAR (tail)))
+	describe_vector (XCAR (tail),
 			 elt_prefix, elt_describer, partial, shadow, map,
 			 (int *)0, 0);
-      else if (CONSP (XCONS (tail)->car))
+      else if (CONSP (XCAR (tail)))
 	{
-	  event = XCONS (XCONS (tail)->car)->car;
+	  event = XCAR (XCAR (tail));
 
 	  /* Ignore bindings whose "keys" are not really valid events.
 	     (We get these in the frames and buffers menu.)  */
@@ -2812,7 +2812,7 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
 	  if (nomenu && EQ (event, Qmenu_bar))
 	    continue;
 
-	  definition = get_keyelt (XCONS (XCONS (tail)->car)->cdr, 0);
+	  definition = get_keyelt (XCDR (XCAR (tail)), 0);
 
 	  /* Don't show undefined commands or suppressed commands.  */
 	  if (NILP (definition)) continue;
@@ -2854,13 +2854,13 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
 	     for alignment purposes.  */
 	  (*elt_describer) (definition);
 	}
-      else if (EQ (XCONS (tail)->car, Qkeymap))
+      else if (EQ (XCAR (tail), Qkeymap))
 	{
 	  /* The same keymap might be in the structure twice, if we're
 	     using an inherited keymap.  So skip anything we've already
 	     encountered.  */
 	  tem = Fassq (tail, *seen);
-	  if (CONSP (tem) && !NILP (Fequal (XCONS (tem)->car, keys)))
+	  if (CONSP (tem) && !NILP (Fequal (XCAR (tem), keys)))
 	    break;
 	  *seen = Fcons (Fcons (tail, keys), *seen);
 	}