Delete the autoloads for functions defined with ibuffer-specific commands.

[gnu-emacs] / src / print.c

diff --git a/src/print.c b/src/print.c
index 46943bcb3614c3ab2de392cd8704206ac29ab5d5..f0501bd0fb7a545b31a2aa46508b07fbfaea5306 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -1,5 +1,5 @@
 /* Lisp object printing and output streams.
 /* Lisp object printing and output streams.

-   Copyright (C) 1985, 86, 88, 93, 94, 95, 97, 98, 1999
+   Copyright (C) 1985, 86, 88, 93, 94, 95, 97, 98, 1999, 2000, 2001

        Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
        Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.


@@ -25,12 +25,12 @@ Boston, MA 02111-1307, USA.  */
 #include "lisp.h"
 #include "buffer.h"
 #include "charset.h"
 #include "lisp.h"
 #include "buffer.h"
 #include "charset.h"

+#include "keyboard.h"

 #include "frame.h"
 #include "window.h"
 #include "process.h"
 #include "dispextern.h"
 #include "termchar.h"
 #include "frame.h"
 #include "window.h"
 #include "process.h"
 #include "dispextern.h"
 #include "termchar.h"

-#include "keyboard.h"

 #include "intervals.h"
 
 Lisp_Object Vstandard_output, Qstandard_output;
 #include "intervals.h"
 
 Lisp_Object Vstandard_output, Qstandard_output;


@@ -40,7 +40,6 @@ Lisp_Object Qtemp_buffer_setup_hook;
 /* These are used to print like we read.  */
 extern Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
 
 /* These are used to print like we read.  */
 extern Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
 

-#ifdef LISP_FLOAT_TYPE

 Lisp_Object Vfloat_output_format, Qfloat_output_format;
 
 /* Work around a problem that happens because math.h on hpux 7
 Lisp_Object Vfloat_output_format, Qfloat_output_format;
 
 /* Work around a problem that happens because math.h on hpux 7


@@ -89,8 +88,6 @@ Lisp_Object Vfloat_output_format, Qfloat_output_format;
 #define DOUBLE_DIGITS_BOUND ((int) ceil (log10 (pow (FLT_RADIX, DBL_MANT_DIG))))
 #endif
 
 #define DOUBLE_DIGITS_BOUND ((int) ceil (log10 (pow (FLT_RADIX, DBL_MANT_DIG))))
 #endif
 

-#endif /* LISP_FLOAT_TYPE */
-

 /* Avoid actual stack overflow in print.  */
 int print_depth;
 
 /* Avoid actual stack overflow in print.  */
 int print_depth;
 


@@ -193,8 +190,8 @@ void print_interval ();
 
 #define PRINTDECLARE                                                   \
    struct buffer *old = current_buffer;                                        \
 
 #define PRINTDECLARE                                                   \
    struct buffer *old = current_buffer;                                        \

-   int old_point = -1, start_point;                                    \
-   int old_point_byte, start_point_byte;                               \
+   int old_point = -1, start_point = -1;                               \
+   int old_point_byte = -1, start_point_byte = -1;                     \

    int specpdl_count = specpdl_ptr - specpdl;                          \
    int free_print_buffer = 0;                                          \
    int multibyte = !NILP (current_buffer->enable_multibyte_characters);        \
    int specpdl_count = specpdl_ptr - specpdl;                          \
    int free_print_buffer = 0;                                          \
    int multibyte = !NILP (current_buffer->enable_multibyte_characters);        \


@@ -248,7 +245,7 @@ void print_interval ();
        print_buffer_pos = 0;                                           \
        print_buffer_pos_byte = 0;                                      \
      }                                                                 \
        print_buffer_pos = 0;                                           \
        print_buffer_pos_byte = 0;                                      \
      }                                                                 \

-   if (EQ (printcharfun, Qt))                                          \
+   if (EQ (printcharfun, Qt) && ! noninteractive)                      \

      setup_echo_area_for_printing (multibyte);
 
 #define PRINTFINISH                                                    \
      setup_echo_area_for_printing (multibyte);
 
 #define PRINTFINISH                                                    \


@@ -294,6 +291,7 @@ print_unwind (saved_text)
      Lisp_Object saved_text;
 {
   bcopy (XSTRING (saved_text)->data, print_buffer, XSTRING (saved_text)->size);
      Lisp_Object saved_text;
 {
   bcopy (XSTRING (saved_text)->data, print_buffer, XSTRING (saved_text)->size);

+  return Qnil;

 }
 
 
 }
 
 


@@ -316,9 +314,9 @@ printchar (ch, fun)
     call1 (fun, make_number (ch));
   else
     {
     call1 (fun, make_number (ch));
   else
     {

-      unsigned char work[4], *str;
-      int len = CHAR_STRING (ch, work, str);
-    
+      unsigned char str[MAX_MULTIBYTE_LENGTH];
+      int len = CHAR_STRING (ch, str);
+

       QUIT;
       
       if (NILP (fun))
       QUIT;
       
       if (NILP (fun))


@@ -340,9 +338,7 @@ printchar (ch, fun)
          int multibyte_p
            = !NILP (current_buffer->enable_multibyte_characters);
          
          int multibyte_p
            = !NILP (current_buffer->enable_multibyte_characters);
          

-         if (!message_buf_print)
-           setup_echo_area_for_printing (multibyte_p);
-
+         setup_echo_area_for_printing (multibyte_p);

          insert_char (ch);
          message_dolog (str, len, 0, multibyte_p);
        }
          insert_char (ch);
          message_dolog (str, len, 0, multibyte_p);
        }


@@ -399,15 +395,13 @@ strout (ptr, size, size_byte, printcharfun, multibyte)
       int multibyte_p
        = !NILP (current_buffer->enable_multibyte_characters);
       
       int multibyte_p
        = !NILP (current_buffer->enable_multibyte_characters);
       

-      if (!message_buf_print)
-       setup_echo_area_for_printing (multibyte_p);
-      
+      setup_echo_area_for_printing (multibyte_p);

       message_dolog (ptr, size_byte, 0, multibyte_p);
       
       if (size == size_byte)
        {
          for (i = 0; i < size; ++i)
       message_dolog (ptr, size_byte, 0, multibyte_p);
       
       if (size == size_byte)
        {
          for (i = 0; i < size; ++i)

-           insert_char (*ptr++);
+           insert_char ((unsigned char )*ptr++);

        }
       else
        {
        }
       else
        {


@@ -471,8 +465,23 @@ print_string (string, printcharfun)
       else if (EQ (printcharfun, Qt)
               ? ! NILP (buffer_defaults.enable_multibyte_characters)
               : ! NILP (current_buffer->enable_multibyte_characters))
       else if (EQ (printcharfun, Qt)
               ? ! NILP (buffer_defaults.enable_multibyte_characters)
               : ! NILP (current_buffer->enable_multibyte_characters))

-       chars = multibyte_chars_in_text (XSTRING (string)->data,
-                                        STRING_BYTES (XSTRING (string)));
+       {
+         /* If unibyte string STRING contains 8-bit codes, we must
+            convert STRING to a multibyte string containing the same
+            character codes.  */
+         Lisp_Object newstr;
+         int bytes;
+
+         chars = STRING_BYTES (XSTRING (string));
+         bytes = parse_str_to_multibyte (XSTRING (string)->data, chars);
+         if (chars < bytes)
+           {
+             newstr = make_uninit_multibyte_string (chars, bytes);
+             bcopy (XSTRING (string)->data, XSTRING (newstr)->data, chars);
+             str_to_multibyte (XSTRING (newstr)->data, bytes, chars);
+             string = newstr;
+           }
+       }

       else
        chars = STRING_BYTES (XSTRING (string));
 
       else
        chars = STRING_BYTES (XSTRING (string));
 


@@ -514,16 +523,16 @@ print_string (string, printcharfun)
 }
 \f
 DEFUN ("write-char", Fwrite_char, Swrite_char, 1, 2, 0,
 }
 \f
 DEFUN ("write-char", Fwrite_char, Swrite_char, 1, 2, 0,

-  "Output character CHARACTER to stream PRINTCHARFUN.\n\
-PRINTCHARFUN defaults to the value of `standard-output' (which see).")
-  (character, printcharfun)
+       doc: /* Output character CHARACTER to stream PRINTCHARFUN.
+PRINTCHARFUN defaults to the value of `standard-output' (which see).  */)
+     (character, printcharfun)

      Lisp_Object character, printcharfun;
 {
   PRINTDECLARE;
 
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
      Lisp_Object character, printcharfun;
 {
   PRINTDECLARE;
 
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;

-  CHECK_NUMBER (character, 0);
+  CHECK_NUMBER (character);

   PRINTPREPARE;
   PRINTCHAR (XINT (character));
   PRINTFINISH;
   PRINTPREPARE;
   PRINTCHAR (XINT (character));
   PRINTFINISH;


@@ -590,7 +599,7 @@ temp_output_buffer_setup (bufname)
   Ferase_buffer ();
   XSETBUFFER (buf, current_buffer);
 
   Ferase_buffer ();
   XSETBUFFER (buf, current_buffer);
 

-  call1 (Vrun_hooks, Qtemp_buffer_setup_hook);
+  Frun_hooks (1, &Qtemp_buffer_setup_hook);

 
   unbind_to (count, Qnil);
 
 
   unbind_to (count, Qnil);
 


@@ -622,25 +631,28 @@ internal_with_output_to_temp_buffer (bufname, function, args)
   return unbind_to (count, val);
 }
 
   return unbind_to (count, val);
 }
 

-DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer, Swith_output_to_temp_buffer,
+DEFUN ("with-output-to-temp-buffer",
+       Fwith_output_to_temp_buffer, Swith_output_to_temp_buffer,

        1, UNEVALLED, 0,
        1, UNEVALLED, 0,

-  "Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.\n\
-The buffer is cleared out initially, and marked as unmodified when done.\n\
-All output done by BODY is inserted in that buffer by default.\n\
-The buffer is displayed in another window, but not selected.\n\
-The value of the last form in BODY is returned.\n\
-If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\
-\n\
-The hook `temp-buffer-setup-hook' is run before BODY,\n\
-with the buffer BUFNAME temporarily current.\n\
-The hook `temp-buffer-show-hook' is run after the buffer is displayed,\n\
-with the buffer temporarily current, and the window that was used\n\
-to display it temporarily selected.\n\
-\n\
-If variable `temp-buffer-show-function' is non-nil, call it at the end\n\
-to get the buffer displayed instead of just displaying the non-selected\n\
-buffer and calling the hook.  It gets one argument, the buffer to display.")
-  (args)
+       doc: /* Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
+The buffer is cleared out initially, and marked as unmodified when done.
+All output done by BODY is inserted in that buffer by default.
+The buffer is displayed in another window, but not selected.
+The value of the last form in BODY is returned.
+If BODY does not finish normally, the buffer BUFNAME is not displayed.
+
+The hook `temp-buffer-setup-hook' is run before BODY,
+with the buffer BUFNAME temporarily current.
+The hook `temp-buffer-show-hook' is run after the buffer is displayed,
+with the buffer temporarily current, and the window that was used
+to display it temporarily selected.
+
+If variable `temp-buffer-show-function' is non-nil, call it at the end
+to get the buffer displayed instead of just displaying the non-selected
+buffer and calling the hook.  It gets one argument, the buffer to display.  
+
+usage: (with-output-to-temp-buffer BUFFNAME BODY ...)  */)
+     (args)

      Lisp_Object args;
 {
   struct gcpro gcpro1;
      Lisp_Object args;
 {
   struct gcpro gcpro1;


@@ -650,15 +662,16 @@ buffer and calling the hook.  It gets one argument, the buffer to display.")
 
   GCPRO1(args);
   name = Feval (Fcar (args));
 
   GCPRO1(args);
   name = Feval (Fcar (args));

-  UNGCPRO;
-
-  CHECK_STRING (name, 0);
+  CHECK_STRING (name);

   temp_output_buffer_setup (XSTRING (name)->data);
   buf = Vstandard_output;
   temp_output_buffer_setup (XSTRING (name)->data);
   buf = Vstandard_output;

+  UNGCPRO;

 
 

-  val = Fprogn (Fcdr (args));
+  val = Fprogn (XCDR (args));

 
 

+  GCPRO1 (val);

   temp_output_buffer_show (buf);
   temp_output_buffer_show (buf);

+  UNGCPRO;

 
   return unbind_to (count, val);
 }
 
   return unbind_to (count, val);
 }


@@ -670,8 +683,8 @@ static void print_preprocess_string ();
 static void print_object ();
 
 DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
 static void print_object ();
 
 DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,

