emacs: src/print.c comparison

comparison src/print.c @ 110548:f7b98576d87f

Fix all EMACS_INT/int conversion errors in print.c (and related files).

author	Lars Magne Ingebrigtsen <larsi@gnus.org>
date	Fri, 24 Sep 2010 17:01:03 +0200
parents	c4c8e4a16194
children	3b57f0a3b766

comparison

equal deleted inserted replaced

-:a6fc92a6d443
+:f7b98576d87f
 /* When printing into a buffer, first we put the text in this
 block, then insert it all at once.  */
 char *print_buffer;
 /* Size allocated in print_buffer.  */
-int print_buffer_size;
+EMACS_INT print_buffer_size;
 /* Chars stored in print_buffer.  */
-int print_buffer_pos;
+EMACS_INT print_buffer_pos;
 /* Bytes stored in print_buffer.  */
-int print_buffer_pos_byte;
+EMACS_INT print_buffer_pos_byte;
 /* Maximum length of list to print in full; noninteger means
 effectively infinity */
 Lisp_Object Vprint_length;
 Use PRINTCHAR to output one character,
 or call strout to output a block of characters. */
 #define PRINTDECLARE							\
 struct buffer *old = current_buffer;					\
-int old_point = -1, start_point = -1;				\
+EMACS_INT old_point = -1, start_point = -1;				\
-int old_point_byte = -1, start_point_byte = -1;			\
+EMACS_INT old_point_byte = -1, start_point_byte = -1;		\
 int specpdl_count = SPECPDL_INDEX ();				\
 int free_print_buffer = 0;						\
 int multibyte = !NILP (current_buffer->enable_multibyte_characters);	\
 Lisp_Object original
 In the case where PRINTCHARFUN is nil, it is safe for PTR to point
 to data in a Lisp string.  Otherwise that is not safe.  */
 static void
-strout (const char *ptr, int size, int size_byte, Lisp_Object printcharfun,
+strout (const char *ptr, EMACS_INT size, EMACS_INT size_byte,
-	int multibyte)
+	Lisp_Object printcharfun, int multibyte)
 {
 if (size < 0)
 size_byte = size = strlen (ptr);
 if (NILP (printcharfun))
 static void
 print_string (Lisp_Object string, Lisp_Object printcharfun)
 {
 if (EQ (printcharfun, Qt) || NILP (printcharfun))
 {
-int chars;
+EMACS_INT chars;
 if (print_escape_nonascii)
 	string = string_escape_byte8 (string);
 if (STRING_MULTIBYTE (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;
+	  EMACS_INT bytes;
 	  chars = SBYTES (string);
 	  bytes = parse_str_to_multibyte (SDATA (string), chars);
 	  if (chars < bytes)
 	    {
 	chars = SBYTES (string);
 if (EQ (printcharfun, Qt))
 	{
 	  /* Output to echo area.  */
-	  int nbytes = SBYTES (string);
+	  EMACS_INT nbytes = SBYTES (string);
 	  char *buffer;
 	  /* Copy the string contents so that relocation of STRING by
 	     GC does not cause trouble.  */
 	  USE_SAFE_ALLOCA;
 else
 {
 /* Otherwise, string may be relocated by printing one char.
 	 So re-fetch the string address for each character.  */
 int i;
-int size = SCHARS (string);
+EMACS_INT size = SCHARS (string);
-int size_byte = SBYTES (string);
+EMACS_INT size_byte = SBYTES (string);
 struct gcpro gcpro1;
 GCPRO1 (string);
 if (size == size_byte)
 	for (i = 0; i < size; i++)
 	  PRINTCHAR (SREF (string, i));
 You can call print while debugging emacs, and pass it this function
 to make it write to the debugging output.  */)
 (Lisp_Object character)
 {
 CHECK_NUMBER (character);
-putc (XINT (character), stderr);
+putc ((int) XINT (character), stderr);
 #ifdef WINDOWSNT
 /* Send the output to a debugger (nothing happens if there isn't one).  */
 if (print_output_debug_flag)
 {
 }
 if (NILP (Vprint_charset_text_property)
 || ! (print_check_string_result & PRINT_STRING_UNSAFE_CHARSET_FOUND))
 {
 int i, c;
-int charpos = interval->position;
+EMACS_INT charpos = interval->position;
-int bytepos = string_char_to_byte (string, charpos);
+EMACS_INT bytepos = string_char_to_byte (string, charpos);
 Lisp_Object charset;
 charset = XCAR (XCDR (val));
 for (i = 0; i < LENGTH (interval); i++)
 	{
 else
 	{
 	  register int i, i_byte;
 	  struct gcpro gcpro1;
 	  unsigned char *str;
-	  int size_byte;
+	  EMACS_INT size_byte;
 	  /* 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);
 {
 	register int confusing;
 	register unsigned char *p = SDATA (SYMBOL_NAME (obj));
 	register unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
 	register int c;
-	int i, i_byte, size_byte;
+	int i, i_byte;
+	EMACS_INT size_byte;
 	Lisp_Object name;
 	name = SYMBOL_NAME (obj);
 	if (p != end && (*p == '-' || *p == '+')) p++;
 	      obj = XCDR (obj);
 	    }
 	  {
-	    int print_length, i;
+	    EMACS_INT print_length;
+	    int i;
 	    Lisp_Object halftail = obj;
 	    /* Negative values of print-length are invalid in CL.
 	       Treat them like nil, as CMUCL does.  */
 	    if (NATNUMP (Vprint_length))
 else if (BOOL_VECTOR_P (obj))
 	{
 	  register int i;
 	  register unsigned char c;
 	  struct gcpro gcpro1;
-	  int size_in_chars
+	  EMACS_INT size_in_chars
 	    = ((XBOOL_VECTOR (obj)->size + BOOL_VECTOR_BITS_PER_CHAR - 1)
 	       / BOOL_VECTOR_BITS_PER_CHAR);
 	  GCPRO1 (obj);
 	  PRINTCHAR ('>');
 	}
 else if (HASH_TABLE_P (obj))
 	{
 	  struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
-	  int i, real_size, size;
+	  int i;
+	  EMACS_INT real_size, size;
 #if 0
 	  strout ("#<hash-table", -1, -1, printcharfun, 0);
 	  if (SYMBOLP (h->test))
 	    {
 	      PRINTCHAR (' ');
 	  PRINTCHAR ('[');
 	  {
 	    register int i;
 	    register Lisp_Object tem;
-	    int real_size = size;
+	    EMACS_INT real_size = size;
 	    /* Don't print more elements than the specified maximum.  */
 	    if (NATNUMP (Vprint_length)
 		&& XFASTINT (Vprint_length) < size)
 	      size = XFASTINT (Vprint_length);

Mercurial > emacs

comparison src/print.c @ 110548:f7b98576d87f