1 files changed, 64 insertions, 67 deletions

diff --git a/src/print.c b/src/print.c
index b8266422473..17a896bba8d 100644
--- a/src/print.c
+++ b/src/print.c
@@ -273,7 +273,7 @@ printchar (unsigned int ch, Lisp_Object fun)
 
 static void
 strout (const char *ptr, EMACS_INT size, EMACS_INT size_byte,
-        Lisp_Object printcharfun, int multibyte)
+        Lisp_Object printcharfun)
 {
   if (size < 0)
     size_byte = size = strlen (ptr);
@@ -406,16 +406,13 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
           SAFE_ALLOCA (buffer, char *, nbytes);
           memcpy (buffer, SDATA (string), nbytes);
 
-          strout (buffer, chars, SBYTES (string),
-                  printcharfun, STRING_MULTIBYTE (string));
+          strout (buffer, chars, SBYTES (string), printcharfun);
 
           SAFE_FREE ();
         }
       else
         /* No need to copy, since output to print_buffer can't GC.  */
-        strout (SSDATA (string),
-                chars, SBYTES (string),
-                printcharfun, STRING_MULTIBYTE (string));
+        strout (SSDATA (string), chars, SBYTES (string), printcharfun);
     }
   else
     {
@@ -472,7 +469,7 @@ write_string (const char *data, int size)
   printcharfun = Vstandard_output;
 
   PRINTPREPARE;
-  strout (data, size, size, printcharfun, 0);
+  strout (data, size, size, printcharfun);
   PRINTFINISH;
 }
 
@@ -486,7 +483,7 @@ write_string_1 (const char *data, int size, Lisp_Object printcharfun)
   PRINTDECLARE;
 
   PRINTPREPARE;
-  strout (data, size, size, printcharfun, 0);
+  strout (data, size, size, printcharfun);
   PRINTFINISH;
 }
 
@@ -1351,7 +1348,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             if (EQ (obj, being_printed[i]))
               {
                 sprintf (buf, "#%d", i);
-                strout (buf, -1, -1, printcharfun, 0);
+                strout (buf, -1, -1, printcharfun);
                 return;
               }
           being_printed[print_depth] = obj;
@@ -1367,7 +1364,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 { /* Add a prefix #n= if OBJ has not yet been printed;
                      that is, its status field is nil.  */
                   sprintf (buf, "#%d=", -n);
-                  strout (buf, -1, -1, printcharfun, 0);
+                  strout (buf, -1, -1, printcharfun);
                   /* OBJ is going to be printed.  Remember that fact.  */
                   Fputhash (obj, make_number (- n), Vprint_number_table);
                 }
@@ -1375,7 +1372,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 {
                   /* Just print #n# if OBJ has already been printed.  */
                   sprintf (buf, "#%d#", n);
-                  strout (buf, -1, -1, printcharfun, 0);
+                  strout (buf, -1, -1, printcharfun);
                   return;
                 }
             }
@@ -1393,7 +1390,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         sprintf (buf, "%ld", (long) XINT (obj));
       else
         abort ();
-      strout (buf, -1, -1, printcharfun, 0);
+      strout (buf, -1, -1, printcharfun);
       break;
 
     case Lisp_Float:
@@ -1401,7 +1398,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         char pigbuf[FLOAT_TO_STRING_BUFSIZE];
 
         float_to_string (pigbuf, XFLOAT_DATA (obj));
-        strout (pigbuf, -1, -1, printcharfun, 0);
+        strout (pigbuf, -1, -1, printcharfun);
       }
       break;
 
@@ -1479,7 +1476,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                       sprintf (outbuf, "\\x%04x", c);
                       need_nonhex = 1;
                     }
-                  strout (outbuf, -1, -1, printcharfun, 0);
+                  strout (outbuf, -1, -1, printcharfun);
                 }
               else if (! multibyte
                        && SINGLE_BYTE_CHAR_P (c) && ! ASCII_BYTE_P (c)
@@ -1491,7 +1488,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                      using octal escapes.  */
                   char outbuf[5];
                   sprintf (outbuf, "\\%03o", c);
-                  strout (outbuf, -1, -1, printcharfun, 0);
+                  strout (outbuf, -1, -1, printcharfun);
                 }
               else
                 {
@@ -1504,7 +1501,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                       if ((c >= 'a' && c <= 'f')
                           || (c >= 'A' && c <= 'F')
                           || (c >= '0' && c <= '9'))
-                        strout ("\\ ", -1, -1, printcharfun, 0);
+                        strout ("\\ ", -1, -1, printcharfun);
                     }
 
                   if (c == '\"' || c == '\\')
@@ -1592,7 +1589,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       /* If deeper than spec'd depth, print placeholder.  */
       if (INTEGERP (Vprint_level)
           && print_depth > XINT (Vprint_level))
-        strout ("...", -1, -1, printcharfun, 0);
+        strout ("...", -1, -1, printcharfun);
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
                && (EQ (XCAR (obj), Qquote)))
         {
@@ -1652,7 +1649,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                     if (i != 0 && EQ (obj, halftail))
                       {
                         sprintf (buf, " . #%d", i / 2);
-                        strout (buf, -1, -1, printcharfun, 0);
+                        strout (buf, -1, -1, printcharfun);
                         goto end_of_list;
                       }
                   }
@@ -1664,7 +1661,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                         Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
                         if (INTEGERP (num))
                           {
-                            strout (" . ", 3, 3, printcharfun, 0);
+                            strout (" . ", 3, 3, printcharfun);
                             print_object (obj, printcharfun, escapeflag);
                             goto end_of_list;
                           }
@@ -1676,7 +1673,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
 
                 if (print_length && i > print_length)
                   {
-                    strout ("...", 3, 3, printcharfun, 0);
+                    strout ("...", 3, 3, printcharfun);
                     goto end_of_list;
                   }
 
@@ -1691,7 +1688,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           /* OBJ non-nil here means it's the end of a dotted list.  */
           if (!NILP (obj))
             {
-              strout (" . ", 3, 3, printcharfun, 0);
+              strout (" . ", 3, 3, printcharfun);
               print_object (obj, printcharfun, escapeflag);
             }
 
@@ -1705,7 +1702,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         {
           if (escapeflag)
             {
-              strout ("#<process ", -1, -1, printcharfun, 0);
+              strout ("#<process ", -1, -1, printcharfun);
               print_string (XPROCESS (obj)->name, printcharfun);
               PRINTCHAR ('>');
             }
@@ -1726,7 +1723,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           PRINTCHAR ('#');
           PRINTCHAR ('&');
           sprintf (buf, "%ld", (long) XBOOL_VECTOR (obj)->size);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('\"');
 
           /* Don't print more characters than the specified maximum.
@@ -1771,18 +1768,18 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         }
       else if (SUBRP (obj))
         {
-          strout ("#<subr ", -1, -1, printcharfun, 0);
-          strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun, 0);
+          strout ("#<subr ", -1, -1, printcharfun);
+          strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun);
           PRINTCHAR ('>');
         }
       else if (WINDOWP (obj))
         {
-          strout ("#<window ", -1, -1, printcharfun, 0);
+          strout ("#<window ", -1, -1, printcharfun);
           sprintf (buf, "%ld", (long) XFASTINT (XWINDOW (obj)->sequence_number));
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           if (!NILP (XWINDOW (obj)->buffer))
             {
-              strout (" on ", -1, -1, printcharfun, 0);
+              strout (" on ", -1, -1, printcharfun);
               print_string (BVAR (XBUFFER (XWINDOW (obj)->buffer), name), printcharfun);
             }
           PRINTCHAR ('>');
@@ -1790,13 +1787,13 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       else if (TERMINALP (obj))
         {
           struct terminal *t = XTERMINAL (obj);
-          strout ("#<terminal ", -1, -1, printcharfun, 0);
+          strout ("#<terminal ", -1, -1, printcharfun);
           sprintf (buf, "%d", t->id);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           if (t->name)
             {
-              strout (" on ", -1, -1, printcharfun, 0);
-              strout (t->name, -1, -1, printcharfun, 0);
+              strout (" on ", -1, -1, printcharfun);
+              strout (t->name, -1, -1, printcharfun);
             }
           PRINTCHAR ('>');
         }
@@ -1806,21 +1803,21 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           int i;
           EMACS_INT real_size, size;
 #if 0
-          strout ("#<hash-table", -1, -1, printcharfun, 0);
+          strout ("#<hash-table", -1, -1, printcharfun);
           if (SYMBOLP (h->test))
             {
               PRINTCHAR (' ');
               PRINTCHAR ('\'');
-              strout (SDATA (SYMBOL_NAME (h->test)), -1, -1, printcharfun, 0);
+              strout (SDATA (SYMBOL_NAME (h->test)), -1, -1, printcharfun);
               PRINTCHAR (' ');
-              strout (SDATA (SYMBOL_NAME (h->weak)), -1, -1, printcharfun, 0);
+              strout (SDATA (SYMBOL_NAME (h->weak)), -1, -1, printcharfun);
               PRINTCHAR (' ');
               sprintf (buf, "%ld/%ld", (long) h->count,
                        (long) XVECTOR (h->next)->size);
-              strout (buf, -1, -1, printcharfun, 0);
+              strout (buf, -1, -1, printcharfun);
             }
           sprintf (buf, " 0x%lx", (unsigned long) h);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
 #endif
           /* Implement a readable output, e.g.:
@@ -1828,33 +1825,33 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           /* Always print the size. */
           sprintf (buf, "#s(hash-table size %ld",
                    (long) XVECTOR (h->next)->size);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
 
           if (!NILP (h->test))
             {
-              strout (" test ", -1, -1, printcharfun, 0);
+              strout (" test ", -1, -1, printcharfun);
               print_object (h->test, printcharfun, escapeflag);
             }
 
           if (!NILP (h->weak))
             {
-              strout (" weakness ", -1, -1, printcharfun, 0);
+              strout (" weakness ", -1, -1, printcharfun);
               print_object (h->weak, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_size))
             {
-              strout (" rehash-size ", -1, -1, printcharfun, 0);
+              strout (" rehash-size ", -1, -1, printcharfun);
               print_object (h->rehash_size, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_threshold))
             {
-              strout (" rehash-threshold ", -1, -1, printcharfun, 0);
+              strout (" rehash-threshold ", -1, -1, printcharfun);
               print_object (h->rehash_threshold, printcharfun, escapeflag);
             }
 
-          strout (" data ", -1, -1, printcharfun, 0);
+          strout (" data ", -1, -1, printcharfun);
 
           /* Print the data here as a plist. */
           real_size = HASH_TABLE_SIZE (h);
@@ -1876,7 +1873,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
               }
 
           if (size < real_size)
-            strout (" ...", 4, 4, printcharfun, 0);
+            strout (" ...", 4, 4, printcharfun);
 
           PRINTCHAR (')');
           PRINTCHAR (')');
@@ -1885,10 +1882,10 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       else if (BUFFERP (obj))
         {
           if (NILP (BVAR (XBUFFER (obj), name)))
-            strout ("#<killed buffer>", -1, -1, printcharfun, 0);
+            strout ("#<killed buffer>", -1, -1, printcharfun);
           else if (escapeflag)
             {
-              strout ("#<buffer ", -1, -1, printcharfun, 0);
+              strout ("#<buffer ", -1, -1, printcharfun);
               print_string (BVAR (XBUFFER (obj), name), printcharfun);
               PRINTCHAR ('>');
             }
@@ -1897,16 +1894,16 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         }
       else if (WINDOW_CONFIGURATIONP (obj))
         {
-          strout ("#<window-configuration>", -1, -1, printcharfun, 0);
+          strout ("#<window-configuration>", -1, -1, printcharfun);
         }
       else if (FRAMEP (obj))
         {
           strout ((FRAME_LIVE_P (XFRAME (obj))
                    ? "#<frame " : "#<dead frame "),
-                  -1, -1, printcharfun, 0);
+                  -1, -1, printcharfun);
           print_string (XFRAME (obj)->name, printcharfun);
           sprintf (buf, " 0x%lx", (unsigned long) (XFRAME (obj)));
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
         }
       else if (FONTP (obj))
@@ -1916,9 +1913,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           if (! FONT_OBJECT_P (obj))
             {
               if (FONT_SPEC_P (obj))
-                strout ("#<font-spec", -1, -1, printcharfun, 0);
+                strout ("#<font-spec", -1, -1, printcharfun);
               else
-                strout ("#<font-entity", -1, -1, printcharfun, 0);
+                strout ("#<font-entity", -1, -1, printcharfun);
               for (i = 0; i < FONT_SPEC_MAX; i++)
                 {
                   PRINTCHAR (' ');
@@ -1931,7 +1928,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             }
           else
             {
-              strout ("#<font-object ", -1, -1, printcharfun, 0);
+              strout ("#<font-object ", -1, -1, printcharfun);
               print_object (AREF (obj, FONT_NAME_INDEX), printcharfun,
                             escapeflag);
             }
@@ -1984,7 +1981,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 print_object (tem, printcharfun, escapeflag);
               }
             if (size < real_size)
-              strout (" ...", 4, 4, printcharfun, 0);
+              strout (" ...", 4, 4, printcharfun);
           }
           PRINTCHAR (']');
         }
@@ -1994,32 +1991,32 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       switch (XMISCTYPE (obj))
         {
         case Lisp_Misc_Marker:
-          strout ("#<marker ", -1, -1, printcharfun, 0);
+          strout ("#<marker ", -1, -1, printcharfun);
           /* Do you think this is necessary?  */
           if (XMARKER (obj)->insertion_type != 0)
-            strout ("(moves after insertion) ", -1, -1, printcharfun, 0);
+            strout ("(moves after insertion) ", -1, -1, printcharfun);
           if (! XMARKER (obj)->buffer)
-            strout ("in no buffer", -1, -1, printcharfun, 0);
+            strout ("in no buffer", -1, -1, printcharfun);
           else
             {
               sprintf (buf, "at %ld", (long)marker_position (obj));
-              strout (buf, -1, -1, printcharfun, 0);
-              strout (" in ", -1, -1, printcharfun, 0);
+              strout (buf, -1, -1, printcharfun);
+              strout (" in ", -1, -1, printcharfun);
               print_string (BVAR (XMARKER (obj)->buffer, name), printcharfun);
             }
           PRINTCHAR ('>');
           break;
 
         case Lisp_Misc_Overlay:
-          strout ("#<overlay ", -1, -1, printcharfun, 0);
+          strout ("#<overlay ", -1, -1, printcharfun);
           if (! XMARKER (OVERLAY_START (obj))->buffer)
-            strout ("in no buffer", -1, -1, printcharfun, 0);
+            strout ("in no buffer", -1, -1, printcharfun);
           else
             {
               sprintf (buf, "from %ld to %ld in ",
                        (long)marker_position (OVERLAY_START (obj)),
                        (long)marker_position (OVERLAY_END   (obj)));
-              strout (buf, -1, -1, printcharfun, 0);
+              strout (buf, -1, -1, printcharfun);
               print_string (BVAR (XMARKER (OVERLAY_START (obj))->buffer, name),
                             printcharfun);
             }
@@ -2029,15 +2026,15 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       /* Remaining cases shouldn't happen in normal usage, but let's print
          them anyway for the benefit of the debugger.  */
         case Lisp_Misc_Free:
-          strout ("#<misc free cell>", -1, -1, printcharfun, 0);
+          strout ("#<misc free cell>", -1, -1, printcharfun);
           break;
 
         case Lisp_Misc_Save_Value:
-          strout ("#<save_value ", -1, -1, printcharfun, 0);
+          strout ("#<save_value ", -1, -1, printcharfun);
           sprintf(buf, "ptr=0x%08lx int=%d",
                   (unsigned long) XSAVE_VALUE (obj)->pointer,
                   XSAVE_VALUE (obj)->integer);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
           break;
 
@@ -2051,16 +2048,16 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       {
         /* We're in trouble if this happens!
            Probably should just abort () */
-        strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun, 0);
+        strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun);
         if (MISCP (obj))
           sprintf (buf, "(MISC 0x%04x)", (int) XMISCTYPE (obj));
         else if (VECTORLIKEP (obj))
           sprintf (buf, "(PVEC 0x%08x)", (int) XVECTOR (obj)->size);
         else
           sprintf (buf, "(0x%02x)", (int) XTYPE (obj));
-        strout (buf, -1, -1, printcharfun, 0);
+        strout (buf, -1, -1, printcharfun);
         strout (" Save your buffers immediately and please report this bug>",
-                -1, -1, printcharfun, 0);
+                -1, -1, printcharfun);
       }
     }