Use XCAR and XCDR instead of explicit member access.

diff --git a/src/lread.c b/src/lread.c
index d4e556a..d02d2b3 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -748,8 +748,8 @@ Return t if file exists.")
 
   GCPRO1 (file);
   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);
   record_unwind_protect (load_unwind, lispstream);
   record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
   specbind (Qload_file_name, found);
@@ -793,8 +793,8 @@ static Lisp_Object
 load_unwind (stream)  /* used as unwind-protect function in load */
      Lisp_Object stream;
 {
-  fclose ((FILE *) (XFASTINT (XCONS (stream)->car) << 16
-                   | XFASTINT (XCONS (stream)->cdr)));
+  fclose ((FILE *) (XFASTINT (XCAR (stream)) << 16
+                   | XFASTINT (XCDR (stream))));
   if (--load_in_progress < 0) load_in_progress = 0;
   return Qnil;
 }
@@ -815,8 +815,8 @@ close_load_descs ()
 {
 #ifndef WINDOWSNT
   Lisp_Object tail;
-  for (tail = load_descriptor_list; !NILP (tail); tail = XCONS (tail)->cdr)
-    close (XFASTINT (XCONS (tail)->car));
+  for (tail = load_descriptor_list; !NILP (tail); tail = XCDR (tail))
+    close (XFASTINT (XCAR (tail)));
 #endif
 }
 \f
@@ -2454,8 +2454,8 @@ read_vector (readcharfun, bytecodeflag)
                    error ("invalid byte code");
 
                  otem = XCONS (item);
-                 bytestr = XCONS (item)->car;
-                 item = XCONS (item)->cdr;
+                 bytestr = XCAR (item);
+                 item = XCDR (item);
                  free_cons (otem);
                }
 
@@ -2547,7 +2547,7 @@ read_list (flag, readcharfun)
            {
              GCPRO2 (val, tail);
              if (!NILP (tail))
-               XCONS (tail)->cdr = read0 (readcharfun);
+               XCDR (tail) = read0 (readcharfun);
              else
                val = read0 (readcharfun);
              read1 (readcharfun, &ch, 0);
@@ -2560,7 +2560,7 @@ read_list (flag, readcharfun)
                    {
                      /* Get a doc string from the file we are loading.
                         If it's in saved_doc_string, get it from there.  */
-                     int pos = XINT (XCONS (val)->cdr);
+                     int pos = XINT (XCDR (val));
                      /* Position is negative for user variables.  */
                      if (pos < 0) pos = -pos;
                      if (pos >= saved_doc_string_position
@@ -2640,7 +2640,7 @@ read_list (flag, readcharfun)
             ? pure_cons (elt, Qnil)
             : Fcons (elt, Qnil));
       if (!NILP (tail))
-       XCONS (tail)->cdr = tem;
+       XCDR (tail) = tem;
       else
        val = tem;
       tail = tem;
@@ -3265,7 +3265,7 @@ init_lread ()
 
       for (path_tail = Vload_path;
           !NILP (path_tail);
-          path_tail = XCONS (path_tail)->cdr)
+          path_tail = XCDR (path_tail))
        {
          Lisp_Object dirfile;
          dirfile = Fcar (path_tail);
@@ -3274,7 +3274,7 @@ init_lread ()
              dirfile = Fdirectory_file_name (dirfile);
              if (access (XSTRING (dirfile)->data, 0) < 0)
                dir_warning ("Warning: Lisp directory `%s' does not exist.\n",
-                            XCONS (path_tail)->car);
+                            XCAR (path_tail));
            }
        }
     }

diff --git a/src/search.c b/src/search.c
index da4f635..cbecadc 100644 (file)
--- a/src/search.c
+++ b/src/search.c
@@ -2599,19 +2599,19 @@ to hold all the values, and if INTEGERS is non-nil, no consing is done.")
   /* If REUSE is a list, store as many value elements as will fit
      into the elements of REUSE.  */
   for (i = 0, tail = reuse; CONSP (tail);
-       i++, tail = XCONS (tail)->cdr)
+       i++, tail = XCDR (tail))
     {
       if (i < 2 * len + 2)
-       XCONS (tail)->car = data[i];
+       XCAR (tail) = data[i];
       else
-       XCONS (tail)->car = Qnil;
+       XCAR (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)
-    XCONS (prev)->cdr = Flist (2 * len + 2 - i, data + i);
+    XCDR (prev) = Flist (2 * len + 2 - i, data + i);
 
   return reuse;
 }

diff --git a/src/sunfns.c b/src/sunfns.c
index efc4e97..504eed3 100644 (file)
--- a/src/sunfns.c
+++ b/src/sunfns.c
@@ -459,8 +459,8 @@ as a menu label.")
   {static Lisp_Object symbol[2];
    symbol[0] = Fintern (sm_kludge_string, Qnil);
    Pair = Ffuncall (1, symbol);
-   xpos += XINT (XCONS (Pair)->cdr);
-   ypos += XINT (XCONS (Pair)->car);
+   xpos += XINT (XCDR (Pair));
+   ypos += XINT (XCAR (Pair));
  }
 #endif
 

diff --git a/src/syntax.c b/src/syntax.c
index d183046..9882986 100644 (file)
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -979,8 +979,8 @@ describe_syntax (value)
       return;
     }
 
