diff --git a/src/ChangeLog b/src/ChangeLog index 821e4090cfd..59fb2d89b24 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,253 @@ +2011-06-15 Paul Eggert + + Integer overflow and signedness fixes (Bug#8873). + + * ccl.c (ASCENDING_ORDER): New macro, to work around GCC bug 43772. + (GET_CCL_RANGE, IN_INT_RANGE): Use it. + + * fileio.c: Don't assume EMACS_INT fits in off_t. + (emacs_lseek): New static function. + (Finsert_file_contents, Fwrite_region): Use it. + Use SEEK_SET, SEEK_CUR, SEEK_END as appropriate. + + * fns.c (Fload_average): Don't assume 100 * load average fits in int. + + * fns.c: Don't overflow int when computing a list length. + * fns.c (QUIT_COUNT_HEURISTIC): New constant. + (Flength, Fsafe_length): Use EMACS_INT, not int, to avoid unwanted + truncation on 64-bit hosts. Check for QUIT every + QUIT_COUNT_HEURISTIC entries rather than every other entry; that's + faster and is responsive enough. + (Flength): Report an error instead of overflowing an integer. + (Fsafe_length): Return a float if the value is not representable + as a fixnum. This shouldn't happen except in contrived situations. + (Fnthcdr, Fsort): Don't assume list length fits in int. + (Fcopy_sequence): Don't assume vector length fits in int. + + * alloc.c: Check that resized vectors' lengths fit in fixnums. + (header_size, word_size): New constants. + (allocate_vectorlike): Don't check size overflow here. + (allocate_vector): Check it here instead, since this is the only + caller of allocate_vectorlike that could cause overflow. + Check that the new vector's length is representable as a fixnum. + + * fns.c (next_almost_prime): Don't return a multiple of 3 or 5. + The previous code was bogus. For example, next_almost_prime (32) + returned 39, which is undesirable as it is a multiple of 3; and + next_almost_prime (24) returned 25, which is a multiple of 5 so + why was the code bothering to check for multiples of 7? + + * bytecode.c (exec_byte_code): Use ptrdiff_t, not int, for vector length. + + * eval.c, doprnt.c (SIZE_MAX): Remove; inttypes.h defines this now. + + Variadic C functions now count arguments with ptrdiff_t. + This partly undoes my 2011-03-30 change, which replaced int with size_t. + Back then I didn't know that the Emacs coding style prefers signed int. + Also, in the meantime I found a few more instances where arguments + were being counted with int, which may truncate counts on 64-bit + machines, or EMACS_INT, which may be unnecessarily wide. + * lisp.h (struct Lisp_Subr.function.aMANY) + (DEFUN_ARGS_MANY, internal_condition_case_n, safe_call): + Arg counts are now ptrdiff_t, not size_t. + All variadic functions and their callers changed accordingly. + (struct gcpro.nvars): Now size_t, not size_t. All uses changed. + * bytecode.c (exec_byte_code): Check maxdepth for overflow, + to avoid potential buffer overrun. Don't assume arg counts fit in 'int'. + * callint.c (Fcall_interactively): Check arg count for overflow, + to avoid potential buffer overrun. Use signed char, not 'int', + for 'varies' array, so that we needn't bother to check its size + calculation for overflow. + * editfns.c (Fformat): Use ptrdiff_t, not EMACS_INT, to count args. + * eval.c (apply_lambda): + * fns.c (Fmapconcat): Use XFASTINT, not XINT, to get args length. + (struct textprop_rec.argnum): Now ptrdiff_t, not int. All uses changed. + (mapconcat): Use ptrdiff_t, not int and EMACS_INT, to count args. + + * callint.c (Fcall_interactively): Don't use index var as event count. + + * vm-limit.c (check_memory_limits): Fix incorrect extern function decls. + * mem-limits.h (SIZE): Remove; no longer used. + + * xterm.c (x_alloc_nearest_color_1): Prefer int to long when int works. + + Remove unnecessary casts. + * xterm.c (x_term_init): + * xfns.c (x_set_border_pixel): + * widget.c (create_frame_gcs): Remove casts to unsigned long etc. + These aren't needed now that we assume ANSI C. + + * sound.c (Fplay_sound_internal): Remove cast to unsigned long. + It's more likely to cause problems (due to unsigned overflow) + than to cure them. + + * dired.c (Ffile_attributes): Don't use 32-bit hack on 64-bit hosts. + + * unexelf.c (unexec): Don't assume BSS addr fits in unsigned. + + * xterm.c (handle_one_xevent): Omit unnecessary casts to unsigned. + + * keyboard.c (modify_event_symbol): Don't limit alist len to UINT_MAX. + + * lisp.h (CHAR_TABLE_SET): Omit now-redundant test. + + * lread.c (Fload): Don't compare a possibly-garbage time_t value. + + GLYPH_CODE_FACE returns EMACS_INT, not int. + * dispextern.h (merge_faces): + * xfaces.c (merge_faces): + * xdisp.c (get_next_display_element, next_element_from_display_vector): + Don't assume EMACS_INT fits in int. + + * character.h (CHAR_VALID_P): Remove unused parameter. + * fontset.c, lisp.h, xdisp.c: All uses changed. + + * editfns.c (Ftranslate_region_internal): Omit redundant test. + + * fns.c (concat): Minor tuning based on overflow analysis. + This doesn't fix any bugs. Use int to hold character, instead + of constantly refetching from Emacs object. Use XFASTINT, not + XINT, for value known to be a character. Don't bother comparing + a single byte to 0400, as it's always less. + + * floatfns.c (Fexpt): + * fileio.c (make_temp_name): Omit unnecessary cast to unsigned. + + * editfns.c (Ftranslate_region_internal): Use int, not EMACS_INT + for characters. + + * doc.c (get_doc_string): Omit (unsigned)c that mishandled negatives. + + * data.c (Faset): If ARRAY is a string, check that NEWELT is a char. + Without this fix, on a 64-bit host (aset S 0 4294967386) would + incorrectly succeed when S was a string, because 4294967386 was + truncated before it was used. + + * chartab.c (Fchar_table_range): Use CHARACTERP to check range. + Otherwise, an out-of-range integer could cause undefined behavior + on a 64-bit host. + + * composite.c: Use int, not EMACS_INT, for characters. + (fill_gstring_body, composition_compute_stop_pos): Use int, not + EMACS_INT, for values that are known to be in character range. + This doesn't fix any bugs but is the usual style inside Emacs and + may generate better code on 32-bit machines. + + Make sure a 64-bit char is never passed to ENCODE_CHAR. + This is for reasons similar to the recent CHAR_STRING fix. + * charset.c (Fencode_char): Check that character arg is actually + a character. Pass an int to ENCODE_CHAR. + * charset.h (ENCODE_CHAR): Verify that the character argument is no + wider than 'int', as a compile-time check to prevent future regressions + in this area. + + * character.c (char_string): Remove unnecessary casts. + + Make sure a 64-bit char is never passed to CHAR_STRING. + Otherwise, CHAR_STRING would do the wrong thing on a 64-bit platform, + by silently ignoring the top 32 bits, allowing some values + that were far too large to be valid characters. + * character.h: Include . + (CHAR_STRING, CHAR_STRING_ADVANCE): Verify that the character + arguments are no wider than unsigned, as a compile-time check + to prevent future regressions in this area. + * data.c (Faset): + * editfns.c (Fchar_to_string, general_insert_function, Finsert_char) + (Fsubst_char_in_region): + * fns.c (concat): + * xdisp.c (decode_mode_spec_coding): + Adjust to CHAR_STRING's new requirement. + * editfns.c (Finsert_char, Fsubst_char_in_region): + * fns.c (concat): Check that character args are actually + characters. Without this test, these functions did the wrong + thing with wildly out-of-range values on 64-bit hosts. + + Remove incorrect casts to 'unsigned' that lose info on 64-bit hosts. + These casts should not be needed on 32-bit hosts, either. + * keyboard.c (read_char): + * lread.c (Fload): Remove casts to unsigned. + + * lisp.h (UNSIGNED_CMP): New macro. + This fixes comparison bugs on 64-bit hosts. + (ASCII_CHAR_P): Use it. + * casefiddle.c (casify_object): + * character.h (ASCII_BYTE_P, CHAR_VALID_P) + (SINGLE_BYTE_CHAR_P, CHAR_STRING): + * composite.h (COMPOSITION_ENCODE_RULE_VALID): + * dispextern.h (FACE_FROM_ID): + * keyboard.c (read_char): Use UNSIGNED_CMP. + + * xmenu.c (dialog_selection_callback) [!USE_GTK]: Cast to intptr_t, + not to EMACS_INT, to avoid GCC warning. + + * xfns.c (x_set_scroll_bar_default_width): Remove unused 'int' locals. + + * buffer.h (PTR_BYTE_POS, BUF_PTR_BYTE_POS): Remove harmful cast. + The cast incorrectly truncated 64-bit byte offsets to 32 bits, and + isn't needed on 32-bit machines. + + * buffer.c (Fgenerate_new_buffer_name): + Use EMACS_INT for count, not int. + (advance_to_char_boundary): Return EMACS_INT, not int. + + * data.c (Qcompiled_function): Now static. + + * window.c (window_body_lines): Now static. + + * image.c (gif_load): Rename local to avoid shadowing. + + * lisp.h (SAFE_ALLOCA_LISP): Check for integer overflow. + (struct Lisp_Save_Value): Use ptrdiff_t, not int, for 'integer' member. + * alloc.c (make_save_value): Integer argument is now of type + ptrdiff_t, not int. + (mark_object): Use ptrdiff_t, not int. + * lisp.h (pD): New macro. + * print.c (print_object): Use it. + + * alloc.c: Use EMACS_INT, not int, to count objects. + (total_conses, total_markers, total_symbols, total_vector_size) + (total_free_conses, total_free_markers, total_free_symbols) + (total_free_floats, total_floats, total_free_intervals) + (total_intervals, total_strings, total_free_strings): + Now EMACS_INT, not int. All uses changed. + (Fgarbage_collect): Compute overall total using a double, so that + integer overflow is less likely to be a problem. Check for overflow + when converting back to an integer. + (n_interval_blocks, n_string_blocks, n_float_blocks, n_cons_blocks) + (n_vectors, n_symbol_blocks, n_marker_blocks): Remove. + These were 'int' variables that could overflow on 64-bit hosts; + they were never used, so remove them instead of repairing them. + (nzombies, ngcs, max_live, max_zombies): Now EMACS_INT, not 'int'. + (inhibit_garbage_collection): Set gc_cons_threshold to max value. + Previously, this ceilinged at INT_MAX, but that doesn't work on + 64-bit machines. + (allocate_pseudovector): Don't use EMACS_INT when int would do. + + * alloc.c (Fmake_bool_vector): Don't assume vector size fits in int. + (allocate_vectorlike): Check for ptrdiff_t overflow. + (mark_vectorlike, mark_char_table, mark_object): Avoid EMACS_UINT + when a (possibly-narrower) signed value would do just as well. + We prefer using signed arithmetic, to avoid comparison confusion. + + * alloc.c: Catch some string size overflows that we were missing. + (XMALLOC_OVERRUN_CHECK_SIZE) [!XMALLOC_OVERRUN_CHECK]: Define to 0, + for convenience in STRING_BYTES_MAX. + (STRING_BYTES_MAX): New macro, superseding the old one in lisp.h. + The definition here is exact; the one in lisp.h was approximate. + (allocate_string_data): Check for string overflow. This catches + some instances we weren't catching before. Also, it catches + size_t overflow on (unusual) hosts where SIZE_MAX <= min + (PTRDIFF_MAX, MOST_POSITIVE_FIXNUM), e.g., when size_t is 32 bits + and ptrdiff_t and EMACS_INT are both 64 bits. + + * character.c, coding.c, doprnt.c, editfns.c, eval.c: + All uses of STRING_BYTES_MAX replaced by STRING_BYTES_BOUND. + * lisp.h (STRING_BYTES_BOUND): Renamed from STRING_BYTES_MAX. + + * character.c (string_escape_byte8): Fix nbytes/nchars typo. + + * alloc.c (Fmake_string): Check for out-of-range init. + 2011-06-15 Stefan Monnier * eval.c (Fdefvaralias): Also mark the target as variable-special-p. diff --git a/src/alloc.c b/src/alloc.c index cfbb79b2e61..00d330c1b6a 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -180,9 +180,9 @@ int abort_on_gc; /* Number of live and free conses etc. */ -static int total_conses, total_markers, total_symbols, total_vector_size; -static int total_free_conses, total_free_markers, total_free_symbols; -static int total_free_floats, total_floats; +static EMACS_INT total_conses, total_markers, total_symbols, total_vector_size; +static EMACS_INT total_free_conses, total_free_markers, total_free_symbols; +static EMACS_INT total_free_floats, total_floats; /* Points to memory space allocated as "spare", to be freed if we run out of memory. We keep one large block, four cons-blocks, and @@ -485,7 +485,9 @@ buffer_memory_full (EMACS_INT nbytes) } -#ifdef XMALLOC_OVERRUN_CHECK +#ifndef XMALLOC_OVERRUN_CHECK +#define XMALLOC_OVERRUN_CHECK_SIZE 0 +#else /* Check for overrun in malloc'ed buffers by wrapping a 16 byte header and a 16 byte trailer around each block. @@ -1336,16 +1338,12 @@ static int interval_block_index; /* Number of free and live intervals. */ -static int total_free_intervals, total_intervals; +static EMACS_INT total_free_intervals, total_intervals; /* List of free intervals. */ static INTERVAL interval_free_list; -/* Total number of interval blocks now in use. */ - -static int n_interval_blocks; - /* Initialize interval allocation. */ @@ -1355,7 +1353,6 @@ init_intervals (void) interval_block = NULL; interval_block_index = INTERVAL_BLOCK_SIZE; interval_free_list = 0; - n_interval_blocks = 0; } @@ -1387,7 +1384,6 @@ make_interval (void) newi->next = interval_block; interval_block = newi; interval_block_index = 0; - n_interval_blocks++; } val = &interval_block->intervals[interval_block_index++]; } @@ -1580,10 +1576,9 @@ static struct sblock *oldest_sblock, *current_sblock; static struct sblock *large_sblocks; -/* List of string_block structures, and how many there are. */ +/* List of string_block structures. */ static struct string_block *string_blocks; -static int n_string_blocks; /* Free-list of Lisp_Strings. */ @@ -1591,7 +1586,7 @@ static struct Lisp_String *string_free_list; /* Number of live and free Lisp_Strings. */ -static int total_strings, total_free_strings; +static EMACS_INT total_strings, total_free_strings; /* Number of bytes used by live strings. */ @@ -1659,6 +1654,18 @@ static char const string_overrun_cookie[GC_STRING_OVERRUN_COOKIE_SIZE] = #define GC_STRING_EXTRA (GC_STRING_OVERRUN_COOKIE_SIZE) +/* Exact bound on the number of bytes in a string, not counting the + terminating null. A string cannot contain more bytes than + STRING_BYTES_BOUND, nor can it be so long that the size_t + arithmetic in allocate_string_data would overflow while it is + calculating a value to be passed to malloc. */ +#define STRING_BYTES_MAX \ + min (STRING_BYTES_BOUND, \ + ((SIZE_MAX - XMALLOC_OVERRUN_CHECK_SIZE - GC_STRING_EXTRA \ + - offsetof (struct sblock, first_data) \ + - SDATA_DATA_OFFSET) \ + & ~(sizeof (EMACS_INT) - 1))) + /* Initialize string allocation. Called from init_alloc_once. */ static void @@ -1667,7 +1674,6 @@ init_strings (void) total_strings = total_free_strings = total_string_size = 0; oldest_sblock = current_sblock = large_sblocks = NULL; string_blocks = NULL; - n_string_blocks = 0; string_free_list = NULL; empty_unibyte_string = make_pure_string ("", 0, 0, 0); empty_multibyte_string = make_pure_string ("", 0, 0, 1); @@ -1799,7 +1805,6 @@ allocate_string (void) memset (b, 0, sizeof *b); b->next = string_blocks; string_blocks = b; - ++n_string_blocks; for (i = STRING_BLOCK_SIZE - 1; i >= 0; --i) { @@ -1858,6 +1863,9 @@ allocate_string_data (struct Lisp_String *s, struct sblock *b; EMACS_INT needed, old_nbytes; + if (STRING_BYTES_MAX < nbytes) + string_overflow (); + /* Determine the number of bytes needed to store NBYTES bytes of string data. */ needed = SDATA_SIZE (nbytes); @@ -2025,7 +2033,6 @@ sweep_strings (void) && total_free_strings > STRING_BLOCK_SIZE) { lisp_free (b); - --n_string_blocks; string_free_list = free_list_before; } else @@ -2186,9 +2193,9 @@ INIT must be an integer that represents a character. */) EMACS_INT nbytes; CHECK_NATNUM (length); - CHECK_NUMBER (init); + CHECK_CHARACTER (init); - c = XINT (init); + c = XFASTINT (init); if (ASCII_CHAR_P (c)) { nbytes = XINT (length); @@ -2229,7 +2236,6 @@ LENGTH must be a number. INIT matters only in whether it is t or nil. */) { register Lisp_Object val; struct Lisp_Bool_Vector *p; - int real_init, i; EMACS_INT length_in_chars, length_in_elts; int bits_per_value; @@ -2251,9 +2257,7 @@ LENGTH must be a number. INIT matters only in whether it is t or nil. */) p = XBOOL_VECTOR (val); p->size = XFASTINT (length); - real_init = (NILP (init) ? 0 : -1); - for (i = 0; i < length_in_chars ; i++) - p->data[i] = real_init; + memset (p->data, NILP (init) ? 0 : -1, length_in_chars); /* Clear the extraneous bits in the last byte. */ if (XINT (length) != length_in_chars * BOOL_VECTOR_BITS_PER_CHAR) @@ -2463,10 +2467,6 @@ static struct float_block *float_block; static int float_block_index; -/* Total number of float blocks now in use. */ - -static int n_float_blocks; - /* Free-list of Lisp_Floats. */ static struct Lisp_Float *float_free_list; @@ -2480,7 +2480,6 @@ init_float (void) float_block = NULL; float_block_index = FLOAT_BLOCK_SIZE; /* Force alloc of new float_block. */ float_free_list = 0; - n_float_blocks = 0; } @@ -2514,7 +2513,6 @@ make_float (double float_value) memset (new->gcmarkbits, 0, sizeof new->gcmarkbits); float_block = new; float_block_index = 0; - n_float_blocks++; } XSETFLOAT (val, &float_block->floats[float_block_index]); float_block_index++; @@ -2579,10 +2577,6 @@ static int cons_block_index; static struct Lisp_Cons *cons_free_list; -/* Total number of cons blocks now in use. */ - -static int n_cons_blocks; - /* Initialize cons allocation. */ @@ -2592,7 +2586,6 @@ init_cons (void) cons_block = NULL; cons_block_index = CONS_BLOCK_SIZE; /* Force alloc of new cons_block. */ cons_free_list = 0; - n_cons_blocks = 0; } @@ -2636,7 +2629,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0, new->next = cons_block; cons_block = new; cons_block_index = 0; - n_cons_blocks++; } XSETCONS (val, &cons_block->conses[cons_block_index]); cons_block_index++; @@ -2705,7 +2697,7 @@ DEFUN ("list", Flist, Slist, 0, MANY, 0, doc: /* Return a newly created list with specified arguments as elements. Any number of arguments, even zero arguments, are allowed. usage: (list &rest OBJECTS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { register Lisp_Object val; val = Qnil; @@ -2775,10 +2767,12 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0, static struct Lisp_Vector *all_vectors; -/* Total number of vector-like objects now in use. */ - -static int n_vectors; - +/* Handy constants for vectorlike objects. */ +enum + { + header_size = offsetof (struct Lisp_Vector, contents), + word_size = sizeof (Lisp_Object) + }; /* Value is a pointer to a newly allocated Lisp_Vector structure with room for LEN Lisp_Objects. */ @@ -2788,11 +2782,6 @@ allocate_vectorlike (EMACS_INT len) { struct Lisp_Vector *p; size_t nbytes; - int header_size = offsetof (struct Lisp_Vector, contents); - int word_size = sizeof p->contents[0]; - - if ((SIZE_MAX - header_size) / word_size < len) - memory_full (SIZE_MAX); MALLOC_BLOCK_INPUT; @@ -2822,18 +2811,22 @@ allocate_vectorlike (EMACS_INT len) MALLOC_UNBLOCK_INPUT; - ++n_vectors; return p; } -/* Allocate a vector with NSLOTS slots. */ +/* Allocate a vector with LEN slots. */ struct Lisp_Vector * -allocate_vector (EMACS_INT nslots) +allocate_vector (EMACS_INT len) { - struct Lisp_Vector *v = allocate_vectorlike (nslots); - v->header.size = nslots; + struct Lisp_Vector *v; + ptrdiff_t nbytes_max = min (PTRDIFF_MAX, SIZE_MAX); + + if (min ((nbytes_max - header_size) / word_size, MOST_POSITIVE_FIXNUM) < len) + memory_full (SIZE_MAX); + v = allocate_vectorlike (len); + v->header.size = len; return v; } @@ -2844,7 +2837,7 @@ struct Lisp_Vector * allocate_pseudovector (int memlen, int lisplen, EMACS_INT tag) { struct Lisp_Vector *v = allocate_vectorlike (memlen); - EMACS_INT i; + int i; /* Only the first lisplen slots will be traced normally by the GC. */ for (i = 0; i < lisplen; ++i) @@ -2925,10 +2918,10 @@ DEFUN ("vector", Fvector, Svector, 0, MANY, 0, doc: /* Return a newly created vector with specified arguments as elements. Any number of arguments, even zero arguments, are allowed. usage: (vector &rest OBJECTS) */) - (register size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { register Lisp_Object len, val; - register size_t i; + ptrdiff_t i; register struct Lisp_Vector *p; XSETFASTINT (len, nargs); @@ -2956,15 +2949,15 @@ argument to catch the left-over arguments. If such an integer is used, the arguments will not be dynamically bound but will be instead pushed on the stack before executing the byte-code. usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS) */) - (register size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { register Lisp_Object len, val; - register size_t i; + ptrdiff_t i; register struct Lisp_Vector *p; XSETFASTINT (len, nargs); if (!NILP (Vpurify_flag)) - val = make_pure_vector ((EMACS_INT) nargs); + val = make_pure_vector (nargs); else val = Fmake_vector (len, Qnil); @@ -3018,10 +3011,6 @@ static int symbol_block_index; static struct Lisp_Symbol *symbol_free_list; -/* Total number of symbol blocks now in use. */ - -static int n_symbol_blocks; - /* Initialize symbol allocation. */ @@ -3031,7 +3020,6 @@ init_symbol (void) symbol_block = NULL; symbol_block_index = SYMBOL_BLOCK_SIZE; symbol_free_list = 0; - n_symbol_blocks = 0; } @@ -3064,7 +3052,6 @@ Its value and function definition are void, and its property list is nil. */) new->next = symbol_block; symbol_block = new; symbol_block_index = 0; - n_symbol_blocks++; } XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]); symbol_block_index++; @@ -3112,17 +3099,12 @@ static int marker_block_index; static union Lisp_Misc *marker_free_list; -/* Total number of marker blocks now in use. */ - -static int n_marker_blocks; - static void init_marker (void) { marker_block = NULL; marker_block_index = MARKER_BLOCK_SIZE; marker_free_list = 0; - n_marker_blocks = 0; } /* Return a newly allocated Lisp_Misc object, with no substructure. */ @@ -3151,7 +3133,6 @@ allocate_misc (void) new->next = marker_block; marker_block = new; marker_block_index = 0; - n_marker_blocks++; total_free_markers += MARKER_BLOCK_SIZE; } XSETMISC (val, &marker_block->markers[marker_block_index]); @@ -3184,7 +3165,7 @@ free_misc (Lisp_Object misc) The unwind function can get the C values back using XSAVE_VALUE. */ Lisp_Object -make_save_value (void *pointer, int integer) +make_save_value (void *pointer, ptrdiff_t integer) { register Lisp_Object val; register struct Lisp_Save_Value *p; @@ -3929,11 +3910,11 @@ static Lisp_Object zombies[MAX_ZOMBIES]; /* Number of zombie objects. */ -static int nzombies; +static EMACS_INT nzombies; /* Number of garbage collections. */ -static int ngcs; +static EMACS_INT ngcs; /* Average percentage of zombies per collection. */ @@ -3941,7 +3922,7 @@ static double avg_zombies; /* Max. number of live and zombie objects. */ -static int max_live, max_zombies; +static EMACS_INT max_live, max_zombies; /* Average number of live objects per GC. */ @@ -3952,7 +3933,7 @@ DEFUN ("gc-status", Fgc_status, Sgc_status, 0, 0, "", (void) { Lisp_Object args[8], zombie_list = Qnil; - int i; + EMACS_INT i; for (i = 0; i < nzombies; i++) zombie_list = Fcons (zombies[i], zombie_list); args[0] = build_string ("%d GCs, avg live/zombies = %.2f/%.2f (%f%%), max %d/%d\nzombies: %S"); @@ -4262,7 +4243,7 @@ static void check_gcpros (void) { struct gcpro *p; - size_t i; + ptrdiff_t i; for (p = gcprolist; p; p = p->next) for (i = 0; i < p->nvars; ++i) @@ -4279,7 +4260,7 @@ dump_zombies (void) { int i; - fprintf (stderr, "\nZombies kept alive = %d:\n", nzombies); + fprintf (stderr, "\nZombies kept alive = %"pI":\n", nzombies); for (i = 0; i < min (MAX_ZOMBIES, nzombies); ++i) { fprintf (stderr, " %d = ", i); @@ -4851,9 +4832,8 @@ int inhibit_garbage_collection (void) { int count = SPECPDL_INDEX (); - int nbits = min (VALBITS, BITS_PER_INT); - specbind (Qgc_cons_threshold, make_number (((EMACS_INT) 1 << (nbits - 1)) - 1)); + specbind (Qgc_cons_threshold, make_number (MOST_POSITIVE_FIXNUM)); return count; } @@ -4873,7 +4853,7 @@ returns nil, because real GC can't be done. */) { register struct specbinding *bind; char stack_top_variable; - register size_t i; + ptrdiff_t i; int message_p; Lisp_Object total[8]; int count = SPECPDL_INDEX (); @@ -5103,9 +5083,10 @@ returns nil, because real GC can't be done. */) if (gc_cons_threshold < 10000) gc_cons_threshold = 10000; + gc_relative_threshold = 0; if (FLOATP (Vgc_cons_percentage)) { /* Set gc_cons_combined_threshold. */ - EMACS_INT tot = 0; + double tot = 0; tot += total_conses * sizeof (struct Lisp_Cons); tot += total_symbols * sizeof (struct Lisp_Symbol); @@ -5116,10 +5097,15 @@ returns nil, because real GC can't be done. */) tot += total_intervals * sizeof (struct interval); tot += total_strings * sizeof (struct Lisp_String); - gc_relative_threshold = tot * XFLOAT_DATA (Vgc_cons_percentage); + tot *= XFLOAT_DATA (Vgc_cons_percentage); + if (0 < tot) + { + if (tot < TYPE_MAXIMUM (EMACS_INT)) + gc_relative_threshold = tot; + else + gc_relative_threshold = TYPE_MAXIMUM (EMACS_INT); + } } - else - gc_relative_threshold = 0; if (garbage_collection_messages) { @@ -5250,8 +5236,8 @@ static size_t mark_object_loop_halt; static void mark_vectorlike (struct Lisp_Vector *ptr) { - register EMACS_UINT size = ptr->header.size; - register EMACS_UINT i; + EMACS_INT size = ptr->header.size; + EMACS_INT i; eassert (!VECTOR_MARKED_P (ptr)); VECTOR_MARK (ptr); /* Else mark it */ @@ -5273,8 +5259,8 @@ mark_vectorlike (struct Lisp_Vector *ptr) static void mark_char_table (struct Lisp_Vector *ptr) { - register EMACS_UINT size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK; - register EMACS_UINT i; + int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK; + int i; eassert (!VECTOR_MARKED_P (ptr)); VECTOR_MARK (ptr); @@ -5402,12 +5388,11 @@ mark_object (Lisp_Object arg) recursion there. */ { register struct Lisp_Vector *ptr = XVECTOR (obj); - register EMACS_UINT size = ptr->header.size; - register EMACS_UINT i; + int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK; + int i; CHECK_LIVE (live_vector_p); VECTOR_MARK (ptr); /* Else mark it */ - size &= PSEUDOVECTOR_SIZE_MASK; for (i = 0; i < size; i++) /* and then mark its elements */ { if (i != COMPILED_CONSTANTS) @@ -5534,7 +5519,7 @@ mark_object (Lisp_Object arg) if (ptr->dogc) { Lisp_Object *p = (Lisp_Object *) ptr->pointer; - int nelt; + ptrdiff_t nelt; for (nelt = ptr->integer; nelt > 0; nelt--, p++) mark_maybe_object (*p); } @@ -5734,7 +5719,7 @@ gc_sweep (void) register struct cons_block *cblk; struct cons_block **cprev = &cons_block; register int lim = cons_block_index; - register int num_free = 0, num_used = 0; + EMACS_INT num_free = 0, num_used = 0; cons_free_list = 0; @@ -5795,7 +5780,6 @@ gc_sweep (void) /* Unhook from the free list. */ cons_free_list = cblk->conses[0].u.chain; lisp_align_free (cblk); - n_cons_blocks--; } else { @@ -5812,7 +5796,7 @@ gc_sweep (void) register struct float_block *fblk; struct float_block **fprev = &float_block; register int lim = float_block_index; - register int num_free = 0, num_used = 0; + EMACS_INT num_free = 0, num_used = 0; float_free_list = 0; @@ -5842,7 +5826,6 @@ gc_sweep (void) /* Unhook from the free list. */ float_free_list = fblk->floats[0].u.chain; lisp_align_free (fblk); - n_float_blocks--; } else { @@ -5859,7 +5842,7 @@ gc_sweep (void) register struct interval_block *iblk; struct interval_block **iprev = &interval_block; register int lim = interval_block_index; - register int num_free = 0, num_used = 0; + EMACS_INT num_free = 0, num_used = 0; interval_free_list = 0; @@ -5892,7 +5875,6 @@ gc_sweep (void) /* Unhook from the free list. */ interval_free_list = INTERVAL_PARENT (&iblk->intervals[0]); lisp_free (iblk); - n_interval_blocks--; } else { @@ -5909,7 +5891,7 @@ gc_sweep (void) register struct symbol_block *sblk; struct symbol_block **sprev = &symbol_block; register int lim = symbol_block_index; - register int num_free = 0, num_used = 0; + EMACS_INT num_free = 0, num_used = 0; symbol_free_list = NULL; @@ -5956,7 +5938,6 @@ gc_sweep (void) /* Unhook from the free list. */ symbol_free_list = sblk->symbols[0].next; lisp_free (sblk); - n_symbol_blocks--; } else { @@ -5974,7 +5955,7 @@ gc_sweep (void) register struct marker_block *mblk; struct marker_block **mprev = &marker_block; register int lim = marker_block_index; - register int num_free = 0, num_used = 0; + EMACS_INT num_free = 0, num_used = 0; marker_free_list = 0; @@ -6013,7 +5994,6 @@ gc_sweep (void) /* Unhook from the free list. */ marker_free_list = mblk->markers[0].u_free.chain; lisp_free (mblk); - n_marker_blocks--; } else { @@ -6063,7 +6043,6 @@ gc_sweep (void) all_vectors = vector->header.next.vector; next = vector->header.next.vector; lisp_free (vector); - n_vectors--; vector = next; } diff --git a/src/buffer.c b/src/buffer.c index 7030fea1002..d7adf63c98b 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -850,8 +850,8 @@ it is in the sequence to be tried) even if a buffer with that name exists. */) (register Lisp_Object name, Lisp_Object ignore) { register Lisp_Object gentemp, tem; - int count; - char number[10]; + EMACS_INT count; + char number[INT_BUFSIZE_BOUND (EMACS_INT) + sizeof "<>"]; CHECK_STRING (name); @@ -865,7 +865,7 @@ it is in the sequence to be tried) even if a buffer with that name exists. */) count = 1; while (1) { - sprintf (number, "<%d>", ++count); + sprintf (number, "<%"pI"d>", ++count); gentemp = concat2 (name, build_string (number)); tem = Fstring_equal (gentemp, ignore); if (!NILP (tem)) @@ -1969,7 +1969,7 @@ validate_region (register Lisp_Object *b, register Lisp_Object *e) /* Advance BYTE_POS up to a character boundary and return the adjusted position. */ -static int +static EMACS_INT advance_to_char_boundary (EMACS_INT byte_pos) { int c; diff --git a/src/buffer.h b/src/buffer.h index 3540bd87cea..dc1d62beb00 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -338,7 +338,7 @@ while (0) #define PTR_BYTE_POS(ptr) \ ((ptr) - (current_buffer)->text->beg \ - - (ptr - (current_buffer)->text->beg <= (unsigned) (GPT_BYTE - BEG_BYTE) ? 0 : GAP_SIZE) \ + - (ptr - (current_buffer)->text->beg <= GPT_BYTE - BEG_BYTE ? 0 : GAP_SIZE) \ + BEG_BYTE) /* Return character at byte position POS. */ @@ -397,7 +397,7 @@ extern unsigned char *_fetch_multibyte_char_p; #define BUF_PTR_BYTE_POS(buf, ptr) \ ((ptr) - (buf)->text->beg \ - - (ptr - (buf)->text->beg <= (unsigned) (BUF_GPT_BYTE ((buf)) - BEG_BYTE)\ + - (ptr - (buf)->text->beg <= BUF_GPT_BYTE (buf) - BEG_BYTE \ ? 0 : BUF_GAP_SIZE ((buf))) \ + BEG_BYTE) diff --git a/src/bytecode.c b/src/bytecode.c index 74cf401bf1d..58b26c79b84 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -433,7 +433,7 @@ If the third argument is incorrect, Emacs may crash. */) Lisp_Object exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, - Lisp_Object args_template, int nargs, Lisp_Object *args) + Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args) { int count = SPECPDL_INDEX (); #ifdef BYTE_CODE_METER @@ -444,7 +444,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, /* Lisp_Object v1, v2; */ Lisp_Object *vectorp; #ifdef BYTE_CODE_SAFE - int const_length; + ptrdiff_t const_length; Lisp_Object *stacke; int bytestr_length; #endif @@ -464,7 +464,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, CHECK_STRING (bytestr); CHECK_VECTOR (vector); - CHECK_NUMBER (maxdepth); + CHECK_NATNUM (maxdepth); #ifdef BYTE_CODE_SAFE const_length = ASIZE (vector); @@ -486,6 +486,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, stack.byte_string = bytestr; stack.pc = stack.byte_string_start = SDATA (bytestr); stack.constants = vector; + if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) < XFASTINT (maxdepth)) + memory_full (SIZE_MAX); top = (Lisp_Object *) alloca (XFASTINT (maxdepth) * sizeof (Lisp_Object)); #if BYTE_MAINTAIN_TOP @@ -502,14 +504,14 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, if (INTEGERP (args_template)) { - int at = XINT (args_template); + ptrdiff_t at = XINT (args_template); int rest = at & 128; int mandatory = at & 127; - int nonrest = at >> 8; + ptrdiff_t nonrest = at >> 8; eassert (mandatory <= nonrest); if (nargs <= nonrest) { - int i; + ptrdiff_t i; for (i = 0 ; i < nargs; i++, args++) PUSH (*args); if (nargs < mandatory) @@ -528,7 +530,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, } else if (rest) { - int i; + ptrdiff_t i; for (i = 0 ; i < nonrest; i++, args++) PUSH (*args); PUSH (Flist (nargs - nonrest, args)); diff --git a/src/callint.c b/src/callint.c index 2cc3a7cb537..dc5e6a4c37a 100644 --- a/src/callint.c +++ b/src/callint.c @@ -269,10 +269,9 @@ invoke it. If KEYS is omitted or nil, the return value of /* If varies[i] > 0, the i'th argument shouldn't just have its value in this call quoted in the command history. It should be recorded as a call to the function named callint_argfuns[varies[i]]. */ - int *varies; + signed char *varies; - register size_t i; - size_t nargs; + ptrdiff_t i, nargs; int foo; char prompt1[100]; char *tem1; @@ -339,7 +338,7 @@ invoke it. If KEYS is omitted or nil, the return value of { Lisp_Object input; Lisp_Object funval = Findirect_function (function, Qt); - i = num_input_events; + size_t events = num_input_events; input = specs; /* Compute the arg values using the user's expression. */ GCPRO2 (input, filter_specs); @@ -347,7 +346,7 @@ invoke it. If KEYS is omitted or nil, the return value of CONSP (funval) && EQ (Qclosure, XCAR (funval)) ? Qt : Qnil); UNGCPRO; - if (i != num_input_events || !NILP (record_flag)) + if (events != num_input_events || !NILP (record_flag)) { /* We should record this command on the command history. */ Lisp_Object values; @@ -465,9 +464,14 @@ invoke it. If KEYS is omitted or nil, the return value of break; } + if (min (MOST_POSITIVE_FIXNUM, + min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)) + < nargs) + memory_full (SIZE_MAX); + args = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object)); visargs = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object)); - varies = (int *) alloca (nargs * sizeof (int)); + varies = (signed char *) alloca (nargs); for (i = 0; i < nargs; i++) { diff --git a/src/callproc.c b/src/callproc.c index 7bb2ac05933..d6bad2a44e7 100644 --- a/src/callproc.c +++ b/src/callproc.c @@ -184,7 +184,7 @@ and returns a numeric exit status or a signal description string. If you quit, the process is killed with SIGINT, or SIGKILL if you quit again. usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object infile, buffer, current_dir, path; volatile int display_p_volatile; @@ -231,7 +231,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */) /* Decide the coding-system for giving arguments. */ { Lisp_Object val, *args2; - size_t i; + ptrdiff_t i; /* If arguments are supplied, we may have to encode them. */ if (nargs >= 5) @@ -422,7 +422,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */) (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv); if (nargs > 4) { - register size_t i; + ptrdiff_t i; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; GCPRO5 (infile, buffer, current_dir, path, error_file); @@ -716,7 +716,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */) { if (EQ (coding_systems, Qt)) { - size_t i; + ptrdiff_t i; SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2); args2[0] = Qcall_process; @@ -944,7 +944,7 @@ and returns a numeric exit status or a signal description string. If you quit, the process is killed with SIGINT, or SIGKILL if you quit again. usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { struct gcpro gcpro1; Lisp_Object filename_string; @@ -953,7 +953,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r /* Qt denotes we have not yet called Ffind_operation_coding_system. */ Lisp_Object coding_systems; Lisp_Object val, *args2; - size_t i; + ptrdiff_t i; char *tempfile; Lisp_Object tmpdir, pattern; diff --git a/src/casefiddle.c b/src/casefiddle.c index 9f286d73a5e..1a0a62f273c 100644 --- a/src/casefiddle.c +++ b/src/casefiddle.c @@ -52,7 +52,7 @@ casify_object (enum case_action flag, Lisp_Object obj) /* If the character has higher bits set above the flags, return it unchanged. It is not a real character. */ - if ((unsigned) XFASTINT (obj) > (unsigned) flagbits) + if (UNSIGNED_CMP (XFASTINT (obj), >, flagbits)) return obj; c1 = XFASTINT (obj) & ~flagbits; diff --git a/src/ccl.c b/src/ccl.c index e2ef4f194f3..30d151f00a0 100644 --- a/src/ccl.c +++ b/src/ccl.c @@ -745,11 +745,15 @@ while(0) #endif +/* Use "&" rather than "&&" to suppress a bogus GCC warning; see + . */ +#define ASCENDING_ORDER(lo, med, hi) (((lo) <= (med)) & ((med) <= (hi))) + #define GET_CCL_RANGE(var, ccl_prog, ic, lo, hi) \ do \ { \ EMACS_INT prog_word = XINT ((ccl_prog)[ic]); \ - if (! ((lo) <= prog_word && prog_word <= (hi))) \ + if (! ASCENDING_ORDER (lo, prog_word, hi)) \ CCL_INVALID_CMD; \ (var) = prog_word; \ } \ @@ -761,7 +765,7 @@ while(0) #define GET_CCL_INT(var, ccl_prog, ic) \ GET_CCL_RANGE (var, ccl_prog, ic, INT_MIN, INT_MAX) -#define IN_INT_RANGE(val) (INT_MIN <= (val) && (val) <= INT_MAX) +#define IN_INT_RANGE(val) ASCENDING_ORDER (INT_MIN, val, INT_MAX) /* Encode one character CH to multibyte form and write to the current output buffer. If CH is less than 256, CH is written as is. */ diff --git a/src/character.c b/src/character.c index 170952619e7..7fc5d647ff5 100644 --- a/src/character.c +++ b/src/character.c @@ -123,7 +123,7 @@ char_string (unsigned int c, unsigned char *p) if (c & CHAR_MODIFIER_MASK) { - c = (unsigned) char_resolve_modifier_mask ((int) c); + c = char_resolve_modifier_mask (c); /* If C still has any modifier bits, just ignore it. */ c &= ~CHAR_MODIFIER_MASK; } @@ -838,7 +838,7 @@ string_escape_byte8 (Lisp_Object string) if (multibyte) { if ((MOST_POSITIVE_FIXNUM - nchars) / 3 < byte8_count - || (STRING_BYTES_MAX - nbytes) / 2 < byte8_count) + || (STRING_BYTES_BOUND - nbytes) / 2 < byte8_count) string_overflow (); /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */ @@ -847,7 +847,7 @@ string_escape_byte8 (Lisp_Object string) } else { - if ((STRING_BYTES_MAX - nchars) / 3 < byte8_count) + if ((STRING_BYTES_BOUND - nbytes) / 3 < byte8_count) string_overflow (); /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */ @@ -893,9 +893,9 @@ DEFUN ("string", Fstring, Sstring, 0, MANY, 0, doc: /* Concatenate all the argument characters and make the result a string. usage: (string &rest CHARACTERS) */) - (size_t n, Lisp_Object *args) + (ptrdiff_t n, Lisp_Object *args) { - size_t i; + ptrdiff_t i; int c; unsigned char *buf, *p; Lisp_Object str; @@ -919,9 +919,9 @@ usage: (string &rest CHARACTERS) */) DEFUN ("unibyte-string", Funibyte_string, Sunibyte_string, 0, MANY, 0, doc: /* Concatenate all the argument bytes and make the result a unibyte string. usage: (unibyte-string &rest BYTES) */) - (size_t n, Lisp_Object *args) + (ptrdiff_t n, Lisp_Object *args) { - size_t i; + ptrdiff_t i; int c; unsigned char *buf, *p; Lisp_Object str; diff --git a/src/character.h b/src/character.h index 884833775de..9a45e7f0033 100644 --- a/src/character.h +++ b/src/character.h @@ -23,6 +23,8 @@ along with GNU Emacs. If not, see . */ #ifndef EMACS_CHARACTER_H #define EMACS_CHARACTER_H +#include + /* character code 1st byte byte sequence -------------- -------- ------------- 0-7F 00..7F 0xxxxxxx @@ -102,13 +104,13 @@ along with GNU Emacs. If not, see . */ #define make_char(c) make_number (c) /* Nonzero iff C is an ASCII byte. */ -#define ASCII_BYTE_P(c) ((unsigned) (c) < 0x80) +#define ASCII_BYTE_P(c) UNSIGNED_CMP (c, <, 0x80) /* Nonzero iff X is a character. */ #define CHARACTERP(x) (NATNUMP (x) && XFASTINT (x) <= MAX_CHAR) -/* Nonzero iff C is valid as a character code. GENERICP is not used. */ -#define CHAR_VALID_P(c, genericp) ((unsigned) (c) <= MAX_CHAR) +/* Nonzero iff C is valid as a character code. */ +#define CHAR_VALID_P(c) UNSIGNED_CMP (c, <=, MAX_CHAR) /* Check if Lisp object X is a character or not. */ #define CHECK_CHARACTER(x) \ @@ -129,7 +131,7 @@ along with GNU Emacs. If not, see . */ } while (0) /* Nonzero iff C is a character of code less than 0x100. */ -#define SINGLE_BYTE_CHAR_P(c) ((unsigned) (c) < 0x100) +#define SINGLE_BYTE_CHAR_P(c) UNSIGNED_CMP (c, <, 0x100) /* Nonzero if character C has a printable glyph. */ #define CHAR_PRINTABLE_P(c) \ @@ -161,19 +163,19 @@ along with GNU Emacs. If not, see . */ Returns the length of the multibyte form. */ #define CHAR_STRING(c, p) \ - ((unsigned) (c) <= MAX_1_BYTE_CHAR \ + (UNSIGNED_CMP (c, <=, MAX_1_BYTE_CHAR) \ ? ((p)[0] = (c), \ 1) \ - : (unsigned) (c) <= MAX_2_BYTE_CHAR \ + : UNSIGNED_CMP (c, <=, MAX_2_BYTE_CHAR) \ ? ((p)[0] = (0xC0 | ((c) >> 6)), \ (p)[1] = (0x80 | ((c) & 0x3F)), \ 2) \ - : (unsigned) (c) <= MAX_3_BYTE_CHAR \ + : UNSIGNED_CMP (c, <=, MAX_3_BYTE_CHAR) \ ? ((p)[0] = (0xE0 | ((c) >> 12)), \ (p)[1] = (0x80 | (((c) >> 6) & 0x3F)), \ (p)[2] = (0x80 | ((c) & 0x3F)), \ 3) \ - : char_string ((unsigned) c, p)) + : verify_expr (sizeof (c) <= sizeof (unsigned), char_string (c, p))) /* Store multibyte form of byte B in P. The caller should allocate at least MAX_MULTIBYTE_LENGTH bytes area at P in advance. Returns the @@ -201,7 +203,10 @@ along with GNU Emacs. If not, see . */ *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \ *(p)++ = (0x80 | ((c) & 0x3F)); \ else \ - (p) += char_string ((c), (p)); \ + { \ + verify (sizeof (c) <= sizeof (unsigned)); \ + (p) += char_string (c, p); \ + } \ } while (0) diff --git a/src/charset.c b/src/charset.c index 770e98c99e1..55234aa76aa 100644 --- a/src/charset.c +++ b/src/charset.c @@ -844,7 +844,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_internal, Sdefine_charset_internal, charset_arg_max, MANY, 0, doc: /* For internal use only. usage: (define-charset-internal ...) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { /* Charset attr vector. */ Lisp_Object attrs; @@ -1862,14 +1862,15 @@ Optional argument RESTRICTION specifies a way to map CH to a code-point in CCS. Currently not supported and just ignored. */) (Lisp_Object ch, Lisp_Object charset, Lisp_Object restriction) { - int id; + int c, id; unsigned code; struct charset *charsetp; CHECK_CHARSET_GET_ID (charset, id); - CHECK_NATNUM (ch); + CHECK_CHARACTER (ch); + c = XFASTINT (ch); charsetp = CHARSET_FROM_ID (id); - code = ENCODE_CHAR (charsetp, XINT (ch)); + code = ENCODE_CHAR (charsetp, c); if (code == CHARSET_INVALID_CODE (charsetp)) return Qnil; return INTEGER_TO_CONS (code); @@ -2144,11 +2145,11 @@ DEFUN ("set-charset-priority", Fset_charset_priority, Sset_charset_priority, 1, MANY, 0, doc: /* Assign higher priority to the charsets given as arguments. usage: (set-charset-priority &rest charsets) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object new_head, old_list, arglist[2]; Lisp_Object list_2022, list_emacs_mule; - size_t i; + ptrdiff_t i; int id; old_list = Fcopy_sequence (Vcharset_ordered_list); diff --git a/src/charset.h b/src/charset.h index 16f45ff9865..c2a52a38e7e 100644 --- a/src/charset.h +++ b/src/charset.h @@ -27,6 +27,8 @@ along with GNU Emacs. If not, see . */ #ifndef EMACS_CHARSET_H #define EMACS_CHARSET_H +#include + /* Index to arguments of Fdefine_charset_internal. */ enum define_charset_arg_index @@ -424,28 +426,30 @@ extern Lisp_Object charset_work; /* Return a code point of CHAR in CHARSET. Try some optimization before calling encode_char. */ -#define ENCODE_CHAR(charset, c) \ - ((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p) \ - ? (c) \ - : ((charset)->unified_p \ - || (charset)->method == CHARSET_METHOD_SUBSET \ - || (charset)->method == CHARSET_METHOD_SUPERSET) \ - ? encode_char ((charset), (c)) \ - : ((c) < (charset)->min_char || (c) > (charset)->max_char) \ - ? (charset)->invalid_code \ - : (charset)->method == CHARSET_METHOD_OFFSET \ - ? ((charset)->code_linear_p \ - ? (c) - (charset)->code_offset + (charset)->min_code \ - : encode_char ((charset), (c))) \ - : (charset)->method == CHARSET_METHOD_MAP \ - ? (((charset)->compact_codes_p \ - && CHAR_TABLE_P (CHARSET_ENCODER (charset))) \ - ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c)), \ - (NILP (charset_work) \ - ? (charset)->invalid_code \ - : XFASTINT (charset_work))) \ - : encode_char ((charset), (c))) \ - : encode_char ((charset), (c))) +#define ENCODE_CHAR(charset, c) \ + (verify_expr \ + (sizeof (c) <= sizeof (int), \ + (ASCII_CHAR_P (c) && (charset)->ascii_compatible_p \ + ? (c) \ + : ((charset)->unified_p \ + || (charset)->method == CHARSET_METHOD_SUBSET \ + || (charset)->method == CHARSET_METHOD_SUPERSET) \ + ? encode_char (charset, c) \ + : (c) < (charset)->min_char || (c) > (charset)->max_char \ + ? (charset)->invalid_code \ + : (charset)->method == CHARSET_METHOD_OFFSET \ + ? ((charset)->code_linear_p \ + ? (c) - (charset)->code_offset + (charset)->min_code \ + : encode_char (charset, c)) \ + : (charset)->method == CHARSET_METHOD_MAP \ + ? (((charset)->compact_codes_p \ + && CHAR_TABLE_P (CHARSET_ENCODER (charset))) \ + ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), c), \ + (NILP (charset_work) \ + ? (charset)->invalid_code \ + : XFASTINT (charset_work))) \ + : encode_char (charset, c)) \ + : encode_char (charset, c)))) /* Set to 1 when a charset map is loaded to warn that a buffer text diff --git a/src/chartab.c b/src/chartab.c index 2f40ceee6ce..ed5b238646e 100644 --- a/src/chartab.c +++ b/src/chartab.c @@ -524,15 +524,15 @@ a cons of character codes (for characters in the range), or a character code. * if (EQ (range, Qnil)) val = XCHAR_TABLE (char_table)->defalt; - else if (INTEGERP (range)) - val = CHAR_TABLE_REF (char_table, XINT (range)); + else if (CHARACTERP (range)) + val = CHAR_TABLE_REF (char_table, XFASTINT (range)); else if (CONSP (range)) { int from, to; CHECK_CHARACTER_CAR (range); CHECK_CHARACTER_CDR (range); - val = char_table_ref_and_range (char_table, XINT (XCAR (range)), + val = char_table_ref_and_range (char_table, XFASTINT (XCAR (range)), &from, &to); /* Not yet implemented. */ } diff --git a/src/coding.c b/src/coding.c index 64e8e41a5a1..04985ab3c74 100644 --- a/src/coding.c +++ b/src/coding.c @@ -1071,7 +1071,7 @@ coding_set_destination (struct coding_system *coding) static void coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes) { - if (STRING_BYTES_MAX - coding->dst_bytes < bytes) + if (STRING_BYTES_BOUND - coding->dst_bytes < bytes) string_overflow (); coding->destination = (unsigned char *) xrealloc (coding->destination, coding->dst_bytes + bytes); @@ -9278,7 +9278,7 @@ function to call for FILENAME, that function should examine the contents of BUFFER instead of reading the file. usage: (find-operation-coding-system OPERATION ARGUMENTS...) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object operation, target_idx, target, val; register Lisp_Object chain; @@ -9355,9 +9355,9 @@ If multiple coding systems belong to the same category, all but the first one are ignored. usage: (set-coding-system-priority &rest coding-systems) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { - size_t i, j; + ptrdiff_t i, j; int changed[coding_category_max]; enum coding_category priorities[coding_category_max]; @@ -9461,7 +9461,7 @@ DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal, Sdefine_coding_system_internal, coding_arg_max, MANY, 0, doc: /* For internal use only. usage: (define-coding-system-internal ...) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object name; Lisp_Object spec_vec; /* [ ATTRS ALIASE EOL_TYPE ] */ diff --git a/src/composite.c b/src/composite.c index ab9ec3f5a03..51b7669cb4f 100644 --- a/src/composite.c +++ b/src/composite.c @@ -858,7 +858,7 @@ fill_gstring_body (Lisp_Object gstring) for (i = 0; i < len; i++) { Lisp_Object g = LGSTRING_GLYPH (gstring, i); - EMACS_INT c = XINT (AREF (header, i + 1)); + int c = XFASTINT (AREF (header, i + 1)); if (NILP (g)) { @@ -995,7 +995,8 @@ static int _work_char; void composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT endpos, Lisp_Object string) { - EMACS_INT start, end, c; + EMACS_INT start, end; + int c; Lisp_Object prop, val; /* This is from forward_to_next_line_start in xdisp.c. */ const int MAX_NEWLINE_DISTANCE = 500; diff --git a/src/composite.h b/src/composite.h index 0f81911f0b0..8cedfdbe352 100644 --- a/src/composite.h +++ b/src/composite.h @@ -151,7 +151,7 @@ extern Lisp_Object composition_temp; /* Nonzero if the global reference point GREF and new reference point NREF are valid. */ #define COMPOSITION_ENCODE_RULE_VALID(gref, nref) \ - ((unsigned) (gref) < 12 && (unsigned) (nref) < 12) + (UNSIGNED_CMP (gref, <, 12) && UNSIGNED_CMP (nref, <, 12)) /* Return encoded composition rule for the pair of global reference point GREF and new reference point NREF. Arguments must be valid. */ diff --git a/src/data.c b/src/data.c index 57d7753e393..cf01d38036d 100644 --- a/src/data.c +++ b/src/data.c @@ -2148,61 +2148,62 @@ bool-vector. IDX starts at 0. */) CHECK_CHARACTER (idx); CHAR_TABLE_SET (array, idxval, newelt); } - else if (STRING_MULTIBYTE (array)) + else { - EMACS_INT idxval_byte, prev_bytes, new_bytes, nbytes; - unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1; + int c; if (idxval < 0 || idxval >= SCHARS (array)) args_out_of_range (array, idx); CHECK_CHARACTER (newelt); + c = XFASTINT (newelt); - nbytes = SBYTES (array); - - idxval_byte = string_char_to_byte (array, idxval); - p1 = SDATA (array) + idxval_byte; - prev_bytes = BYTES_BY_CHAR_HEAD (*p1); - new_bytes = CHAR_STRING (XINT (newelt), p0); - if (prev_bytes != new_bytes) + if (STRING_MULTIBYTE (array)) { - /* We must relocate the string data. */ - EMACS_INT nchars = SCHARS (array); - unsigned char *str; - USE_SAFE_ALLOCA; + EMACS_INT idxval_byte, prev_bytes, new_bytes, nbytes; + unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1; - SAFE_ALLOCA (str, unsigned char *, nbytes); - memcpy (str, SDATA (array), nbytes); - allocate_string_data (XSTRING (array), nchars, - nbytes + new_bytes - prev_bytes); - memcpy (SDATA (array), str, idxval_byte); + nbytes = SBYTES (array); + idxval_byte = string_char_to_byte (array, idxval); p1 = SDATA (array) + idxval_byte; - memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes, - nbytes - (idxval_byte + prev_bytes)); - SAFE_FREE (); - clear_string_char_byte_cache (); - } - while (new_bytes--) - *p1++ = *p0++; - } - else - { - if (idxval < 0 || idxval >= SCHARS (array)) - args_out_of_range (array, idx); - CHECK_NUMBER (newelt); + prev_bytes = BYTES_BY_CHAR_HEAD (*p1); + new_bytes = CHAR_STRING (c, p0); + if (prev_bytes != new_bytes) + { + /* We must relocate the string data. */ + EMACS_INT nchars = SCHARS (array); + unsigned char *str; + USE_SAFE_ALLOCA; - if (XINT (newelt) >= 0 && ! SINGLE_BYTE_CHAR_P (XINT (newelt))) + SAFE_ALLOCA (str, unsigned char *, nbytes); + memcpy (str, SDATA (array), nbytes); + allocate_string_data (XSTRING (array), nchars, + nbytes + new_bytes - prev_bytes); + memcpy (SDATA (array), str, idxval_byte); + p1 = SDATA (array) + idxval_byte; + memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes, + nbytes - (idxval_byte + prev_bytes)); + SAFE_FREE (); + clear_string_char_byte_cache (); + } + while (new_bytes--) + *p1++ = *p0++; + } + else { - int i; + if (! SINGLE_BYTE_CHAR_P (c)) + { + int i; - for (i = SBYTES (array) - 1; i >= 0; i--) - if (SREF (array, i) >= 0x80) - args_out_of_range (array, newelt); - /* ARRAY is an ASCII string. Convert it to a multibyte - string, and try `aset' again. */ - STRING_SET_MULTIBYTE (array); - return Faset (array, idx, newelt); + for (i = SBYTES (array) - 1; i >= 0; i--) + if (SREF (array, i) >= 0x80) + args_out_of_range (array, newelt); + /* ARRAY is an ASCII string. Convert it to a multibyte + string, and try `aset' again. */ + STRING_SET_MULTIBYTE (array); + return Faset (array, idx, newelt); + } + SSET (array, idxval, c); } - SSET (array, idxval, XINT (newelt)); } return newelt; @@ -2502,18 +2503,18 @@ enum arithop Amin }; -static Lisp_Object float_arith_driver (double, size_t, enum arithop, - size_t, Lisp_Object *); +static Lisp_Object float_arith_driver (double, ptrdiff_t, enum arithop, + ptrdiff_t, Lisp_Object *); static Lisp_Object -arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args) +arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args) { register Lisp_Object val; - register size_t argnum; + ptrdiff_t argnum; register EMACS_INT accum = 0; register EMACS_INT next; int overflow = 0; - size_t ok_args; + ptrdiff_t ok_args; EMACS_INT ok_accum; switch (SWITCH_ENUM_CAST (code)) @@ -2617,8 +2618,8 @@ arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args) #define isnan(x) ((x) != (x)) static Lisp_Object -float_arith_driver (double accum, register size_t argnum, enum arithop code, - size_t nargs, register Lisp_Object *args) +float_arith_driver (double accum, ptrdiff_t argnum, enum arithop code, + ptrdiff_t nargs, Lisp_Object *args) { register Lisp_Object val; double next; @@ -2680,7 +2681,7 @@ float_arith_driver (double accum, register size_t argnum, enum arithop code, DEFUN ("+", Fplus, Splus, 0, MANY, 0, doc: /* Return sum of any number of arguments, which are numbers or markers. usage: (+ &rest NUMBERS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Aadd, nargs, args); } @@ -2690,7 +2691,7 @@ DEFUN ("-", Fminus, Sminus, 0, MANY, 0, With one arg, negates it. With more than one arg, subtracts all but the first from the first. usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Asub, nargs, args); } @@ -2698,7 +2699,7 @@ usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */) DEFUN ("*", Ftimes, Stimes, 0, MANY, 0, doc: /* Return product of any number of arguments, which are numbers or markers. usage: (* &rest NUMBERS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Amult, nargs, args); } @@ -2707,9 +2708,9 @@ DEFUN ("/", Fquo, Squo, 2, MANY, 0, doc: /* Return first argument divided by all the remaining arguments. The arguments must be numbers or markers. usage: (/ DIVIDEND DIVISOR &rest DIVISORS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { - size_t argnum; + ptrdiff_t argnum; for (argnum = 2; argnum < nargs; argnum++) if (FLOATP (args[argnum])) return float_arith_driver (0, 0, Adiv, nargs, args); @@ -2791,7 +2792,7 @@ DEFUN ("max", Fmax, Smax, 1, MANY, 0, doc: /* Return largest of all the arguments (which must be numbers or markers). The value is always a number; markers are converted to numbers. usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Amax, nargs, args); } @@ -2800,7 +2801,7 @@ DEFUN ("min", Fmin, Smin, 1, MANY, 0, doc: /* Return smallest of all the arguments (which must be numbers or markers). The value is always a number; markers are converted to numbers. usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Amin, nargs, args); } @@ -2809,7 +2810,7 @@ DEFUN ("logand", Flogand, Slogand, 0, MANY, 0, doc: /* Return bitwise-and of all the arguments. Arguments may be integers, or markers converted to integers. usage: (logand &rest INTS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Alogand, nargs, args); } @@ -2818,7 +2819,7 @@ DEFUN ("logior", Flogior, Slogior, 0, MANY, 0, doc: /* Return bitwise-or of all the arguments. Arguments may be integers, or markers converted to integers. usage: (logior &rest INTS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Alogior, nargs, args); } @@ -2827,7 +2828,7 @@ DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0, doc: /* Return bitwise-exclusive-or of all the arguments. Arguments may be integers, or markers converted to integers. usage: (logxor &rest INTS-OR-MARKERS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return arith_driver (Alogxor, nargs, args); } diff --git a/src/dbusbind.c b/src/dbusbind.c index d8d0c7c2ef0..f662d5b38a2 100644 --- a/src/dbusbind.c +++ b/src/dbusbind.c @@ -1078,7 +1078,7 @@ object is returned instead of a list containing this single Lisp object. => "i686" usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TIMEOUT &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service, path, interface, method; Lisp_Object result; @@ -1090,7 +1090,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI DBusError derror; unsigned int dtype; int timeout = -1; - size_t i = 5; + ptrdiff_t i = 5; char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH]; /* Check parameters. */ @@ -1143,7 +1143,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]); - XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4, SDATA (format2 ("%s", args[i], Qnil)), SDATA (format2 ("%s", args[i+1], Qnil))); ++i; @@ -1151,7 +1151,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI else { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); - XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4, SDATA (format2 ("%s", args[i], Qnil))); } @@ -1260,7 +1260,7 @@ HANDLER is called. -| i686 usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLER &optional :timeout TIMEOUT &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service, path, interface, method, handler; Lisp_Object result; @@ -1271,7 +1271,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE unsigned int dtype; dbus_uint32_t serial; int timeout = -1; - size_t i = 6; + ptrdiff_t i = 6; char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH]; /* Check parameters. */ @@ -1326,7 +1326,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]); - XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4, SDATA (format2 ("%s", args[i], Qnil)), SDATA (format2 ("%s", args[i+1], Qnil))); ++i; @@ -1334,7 +1334,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE else { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); - XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i - 4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4, SDATA (format2 ("%s", args[i], Qnil))); } @@ -1386,7 +1386,7 @@ DEFUN ("dbus-method-return-internal", Fdbus_method_return_internal, This is an internal function, it shall not be used outside dbus.el. usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service; struct gcpro gcpro1, gcpro2; @@ -1395,7 +1395,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS) */) DBusMessageIter iter; dbus_uint32_t serial; unsigned int ui_serial, dtype; - size_t i; + ptrdiff_t i; char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH]; /* Check parameters. */ @@ -1435,7 +1435,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS) */) { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]); - XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2, SDATA (format2 ("%s", args[i], Qnil)), SDATA (format2 ("%s", args[i+1], Qnil))); ++i; @@ -1443,7 +1443,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS) */) else { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); - XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2, SDATA (format2 ("%s", args[i], Qnil))); } @@ -1475,7 +1475,7 @@ DEFUN ("dbus-method-error-internal", Fdbus_method_error_internal, This is an internal function, it shall not be used outside dbus.el. usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service; struct gcpro gcpro1, gcpro2; @@ -1484,7 +1484,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS) */) DBusMessageIter iter; dbus_uint32_t serial; unsigned int ui_serial, dtype; - size_t i; + ptrdiff_t i; char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH]; /* Check parameters. */ @@ -1525,7 +1525,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS) */) { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]); - XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2, SDATA (format2 ("%s", args[i], Qnil)), SDATA (format2 ("%s", args[i+1], Qnil))); ++i; @@ -1533,7 +1533,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS) */) else { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); - XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2, SDATA (format2 ("%s", args[i], Qnil))); } @@ -1588,7 +1588,7 @@ type symbols, see Info node `(dbus)Type Conversion'. "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs") usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service, path, interface, signal; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; @@ -1596,7 +1596,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS) */) DBusMessage *dmessage; DBusMessageIter iter; unsigned int dtype; - size_t i; + ptrdiff_t i; char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH]; /* Check parameters. */ @@ -1640,7 +1640,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS) */) { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]); - XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4, SDATA (format2 ("%s", args[i], Qnil)), SDATA (format2 ("%s", args[i+1], Qnil))); ++i; @@ -1648,7 +1648,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS) */) else { XD_DEBUG_VALID_LISP_OBJECT_P (args[i]); - XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4), + XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4, SDATA (format2 ("%s", args[i], Qnil))); } @@ -1919,11 +1919,11 @@ placed in the queue. => :already-owner. usage: (dbus-register-service BUS SERVICE &rest FLAGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service; DBusConnection *connection; - size_t i; + ptrdiff_t i; unsigned int value; unsigned int flags = 0; int result; @@ -2019,13 +2019,13 @@ INTERFACE, SIGNAL and HANDLER must not be nil. Example: `dbus-unregister-object' for removing the registration. usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object bus, service, path, interface, signal, handler; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6; Lisp_Object uname, key, key1, value; DBusConnection *connection; - size_t i; + ptrdiff_t i; char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH]; char x[DBUS_MAXIMUM_MATCH_RULE_LENGTH]; DBusError derror; @@ -2095,7 +2095,7 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG if (!NILP (args[i])) { CHECK_STRING (args[i]); - sprintf (x, ",arg%lu='%s'", (unsigned long) (i-6), + sprintf (x, ",arg%"pD"d='%s'", i - 6, SDATA (args[i])); strcat (rule, x); } diff --git a/src/dired.c b/src/dired.c index a95882060fb..3ab1ba8a900 100644 --- a/src/dired.c +++ b/src/dired.c @@ -978,11 +978,14 @@ so last access time will always be midnight of that day. */) values[4] = make_time (s.st_atime); values[5] = make_time (s.st_mtime); values[6] = make_time (s.st_ctime); - values[7] = make_fixnum_or_float (s.st_size); - /* If the size is negative, and its type is long, convert it back to - positive. */ - if (s.st_size < 0 && sizeof (s.st_size) == sizeof (long)) - values[7] = make_float ((double) ((unsigned long) s.st_size)); + + /* If the file size is a 4-byte type, assume that files of sizes in + the 2-4 GiB range wrap around to negative values, as this is a + common bug on older 32-bit platforms. */ + if (sizeof (s.st_size) == 4) + values[7] = make_fixnum_or_float (s.st_size & 0xffffffffu); + else + values[7] = make_fixnum_or_float (s.st_size); filemodestring (&s, modes); values[8] = make_string (modes, 10); diff --git a/src/dispextern.h b/src/dispextern.h index 211a1b06659..0ededf33ac6 100644 --- a/src/dispextern.h +++ b/src/dispextern.h @@ -1729,7 +1729,7 @@ struct face_cache face doesn't exist. */ #define FACE_FROM_ID(F, ID) \ - (((unsigned) (ID) < FRAME_FACE_CACHE (F)->used) \ + (UNSIGNED_CMP (ID, <, FRAME_FACE_CACHE (F)->used) \ ? FRAME_FACE_CACHE (F)->faces_by_id[ID] \ : NULL) @@ -3163,7 +3163,7 @@ int face_at_string_position (struct window *w, Lisp_Object string, EMACS_INT pos, EMACS_INT bufpos, EMACS_INT region_beg, EMACS_INT region_end, EMACS_INT *endptr, enum face_id, int mouse); -int merge_faces (struct frame *, Lisp_Object, int, int); +int merge_faces (struct frame *, Lisp_Object, EMACS_INT, int); int compute_char_face (struct frame *, int, Lisp_Object); void free_all_realized_faces (Lisp_Object); extern Lisp_Object Qforeground_color, Qbackground_color; diff --git a/src/doc.c b/src/doc.c index 89a7d322966..48e0936510b 100644 --- a/src/doc.c +++ b/src/doc.c @@ -253,9 +253,12 @@ get_doc_string (Lisp_Object filepos, int unibyte, int definition) else if (c == '_') *to++ = 037; else - error ("\ + { + unsigned char uc = c; + error ("\ Invalid data in documentation file -- %c followed by code %03o", - 1, (unsigned)c); + 1, uc); + } } else *to++ = *from++; diff --git a/src/doprnt.c b/src/doprnt.c index 5ca3ea89be6..195598c07ea 100644 --- a/src/doprnt.c +++ b/src/doprnt.c @@ -118,10 +118,6 @@ along with GNU Emacs. If not, see . */ another macro. */ #include "character.h" -#ifndef SIZE_MAX -# define SIZE_MAX ((size_t) -1) -#endif - #ifndef DBL_MAX_10_EXP #define DBL_MAX_10_EXP 308 /* IEEE double */ #endif @@ -329,7 +325,7 @@ doprnt (char *buffer, register size_t bufsize, const char *format, minlen = atoi (&fmtcpy[1]); string = va_arg (ap, char *); tem = strlen (string); - if (tem > STRING_BYTES_MAX) + if (STRING_BYTES_BOUND < tem) error ("String for %%s or %%S format is too long"); width = strwidth (string, tem); goto doit1; @@ -338,7 +334,7 @@ doprnt (char *buffer, register size_t bufsize, const char *format, doit: /* Coming here means STRING contains ASCII only. */ tem = strlen (string); - if (tem > STRING_BYTES_MAX) + if (STRING_BYTES_BOUND < tem) error ("Format width or precision too large"); width = tem; doit1: diff --git a/src/editfns.c b/src/editfns.c index b4ce9a1c571..9678d4da6a2 100644 --- a/src/editfns.c +++ b/src/editfns.c @@ -96,7 +96,7 @@ static void general_insert_function (void (*) (const char *, EMACS_INT), void (*) (Lisp_Object, EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT, int), - int, size_t, Lisp_Object *); + int, ptrdiff_t, Lisp_Object *); static Lisp_Object subst_char_in_region_unwind (Lisp_Object); static Lisp_Object subst_char_in_region_unwind_1 (Lisp_Object); static void transpose_markers (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT, @@ -185,12 +185,13 @@ DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0, usage: (char-to-string CHAR) */) (Lisp_Object character) { - int len; + int c, len; unsigned char str[MAX_MULTIBYTE_LENGTH]; CHECK_CHARACTER (character); + c = XFASTINT (character); - len = CHAR_STRING (XFASTINT (character), str); + len = CHAR_STRING (c, str); return make_string_from_bytes ((char *) str, 1, len); } @@ -1857,7 +1858,7 @@ Years before 1970 are not guaranteed to work. On some systems, year values as low as 1901 do work. usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { time_t value; struct tm tm; @@ -2193,9 +2194,9 @@ general_insert_function (void (*insert_func) void (*insert_from_string_func) (Lisp_Object, EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT, int), - int inherit, size_t nargs, Lisp_Object *args) + int inherit, ptrdiff_t nargs, Lisp_Object *args) { - register size_t argnum; + ptrdiff_t argnum; register Lisp_Object val; for (argnum = 0; argnum < nargs; argnum++) @@ -2203,16 +2204,15 @@ general_insert_function (void (*insert_func) val = args[argnum]; if (CHARACTERP (val)) { + int c = XFASTINT (val); unsigned char str[MAX_MULTIBYTE_LENGTH]; int len; if (!NILP (BVAR (current_buffer, enable_multibyte_characters))) - len = CHAR_STRING (XFASTINT (val), str); + len = CHAR_STRING (c, str); else { - str[0] = (ASCII_CHAR_P (XINT (val)) - ? XINT (val) - : multibyte_char_to_unibyte (XINT (val))); + str[0] = ASCII_CHAR_P (c) ? c : multibyte_char_to_unibyte (c); len = 1; } (*insert_func) ((char *) str, len); @@ -2258,7 +2258,7 @@ buffer; to accomplish this, apply `string-as-multibyte' to the string and insert the result. usage: (insert &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { general_insert_function (insert, insert_from_string, 0, nargs, args); return Qnil; @@ -2277,7 +2277,7 @@ If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion. usage: (insert-and-inherit &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { general_insert_function (insert_and_inherit, insert_from_string, 1, nargs, args); @@ -2294,7 +2294,7 @@ If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion. usage: (insert-before-markers &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { general_insert_function (insert_before_markers, insert_from_string_before_markers, 0, @@ -2313,7 +2313,7 @@ If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion. usage: (insert-before-markers-and-inherit &rest ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { general_insert_function (insert_before_markers_and_inherit, insert_from_string_before_markers, 1, @@ -2332,16 +2332,17 @@ from adjoining text, if those properties are sticky. */) register EMACS_INT stringlen; register int i; register EMACS_INT n; - int len; + int c, len; unsigned char str[MAX_MULTIBYTE_LENGTH]; - CHECK_NUMBER (character); + CHECK_CHARACTER (character); CHECK_NUMBER (count); + c = XFASTINT (character); if (!NILP (BVAR (current_buffer, enable_multibyte_characters))) - len = CHAR_STRING (XFASTINT (character), str); + len = CHAR_STRING (c, str); else - str[0] = XFASTINT (character), len = 1; + str[0] = c, len = 1; if (BUF_BYTES_MAX / len < XINT (count)) error ("Maximum buffer size would be exceeded"); n = XINT (count) * len; @@ -2784,17 +2785,20 @@ Both characters must have the same length of multi-byte form. */) int maybe_byte_combining = COMBINING_NO; EMACS_INT last_changed = 0; int multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters)); + int fromc, toc; restart: validate_region (&start, &end); - CHECK_NUMBER (fromchar); - CHECK_NUMBER (tochar); + CHECK_CHARACTER (fromchar); + CHECK_CHARACTER (tochar); + fromc = XFASTINT (fromchar); + toc = XFASTINT (tochar); if (multibyte_p) { - len = CHAR_STRING (XFASTINT (fromchar), fromstr); - if (CHAR_STRING (XFASTINT (tochar), tostr) != len) + len = CHAR_STRING (fromc, fromstr); + if (CHAR_STRING (toc, tostr) != len) error ("Characters in `subst-char-in-region' have different byte-lengths"); if (!ASCII_BYTE_P (*tostr)) { @@ -2811,8 +2815,8 @@ Both characters must have the same length of multi-byte form. */) else { len = 1; - fromstr[0] = XFASTINT (fromchar); - tostr[0] = XFASTINT (tochar); + fromstr[0] = fromc; + tostr[0] = toc; } pos = XINT (start); @@ -3084,14 +3088,11 @@ It returns the number of characters changed. */) } else { - EMACS_INT c; - nc = oc; val = CHAR_TABLE_REF (table, oc); - if (CHARACTERP (val) - && (c = XINT (val), CHAR_VALID_P (c, 0))) + if (CHARACTERP (val)) { - nc = c; + nc = XFASTINT (val); str_len = CHAR_STRING (nc, buf); str = buf; } @@ -3385,7 +3386,7 @@ any existing message; this lets the minibuffer contents show. See also `current-message'. usage: (message FORMAT-STRING &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { if (NILP (args[0]) || (STRINGP (args[0]) @@ -3413,7 +3414,7 @@ If the first argument is nil or the empty string, clear any existing message; let the minibuffer contents show. usage: (message-box FORMAT-STRING &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { if (NILP (args[0])) { @@ -3470,7 +3471,7 @@ If the first argument is nil or the empty string, clear any existing message; let the minibuffer contents show. usage: (message-or-box FORMAT-STRING &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { #ifdef HAVE_MENUS if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event)) @@ -3494,11 +3495,11 @@ First argument is the string to copy. Remaining arguments form a sequence of PROPERTY VALUE pairs for text properties to add to the result. usage: (propertize STRING &rest PROPERTIES) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object properties, string; struct gcpro gcpro1, gcpro2; - size_t i; + ptrdiff_t i; /* Number of args must be odd. */ if ((nargs & 1) == 0) @@ -3583,13 +3584,13 @@ decimal point itself is omitted. For %s and %S, the precision specifier truncates the string to the given width. usage: (format STRING &rest OBJECTS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { - EMACS_INT n; /* The number of the next arg to substitute */ + ptrdiff_t n; /* The number of the next arg to substitute */ char initial_buffer[4000]; char *buf = initial_buffer; EMACS_INT bufsize = sizeof initial_buffer; - EMACS_INT max_bufsize = STRING_BYTES_MAX + 1; + EMACS_INT max_bufsize = STRING_BYTES_BOUND + 1; char *p; Lisp_Object buf_save_value IF_LINT (= {0}); register char *format, *end, *format_start; @@ -3634,7 +3635,7 @@ usage: (format STRING &rest OBJECTS) */) /* Allocate the info and discarded tables. */ { - EMACS_INT i; + ptrdiff_t i; if ((SIZE_MAX - formatlen) / sizeof (struct info) <= nargs) memory_full (SIZE_MAX); SAFE_ALLOCA (info, struct info *, (nargs + 1) * sizeof *info + formatlen); @@ -3673,7 +3674,7 @@ usage: (format STRING &rest OBJECTS) */) while (format != end) { /* The values of N and FORMAT when the loop body is entered. */ - EMACS_INT n0 = n; + ptrdiff_t n0 = n; char *format0 = format; /* Bytes needed to represent the output of this conversion. */ diff --git a/src/eval.c b/src/eval.c index d6f9a9ede81..be582775fea 100644 --- a/src/eval.c +++ b/src/eval.c @@ -32,10 +32,6 @@ along with GNU Emacs. If not, see . */ #include "xterm.h" #endif -#ifndef SIZE_MAX -# define SIZE_MAX ((size_t) -1) -#endif - /* This definition is duplicated in alloc.c and keyboard.c. */ /* Putting it in lisp.h makes cc bomb out! */ @@ -139,7 +135,7 @@ Lisp_Object Vsignaling_function; int handling_signal; -static Lisp_Object funcall_lambda (Lisp_Object, size_t, Lisp_Object *); +static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *); static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN; static int interactive_p (int); static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args); @@ -1053,7 +1049,7 @@ usage: (let VARLIST BODY...) */) Lisp_Object *temps, tem, lexenv; register Lisp_Object elt, varlist; int count = SPECPDL_INDEX (); - register size_t argnum; + ptrdiff_t argnum; struct gcpro gcpro1, gcpro2; USE_SAFE_ALLOCA; @@ -1609,8 +1605,8 @@ internal_condition_case_2 (Lisp_Object (*bfun) (Lisp_Object, Lisp_Object), and ARGS as second argument. */ Lisp_Object -internal_condition_case_n (Lisp_Object (*bfun) (size_t, Lisp_Object *), - size_t nargs, +internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *), + ptrdiff_t nargs, Lisp_Object *args, Lisp_Object handlers, Lisp_Object (*hfun) (Lisp_Object)) @@ -1995,7 +1991,7 @@ verror (const char *m, va_list ap) { char buf[4000]; size_t size = sizeof buf; - size_t size_max = STRING_BYTES_MAX + 1; + size_t size_max = STRING_BYTES_BOUND + 1; size_t mlen = strlen (m); char *buffer = buf; size_t used; @@ -2337,7 +2333,7 @@ eval_sub (Lisp_Object form) { /* Pass a vector of evaluated arguments. */ Lisp_Object *vals; - register size_t argnum = 0; + ptrdiff_t argnum = 0; USE_SAFE_ALLOCA; SAFE_ALLOCA_LISP (vals, XINT (numargs)); @@ -2467,9 +2463,9 @@ DEFUN ("apply", Fapply, Sapply, 2, MANY, 0, Then return the value FUNCTION returns. Thus, (apply '+ 1 2 '(3 4)) returns 10. usage: (apply FUNCTION &rest ARGUMENTS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { - register size_t i, numargs; + ptrdiff_t i, numargs; register Lisp_Object spread_arg; register Lisp_Object *funcall_args; Lisp_Object fun, retval; @@ -2551,7 +2547,7 @@ usage: (apply FUNCTION &rest ARGUMENTS) */) /* Run hook variables in various ways. */ static Lisp_Object -funcall_nil (size_t nargs, Lisp_Object *args) +funcall_nil (ptrdiff_t nargs, Lisp_Object *args) { Ffuncall (nargs, args); return Qnil; @@ -2572,10 +2568,10 @@ hook; they should use `run-mode-hooks' instead. Do not use `make-local-variable' to make a hook variable buffer-local. Instead, use `add-hook' and specify t for the LOCAL argument. usage: (run-hooks &rest HOOKS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object hook[1]; - register size_t i; + ptrdiff_t i; for (i = 0; i < nargs; i++) { @@ -2601,7 +2597,7 @@ as that may change. Do not use `make-local-variable' to make a hook variable buffer-local. Instead, use `add-hook' and specify t for the LOCAL argument. usage: (run-hook-with-args HOOK &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return run_hook_with_args (nargs, args, funcall_nil); } @@ -2621,13 +2617,13 @@ However, if they all return nil, we return nil. Do not use `make-local-variable' to make a hook variable buffer-local. Instead, use `add-hook' and specify t for the LOCAL argument. usage: (run-hook-with-args-until-success HOOK &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return run_hook_with_args (nargs, args, Ffuncall); } static Lisp_Object -funcall_not (size_t nargs, Lisp_Object *args) +funcall_not (ptrdiff_t nargs, Lisp_Object *args) { return NILP (Ffuncall (nargs, args)) ? Qt : Qnil; } @@ -2646,13 +2642,13 @@ Then we return nil. However, if they all return non-nil, we return non-nil. Do not use `make-local-variable' to make a hook variable buffer-local. Instead, use `add-hook' and specify t for the LOCAL argument. usage: (run-hook-with-args-until-failure HOOK &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return NILP (run_hook_with_args (nargs, args, funcall_not)) ? Qt : Qnil; } static Lisp_Object -run_hook_wrapped_funcall (size_t nargs, Lisp_Object *args) +run_hook_wrapped_funcall (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object tmp = args[0], ret; args[0] = args[1]; @@ -2670,7 +2666,7 @@ it calls WRAP-FUNCTION with arguments FUN and ARGS. As soon as a call to WRAP-FUNCTION returns non-nil, `run-hook-wrapped' aborts and returns that value. usage: (run-hook-wrapped HOOK WRAP-FUNCTION &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return run_hook_with_args (nargs, args, run_hook_wrapped_funcall); } @@ -2683,8 +2679,8 @@ usage: (run-hook-wrapped HOOK WRAP-FUNCTION &rest ARGS) */) except that it isn't necessary to gcpro ARGS[0]. */ Lisp_Object -run_hook_with_args (size_t nargs, Lisp_Object *args, - Lisp_Object (*funcall) (size_t nargs, Lisp_Object *args)) +run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args, + Lisp_Object (*funcall) (ptrdiff_t nargs, Lisp_Object *args)) { Lisp_Object sym, val, ret = Qnil; struct gcpro gcpro1, gcpro2, gcpro3; @@ -2957,16 +2953,16 @@ DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0, Return the value that function returns. Thus, (funcall 'cons 'x 'y) returns (x . y). usage: (funcall FUNCTION &rest ARGUMENTS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object fun, original_fun; Lisp_Object funcar; - size_t numargs = nargs - 1; + ptrdiff_t numargs = nargs - 1; Lisp_Object lisp_numargs; Lisp_Object val; struct backtrace backtrace; register Lisp_Object *internal_args; - register size_t i; + ptrdiff_t i; QUIT; if ((consing_since_gc > gc_cons_threshold @@ -3120,14 +3116,13 @@ static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args) { Lisp_Object args_left; - size_t numargs; + ptrdiff_t i, numargs; register Lisp_Object *arg_vector; struct gcpro gcpro1, gcpro2, gcpro3; - register size_t i; register Lisp_Object tem; USE_SAFE_ALLOCA; - numargs = XINT (Flength (args)); + numargs = XFASTINT (Flength (args)); SAFE_ALLOCA_LISP (arg_vector, numargs); args_left = args; @@ -3163,12 +3158,12 @@ apply_lambda (Lisp_Object fun, Lisp_Object args) FUN must be either a lambda-expression or a compiled-code object. */ static Lisp_Object -funcall_lambda (Lisp_Object fun, size_t nargs, +funcall_lambda (Lisp_Object fun, ptrdiff_t nargs, register Lisp_Object *arg_vector) { Lisp_Object val, syms_left, next, lexenv; int count = SPECPDL_INDEX (); - size_t i; + ptrdiff_t i; int optional, rest; if (CONSP (fun)) @@ -3585,7 +3580,7 @@ Output stream used is value of `standard-output'. */) } else { - size_t i; + ptrdiff_t i; for (i = 0; i < backlist->nargs; i++) { if (i) write_string (" ", -1); @@ -3645,7 +3640,7 @@ void mark_backtrace (void) { register struct backtrace *backlist; - register size_t i; + ptrdiff_t i; for (backlist = backtrace_list; backlist; backlist = backlist->next) { diff --git a/src/fileio.c b/src/fileio.c index d9bc28d8c37..fd5277cbd59 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -643,7 +643,7 @@ make_temp_name (Lisp_Object prefix, int base64_p) if (!make_temp_name_count_initialized_p) { - make_temp_name_count = (unsigned) time (NULL); + make_temp_name_count = time (NULL); make_temp_name_count_initialized_p = 1; } @@ -3109,6 +3109,21 @@ read_non_regular_quit (Lisp_Object ignore) return Qnil; } +/* Reposition FD to OFFSET, based on WHENCE. This acts like lseek + except that it also tests for OFFSET being out of lseek's range. */ +static off_t +emacs_lseek (int fd, EMACS_INT offset, int whence) +{ + /* Use "&" rather than "&&" to suppress a bogus GCC warning; see + . */ + if (! ((TYPE_MINIMUM (off_t) <= offset) & (offset <= TYPE_MAXIMUM (off_t)))) + { + errno = EINVAL; + return -1; + } + return lseek (fd, offset, whence); +} + DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents, 1, 5, 0, @@ -3317,7 +3332,7 @@ variable `last-coding-system-used' to the coding system actually used. */) nread = emacs_read (fd, read_buf, 1024); if (nread >= 0) { - if (lseek (fd, st.st_size - (1024 * 3), 0) < 0) + if (lseek (fd, st.st_size - (1024 * 3), SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); nread += emacs_read (fd, read_buf + nread, 1024 * 3); @@ -3361,7 +3376,7 @@ variable `last-coding-system-used' to the coding system actually used. */) specpdl_ptr--; /* Rewind the file for the actual read done later. */ - if (lseek (fd, 0, 0) < 0) + if (lseek (fd, 0, SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); } @@ -3428,7 +3443,7 @@ variable `last-coding-system-used' to the coding system actually used. */) if (XINT (beg) != 0) { - if (lseek (fd, XINT (beg), 0) < 0) + if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); } @@ -3500,7 +3515,7 @@ variable `last-coding-system-used' to the coding system actually used. */) break; /* How much can we scan in the next step? */ trial = min (curpos, sizeof buffer); - if (lseek (fd, curpos - trial, 0) < 0) + if (emacs_lseek (fd, curpos - trial, SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); @@ -3618,7 +3633,7 @@ variable `last-coding-system-used' to the coding system actually used. */) /* First read the whole file, performing code conversion into CONVERSION_BUFFER. */ - if (lseek (fd, XINT (beg), 0) < 0) + if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); @@ -3817,7 +3832,7 @@ variable `last-coding-system-used' to the coding system actually used. */) if (XINT (beg) != 0 || !NILP (replace)) { - if (lseek (fd, XINT (beg), 0) < 0) + if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0) report_file_error ("Setting file position", Fcons (orig_filename, Qnil)); } @@ -4549,9 +4564,9 @@ This calls `write-region-annotate-functions' at the start, and long ret; if (NUMBERP (append)) - ret = lseek (desc, XINT (append), 1); + ret = emacs_lseek (desc, XINT (append), SEEK_CUR); else - ret = lseek (desc, 0, 2); + ret = lseek (desc, 0, SEEK_END); if (ret < 0) { #ifdef CLASH_DETECTION diff --git a/src/floatfns.c b/src/floatfns.c index 1232fc0afa1..b5c8b4af5c3 100644 --- a/src/floatfns.c +++ b/src/floatfns.c @@ -507,7 +507,7 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0, if (y & 1) acc *= x; x *= x; - y = (unsigned)y >> 1; + y >>= 1; } } XSETINT (val, acc); diff --git a/src/fns.c b/src/fns.c index 7a2845741f9..a19c886e3e1 100644 --- a/src/fns.c +++ b/src/fns.c @@ -99,6 +99,10 @@ Other values of LIMIT are ignored. */) return lispy_val; } +/* Heuristic on how many iterations of a tight loop can be safely done + before it's time to do a QUIT. This must be a power of 2. */ +enum { QUIT_COUNT_HEURISTIC = 1 << 16 }; + /* Random data-structure functions */ DEFUN ("length", Flength, Slength, 1, 1, 0, @@ -110,7 +114,6 @@ To get the number of bytes, use `string-bytes'. */) (register Lisp_Object sequence) { register Lisp_Object val; - register int i; if (STRINGP (sequence)) XSETFASTINT (val, SCHARS (sequence)); @@ -124,19 +127,20 @@ To get the number of bytes, use `string-bytes'. */) XSETFASTINT (val, ASIZE (sequence) & PSEUDOVECTOR_SIZE_MASK); else if (CONSP (sequence)) { - i = 0; - while (CONSP (sequence)) + EMACS_INT i = 0; + + do { - sequence = XCDR (sequence); ++i; - - if (!CONSP (sequence)) - break; - + if ((i & (QUIT_COUNT_HEURISTIC - 1)) == 0) + { + if (MOST_POSITIVE_FIXNUM < i) + error ("List too long"); + QUIT; + } sequence = XCDR (sequence); - ++i; - QUIT; } + while (CONSP (sequence)); CHECK_LIST_END (sequence, sequence); @@ -159,22 +163,38 @@ it returns 0. If LIST is circular, it returns a finite value which is at least the number of distinct elements. */) (Lisp_Object list) { - Lisp_Object tail, halftail, length; - int len = 0; + Lisp_Object tail, halftail; + double hilen = 0; + uintmax_t lolen = 1; + + if (! CONSP (list)) + return 0; /* halftail is used to detect circular lists. */ - halftail = list; - for (tail = list; CONSP (tail); tail = XCDR (tail)) + for (tail = halftail = list; ; ) { - if (EQ (tail, halftail) && len != 0) + tail = XCDR (tail); + if (! CONSP (tail)) break; - len++; - if ((len & 1) == 0) - halftail = XCDR (halftail); + if (EQ (tail, halftail)) + break; + lolen++; + if ((lolen & 1) == 0) + { + halftail = XCDR (halftail); + if ((lolen & (QUIT_COUNT_HEURISTIC - 1)) == 0) + { + QUIT; + if (lolen == 0) + hilen += UINTMAX_MAX + 1.0; + } + } } - XSETINT (length, len); - return length; + /* If the length does not fit into a fixnum, return a float. + On all known practical machines this returns an upper bound on + the true length. */ + return hilen ? make_float (hilen + lolen) : make_fixnum_or_float (lolen); } DEFUN ("string-bytes", Fstring_bytes, Sstring_bytes, 1, 1, 0, @@ -344,7 +364,7 @@ Symbols are also allowed; their print names are used instead. */) return i1 < SCHARS (s2) ? Qt : Qnil; } -static Lisp_Object concat (size_t nargs, Lisp_Object *args, +static Lisp_Object concat (ptrdiff_t nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_special); /* ARGSUSED */ @@ -374,7 +394,7 @@ The result is a list whose elements are the elements of all the arguments. Each argument may be a list, vector or string. The last argument is not copied, just used as the tail of the new list. usage: (append &rest SEQUENCES) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return concat (nargs, args, Lisp_Cons, 1); } @@ -384,7 +404,7 @@ DEFUN ("concat", Fconcat, Sconcat, 0, MANY, 0, The result is a string whose elements are the elements of all the arguments. Each argument may be a string or a list or vector of characters (integers). usage: (concat &rest SEQUENCES) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return concat (nargs, args, Lisp_String, 0); } @@ -394,7 +414,7 @@ DEFUN ("vconcat", Fvconcat, Svconcat, 0, MANY, 0, The result is a vector whose elements are the elements of all the arguments. Each argument may be a list, vector or string. usage: (vconcat &rest SEQUENCES) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { return concat (nargs, args, Lisp_Vectorlike, 0); } @@ -416,7 +436,7 @@ with the original. */) if (BOOL_VECTOR_P (arg)) { Lisp_Object val; - int size_in_chars + ptrdiff_t size_in_chars = ((XBOOL_VECTOR (arg)->size + BOOL_VECTOR_BITS_PER_CHAR - 1) / BOOL_VECTOR_BITS_PER_CHAR); @@ -436,13 +456,13 @@ with the original. */) a string and has text properties to be copied. */ struct textprop_rec { - int argnum; /* refer to ARGS (arguments of `concat') */ + ptrdiff_t argnum; /* refer to ARGS (arguments of `concat') */ EMACS_INT from; /* refer to ARGS[argnum] (argument string) */ EMACS_INT to; /* refer to VAL (the target string) */ }; static Lisp_Object -concat (size_t nargs, Lisp_Object *args, +concat (ptrdiff_t nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_special) { Lisp_Object val; @@ -452,7 +472,7 @@ concat (size_t nargs, Lisp_Object *args, EMACS_INT toindex_byte = 0; register EMACS_INT result_len; register EMACS_INT result_len_byte; - register size_t argnum; + ptrdiff_t argnum; Lisp_Object last_tail; Lisp_Object prev; int some_multibyte; @@ -463,7 +483,7 @@ concat (size_t nargs, Lisp_Object *args, here, and copy the text properties after the concatenation. */ struct textprop_rec *textprops = NULL; /* Number of elements in textprops. */ - int num_textprops = 0; + ptrdiff_t num_textprops = 0; USE_SAFE_ALLOCA; tail = Qnil; @@ -504,6 +524,7 @@ concat (size_t nargs, Lisp_Object *args, as well as the number of characters. */ EMACS_INT i; Lisp_Object ch; + int c; EMACS_INT this_len_byte; if (VECTORP (this) || COMPILEDP (this)) @@ -511,9 +532,10 @@ concat (size_t nargs, Lisp_Object *args, { ch = AREF (this, i); CHECK_CHARACTER (ch); - this_len_byte = CHAR_BYTES (XINT (ch)); + c = XFASTINT (ch); + this_len_byte = CHAR_BYTES (c); result_len_byte += this_len_byte; - if (! ASCII_CHAR_P (XINT (ch)) && ! CHAR_BYTE8_P (XINT (ch))) + if (! ASCII_CHAR_P (c) && ! CHAR_BYTE8_P (c)) some_multibyte = 1; } else if (BOOL_VECTOR_P (this) && XBOOL_VECTOR (this)->size > 0) @@ -523,9 +545,10 @@ concat (size_t nargs, Lisp_Object *args, { ch = XCAR (this); CHECK_CHARACTER (ch); - this_len_byte = CHAR_BYTES (XINT (ch)); + c = XFASTINT (ch); + this_len_byte = CHAR_BYTES (c); result_len_byte += this_len_byte; - if (! ASCII_CHAR_P (XINT (ch)) && ! CHAR_BYTE8_P (XINT (ch))) + if (! ASCII_CHAR_P (c) && ! CHAR_BYTE8_P (c)) some_multibyte = 1; } else if (STRINGP (this)) @@ -631,23 +654,16 @@ concat (size_t nargs, Lisp_Object *args, { int c; if (STRING_MULTIBYTE (this)) - { - FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, this, - thisindex, - thisindex_byte); - XSETFASTINT (elt, c); - } + FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, this, + thisindex, + thisindex_byte); else { - XSETFASTINT (elt, SREF (this, thisindex)); thisindex++; - if (some_multibyte - && !ASCII_CHAR_P (XINT (elt)) - && XINT (elt) < 0400) - { - c = BYTE8_TO_CHAR (XINT (elt)); - XSETINT (elt, c); - } + c = SREF (this, thisindex); thisindex++; + if (some_multibyte && !ASCII_CHAR_P (c)) + c = BYTE8_TO_CHAR (c); } + XSETFASTINT (elt, c); } else if (BOOL_VECTOR_P (this)) { @@ -679,12 +695,13 @@ concat (size_t nargs, Lisp_Object *args, } else { - CHECK_NUMBER (elt); + int c; + CHECK_CHARACTER (elt); + c = XFASTINT (elt); if (some_multibyte) - toindex_byte += CHAR_STRING (XINT (elt), - SDATA (val) + toindex_byte); + toindex_byte += CHAR_STRING (c, SDATA (val) + toindex_byte); else - SSET (val, toindex_byte++, XINT (elt)); + SSET (val, toindex_byte++, c); toindex++; } } @@ -1269,7 +1286,7 @@ DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, 0, doc: /* Take cdr N times on LIST, return the result. */) (Lisp_Object n, Lisp_Object list) { - register int i, num; + EMACS_INT i, num; CHECK_NUMBER (n); num = XINT (n); for (i = 0; i < num && !NILP (list); i++) @@ -1734,7 +1751,7 @@ if the first element should sort before the second. */) Lisp_Object front, back; register Lisp_Object len, tem; struct gcpro gcpro1, gcpro2; - register int length; + EMACS_INT length; front = list; len = Flength (list); @@ -2220,9 +2237,9 @@ DEFUN ("nconc", Fnconc, Snconc, 0, MANY, 0, doc: /* Concatenate any number of lists by altering them. Only the last argument is not altered, and need not be a list. usage: (nconc &rest LISTS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { - register size_t argnum; + ptrdiff_t argnum; register Lisp_Object tail, tem, val; val = tail = Qnil; @@ -2345,9 +2362,8 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */) { Lisp_Object len; register EMACS_INT leni; - int nargs; + ptrdiff_t i, nargs; register Lisp_Object *args; - register EMACS_INT i; struct gcpro gcpro1; Lisp_Object ret; USE_SAFE_ALLOCA; @@ -2526,8 +2542,8 @@ advisable. */) while (loads-- > 0) { - Lisp_Object load = (NILP (use_floats) ? - make_number ((int) (100.0 * load_ave[loads])) + Lisp_Object load = (NILP (use_floats) + ? make_number (100.0 * load_ave[loads]) : make_float (load_ave[loads])); ret = Fcons (load, ret); } @@ -2751,7 +2767,7 @@ DEFUN ("widget-apply", Fwidget_apply, Swidget_apply, 2, MANY, 0, doc: /* Apply the value of WIDGET's PROPERTY to the widget itself. ARGS are passed as extra arguments to the function. usage: (widget-apply WIDGET PROPERTY &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { /* This function can GC. */ Lisp_Object newargs[3]; @@ -3356,7 +3372,7 @@ static Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value; /* Function prototypes. */ static struct Lisp_Hash_Table *check_hash_table (Lisp_Object); -static size_t get_key_arg (Lisp_Object, size_t, Lisp_Object *, char *); +static ptrdiff_t get_key_arg (Lisp_Object, ptrdiff_t, Lisp_Object *, char *); static void maybe_resize_hash_table (struct Lisp_Hash_Table *); static int sweep_weak_table (struct Lisp_Hash_Table *, int); @@ -3383,13 +3399,9 @@ check_hash_table (Lisp_Object obj) EMACS_INT next_almost_prime (EMACS_INT n) { - if (n % 2 == 0) - n += 1; - if (n % 3 == 0) - n += 2; - if (n % 7 == 0) - n += 4; - return n; + for (n |= 1; ; n += 2) + if (n % 3 != 0 && n % 5 != 0 && n % 7 != 0) + return n; } @@ -3399,10 +3411,10 @@ next_almost_prime (EMACS_INT n) 0. This function is used to extract a keyword/argument pair from a DEFUN parameter list. */ -static size_t -get_key_arg (Lisp_Object key, size_t nargs, Lisp_Object *args, char *used) +static ptrdiff_t +get_key_arg (Lisp_Object key, ptrdiff_t nargs, Lisp_Object *args, char *used) { - size_t i; + ptrdiff_t i; for (i = 1; i < nargs; i++) if (!used[i - 1] && EQ (args[i - 1], key)) @@ -4300,12 +4312,12 @@ WEAK. WEAK t is equivalent to `key-and-value'. Default value of WEAK is nil. usage: (make-hash-table &rest KEYWORD-ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object test, size, rehash_size, rehash_threshold, weak; Lisp_Object user_test, user_hash; char *used; - size_t i; + ptrdiff_t i; /* The vector `used' is used to keep track of arguments that have been consumed. */ diff --git a/src/font.c b/src/font.c index 326c9d80e44..ecb61ab6a53 100644 --- a/src/font.c +++ b/src/font.c @@ -3829,10 +3829,10 @@ be an OpenType font whose GPOS table of `thai' script's default language system must contain `mark' feature. usage: (font-spec ARGS...) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object spec = font_make_spec (); - size_t i; + ptrdiff_t i; for (i = 0; i < nargs; i += 2) { diff --git a/src/fontset.c b/src/fontset.c index fec3c56b036..3091f43d6e9 100644 --- a/src/fontset.c +++ b/src/fontset.c @@ -1851,7 +1851,7 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0, face_id = face_at_buffer_position (w, pos, -1, -1, &dummy, pos + 100, 0, -1); } - if (! CHAR_VALID_P (c, 0)) + if (! CHAR_VALID_P (c)) return Qnil; face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil); face = FACE_FROM_ID (f, face_id); diff --git a/src/frame.c b/src/frame.c index 34474417efa..27a31fac3e7 100644 --- a/src/frame.c +++ b/src/frame.c @@ -2807,7 +2807,7 @@ x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist) /* Record in these vectors all the parms specified. */ Lisp_Object *parms; Lisp_Object *values; - size_t i, p; + ptrdiff_t i, p; int left_no_change = 0, top_no_change = 0; int icon_left_no_change = 0, icon_top_no_change = 0; int size_changed = 0; diff --git a/src/keyboard.c b/src/keyboard.c index 89483972a65..e7a0598e839 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -448,7 +448,7 @@ static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object, #endif static Lisp_Object modify_event_symbol (EMACS_INT, unsigned, Lisp_Object, Lisp_Object, const char *const *, - Lisp_Object *, unsigned); + Lisp_Object *, EMACS_INT); static Lisp_Object make_lispy_switch_frame (Lisp_Object); static int help_char_p (Lisp_Object); static void save_getcjmp (jmp_buf); @@ -1901,7 +1901,7 @@ safe_run_hooks_error (Lisp_Object error_data) } static Lisp_Object -safe_run_hook_funcall (size_t nargs, Lisp_Object *args) +safe_run_hook_funcall (ptrdiff_t nargs, Lisp_Object *args) { eassert (nargs == 1); if (CONSP (Vinhibit_quit)) @@ -2906,9 +2906,13 @@ read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event goto exit; if ((STRINGP (KVAR (current_kboard, Vkeyboard_translate_table)) - && SCHARS (KVAR (current_kboard, Vkeyboard_translate_table)) > (unsigned) XFASTINT (c)) + && UNSIGNED_CMP (XFASTINT (c), <, + SCHARS (KVAR (current_kboard, + Vkeyboard_translate_table)))) || (VECTORP (KVAR (current_kboard, Vkeyboard_translate_table)) - && ASIZE (KVAR (current_kboard, Vkeyboard_translate_table)) > (unsigned) XFASTINT (c)) + && UNSIGNED_CMP (XFASTINT (c), <, + ASIZE (KVAR (current_kboard, + Vkeyboard_translate_table)))) || (CHAR_TABLE_P (KVAR (current_kboard, Vkeyboard_translate_table)) && CHARACTERP (c))) { @@ -2955,9 +2959,7 @@ read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event save the echo area contents for it to refer to. */ if (INTEGERP (c) && ! NILP (Vinput_method_function) - && (unsigned) XINT (c) >= ' ' - && (unsigned) XINT (c) != 127 - && (unsigned) XINT (c) < 256) + && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127) { previous_echo_area_message = Fcurrent_message (); Vinput_method_previous_message = previous_echo_area_message; @@ -2982,9 +2984,7 @@ read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event /* Don't run the input method within a key sequence, after the first event of the key sequence. */ && NILP (prev_event) - && (unsigned) XINT (c) >= ' ' - && (unsigned) XINT (c) != 127 - && (unsigned) XINT (c) < 256) + && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127) { Lisp_Object keys; int key_count, key_count_reset; @@ -5391,7 +5391,7 @@ make_lispy_event (struct input_event *event) Qfunction_key, KVAR (current_kboard, Vsystem_key_alist), 0, &KVAR (current_kboard, system_key_syms), - (unsigned) -1); + TYPE_MAXIMUM (EMACS_INT)); } return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET, @@ -6410,7 +6410,7 @@ reorder_modifiers (Lisp_Object symbol) static Lisp_Object modify_event_symbol (EMACS_INT symbol_num, unsigned int modifiers, Lisp_Object symbol_kind, Lisp_Object name_alist_or_stem, const char *const *name_table, - Lisp_Object *symbol_table, unsigned int table_size) + Lisp_Object *symbol_table, EMACS_INT table_size) { Lisp_Object value; Lisp_Object symbol_int; diff --git a/src/lisp.h b/src/lisp.h index 8aa36601dd7..83534e55433 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -60,6 +60,21 @@ extern void check_cons_list (void); # define EMACS_UINT unsigned EMACS_INT #endif +/* Use pD to format ptrdiff_t values, which suffice for indexes into + buffers and strings. Emacs never allocates objects larger than + PTRDIFF_MAX bytes, as they cause problems with pointer subtraction. + In C99, pD can always be "t"; configure it here for the sake of + pre-C99 libraries such as glibc 2.0 and Solaris 8. */ +#if PTRDIFF_MAX == INT_MAX +# define pD "" +#elif PTRDIFF_MAX == LONG_MAX +# define pD "l" +#elif PTRDIFF_MAX == LLONG_MAX +# define pD "ll" +#else +# define pD "t" +#endif + /* Extra internal type checking? */ #ifdef ENABLE_CHECKING @@ -765,11 +780,19 @@ extern EMACS_INT string_bytes (struct Lisp_String *); #endif /* not GC_CHECK_STRING_BYTES */ -/* A string cannot contain more bytes than a fixnum can represent, - nor can it be so long that C pointer arithmetic stops working on - the string plus a terminating null. */ -#define STRING_BYTES_MAX \ - min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1) +/* An upper bound on the number of bytes in a Lisp string, not + counting the terminating null. This a tight enough bound to + prevent integer overflow errors that would otherwise occur during + string size calculations. A string cannot contain more bytes than + a fixnum can represent, nor can it be so long that C pointer + arithmetic stops working on the string plus its terminating null. + Although the actual size limit (see STRING_BYTES_MAX in alloc.c) + may be a bit smaller than STRING_BYTES_BOUND, calculating it here + would expose alloc.c internal details that we'd rather keep + private. The cast to ptrdiff_t ensures that STRING_BYTES_BOUND is + signed. */ +#define STRING_BYTES_BOUND \ + min (MOST_POSITIVE_FIXNUM, (ptrdiff_t) min (SIZE_MAX, PTRDIFF_MAX) - 1) /* Mark STR as a unibyte string. */ #define STRING_SET_UNIBYTE(STR) \ @@ -888,8 +911,18 @@ struct Lisp_Vector #endif /* not __GNUC__ */ +/* Compute A OP B, using the unsigned comparison operator OP. A and B + should be integer expressions. This is not the same as + mathemeatical comparison; for example, UNSIGNED_CMP (0, <, -1) + returns 1. For efficiency, prefer plain unsigned comparison if A + and B's sizes both fit (after integer promotion). */ +#define UNSIGNED_CMP(a, op, b) \ + (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned) \ + ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0) \ + : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0)) + /* Nonzero iff C is an ASCII character. */ -#define ASCII_CHAR_P(c) ((unsigned) (c) < 0x80) +#define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80) /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII characters. Do not check validity of CT. */ @@ -908,8 +941,7 @@ struct Lisp_Vector /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and 8-bit European characters. Do not check validity of CT. */ #define CHAR_TABLE_SET(CT, IDX, VAL) \ - (((IDX) >= 0 && ASCII_CHAR_P (IDX) \ - && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii)) \ + (ASCII_CHAR_P (IDX) && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \ ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] = VAL \ : char_table_set (CT, IDX, VAL)) @@ -1007,7 +1039,7 @@ struct Lisp_Subr Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object); Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object); Lisp_Object (*aUNEVALLED) (Lisp_Object args); - Lisp_Object (*aMANY) (size_t, Lisp_Object *); + Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *); } function; short min_args, max_args; const char *symbol_name; @@ -1447,7 +1479,7 @@ struct Lisp_Save_Value area containing INTEGER potential Lisp_Objects. */ unsigned int dogc : 1; void *pointer; - int integer; + ptrdiff_t integer; }; @@ -1576,7 +1608,7 @@ typedef struct { #define SET_GLYPH(glyph, char, face) ((glyph).ch = (char), (glyph).face_id = (face)) /* Return 1 if GLYPH contains valid character code. */ -#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph), 1) +#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph)) /* Glyph Code from a display vector may either be an integer which @@ -1590,7 +1622,7 @@ typedef struct { (CONSP (gc) ? XINT (XCDR (gc)) : INTEGERP (gc) ? (XINT (gc) >> CHARACTERBITS) : DEFAULT_FACE_ID) /* Return 1 if glyph code from display vector contains valid character code. */ -#define GLYPH_CODE_CHAR_VALID_P(gc) CHAR_VALID_P (GLYPH_CODE_CHAR (gc), 1) +#define GLYPH_CODE_CHAR_VALID_P(gc) CHAR_VALID_P (GLYPH_CODE_CHAR (gc)) #define GLYPH_CODE_P(gc) ((CONSP (gc) && INTEGERP (XCAR (gc)) && INTEGERP (XCDR (gc))) || INTEGERP (gc)) @@ -1864,7 +1896,7 @@ typedef struct { /* Note that the weird token-substitution semantics of ANSI C makes this work for MANY and UNEVALLED. */ -#define DEFUN_ARGS_MANY (size_t, Lisp_Object *) +#define DEFUN_ARGS_MANY (ptrdiff_t, Lisp_Object *) #define DEFUN_ARGS_UNEVALLED (Lisp_Object) #define DEFUN_ARGS_0 (void) #define DEFUN_ARGS_1 (Lisp_Object) @@ -2129,7 +2161,7 @@ struct gcpro volatile Lisp_Object *var; /* Number of consecutive protected variables. */ - size_t nvars; + ptrdiff_t nvars; #ifdef DEBUG_GCPRO int level; @@ -2778,7 +2810,7 @@ extern int abort_on_gc; extern Lisp_Object make_float (double); extern void display_malloc_warning (void); extern int inhibit_garbage_collection (void); -extern Lisp_Object make_save_value (void *, int); +extern Lisp_Object make_save_value (void *, ptrdiff_t); extern void free_marker (Lisp_Object); extern void free_cons (struct Lisp_Cons *); extern void init_alloc_once (void); @@ -2890,9 +2922,9 @@ EXFUN (Frun_hooks, MANY); EXFUN (Frun_hook_with_args, MANY); EXFUN (Frun_hook_with_args_until_failure, MANY); extern void run_hook_with_args_2 (Lisp_Object, Lisp_Object, Lisp_Object); -extern Lisp_Object run_hook_with_args (size_t nargs, Lisp_Object *args, +extern Lisp_Object run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args, Lisp_Object (*funcall) - (size_t nargs, Lisp_Object *args)); + (ptrdiff_t nargs, Lisp_Object *args)); EXFUN (Fprogn, UNEVALLED); EXFUN (Finteractive_p, 0); EXFUN (Fthrow, 2) NO_RETURN; @@ -2924,7 +2956,7 @@ extern Lisp_Object internal_lisp_condition_case (Lisp_Object, Lisp_Object, Lisp_ extern Lisp_Object internal_condition_case (Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)); extern Lisp_Object internal_condition_case_1 (Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)); extern Lisp_Object internal_condition_case_2 (Lisp_Object (*) (Lisp_Object, Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)); -extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (size_t, Lisp_Object *), size_t, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)); +extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (ptrdiff_t, Lisp_Object *), ptrdiff_t, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)); extern void specbind (Lisp_Object, Lisp_Object); extern void record_unwind_protect (Lisp_Object (*) (Lisp_Object), Lisp_Object); extern Lisp_Object unbind_to (int, Lisp_Object); @@ -2934,7 +2966,7 @@ extern void verror (const char *, va_list) extern void do_autoload (Lisp_Object, Lisp_Object); extern Lisp_Object un_autoload (Lisp_Object); extern void init_eval_once (void); -extern Lisp_Object safe_call (size_t, Lisp_Object *); +extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object *); extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object); extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object); extern void init_eval (void); @@ -3316,7 +3348,7 @@ extern void mark_byte_stack (void); #endif extern void unmark_byte_stack (void); extern Lisp_Object exec_byte_code (Lisp_Object, Lisp_Object, Lisp_Object, - Lisp_Object, int, Lisp_Object *); + Lisp_Object, ptrdiff_t, Lisp_Object *); /* Defined in macros.c */ extern Lisp_Object Qexecute_kbd_macro; @@ -3671,18 +3703,19 @@ extern Lisp_Object safe_alloca_unwind (Lisp_Object); #define SAFE_ALLOCA_LISP(buf, nelt) \ do { \ - int size_ = (nelt) * sizeof (Lisp_Object); \ - if (size_ < MAX_ALLOCA) \ - buf = (Lisp_Object *) alloca (size_); \ - else \ + if ((nelt) < MAX_ALLOCA / sizeof (Lisp_Object)) \ + buf = (Lisp_Object *) alloca ((nelt) * sizeof (Lisp_Object)); \ + else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)) \ { \ Lisp_Object arg_; \ - buf = (Lisp_Object *) xmalloc (size_); \ + buf = (Lisp_Object *) xmalloc ((nelt) * sizeof (Lisp_Object)); \ arg_ = make_save_value (buf, nelt); \ XSAVE_VALUE (arg_)->dogc = 1; \ sa_must_free = 1; \ record_unwind_protect (safe_alloca_unwind, arg_); \ } \ + else \ + memory_full (SIZE_MAX); \ } while (0) diff --git a/src/lread.c b/src/lread.c index b22ca930ee6..b789457b223 100644 --- a/src/lread.c +++ b/src/lread.c @@ -1203,12 +1203,15 @@ Return t if the file exists and loads successfully. */) #ifdef DOS_NT fmode = "rb"; #endif /* DOS_NT */ - stat (SSDATA (efound), &s1); - SSET (efound, SBYTES (efound) - 1, 0); - result = stat (SSDATA (efound), &s2); - SSET (efound, SBYTES (efound) - 1, 'c'); + result = stat (SSDATA (efound), &s1); + if (result == 0) + { + SSET (efound, SBYTES (efound) - 1, 0); + result = stat (SSDATA (efound), &s2); + SSET (efound, SBYTES (efound) - 1, 'c'); + } - if (result >= 0 && (unsigned) s1.st_mtime < (unsigned) s2.st_mtime) + if (result == 0 && s1.st_mtime < s2.st_mtime) { /* Make the progress messages mention that source is newer. */ newer = 1; diff --git a/src/mem-limits.h b/src/mem-limits.h index aa3a13c1c34..86b2f44846d 100644 --- a/src/mem-limits.h +++ b/src/mem-limits.h @@ -33,8 +33,6 @@ extern int etext; # endif #endif -typedef unsigned long SIZE; - extern char *start_of_data (void); #if defined USE_LSB_TAG #define EXCEEDS_LISP_PTR(ptr) 0 diff --git a/src/print.c b/src/print.c index 803e3a17214..d07f89702cc 100644 --- a/src/print.c +++ b/src/print.c @@ -2004,7 +2004,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag case Lisp_Misc_Save_Value: strout ("#pointer, XSAVE_VALUE (obj)->integer); strout (buf, -1, -1, printcharfun); diff --git a/src/process.c b/src/process.c index 9ff7dd198dd..5a26bf43146 100644 --- a/src/process.c +++ b/src/process.c @@ -1272,11 +1272,11 @@ the command through a shell and redirect one of them using the shell syntax. usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS) */) - (size_t nargs, register Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object buffer, name, program, proc, current_dir, tem; register unsigned char **new_argv; - register size_t i; + ptrdiff_t i; int count = SPECPDL_INDEX (); buffer = args[1]; @@ -2436,7 +2436,7 @@ initial configuration of the serial port. \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7) usage: (serial-process-configure &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { struct Lisp_Process *p; Lisp_Object contact = Qnil; @@ -2554,7 +2554,7 @@ is available via the function `process-contact'. \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil) usage: (make-serial-process &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { int fd = -1; Lisp_Object proc, contact, port; @@ -2832,7 +2832,7 @@ The original argument list, modified with the actual connection information, is available via the `process-contact' function. usage: (make-network-process &rest ARGS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object proc; Lisp_Object contact; @@ -3148,7 +3148,7 @@ usage: (make-network-process &rest ARGS) */) for (lres = res; lres; lres = lres->ai_next) { - size_t optn; + ptrdiff_t optn; int optbits; #ifdef WINDOWSNT diff --git a/src/puresize.h b/src/puresize.h index 8024aa95d31..c26c496a757 100644 --- a/src/puresize.h +++ b/src/puresize.h @@ -86,7 +86,6 @@ extern EMACS_INT pure[]; && (PNTR_COMPARISON_TYPE) XPNTR (obj) >= (PNTR_COMPARISON_TYPE) pure) #else /* not VIRT_ADDR_VARIES */ -/* When PNTR_COMPARISON_TYPE is not the default (unsigned int). */ extern char my_edata[]; @@ -94,4 +93,3 @@ extern char my_edata[]; ((PNTR_COMPARISON_TYPE) XPNTR (obj) < (PNTR_COMPARISON_TYPE) my_edata) #endif /* VIRT_ADDRESS_VARIES */ - diff --git a/src/sound.c b/src/sound.c index 794c8e64e54..0e71e66352e 100644 --- a/src/sound.c +++ b/src/sound.c @@ -1447,7 +1447,7 @@ Internal use only, use `play-sound' instead. */) } else if (FLOATP (attrs[SOUND_VOLUME])) { - ui_volume_tmp = (unsigned long) XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100; + ui_volume_tmp = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100; } /* Based on some experiments I have conducted, a value of 100 or less diff --git a/src/unexelf.c b/src/unexelf.c index 8b45894f853..951e7c0eea6 100644 --- a/src/unexelf.c +++ b/src/unexelf.c @@ -391,6 +391,7 @@ raid:/nfs/raid/src/dist-18.56/src> dump -h temacs extern void fatal (const char *msgid, ...); #include +#include #include #include #include @@ -784,7 +785,7 @@ unexec (const char *new_name, const char *old_name) fprintf (stderr, "new_data2_incr %x\n", new_data2_incr); #endif - if ((unsigned) new_bss_addr < (unsigned) old_bss_addr + old_bss_size) + if ((uintptr_t) new_bss_addr < (uintptr_t) old_bss_addr + old_bss_size) fatal (".bss shrank when undumping???\n", 0, 0); /* Set the output file to the right size. Allocate a buffer to hold diff --git a/src/vm-limit.c b/src/vm-limit.c index 4694608602f..846946b41c1 100644 --- a/src/vm-limit.c +++ b/src/vm-limit.c @@ -166,9 +166,9 @@ static void check_memory_limits (void) { #ifdef REL_ALLOC - extern POINTER (*real_morecore) (SIZE); + extern POINTER (*real_morecore) (long); #endif - extern POINTER (*__morecore) (SIZE); + extern POINTER (*__morecore) (long); register POINTER cp; unsigned long five_percent; @@ -297,4 +297,3 @@ memory_warnings (POINTER start, void (*warnfun) (const char *)) /* Force data limit to be recalculated on each run. */ lim_data = 0; } - diff --git a/src/widget.c b/src/widget.c index 7d32e30eed7..6d871ad7cb2 100644 --- a/src/widget.c +++ b/src/widget.c @@ -516,14 +516,11 @@ create_frame_gcs (ew) struct frame *s = ew->emacs_frame.frame; s->output_data.x->normal_gc - = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), - (unsigned long)0, (XGCValues *)0); + = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0); s->output_data.x->reverse_gc - = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), - (unsigned long)0, (XGCValues *)0); + = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0); s->output_data.x->cursor_gc - = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), - (unsigned long)0, (XGCValues *)0); + = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0); s->output_data.x->black_relief.gc = 0; s->output_data.x->white_relief.gc = 0; } @@ -582,8 +579,7 @@ setup_frame_gcs (EmacsFrame ew) = XCreatePixmapFromBitmapData (XtDisplay(ew), RootWindowOfScreen (XtScreen (ew)), setup_frame_cursor_bits, 2, 2, - (unsigned long)0, (unsigned long)1, - ew->core.depth); + 0, 1, ew->core.depth); /* Normal video */ gc_values.foreground = ew->emacs_frame.foreground_pixel; diff --git a/src/xdisp.c b/src/xdisp.c index 65f6ddd3889..5a0b0060fa3 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -1335,7 +1335,7 @@ string_char_and_length (const unsigned char *str, int *len) int c; c = STRING_CHAR_AND_LENGTH (str, *len); - if (!CHAR_VALID_P (c, 1)) + if (!CHAR_VALID_P (c)) /* We may not change the length here because other places in Emacs don't use this function, i.e. they silently accept invalid characters. */ @@ -2138,7 +2138,7 @@ safe_eval_handler (Lisp_Object arg) redisplay during the evaluation. */ Lisp_Object -safe_call (size_t nargs, Lisp_Object *args) +safe_call (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object val; @@ -5819,7 +5819,8 @@ get_next_display_element (struct it *it) display. Then, set IT->dpvec to these glyphs. */ Lisp_Object gc; int ctl_len; - int face_id, lface_id = 0 ; + int face_id; + EMACS_INT lface_id = 0; int escape_glyph; /* Handle control characters with ^. */ @@ -6374,7 +6375,7 @@ next_element_from_display_vector (struct it *it) it->face_id = it->dpvec_face_id; else { - int lface_id = GLYPH_CODE_FACE (gc); + EMACS_INT lface_id = GLYPH_CODE_FACE (gc); if (lface_id > 0) it->face_id = merge_faces (it->f, Qt, lface_id, it->saved_face_id); @@ -16570,7 +16571,7 @@ With ARG, turn tracing on if and only if ARG is positive. */) DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "", doc: /* Like `format', but print result to stderr. usage: (trace-to-stderr STRING &rest OBJECTS) */) - (size_t nargs, Lisp_Object *args) + (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object s = Fformat (nargs, args); fprintf (stderr, "%s", SDATA (s)); @@ -19379,7 +19380,8 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_ else if (CHARACTERP (eoltype)) { unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH); - eol_str_len = CHAR_STRING (XINT (eoltype), tmp); + int c = XFASTINT (eoltype); + eol_str_len = CHAR_STRING (c, tmp); eol_str = tmp; } else diff --git a/src/xfaces.c b/src/xfaces.c index b14710245b1..a56e54c90cd 100644 --- a/src/xfaces.c +++ b/src/xfaces.c @@ -6223,7 +6223,8 @@ face_at_string_position (struct window *w, Lisp_Object string, */ int -merge_faces (struct frame *f, Lisp_Object face_name, int face_id, int base_face_id) +merge_faces (struct frame *f, Lisp_Object face_name, EMACS_INT face_id, + int base_face_id) { Lisp_Object attrs[LFACE_VECTOR_SIZE]; struct face *base_face; diff --git a/src/xfns.c b/src/xfns.c index 5bc0cef6154..abc273c2bdf 100644 --- a/src/xfns.c +++ b/src/xfns.c @@ -1074,8 +1074,7 @@ x_set_border_pixel (struct frame *f, int pix) if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0) { BLOCK_INPUT; - XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), - (unsigned long)pix); + XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix); UNBLOCK_INPUT; if (FRAME_VISIBLE_P (f)) diff --git a/src/xterm.c b/src/xterm.c index 9673e5e315e..f40d260dabe 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -1697,16 +1697,18 @@ x_alloc_nearest_color_1 (Display *dpy, Colormap cmap, XColor *color) a least-squares matching, which is what X uses for closest color matching with StaticColor visuals. */ int nearest, i; - unsigned long nearest_delta = ~ (unsigned long) 0; + int max_color_delta = 255; + int max_delta = 3 * max_color_delta; + int nearest_delta = max_delta + 1; int ncells; const XColor *cells = x_color_cells (dpy, &ncells); for (nearest = i = 0; i < ncells; ++i) { - long dred = (color->red >> 8) - (cells[i].red >> 8); - long dgreen = (color->green >> 8) - (cells[i].green >> 8); - long dblue = (color->blue >> 8) - (cells[i].blue >> 8); - unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue; + int dred = (color->red >> 8) - (cells[i].red >> 8); + int dgreen = (color->green >> 8) - (cells[i].green >> 8); + int dblue = (color->blue >> 8) - (cells[i].blue >> 8); + int delta = dred * dred + dgreen * dgreen + dblue * dblue; if (delta < nearest_delta) { @@ -6442,8 +6444,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr, keys". It seems there's no cleaner way. Test IsModifierKey to avoid handling mode_switch incorrectly. */ - || ((unsigned) (keysym) >= XK_Select - && (unsigned)(keysym) < XK_KP_Space) + || (XK_Select <= keysym && keysym < XK_KP_Space) #endif #ifdef XK_dead_circumflex || orig_keysym == XK_dead_circumflex @@ -6496,10 +6497,8 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr, should be treated similarly to Mode_switch by Emacs. */ #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock - || ((unsigned)(orig_keysym) - >= XK_ISO_Lock - && (unsigned)(orig_keysym) - <= XK_ISO_Last_Group_Lock) + || (XK_ISO_Lock <= orig_keysym + && orig_keysym <= XK_ISO_Last_Group_Lock) #endif )) { @@ -10275,7 +10274,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name) = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window, gray_bitmap_bits, gray_bitmap_width, gray_bitmap_height, - (unsigned long) 1, (unsigned long) 0, 1); + 1, 0, 1); } #ifdef HAVE_X_I18N