-  "Output a newline to stream PRINTCHARFUN.\n\
-If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.")
+       doc: /* Output a newline to stream PRINTCHARFUN.
+If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.  */)

   (printcharfun)
      Lisp_Object printcharfun;
 {
   (printcharfun)
      Lisp_Object printcharfun;
 {


@@ -686,11 +699,29 @@ If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.")
 }
 
 DEFUN ("prin1", Fprin1, Sprin1, 1, 2, 0,
 }
 
 DEFUN ("prin1", Fprin1, Sprin1, 1, 2, 0,

-  "Output the printed representation of OBJECT, any Lisp object.\n\
-Quoting characters are printed when needed to make output that `read'\n\
-can handle, whenever this is possible.\n\
-Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
-  (object, printcharfun)
+       doc: /* Output the printed representation of OBJECT, any Lisp object.
+Quoting characters are printed when needed to make output that `read'
+can handle, whenever this is possible.  For complex objects, the behavior
+is controlled by `print-level' and `print-length', which see.
+
+OBJECT is any of the Lisp data types: a number, a string, a symbol,
+a list, a buffer, a window, a frame, etc.
+
+A printed representation of an object is text which describes that object.
+
+Optional argument PRINTCHARFUN is the output stream, which can be one
+of these:
+
+   - a buffer, in which case output is inserted into that buffer at point;
+   - a marker, in which case output is inserted at marker's position;
+   - a function, in which case that function is called once for each
+     character of OBJECT's printed representation;
+   - a symbol, in which case that symbol's function definition is called; or
+   - t, in which case the output is displayed in the echo area.
+
+If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
+is used instead.  */)
+     (object, printcharfun)

      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;
      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;


@@ -710,11 +741,16 @@ Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
 Lisp_Object Vprin1_to_string_buffer;
 
 DEFUN ("prin1-to-string", Fprin1_to_string, Sprin1_to_string, 1, 2, 0,
 Lisp_Object Vprin1_to_string_buffer;
 
 DEFUN ("prin1-to-string", Fprin1_to_string, Sprin1_to_string, 1, 2, 0,

-  "Return a string containing the printed representation of OBJECT,\n\
-any Lisp object.  Quoting characters are used when needed to make output\n\
-that `read' can handle, whenever this is possible, unless the optional\n\
-second argument NOESCAPE is non-nil.")
-  (object, noescape)
+       doc: /* Return a string containing the printed representation of OBJECT.
+OBJECT can be any Lisp object.  This function outputs quoting characters
+when necessary to make output that `read' can handle, whenever possible,
+unless the optional second argument NOESCAPE is non-nil.
+
+OBJECT is any of the Lisp data types: a number, a string, a symbol,
+a list, a buffer, a window, a frame, etc.
+
+A printed representation of an object is text which describes that object.  */)
+     (object, noescape)

      Lisp_Object object, noescape;
 {
   PRINTDECLARE;
      Lisp_Object object, noescape;
 {
   PRINTDECLARE;


@@ -746,11 +782,28 @@ second argument NOESCAPE is non-nil.")
 }
 
 DEFUN ("princ", Fprinc, Sprinc, 1, 2, 0,
 }
 
 DEFUN ("princ", Fprinc, Sprinc, 1, 2, 0,

-  "Output the printed representation of OBJECT, any Lisp object.\n\
-No quoting characters are used; no delimiters are printed around\n\
-the contents of strings.\n\
-Output stream is PRINTCHARFUN, or value of standard-output (which see).")
-  (object, printcharfun)
+       doc: /* Output the printed representation of OBJECT, any Lisp object.
+No quoting characters are used; no delimiters are printed around
+the contents of strings.
+
+OBJECT is any of the Lisp data types: a number, a string, a symbol,
+a list, a buffer, a window, a frame, etc.
+
+A printed representation of an object is text which describes that object.
+
+Optional argument PRINTCHARFUN is the output stream, which can be one
+of these:
+
+   - a buffer, in which case output is inserted into that buffer at point;
+   - a marker, in which case output is inserted at marker's position;
+   - a function, in which case that function is called once for each
+     character of OBJECT's printed representation;
+   - a symbol, in which case that symbol's function definition is called; or
+   - t, in which case the output is displayed in the echo area.
+
+If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
+is used instead.  */)
+     (object, printcharfun)

      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;
      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;


@@ -764,11 +817,29 @@ Output stream is PRINTCHARFUN, or value of standard-output (which see).")
 }
 
 DEFUN ("print", Fprint, Sprint, 1, 2, 0,
 }
 
 DEFUN ("print", Fprint, Sprint, 1, 2, 0,

-  "Output the printed representation of OBJECT, with newlines around it.\n\
-Quoting characters are printed when needed to make output that `read'\n\
-can handle, whenever this is possible.\n\
-Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
-  (object, printcharfun)
+       doc: /* Output the printed representation of OBJECT, with newlines around it.
+Quoting characters are printed when needed to make output that `read'
+can handle, whenever this is possible.  For complex objects, the behavior
+is controlled by `print-level' and `print-length', which see.
+
+OBJECT is any of the Lisp data types: a number, a string, a symbol,
+a list, a buffer, a window, a frame, etc.
+
+A printed representation of an object is text which describes that object.
+
+Optional argument PRINTCHARFUN is the output stream, which can be one
+of these:
+
+   - a buffer, in which case output is inserted into that buffer at point;
+   - a marker, in which case output is inserted at marker's position;
+   - a function, in which case that function is called once for each
+     character of OBJECT's printed representation;
+   - a symbol, in which case that symbol's function definition is called; or
+   - t, in which case the output is displayed in the echo area.
+
+If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
+is used instead.  */)
+     (object, printcharfun)

      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;
      Lisp_Object object, printcharfun;
 {
   PRINTDECLARE;


@@ -799,13 +870,13 @@ Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
 Lisp_Object Qexternal_debugging_output;
 
 DEFUN ("external-debugging-output", Fexternal_debugging_output, Sexternal_debugging_output, 1, 1, 0,
 Lisp_Object Qexternal_debugging_output;
 
 DEFUN ("external-debugging-output", Fexternal_debugging_output, Sexternal_debugging_output, 1, 1, 0,

-  "Write CHARACTER to stderr.\n\
-You can call print while debugging emacs, and pass it this function\n\
-to make it write to the debugging output.\n")
-  (character)
+       doc: /* Write CHARACTER to stderr.
+You can call print while debugging emacs, and pass it this function
+to make it write to the debugging output.  */)
+     (character)

      Lisp_Object character;
 {
      Lisp_Object character;
 {

-  CHECK_NUMBER (character, 0);
+  CHECK_NUMBER (character);

   putc (XINT (character), stderr);
 
 #ifdef WINDOWSNT
   putc (XINT (character), stderr);
 
 #ifdef WINDOWSNT


@@ -831,8 +902,8 @@ debug_print (arg)
 \f
 DEFUN ("error-message-string", Ferror_message_string, Serror_message_string,
        1, 1, 0,
 \f
 DEFUN ("error-message-string", Ferror_message_string, Serror_message_string,
        1, 1, 0,

-  "Convert an error value (ERROR-SYMBOL . DATA) to an error message.")
-  (obj)
+       doc: /* Convert an error value (ERROR-SYMBOL . DATA) to an error message.  */)
+     (obj)

      Lisp_Object obj;
 {
   struct buffer *old = current_buffer;
      Lisp_Object obj;
 {
   struct buffer *old = current_buffer;


@@ -861,8 +932,8 @@ DEFUN ("error-message-string", Ferror_message_string, Serror_message_string,
   return value;
 }
 
   return value;
 }
 

-/* Print an error message for the error DATA
-   onto Lisp output stream STREAM (suitable for the print functions).  */
+/* Print an error message for the error DATA onto Lisp output stream
+   STREAM (suitable for the print functions).  */

 
 void
 print_error_message (data, stream)
 
 void
 print_error_message (data, stream)


@@ -877,15 +948,17 @@ print_error_message (data, stream)
   if (EQ (errname, Qerror))
     {
       data = Fcdr (data);
   if (EQ (errname, Qerror))
     {
       data = Fcdr (data);

-      if (!CONSP (data)) data = Qnil;
+      if (!CONSP (data))
+       data = Qnil;

       errmsg = Fcar (data);
       file_error = Qnil;
     }
   else
     {
       errmsg = Fcar (data);
       file_error = Qnil;
     }
   else
     {

+      Lisp_Object error_conditions;

       errmsg = Fget (errname, Qerror_message);
       errmsg = Fget (errname, Qerror_message);

-      file_error = Fmemq (Qfile_error,
-                         Fget (errname, Qerror_conditions));
+      error_conditions = Fget (errname, Qerror_conditions);
+      file_error = Fmemq (Qfile_error, error_conditions);

     }
 
   /* Print an error message including the data items.  */
     }
 
   /* Print an error message including the data items.  */


@@ -893,6 +966,16 @@ print_error_message (data, stream)
   tail = Fcdr_safe (data);
   GCPRO1 (tail);
 
   tail = Fcdr_safe (data);
   GCPRO1 (tail);
 

+  /* If we know from where the error was signaled, show it in
+     *Messages*.  */
+  if (!NILP (Vsignaling_function) && SYMBOLP (Vsignaling_function))
+    {
+      char *name = XSYMBOL (Vsignaling_function)->name->data;
+      message_dolog (name, strlen (name), 0, 0);
+      message_dolog (": ", 2, 0, 0);
+      Vsignaling_function = Qnil;
+    }
+

   /* For file-error, make error message by concatenating
      all the data items.  They are all strings.  */
   if (!NILP (file_error) && CONSP (tail))
   /* For file-error, make error message by concatenating
      all the data items.  They are all strings.  */
   if (!NILP (file_error) && CONSP (tail))


@@ -903,19 +986,23 @@ print_error_message (data, stream)
   else
     write_string_1 ("peculiar error", -1, stream);
 
   else
     write_string_1 ("peculiar error", -1, stream);
 

-  for (i = 0; CONSP (tail); tail = Fcdr (tail), i++)
+  for (i = 0; CONSP (tail); tail = XCDR (tail), i++)

     {
     {

+      Lisp_Object obj;
+

       write_string_1 (i ? ", " : ": ", 2, stream);
       write_string_1 (i ? ", " : ": ", 2, stream);

-      if (!NILP (file_error))
-       Fprinc (Fcar (tail), stream);
+      obj = XCAR (tail);
+      if (!NILP (file_error) || EQ (errname, Qend_of_file))
+       Fprinc (obj, stream);

       else
       else

-       Fprin1 (Fcar (tail), stream);
+       Fprin1 (obj, stream);

     }
     }

+  

   UNGCPRO;
 }
   UNGCPRO;
 }

-\f
-#ifdef LISP_FLOAT_TYPE

 
 

+
+\f

 /*
  * The buffer should be at least as large as the max string size of the
  * largest float, printed in the biggest notation.  This is undoubtedly
 /*
  * The buffer should be at least as large as the max string size of the
  * largest float, printed in the biggest notation.  This is undoubtedly


@@ -1053,7 +1140,7 @@ float_to_string (buf, data)
        }
     }
 }
        }
     }
 }

-#endif /* LISP_FLOAT_TYPE */
+

 \f
 static void
 print (obj, printcharfun, escapeflag)
 \f
 static void
 print (obj, printcharfun, escapeflag)


@@ -1115,14 +1202,15 @@ print_preprocess (obj)
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
       || COMPILEDP (obj) || CHAR_TABLE_P (obj)
       || (! NILP (Vprint_gensym)
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
       || COMPILEDP (obj) || CHAR_TABLE_P (obj)
       || (! NILP (Vprint_gensym)

-         && SYMBOLP (obj) && NILP (XSYMBOL (obj)->obarray)))
+         && SYMBOLP (obj)
+         && !SYMBOL_INTERNED_P (obj)))

     {
       /* In case print-circle is nil and print-gensym is t,
         add OBJ to Vprint_number_table only when OBJ is a symbol.  */
       if (! NILP (Vprint_circle) || SYMBOLP (obj))
        {
          for (i = 0; i < print_number_index; i++)
     {
       /* In case print-circle is nil and print-gensym is t,
         add OBJ to Vprint_number_table only when OBJ is a symbol.  */
       if (! NILP (Vprint_circle) || SYMBOLP (obj))
        {
          for (i = 0; i < print_number_index; i++)

-           if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+           if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table, i), obj))

              {
                /* OBJ appears more than once.  Let's remember that.  */
                PRINT_NUMBER_STATUS (Vprint_number_table, i) = Qt;
              {
                /* OBJ appears more than once.  Let's remember that.  */
                PRINT_NUMBER_STATUS (Vprint_number_table, i) = Qt;


@@ -1153,8 +1241,9 @@ print_preprocess (obj)
          /* If Vprint_continuous_numbering is non-nil and OBJ is a gensym,
             always print the gensym with a number.  This is a special for
             the lisp function byte-compile-output-docform.  */
          /* If Vprint_continuous_numbering is non-nil and OBJ is a gensym,
             always print the gensym with a number.  This is a special for
             the lisp function byte-compile-output-docform.  */

-         if (! NILP (Vprint_continuous_numbering) && SYMBOLP (obj)
-             && NILP (XSYMBOL (obj)->obarray))
+         if (!NILP (Vprint_continuous_numbering)
+             && SYMBOLP (obj)
+             && !SYMBOL_INTERNED_P (obj))

            PRINT_NUMBER_STATUS (Vprint_number_table, print_number_index) = Qt;
          print_number_index++;
        }
            PRINT_NUMBER_STATUS (Vprint_number_table, print_number_index) = Qt;
          print_number_index++;
        }


@@ -1163,8 +1252,8 @@ print_preprocess (obj)
        {
        case Lisp_String:
          /* A string may have text properties, which can be circular.  */
        {
        case Lisp_String:
          /* A string may have text properties, which can be circular.  */

-         traverse_intervals (XSTRING (obj)->intervals, 0, 0,
-                             print_preprocess_string, Qnil);
+         traverse_intervals_noorder (XSTRING (obj)->intervals,
+                                     print_preprocess_string, Qnil);

          break;
 
        case Lisp_Cons:
          break;
 
        case Lisp_Cons:


@@ -1176,6 +1265,10 @@ print_preprocess (obj)
          size = XVECTOR (obj)->size & PSEUDOVECTOR_SIZE_MASK;
          for (i = 0; i < size; i++)
            print_preprocess (XVECTOR (obj)->contents[i]);
          size = XVECTOR (obj)->size & PSEUDOVECTOR_SIZE_MASK;
          for (i = 0; i < size; i++)
            print_preprocess (XVECTOR (obj)->contents[i]);

+         break;
+
+       default:
+         break;

        }
     }
 }
        }
     }
 }