-  first = XCONS (value)->car;
-  match_lisp = XCONS (value)->cdr;
+  first = XCAR (value);
+  match_lisp = XCDR (value);
 
   if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
     {

diff --git a/src/undo.c b/src/undo.c
index 86bcdc9..51eaa5a 100644 (file)
--- a/src/undo.c
+++ b/src/undo.c
@@ -66,13 +66,13 @@ record_insert (beg, length)
   if (CONSP (current_buffer->undo_list))
     {
       Lisp_Object elt;
-      elt = XCONS (current_buffer->undo_list)->car;
+      elt = XCAR (current_buffer->undo_list);
       if (CONSP (elt)
-         && INTEGERP (XCONS (elt)->car)
-         && INTEGERP (XCONS (elt)->cdr)
-         && XINT (XCONS (elt)->cdr) == beg)
+         && INTEGERP (XCAR (elt))
+         && INTEGERP (XCDR (elt))
+         && XINT (XCDR (elt)) == beg)
        {
-         XSETINT (XCONS (elt)->cdr, beg + length);
+         XSETINT (XCDR (elt), beg + length);
          return;
        }
     }
@@ -114,10 +114,10 @@ record_delete (beg, string)
 
       while (1)
        {
-         elt = XCONS (tail)->car;
-         if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCONS (elt)->car)))
+         elt = XCAR (tail);
+         if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
            break;
-         tail = XCONS (tail)->cdr;
+         tail = XCDR (tail);
        }
       at_boundary = NILP (elt);
     }
@@ -264,7 +264,7 @@ but another undo command will undo to the previous boundary.")
        {
          /* If we have preallocated the cons cell to use here,
             use that one.  */
-         XCONS (pending_boundary)->cdr = current_buffer->undo_list;
+         XCDR (pending_boundary) = current_buffer->undo_list;
          current_buffer->undo_list = pending_boundary;
          pending_boundary = Qnil;
        }
@@ -298,33 +298,33 @@ truncate_undo_list (list, minsize, maxsize)
      Skip, skip, skip the undo, skip, skip, skip the undo,
      Skip, skip, skip the undo, skip to the undo bound'ry. 
      (Get it?  "Skip to my Loo?")  */
-  if (CONSP (next) && NILP (XCONS (next)->car))
+  if (CONSP (next) && NILP (XCAR (next)))
     {
       /* Add in the space occupied by this element and its chain link.  */
       size_so_far += sizeof (struct Lisp_Cons);
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
-  while (CONSP (next) && ! NILP (XCONS (next)->car))
+  while (CONSP (next) && ! NILP (XCAR (next)))
     {
       Lisp_Object elt;
-      elt = XCONS (next)->car;
+      elt = XCAR (next);
 
       /* Add in the space occupied by this element and its chain link.  */
       size_so_far += sizeof (struct Lisp_Cons);
       if (CONSP (elt))
        {
          size_so_far += sizeof (struct Lisp_Cons);
-         if (STRINGP (XCONS (elt)->car))
+         if (STRINGP (XCAR (elt)))
            size_so_far += (sizeof (struct Lisp_String) - 1
-                           + XSTRING (XCONS (elt)->car)->size);
+                           + XSTRING (XCAR (elt))->size);
        }
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
   if (CONSP (next))
     last_boundary = prev;
@@ -332,7 +332,7 @@ truncate_undo_list (list, minsize, maxsize)
   while (CONSP (next))
     {
       Lisp_Object elt;
-      elt = XCONS (next)->car;
+      elt = XCAR (next);
 
       /* When we get to a boundary, decide whether to truncate
         either before or after it.  The lower threshold, MINSIZE,
@@ -352,14 +352,14 @@ truncate_undo_list (list, minsize, maxsize)
       if (CONSP (elt))
        {
          size_so_far += sizeof (struct Lisp_Cons);
-         if (STRINGP (XCONS (elt)->car))
+         if (STRINGP (XCAR (elt)))
            size_so_far += (sizeof (struct Lisp_String) - 1
-                           + XSTRING (XCONS (elt)->car)->size);
+                           + XSTRING (XCAR (elt))->size);
        }
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
 
   /* If we scanned the whole list, it is short enough; don't change it.  */
@@ -369,7 +369,7 @@ truncate_undo_list (list, minsize, maxsize)
   /* Truncate at the boundary where we decided to truncate.  */
   if (!NILP (last_boundary))
     {
-      XCONS (last_boundary)->cdr = Qnil;
+      XCDR (last_boundary) = Qnil;
       return list;
     }
   else

diff --git a/src/vmsproc.c b/src/vmsproc.c
index c229a91..122cf08 100644 (file)
--- a/src/vmsproc.c
+++ b/src/vmsproc.c
@@ -758,9 +758,9 @@ child_sig (vs)
   pid = vs->pid;
   sys$setef (vs->eventFlag);
 
-  for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCONS (tail)->cdr)
+  for (tail = Vprocess_alist; XSYMBOL (tail) != XSYMBOL (Qnil); tail = XCDR (tail))
     {
-      proc = XCONS (XCONS (tail)->car)->cdr;
+      proc = XCDR (XCAR (tail));
       p = XPROCESS (proc);
       if (EQ (p->childp, Qt) && XFASTINT (p->pid) == pid)
        break;