* src/lread.c: Remove `read_pure' which makes no difference.

(read_pure): Remove var.
(unreadpure): Remove function.
(readevalloop): Don't call read_list with -1 flag.
(read1, read_vector): Don't test read_pure any more.
(read_list): Simplify.

2 files changed, 64 insertions, 84 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 911354b7a61..f211bd4c939 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,12 @@
 2012-05-25  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+        * lread.c: Remove `read_pure' which makes no difference.
+        (read_pure): Remove var.
+        (unreadpure): Remove function.
+        (readevalloop): Don't call read_list with -1 flag.
+        (read1, read_vector): Don't test read_pure any more.
+        (read_list): Simplify.
+
         * fileio.c, character.h: Minor style tweaks.
 
 2012-05-24  Dmitry Antipov  <dmantipov@yandex.ru>
diff --git a/src/lread.c b/src/lread.c
index 6b657f61ed0..37ccb16a626 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -61,7 +61,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define file_tell ftell
 #endif
 
-/* hash table read constants */
+/* Hash table read constants.  */
 static Lisp_Object Qhash_table, Qdata;
 static Lisp_Object Qtest, Qsize;
 static Lisp_Object Qweakness;
@@ -105,16 +105,13 @@ static Lisp_Object load_descriptor_list;
 /* File for get_file_char to read from.  Use by load.  */
 static FILE *instream;
 
-/* When nonzero, read conses in pure space */
-static int read_pure;
-
 /* For use within read-from-string (this reader is non-reentrant!!)  */
 static EMACS_INT read_from_string_index;
 static EMACS_INT read_from_string_index_byte;
 static EMACS_INT read_from_string_limit;
 
 /* Number of characters read in the current call to Fread or
-   Fread_from_string. */
+   Fread_from_string.  */
 static EMACS_INT readchar_count;
 
 /* This contains the last string skipped with #@.  */
@@ -187,7 +184,7 @@ static int readbyte_from_string (int, Lisp_Object);
 /* When READCHARFUN is Qget_file_char, Qget_emacs_mule_file_char,
    Qlambda, or a cons, we use this to keep an unread character because
    a file stream can't handle multibyte-char unreading.  The value -1
-   means that there's no unread character. */
+   means that there's no unread character.  */
 static int unread_char;
 
 static int
@@ -447,7 +444,7 @@ readbyte_from_file (int c, Lisp_Object readcharfun)
   c = getc (instream);
 
 #ifdef EINTR
-  /* Interrupted reads have been observed while reading over the network */
+  /* Interrupted reads have been observed while reading over the network.  */
   while (c == EOF && ferror (instream) && errno == EINTR)
     {
       UNBLOCK_INPUT;
@@ -1067,7 +1064,7 @@ Return t if the file exists and loads successfully.  */)
 
 
   /* Avoid weird lossage with null string as arg,
-     since it would try to load a directory as a Lisp file */
+     since it would try to load a directory as a Lisp file.  */
   if (SBYTES (file) > 0)
     {
       ptrdiff_t size = SBYTES (file);
@@ -1171,7 +1168,7 @@ Return t if the file exists and loads successfully.  */)
      Vload_source_file_function.  */
   specbind (Qlexical_binding, Qnil);
 
-  /* Get the name for load-history. */
+  /* Get the name for load-history.  */
   hist_file_name = (! NILP (Vpurify_flag)
                     ? Fconcat (2, (tmp[0] = Ffile_name_directory (file),
                                    tmp[1] = Ffile_name_nondirectory (found),
@@ -1324,7 +1321,7 @@ Return t if the file exists and loads successfully.  */)
     }
   unbind_to (count, Qnil);
 
-  /* Run any eval-after-load forms for this file */
+  /* Run any eval-after-load forms for this file.  */
   if (!NILP (Ffboundp (Qdo_after_load_evaluation)))
     call1 (Qdo_after_load_evaluation, hist_file_name) ;
 
@@ -1356,7 +1353,7 @@ Return t if the file exists and loads successfully.  */)
 }
 
 static Lisp_Object
-load_unwind (Lisp_Object arg)  /* used as unwind-protect function in load */
+load_unwind (Lisp_Object arg)  /* Used as unwind-protect function in load.  */
 {
   FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
   if (stream != NULL)
@@ -1475,13 +1472,13 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
     {
       filename = Fexpand_file_name (str, XCAR (path));
       if (!complete_filename_p (filename))
-        /* If there are non-absolute elts in PATH (eg ".") */
+        /* If there are non-absolute elts in PATH (eg ".").  */
         /* Of course, this could conceivably lose if luser sets
-           default-directory to be something non-absolute... */
+           default-directory to be something non-absolute...  */
         {
           filename = Fexpand_file_name (filename, BVAR (current_buffer, directory));
           if (!complete_filename_p (filename))
-            /* Give up on this path element! */
+            /* Give up on this path element!  */
             continue;
         }
 
@@ -1606,12 +1603,12 @@ build_load_history (Lisp_Object filename, int entire)
     {
       tem = XCAR (tail);
 
-      /* Find the feature's previous assoc list... */
+      /* Find the feature's previous assoc list...  */
       if (!NILP (Fequal (filename, Fcar (tem))))
         {
           foundit = 1;
 
-          /*  If we're loading the entire file, remove old data. */
+          /*  If we're loading the entire file, remove old data.  */
           if (entire)
             {
               if (NILP (prev))
@@ -1653,13 +1650,6 @@ build_load_history (Lisp_Object filename, int entire)
 }
 
 static Lisp_Object
-unreadpure (Lisp_Object junk) /* Used as unwind-protect function in readevalloop */
-{
-  read_pure = 0;
-  return Qnil;
-}
-
-static Lisp_Object
 readevalloop_1 (Lisp_Object old)
 {
   load_convert_to_unibyte = ! NILP (old);
@@ -1735,7 +1725,7 @@ readevalloop (Lisp_Object readcharfun,
 
   GCPRO4 (sourcename, readfun, start, end);
 
-  /* Try to ensure sourcename is a truename, except whilst preloading. */
+  /* Try to ensure sourcename is a truename, except whilst preloading.  */
   if (NILP (Vpurify_flag)
       && !NILP (sourcename) && !NILP (Ffile_name_absolute_p (sourcename))
       && !NILP (Ffboundp (Qfile_truename)))
@@ -1800,8 +1790,7 @@ readevalloop (Lisp_Object readcharfun,
 
       if (!NILP (Vpurify_flag) && c == '(')
         {
-          record_unwind_protect (unreadpure, Qnil);
-          val = read_list (-1, readcharfun);
+          val = read_list (0, readcharfun);
         }
       else
         {
@@ -1929,7 +1918,7 @@ This function does not move point.  */)
   specbind (Qstandard_output, tem);
   specbind (Qeval_buffer_list, Fcons (cbuf, Veval_buffer_list));
 
-  /* readevalloop calls functions which check the type of start and end.  */
+  /* `readevalloop' calls functions which check the type of start and end.  */
   readevalloop (cbuf, 0, BVAR (XBUFFER (cbuf), filename),
                 !NILP (printflag), Qnil, read_function,
                 start, end);
@@ -1972,16 +1961,16 @@ START and END optionally delimit a substring of STRING from which to read;
 {
   Lisp_Object ret;
   CHECK_STRING (string);
-  /* read_internal_start sets read_from_string_index. */
+  /* `read_internal_start' sets `read_from_string_index'.  */
   ret = read_internal_start (string, start, end);
   return Fcons (ret, make_number (read_from_string_index));
 }
 
 /* Function to set up the global context we need in toplevel read
-   calls. */
+   calls.  */
 static Lisp_Object
 read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
-/* start, end only used when stream is a string. */
+/* `start', `end' only used when stream is a string.  */
 {
   Lisp_Object retval;
 
@@ -2046,7 +2035,7 @@ invalid_syntax (const char *s)
 
 
 /* Use this for recursive reads, in contexts where internal tokens
-   are not allowed. */
+   are not allowed.  */
 
 static Lisp_Object
 read0 (Lisp_Object readcharfun)
@@ -2073,7 +2062,7 @@ read_escape (Lisp_Object readcharfun, int stringp)
 {
   register int c = READCHAR;
   /* \u allows up to four hex digits, \U up to eight.  Default to the
-     behavior for \u, and change this value in the case that \U is seen. */
+     behavior for \u, and change this value in the case that \U is seen.  */
   int unicode_hex_count = 4;
 
   switch (c)
@@ -2259,8 +2248,8 @@ read_escape (Lisp_Object readcharfun, int stringp)
         while (++count <= unicode_hex_count)
           {
             c = READCHAR;
-            /* isdigit and isalpha may be locale-specific, which we don't
-               want. */
+            /* `isdigit' and `isalpha' may be locale-specific, which we don't
+               want.  */
             if      (c >= '0' && c <= '9')  i = (i << 4) + (c - '0');
             else if (c >= 'a' && c <= 'f')  i = (i << 4) + (c - 'a') + 10;
             else if (c >= 'A' && c <= 'F')  i = (i << 4) + (c - 'A') + 10;
@@ -2414,13 +2403,13 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
             {
               /* Accept extended format for hashtables (extensible to
                  other types), e.g.
-                 #s(hash-table size 2 test equal data (k1 v1 k2 v2)) */
+                 #s(hash-table size 2 test equal data (k1 v1 k2 v2))  */
               Lisp_Object tmp = read_list (0, readcharfun);
               Lisp_Object head = CAR_SAFE (tmp);
               Lisp_Object data = Qnil;
               Lisp_Object val = Qnil;
               /* The size is 2 * number of allowed keywords to
-                 make-hash-table. */
+                 make-hash-table.  */
               Lisp_Object params[10];
               Lisp_Object ht;
               Lisp_Object key = Qnil;
@@ -2432,36 +2421,36 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
 
               tmp = CDR_SAFE (tmp);
 
-              /* This is repetitive but fast and simple. */
+              /* This is repetitive but fast and simple.  */
               params[param_count] = QCsize;
-              params[param_count+1] = Fplist_get (tmp, Qsize);
+              params[param_count + 1] = Fplist_get (tmp, Qsize);
               if (!NILP (params[param_count + 1]))
                 param_count += 2;
 
               params[param_count] = QCtest;
-              params[param_count+1] = Fplist_get (tmp, Qtest);
+              params[param_count + 1] = Fplist_get (tmp, Qtest);
               if (!NILP (params[param_count + 1]))
                 param_count += 2;
 
               params[param_count] = QCweakness;
-              params[param_count+1] = Fplist_get (tmp, Qweakness);
+              params[param_count + 1] = Fplist_get (tmp, Qweakness);
               if (!NILP (params[param_count + 1]))
                 param_count += 2;
 
               params[param_count] = QCrehash_size;
-              params[param_count+1] = Fplist_get (tmp, Qrehash_size);
+              params[param_count + 1] = Fplist_get (tmp, Qrehash_size);
               if (!NILP (params[param_count + 1]))
                 param_count += 2;
 
               params[param_count] = QCrehash_threshold;
-              params[param_count+1] = Fplist_get (tmp, Qrehash_threshold);
+              params[param_count + 1] = Fplist_get (tmp, Qrehash_threshold);
               if (!NILP (params[param_count + 1]))
                 param_count += 2;
 
-              /* This is the hashtable data. */
+              /* This is the hashtable data.  */
               data = Fplist_get (tmp, Qdata);
 
-              /* Now use params to make a new hashtable and fill it. */
+              /* Now use params to make a new hashtable and fill it.  */
               ht = Fmake_hash_table (param_count, params);
 
               while (CONSP (data))
@@ -2728,7 +2717,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
                       n for #n#.  */
                   if (c == '=')
                     {
-                      /* Make a placeholder for #n# to use temporarily */
+                      /* Make a placeholder for #n# to use temporarily.  */
                       Lisp_Object placeholder;
                       Lisp_Object cell;
 
@@ -2736,10 +2725,10 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
                       cell = Fcons (make_number (n), placeholder);
                       read_objects = Fcons (cell, read_objects);
 
-                      /* Read the object itself. */
+                      /* Read the object itself.  */
                       tem = read0 (readcharfun);
 
-                      /* Now put it everywhere the placeholder was... */
+                      /* Now put it everywhere the placeholder was...  */
                       substitute_object_in_subtree (tem, placeholder);
 
                       /* ...and #n# will use the real value from now on.  */
@@ -2922,7 +2911,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
 
                 ch = read_escape (readcharfun, 1);
 
-                /* CH is -1 if \ newline has just been seen */
+                /* CH is -1 if \ newline has just been seen.  */
                 if (ch == -1)
                   {
                     if (p == read_buffer)
@@ -2937,7 +2926,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
                   force_singlebyte = 1;
                 else if (! ASCII_CHAR_P (ch))
                   force_multibyte = 1;
-                else            /* i.e. ASCII_CHAR_P (ch) */
+                else            /* I.e. ASCII_CHAR_P (ch).  */
                   {
                     /* Allow `\C- ' and `\C-?'.  */
                     if (modifiers == CHAR_CTL)
@@ -3005,10 +2994,6 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
             /* Otherwise, READ_BUFFER contains only ASCII.  */
           }
 
-        if (read_pure)
-          return make_pure_string (read_buffer, nchars, p - read_buffer,
-                                   (force_multibyte
-                                    || (p - read_buffer != nchars)));
         return make_specified_string (read_buffer, nchars, p - read_buffer,
                                       (force_multibyte
                                        || (p - read_buffer != nchars)));
@@ -3128,7 +3113,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
 }
 
 
-/* List of nodes we've seen during substitute_object_in_subtree. */
+/* List of nodes we've seen during substitute_object_in_subtree.  */
 static Lisp_Object seen_list;
 
 static void
@@ -3136,23 +3121,23 @@ substitute_object_in_subtree (Lisp_Object object, Lisp_Object placeholder)
 {
   Lisp_Object check_object;
 
-  /* We haven't seen any objects when we start. */
+  /* We haven't seen any objects when we start.  */
   seen_list = Qnil;
 
-  /* Make all the substitutions. */
+  /* Make all the substitutions.  */
   check_object
     = substitute_object_recurse (object, placeholder, object);
 
-  /* Clear seen_list because we're done with it. */
+  /* Clear seen_list because we're done with it.  */
   seen_list = Qnil;
 
   /* The returned object here is expected to always eq the
-     original. */
+     original.  */
   if (!EQ (check_object, object))
     error ("Unexpected mutation error in reader");
 }
 
-/*  Feval doesn't get called from here, so no gc protection is needed. */
+/*  Feval doesn't get called from here, so no gc protection is needed.  */
 #define SUBSTITUTE(get_val, set_val)                    \
   do {                                                  \
     Lisp_Object old_value = get_val;                    \
@@ -3169,11 +3154,11 @@ substitute_object_in_subtree (Lisp_Object object, Lisp_Object placeholder)
 static Lisp_Object
 substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Object subtree)
 {
-  /* If we find the placeholder, return the target object. */
+  /* If we find the placeholder, return the target object.  */
   if (EQ (placeholder, subtree))
     return object;
 
-  /* If we've been to this node before, don't explore it again. */
+  /* If we've been to this node before, don't explore it again.  */
   if (!EQ (Qnil, Fmemq (subtree, seen_list)))
     return subtree;
 
@@ -3223,7 +3208,7 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
     case Lisp_String:
       {
         /* Check for text properties in each interval.
-           substitute_in_interval contains part of the logic. */
+           substitute_in_interval contains part of the logic.  */
 
         INTERVAL    root_interval = STRING_INTERVALS (subtree);
         Lisp_Object arg           = Fcons (object, placeholder);
@@ -3234,7 +3219,7 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
         return subtree;
       }
 
-      /* Other types don't recurse any further. */
+      /* Other types don't recurse any further.  */
     default:
       return subtree;
     }
@@ -3421,7 +3406,7 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
 
   tem = read_list (1, readcharfun);
   len = Flength (tem);
-  vector = (read_pure ? make_pure_vector (XINT (len)) : Fmake_vector (len, Qnil));
+  vector = Fmake_vector (len, Qnil);
 
   size = ASIZE (vector);
   ptr = XVECTOR (vector)->contents;
@@ -3468,7 +3453,7 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
                 }
 
               /* Now handle the bytecode slot.  */
-              ptr[COMPILED_BYTECODE] = read_pure ? Fpurecopy (bytestr) : bytestr;
+              ptr[COMPILED_BYTECODE] = bytestr;
             }
           else if (i == COMPILED_DOC_STRING
                    && STRINGP (item)
@@ -3480,7 +3465,7 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
                 item = Fstring_as_multibyte (item);
             }
         }
-      ptr[i] = read_pure ? Fpurecopy (item) : item;
+      ptr[i] = item;
       otem = XCONS (tem);
       tem = Fcdr (tem);
       free_cons (otem);
@@ -3488,17 +3473,11 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
   return vector;
 }
 
-/* FLAG = 1 means check for ] to terminate rather than ) and .
-   FLAG = -1 means check for starting with defun
-    and make structure pure.  */
+/* FLAG = 1 means check for ] to terminate rather than ) and .  */
 
 static Lisp_Object
 read_list (int flag, register Lisp_Object readcharfun)
 {
-  /* -1 means check next element for defun,
-     0 means don't check,
-     1 means already checked and found defun. */
-  int defunflag = flag < 0 ? -1 : 0;
   Lisp_Object val, tail;
   register Lisp_Object elt, tem;
   struct gcpro gcpro1, gcpro2;
@@ -3660,24 +3639,18 @@ read_list (int flag, register Lisp_Object readcharfun)
             }
           invalid_syntax ("] in a list");
         }
-      tem = (read_pure && flag <= 0
-             ? pure_cons (elt, Qnil)
-             : Fcons (elt, Qnil));
+      tem = Fcons (elt, Qnil);
       if (!NILP (tail))
         XSETCDR (tail, tem);
       else
         val = tem;
       tail = tem;
-      if (defunflag < 0)
-        defunflag = EQ (elt, Qdefun);
-      else if (defunflag > 0)
-        read_pure = 1;
     }
 }
 
 static Lisp_Object initial_obarray;
 
-/* oblookup stores the bucket number here, for the sake of Funintern.  */
+/* `oblookup' stores the bucket number here, for the sake of Funintern.  */
 
 static size_t oblookup_last_bucket_number;
 
@@ -3909,7 +3882,7 @@ oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_I
   if (EQ (bucket, make_number (0)))
     ;
   else if (!SYMBOLP (bucket))
-    error ("Bad data in guts of obarray"); /* Like CADR error message */
+    error ("Bad data in guts of obarray"); /* Like CADR error message.  */
   else
     for (tail = bucket; ; XSETSYMBOL (tail, XSYMBOL (tail)->next))
       {
@@ -4016,7 +3989,7 @@ defsubr (struct Lisp_Subr *sname)
   XSETSUBR (XSYMBOL (sym)->function, sname);
 }
 
-#ifdef NOTDEF /* use fset in subr.el now */
+#ifdef NOTDEF /* Use fset in subr.el now!  */
 void
 defalias (struct Lisp_Subr *sname, char *string)
 {
@@ -4361,7 +4334,7 @@ dir_warning (const char *format, Lisp_Object dirname)
 {
   fprintf (stderr, format, SDATA (dirname));
 
-  /* Don't log the warning before we've initialized!! */
+  /* Don't log the warning before we've initialized!!  */
   if (initialized)
     {
       char *buffer;