@@ -1202,7 +1295,8 @@ print_object (obj, printcharfun, escapeflag)
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
       || COMPILEDP (obj) || CHAR_TABLE_P (obj)
       || (! NILP (Vprint_gensym)
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
       || COMPILEDP (obj) || CHAR_TABLE_P (obj)
       || (! NILP (Vprint_gensym)

-         && SYMBOLP (obj) && NILP (XSYMBOL (obj)->obarray)))
+         && SYMBOLP (obj)
+         && !SYMBOL_INTERNED_P (obj)))

     {
       if (NILP (Vprint_circle) && NILP (Vprint_gensym))
        {
     {
       if (NILP (Vprint_circle) && NILP (Vprint_gensym))
        {


@@ -1222,7 +1316,7 @@ print_object (obj, printcharfun, escapeflag)
          /* With the print-circle feature.  */
          int i;
          for (i = 0; i < print_number_index; i++)
          /* With the print-circle feature.  */
          int i;
          for (i = 0; i < print_number_index; i++)

-           if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+           if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table, i), obj))

              {
                if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
                  {
              {
                if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
                  {


@@ -1269,7 +1363,6 @@ print_object (obj, printcharfun, escapeflag)
       strout (buf, -1, -1, printcharfun, 0);
       break;
 
       strout (buf, -1, -1, printcharfun, 0);
       break;
 

-#ifdef LISP_FLOAT_TYPE

     case Lisp_Float:
       {
        char pigbuf[350];       /* see comments in float_to_string */
     case Lisp_Float:
       {
        char pigbuf[350];       /* see comments in float_to_string */


@@ -1278,7 +1371,6 @@ print_object (obj, printcharfun, escapeflag)
        strout (pigbuf, -1, -1, printcharfun, 0);
       }
       break;
        strout (pigbuf, -1, -1, printcharfun, 0);
       }
       break;

-#endif

 
     case Lisp_String:
       if (!escapeflag)
 
     case Lisp_String:
       if (!escapeflag)


@@ -1292,6 +1384,7 @@ print_object (obj, printcharfun, escapeflag)
          /* 1 means we must ensure that the next character we output
             cannot be taken as part of a hex character escape.  */
          int need_nonhex = 0;
          /* 1 means we must ensure that the next character we output
             cannot be taken as part of a hex character escape.  */
          int need_nonhex = 0;

+         int multibyte = STRING_MULTIBYTE (obj);

 
          GCPRO1 (obj);
 
 
          GCPRO1 (obj);
 


@@ -1312,7 +1405,7 @@ print_object (obj, printcharfun, escapeflag)
              int len;
              int c;
 
              int len;
              int c;
 

-             if (STRING_MULTIBYTE (obj))
+             if (multibyte)

                {
                  c = STRING_CHAR_AND_LENGTH (str + i_byte,
                                              size_byte - i_byte, len);
                {
                  c = STRING_CHAR_AND_LENGTH (str + i_byte,
                                              size_byte - i_byte, len);


@@ -1336,7 +1429,8 @@ print_object (obj, printcharfun, escapeflag)
                  PRINTCHAR ('\\');
                  PRINTCHAR ('f');
                }
                  PRINTCHAR ('\\');
                  PRINTCHAR ('f');
                }

-             else if (! SINGLE_BYTE_CHAR_P (c) && print_escape_multibyte)
+             else if (multibyte && ! ASCII_BYTE_P (c)
+                      && print_escape_multibyte)

                {
                  /* When multibyte is disabled,
                     print multibyte string chars using hex escapes.  */
                {
                  /* When multibyte is disabled,
                     print multibyte string chars using hex escapes.  */


@@ -1345,7 +1439,8 @@ print_object (obj, printcharfun, escapeflag)
                  strout (outbuf, -1, -1, printcharfun, 0);
                  need_nonhex = 1;
                }
                  strout (outbuf, -1, -1, printcharfun, 0);
                  need_nonhex = 1;
                }

-             else if (SINGLE_BYTE_CHAR_P (c) && ! ASCII_BYTE_P (c)
+             else if (! multibyte
+                      && SINGLE_BYTE_CHAR_P (c) && ! ASCII_BYTE_P (c)

                       && print_escape_nonascii)
                {
                  /* When printing in a multibyte buffer
                       && print_escape_nonascii)
                {
                  /* When printing in a multibyte buffer


@@ -1380,7 +1475,7 @@ print_object (obj, printcharfun, escapeflag)
          if (!NULL_INTERVAL_P (XSTRING (obj)->intervals))
            {
              traverse_intervals (XSTRING (obj)->intervals,
          if (!NULL_INTERVAL_P (XSTRING (obj)->intervals))
            {
              traverse_intervals (XSTRING (obj)->intervals,

-                                 0, 0, print_interval, printcharfun);
+                                 0, print_interval, printcharfun);

              PRINTCHAR (')');
            }
 
              PRINTCHAR (')');
            }
 


@@ -1421,7 +1516,7 @@ print_object (obj, printcharfun, escapeflag)
        else
          confusing = 0;
 
        else
          confusing = 0;
 

-       if (! NILP (Vprint_gensym) && NILP (XSYMBOL (obj)->obarray))
+       if (! NILP (Vprint_gensym) && !SYMBOL_INTERNED_P (obj))

          {
            PRINTCHAR ('#');
            PRINTCHAR (':');
          {
            PRINTCHAR ('#');
            PRINTCHAR (':');


@@ -1433,12 +1528,7 @@ print_object (obj, printcharfun, escapeflag)
          {
            /* Here, we must convert each multi-byte form to the
               corresponding character code before handing it to PRINTCHAR.  */
          {
            /* Here, we must convert each multi-byte form to the
               corresponding character code before handing it to PRINTCHAR.  */

-
-           if (STRING_MULTIBYTE (name))
-             FETCH_STRING_CHAR_ADVANCE (c, name, i, i_byte);
-           else
-             c = XSTRING (name)->data[i_byte++];
-
+           FETCH_STRING_CHAR_ADVANCE (c, name, i, i_byte);

            QUIT;
 
            if (escapeflag)
            QUIT;
 
            if (escapeflag)


@@ -1486,12 +1576,17 @@ print_object (obj, printcharfun, escapeflag)
        {
          PRINTCHAR ('(');
          {
        {
          PRINTCHAR ('(');
          {

-           register int i = 0;
-           register int print_length = 0;
+           int print_length, i;

            Lisp_Object halftail = obj;
 
            Lisp_Object halftail = obj;
 

-           if (INTEGERP (Vprint_length))
-             print_length = XINT (Vprint_length);
+           /* Negative values of print-length are invalid in CL.
+              Treat them like nil, as CMUCL does.  */
+           if (NATNUMP (Vprint_length))
+             print_length = XFASTINT (Vprint_length);
+           else
+             print_length = 0;
+
+           i = 0;

            while (CONSP (obj))
              {
                /* Detect circular list.  */
            while (CONSP (obj))
              {
                /* Detect circular list.  */


@@ -1512,7 +1607,8 @@ print_object (obj, printcharfun, escapeflag)
                      {
                        int i;
                        for (i = 0; i < print_number_index; i++)
                      {
                        int i;
                        for (i = 0; i < print_number_index; i++)

-                         if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+                         if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table, i),
+                                 obj))

                            {
                              if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
                                {
                            {
                              if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
                                {


@@ -1528,24 +1624,31 @@ print_object (obj, printcharfun, escapeflag)
                            }
                      }
                  }
                            }
                      }
                  }

+               

                if (i++)
                  PRINTCHAR (' ');
                if (i++)
                  PRINTCHAR (' ');

+               

                if (print_length && i > print_length)
                  {
                    strout ("...", 3, 3, printcharfun, 0);
                    goto end_of_list;
                  }
                if (print_length && i > print_length)
                  {
                    strout ("...", 3, 3, printcharfun, 0);
                    goto end_of_list;
                  }

+               

                print_object (XCAR (obj), printcharfun, escapeflag);
                print_object (XCAR (obj), printcharfun, escapeflag);

+               

                obj = XCDR (obj);
                if (!(i & 1))
                  halftail = XCDR (halftail);
              }
          }
                obj = XCDR (obj);
                if (!(i & 1))
                  halftail = XCDR (halftail);
              }
          }

+
+         /* OBJ non-nil here means it's the end of a dotted list.  */

          if (!NILP (obj))
            {
              strout (" . ", 3, 3, printcharfun, 0);
              print_object (obj, printcharfun, escapeflag);
            }
          if (!NILP (obj))
            {
              strout (" . ", 3, 3, printcharfun, 0);
              print_object (obj, printcharfun, escapeflag);
            }

+         

        end_of_list:
          PRINTCHAR (')');
        }
        end_of_list:
          PRINTCHAR (')');
        }


@@ -1579,10 +1682,12 @@ print_object (obj, printcharfun, escapeflag)
          strout (buf, -1, -1, printcharfun, 0);
          PRINTCHAR ('\"');
 
          strout (buf, -1, -1, printcharfun, 0);
          PRINTCHAR ('\"');
 

-         /* Don't print more characters than the specified maximum.  */
-         if (INTEGERP (Vprint_length)
-             && XINT (Vprint_length) < size_in_chars)
-           size_in_chars = XINT (Vprint_length);
+         /* Don't print more characters than the specified maximum.
+            Negative values of print-length are invalid.  Treat them
+            like a print-length of nil.  */
+         if (NATNUMP (Vprint_length)
+             && XFASTINT (Vprint_length) < size_in_chars)
+           size_in_chars = XFASTINT (Vprint_length);

 
          for (i = 0; i < size_in_chars; i++)
            {
 
          for (i = 0; i < size_in_chars; i++)
            {


@@ -1700,11 +1805,12 @@ print_object (obj, printcharfun, escapeflag)
          {
            register int i;
            register Lisp_Object tem;
          {
            register int i;
            register Lisp_Object tem;

+           int real_size = size;

 
            /* Don't print more elements than the specified maximum.  */
 
            /* Don't print more elements than the specified maximum.  */

-           if (INTEGERP (Vprint_length)
-               && XINT (Vprint_length) < size)
-             size = XINT (Vprint_length);
+           if (NATNUMP (Vprint_length)
+               && XFASTINT (Vprint_length) < size)
+             size = XFASTINT (Vprint_length);

 
            for (i = 0; i < size; i++)
              {
 
            for (i = 0; i < size; i++)
              {


@@ -1712,6 +1818,8 @@ print_object (obj, printcharfun, escapeflag)
                tem = XVECTOR (obj)->contents[i];
                print_object (tem, printcharfun, escapeflag);
              }
                tem = XVECTOR (obj)->contents[i];
                print_object (tem, printcharfun, escapeflag);
              }

+           if (size < real_size)
+             strout (" ...", 4, 4, printcharfun, 0);

          }
          PRINTCHAR (']');
        }
          }
          PRINTCHAR (']');
        }


@@ -1724,7 +1832,7 @@ print_object (obj, printcharfun, escapeflag)
          strout ("#<marker ", -1, -1, printcharfun, 0);
          /* Do you think this is necessary?  */
          if (XMARKER (obj)->insertion_type != 0)
          strout ("#<marker ", -1, -1, printcharfun, 0);
          /* Do you think this is necessary?  */
          if (XMARKER (obj)->insertion_type != 0)

-           strout ("(before-insertion) ", -1, -1, printcharfun, 0);
+           strout ("(moves after insertion) ", -1, -1, printcharfun, 0);

          if (!(XMARKER (obj)->buffer))
            strout ("in no buffer", -1, -1, printcharfun, 0);
          else
          if (!(XMARKER (obj)->buffer))
            strout ("in no buffer", -1, -1, printcharfun, 0);
          else


@@ -1778,9 +1886,9 @@ print_object (obj, printcharfun, escapeflag)
 
        case Lisp_Misc_Buffer_Objfwd:
          strout ("#<buffer_objfwd to ", -1, -1, printcharfun, 0);
 
        case Lisp_Misc_Buffer_Objfwd:
          strout ("#<buffer_objfwd to ", -1, -1, printcharfun, 0);

-         print_object (*(Lisp_Object *)((char *)current_buffer
-                                        + XBUFFER_OBJFWD (obj)->offset),
-                printcharfun, escapeflag);
+         print_object (PER_BUFFER_VALUE (current_buffer,
+                                         XBUFFER_OBJFWD (obj)->offset),
+                       printcharfun, escapeflag);

          PRINTCHAR ('>');
          break;
 
          PRINTCHAR ('>');
          break;
 


@@ -1788,7 +1896,7 @@ print_object (obj, printcharfun, escapeflag)
          strout ("#<kboard_objfwd to ", -1, -1, printcharfun, 0);
          print_object (*(Lisp_Object *)((char *) current_kboard
                                         + XKBOARD_OBJFWD (obj)->offset),
          strout ("#<kboard_objfwd to ", -1, -1, printcharfun, 0);
          print_object (*(Lisp_Object *)((char *) current_kboard
                                         + XKBOARD_OBJFWD (obj)->offset),

-                printcharfun, escapeflag);
+                       printcharfun, escapeflag);

          PRINTCHAR ('>');
          break;
 
          PRINTCHAR ('>');
          break;
 


@@ -1877,100 +1985,103 @@ syms_of_print ()
   staticpro (&Qtemp_buffer_setup_hook);
 
   DEFVAR_LISP ("standard-output", &Vstandard_output,
   staticpro (&Qtemp_buffer_setup_hook);
 
   DEFVAR_LISP ("standard-output", &Vstandard_output,

-    "Output stream `print' uses by default for outputting a character.\n\
-This may be any function of one argument.\n\
-It may also be a buffer (output is inserted before point)\n\
-or a marker (output is inserted and the marker is advanced)\n\
-or the symbol t (output appears in the echo area).");
+              doc: /* Output stream `print' uses by default for outputting a character.
+This may be any function of one argument.
+It may also be a buffer (output is inserted before point)
+or a marker (output is inserted and the marker is advanced)
+or the symbol t (output appears in the echo area).  */);

   Vstandard_output = Qt;
   Qstandard_output = intern ("standard-output");
   staticpro (&Qstandard_output);
 
   Vstandard_output = Qt;
   Qstandard_output = intern ("standard-output");
   staticpro (&Qstandard_output);
 

-#ifdef LISP_FLOAT_TYPE

   DEFVAR_LISP ("float-output-format", &Vfloat_output_format,
   DEFVAR_LISP ("float-output-format", &Vfloat_output_format,

-    "The format descriptor string used to print floats.\n\
-This is a %-spec like those accepted by `printf' in C,\n\
-but with some restrictions.  It must start with the two characters `%.'.\n\
-After that comes an integer precision specification,\n\
-and then a letter which controls the format.\n\
-The letters allowed are `e', `f' and `g'.\n\
-Use `e' for exponential notation \"DIG.DIGITSeEXPT\"\n\
-Use `f' for decimal point notation \"DIGITS.DIGITS\".\n\
-Use `g' to choose the shorter of those two formats for the number at hand.\n\
-The precision in any of these cases is the number of digits following\n\
-the decimal point.  With `f', a precision of 0 means to omit the\n\
-decimal point.  0 is not allowed with `e' or `g'.\n\n\
-A value of nil means to use the shortest notation\n\
-that represents the number without losing information.");
+              doc: /* The format descriptor string used to print floats.
+This is a %-spec like those accepted by `printf' in C,
+but with some restrictions.  It must start with the two characters `%.'.
+After that comes an integer precision specification,
+and then a letter which controls the format.
+The letters allowed are `e', `f' and `g'.
+Use `e' for exponential notation \"DIG.DIGITSeEXPT\"
+Use `f' for decimal point notation \"DIGITS.DIGITS\".
+Use `g' to choose the shorter of those two formats for the number at hand.
+The precision in any of these cases is the number of digits following
+the decimal point.  With `f', a precision of 0 means to omit the
+decimal point.  0 is not allowed with `e' or `g'.
+
+A value of nil means to use the shortest notation
+that represents the number without losing information.  */);

   Vfloat_output_format = Qnil;
   Qfloat_output_format = intern ("float-output-format");
   staticpro (&Qfloat_output_format);
   Vfloat_output_format = Qnil;
   Qfloat_output_format = intern ("float-output-format");
   staticpro (&Qfloat_output_format);

-#endif /* LISP_FLOAT_TYPE */

 
   DEFVAR_LISP ("print-length", &Vprint_length,
 
   DEFVAR_LISP ("print-length", &Vprint_length,

-    "Maximum length of list to print before abbreviating.\n\
-A value of nil means no limit.");
+              doc: /* Maximum length of list to print before abbreviating.
+A value of nil means no limit.  See also `eval-expression-print-length'.  */);

   Vprint_length = Qnil;
 
   DEFVAR_LISP ("print-level", &Vprint_level,
   Vprint_length = Qnil;
 
   DEFVAR_LISP ("print-level", &Vprint_level,

-    "Maximum depth of list nesting to print before abbreviating.\n\
-A value of nil means no limit.");
+              doc: /* Maximum depth of list nesting to print before abbreviating.
+A value of nil means no limit.  See also `eval-expression-print-level'.  */);

   Vprint_level = Qnil;
 
   DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines,
   Vprint_level = Qnil;
 
   DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines,

-    "Non-nil means print newlines in strings as backslash-n.\n\
-Also print formfeeds as backslash-f.");
+              doc: /* Non-nil means print newlines in strings as `\\n'.
+Also print formfeeds as `\\f'.  */);

   print_escape_newlines = 0;
 
   DEFVAR_BOOL ("print-escape-nonascii", &print_escape_nonascii,
   print_escape_newlines = 0;
 
   DEFVAR_BOOL ("print-escape-nonascii", &print_escape_nonascii,

-    "Non-nil means print unibyte non-ASCII chars in strings as \\OOO.\n\
-\(OOO is the octal representation of the character code.)\n\
-Only single-byte characters are affected, and only in `prin1'.");
+              doc: /* Non-nil means print unibyte non-ASCII chars in strings as \\OOO.
+\(OOO is the octal representation of the character code.)
+Only single-byte characters are affected, and only in `prin1'.  */);

   print_escape_nonascii = 0;
 
   DEFVAR_BOOL ("print-escape-multibyte", &print_escape_multibyte,
   print_escape_nonascii = 0;
 
   DEFVAR_BOOL ("print-escape-multibyte", &print_escape_multibyte,

-    "Non-nil means print multibyte characters in strings as \\xXXXX.\n\
-\(XXX is the hex representation of the character code.)\n\
-This affects only `prin1'.");
+              doc: /* Non-nil means print multibyte characters in strings as \\xXXXX.
+\(XXXX is the hex representation of the character code.)
+This affects only `prin1'.  */);

   print_escape_multibyte = 0;
 
   DEFVAR_BOOL ("print-quoted", &print_quoted,
   print_escape_multibyte = 0;
 
   DEFVAR_BOOL ("print-quoted", &print_quoted,

-    "Non-nil means print quoted forms with reader syntax.\n\
-I.e., (quote foo) prints as 'foo, (function foo) as #'foo, and, backquoted\n\
-forms print in the new syntax.");
+              doc: /* Non-nil means print quoted forms with reader syntax.
+I.e., (quote foo) prints as 'foo, (function foo) as #'foo, and backquoted
+forms print as in the new syntax.  */);

   print_quoted = 0;
 
   DEFVAR_LISP ("print-gensym", &Vprint_gensym,
   print_quoted = 0;
 
   DEFVAR_LISP ("print-gensym", &Vprint_gensym,

-    "Non-nil means print uninterned symbols so they will read as uninterned.\n\
-I.e., the value of (make-symbol \"foobar\") prints as #:foobar.\n\
-When the uninterned symbol appears within a recursive data structure\n\
-and the symbol appears more than once, in addition use the #N# and #N=\n\
-constructs as needed, so that multiple references to the same symbol are\n\
-shared once again when the text is read back.");
+              doc: /* Non-nil means print uninterned symbols so they will read as uninterned.
+I.e., the value of (make-symbol \"foobar\") prints as #:foobar.
+When the uninterned symbol appears within a recursive data structure,
+and the symbol appears more than once, in addition use the #N# and #N=
+constructs as needed, so that multiple references to the same symbol are
+shared once again when the text is read back.  */);

   Vprint_gensym = Qnil;
 
   DEFVAR_LISP ("print-circle", &Vprint_circle,
   Vprint_gensym = Qnil;
 
   DEFVAR_LISP ("print-circle", &Vprint_circle,

-    "*Non-nil means print recursive structures using #N= and #N# syntax.\n\
-If nil, printing proceeds recursively and may lead to\n\
-`max-lisp-eval-depth' being exceeded or an error may occur:\n\
-\"Apparently circular structure being printed.\"  Also see\n\
-`print-length' and `print-level'.\n\
-If non-nil, shared substructures anywhere in the structure are printed\n\
-with `#N=' before the first occurrence (in the order of the print\n\
-representation) and `#N#' in place of each subsequent occurrence,\n\
-where N is a positive decimal integer.");
+              doc: /* *Non-nil means print recursive structures using #N= and #N# syntax.
+If nil, printing proceeds recursively and may lead to
+`max-lisp-eval-depth' being exceeded or an error may occur:
+\"Apparently circular structure being printed.\"  Also see
+`print-length' and `print-level'.
+If non-nil, shared substructures anywhere in the structure are printed
+with `#N=' before the first occurrence (in the order of the print
+representation) and `#N#' in place of each subsequent occurrence,
+where N is a positive decimal integer.  */);

   Vprint_circle = Qnil;
 
   DEFVAR_LISP ("print-continuous-numbering", &Vprint_continuous_numbering,
   Vprint_circle = Qnil;
 
   DEFVAR_LISP ("print-continuous-numbering", &Vprint_continuous_numbering,

-  "*Non-nil means keep numbering between several print functions.\n\
-See `print-gensym' nad `print-circle'.  See also `print-number-table'.");
+              doc: /* *Non-nil means number continuously across print calls.
+This affects the numbers printed for #N= labels and #M# references.
+See also `print-circle', `print-gensym', and `print-number-table'.
+This variable should not be set with `setq'; bind it with a `let' instead.  */);

   Vprint_continuous_numbering = Qnil;
 
   DEFVAR_LISP ("print-number-table", &Vprint_number_table,
   Vprint_continuous_numbering = Qnil;
 
   DEFVAR_LISP ("print-number-table", &Vprint_number_table,

-  "A vector keeping the information of the current printed object.\n\
-This variable shouldn't be modified in Lisp level, but should be binded\n\
-with nil using let at the same position with `print-continuous-numbering',\n\
-so that the value of this variable can be freed after printing.");
+              doc: /* A vector used internally to produce `#N=' labels and `#N#' references.
+The Lisp printer uses this vector to detect Lisp objects referenced more
+than once.  When `print-continuous-numbering' is bound to t, you should
+probably also bind `print-number-table' to nil.  This ensures that the
+value of `print-number-table' can be garbage-collected once the printing
+is done.  */);

   Vprint_number_table = Qnil;
 
   /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
   Vprint_number_table = Qnil;
 
   /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */