src/*.c: Remove unused parameters and other warnings.

* dispextern.h (string_buffer_position): Remove declaration.

* print.c (strout): Remove parameter `multibyte', unused since
  1999-08-21T19:30:[email protected].  All callers changed.

* search.c (boyer_moore): Remove parameters `len', `pos' and `lim',
  never used since function introduction in 1998-02-08T21:33:[email protected].
  All callers changed.

* w32.c (_wsa_errlist): Use braces for struct initializers.

* xdisp.c (string_buffer_position_lim): Remove parameter `w',
  never used since function introduction in 2001-03-09T18:41:[email protected].
  All callers changed.
  (string_buffer_position): Likewise.  Also, make static (it's never
  used outside xdisp.c).
  (cursor_row_p): Remove parameter `w', unused since
  2000-10-17T16:08:[email protected].  All callers changed.
  (decode_mode_spec): Remove parameter `precision', introduced during
  Gerd Moellmann's rewrite at 1999-07-21T21:43:[email protected], but never used.
  All callers changed.

1 files changed, 64 insertions, 67 deletions

diff --git a/src/print.c b/src/print.c
index 5b2778cf25..e44d4d14f3 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;
 }
 
@@ -1404,7 +1401,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;
@@ -1420,7 +1417,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);
 		}
@@ -1428,7 +1425,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;
 		}
 	    }
@@ -1446,7 +1443,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:
@@ -1454,7 +1451,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;
 
@@ -1532,7 +1529,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)
@@ -1544,7 +1541,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
 		{
@@ -1557,7 +1554,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 == '\\')
@@ -1645,7 +1642,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)))
 	{
@@ -1705,7 +1702,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;
 		      }
 		  }
@@ -1717,7 +1714,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;
 			  }
@@ -1729,7 +1726,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;
 		  }
 
@@ -1744,7 +1741,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);
 	    }
 
@@ -1758,7 +1755,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 ('>');
 	    }
@@ -1779,7 +1776,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.
@@ -1824,18 +1821,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 ('>');
@@ -1843,13 +1840,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 ('>');
 	}
@@ -1859,21 +1856,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.:
@@ -1881,33 +1878,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);
@@ -1929,7 +1926,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 (')');
@@ -1938,10 +1935,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 ('>');
 	    }
@@ -1950,16 +1947,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))
@@ -1969,9 +1966,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 (' ');
@@ -1984,7 +1981,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);
 	    }
@@ -2037,7 +2034,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 (']');
 	}
@@ -2047,32 +2044,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);
 	    }
@@ -2082,15 +2079,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;
 
@@ -2104,16 +2101,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);
       }
     }