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 80a897fdb2296e5170ed982d1f1de54363491da2..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;


@@ -190,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);        \


@@ -291,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;

 }
 
 
 }
 
 


@@ -337,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);
        }


@@ -396,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
        {


@@ -468,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));
 


@@ -511,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;


@@ -587,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);
 


@@ -619,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;


@@ -647,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);
 }


@@ -667,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;
 {


@@ -683,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;


@@ -707,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;


@@ -743,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;


@@ -761,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;


@@ -796,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


@@ -828,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;


@@ -892,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))


@@ -1118,7 +1202,8 @@ 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.  */
     {
       /* In case print-circle is nil and print-gensym is t,
         add OBJ to Vprint_number_table only when OBJ is a symbol.  */


@@ -1156,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++;
        }


@@ -1166,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:


@@ -1179,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;

        }
     }
 }
        }
     }
 }


@@ -1205,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))
        {


@@ -1293,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);
 


@@ -1313,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);


@@ -1337,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.  */


@@ -1346,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


@@ -1381,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 (')');
            }
 


@@ -1422,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 (':');


@@ -1434,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)


@@ -1490,7 +1579,7 @@ print_object (obj, printcharfun, escapeflag)
            int print_length, i;
            Lisp_Object halftail = obj;
 
            int print_length, i;
            Lisp_Object halftail = obj;
 

-           /* Negative values of print-length are illegal in CL.
+           /* 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);
               Treat them like nil, as CMUCL does.  */
            if (NATNUMP (Vprint_length))
              print_length = XFASTINT (Vprint_length);


@@ -1594,7 +1683,7 @@ print_object (obj, printcharfun, escapeflag)
          PRINTCHAR ('\"');
 
          /* Don't print more characters than the specified maximum.
          PRINTCHAR ('\"');
 
          /* Don't print more characters than the specified maximum.

-            Negative values of print-length are illegal.  Treat them
+            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)
             like a print-length of nil.  */
          if (NATNUMP (Vprint_length)
              && XFASTINT (Vprint_length) < size_in_chars)


@@ -1716,6 +1805,7 @@ 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.  */
            if (NATNUMP (Vprint_length)
 
            /* Don't print more elements than the specified maximum.  */
            if (NATNUMP (Vprint_length)


@@ -1728,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 (']');
        }


@@ -1740,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


@@ -1893,98 +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);
 
   DEFVAR_LISP ("float-output-format", &Vfloat_output_format,
   Vstandard_output = Qt;
   Qstandard_output = intern ("standard-output");
   staticpro (&Qstandard_output);
 
   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);
 
   DEFVAR_LISP ("print-length", &Vprint_length,
   Vfloat_output_format = Qnil;
   Qfloat_output_format = intern ("float-output-format");
   staticpro (&Qfloat_output_format);
 
   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 */