Integer overflow and signedness fixes (Bug#8873).
This commit is contained in:
Paul Eggert
commit
a7af7fdede
46 changed files with 834 additions and 529 deletions
250
src/ChangeLog
250
src/ChangeLog
|
|
@ -1,3 +1,253 @@
|
|||
2011-06-15 Paul Eggert <eggert@cs.ucla.edu>
|
||||
|
||||
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 <verify.h>.
|
||||
(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 <monnier@iro.umontreal.ca>
|
||||
|
||||
* eval.c (Fdefvaralias): Also mark the target as variable-special-p.
|
||||
|
|
|
|||
181
src/alloc.c
181
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;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -745,11 +745,15 @@ while(0)
|
|||
|
||||
#endif
|
||||
|
||||
/* Use "&" rather than "&&" to suppress a bogus GCC warning; see
|
||||
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43772>. */
|
||||
#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. */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -23,6 +23,8 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
|||
#ifndef EMACS_CHARACTER_H
|
||||
#define EMACS_CHARACTER_H
|
||||
|
||||
#include <verify.h>
|
||||
|
||||
/* character code 1st byte byte sequence
|
||||
-------------- -------- -------------
|
||||
0-7F 00..7F 0xxxxxxx
|
||||
|
|
@ -102,13 +104,13 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
|||
#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 <http://www.gnu.org/licenses/>. */
|
|||
} 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 <http://www.gnu.org/licenses/>. */
|
|||
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 <http://www.gnu.org/licenses/>. */
|
|||
*(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)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -27,6 +27,8 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
|||
#ifndef EMACS_CHARSET_H
|
||||
#define EMACS_CHARSET_H
|
||||
|
||||
#include <verify.h>
|
||||
|
||||
/* 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
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
}
|
||||
|
|
|
|||
10
src/coding.c
10
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 ] */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
119
src/data.c
119
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
13
src/dired.c
13
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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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++;
|
||||
|
|
|
|||
|
|
@ -118,10 +118,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
|||
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:
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
61
src/eval.c
61
src/eval.c
|
|
@ -32,10 +32,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
|||
#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)
|
||||
{
|
||||
|
|
|
|||
33
src/fileio.c
33
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
|
||||
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43772>. */
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
158
src/fns.c
158
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. */
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
83
src/lisp.h
83
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)
|
||||
|
||||
|
||||
|
|
|
|||
13
src/lread.c
13
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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -2004,7 +2004,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
|
|||
|
||||
case Lisp_Misc_Save_Value:
|
||||
strout ("#<save_value ", -1, -1, printcharfun);
|
||||
sprintf(buf, "ptr=%p int=%d",
|
||||
sprintf(buf, "ptr=%p int=%"pD"d",
|
||||
XSAVE_VALUE (obj)->pointer,
|
||||
XSAVE_VALUE (obj)->integer);
|
||||
strout (buf, -1, -1, printcharfun);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -391,6 +391,7 @@ raid:/nfs/raid/src/dist-18.56/src> dump -h temacs
|
|||
extern void fatal (const char *msgid, ...);
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/stat.h>
|
||||
#include <memory.h>
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
12
src/widget.c
12
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;
|
||||
|
|
|
|||
14
src/xdisp.c
14
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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
23
src/xterm.c
23
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
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue