actually mean something.
It's easier to staticpro a single Lisp_Object than an array. */
Lisp_Object this_command_keys;
-int this_command_key_count;
+ptrdiff_t this_command_key_count;
/* 1 after calling Freset_this_command_lengths.
Usually it is 0. */
#define GROW_RAW_KEYBUF \
if (raw_keybuf_count == ASIZE (raw_keybuf)) \
- raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
+ raw_keybuf = larger_vector (raw_keybuf, 1, -1)
/* Number of elements of this_command_keys
that precede this key sequence. */
-static int this_single_command_key_start;
+static ptrdiff_t this_single_command_key_start;
/* Record values of this_command_key_count and echo_length ()
before this command was read. */
-static int before_command_key_count;
-static int before_command_echo_length;
+static ptrdiff_t before_command_key_count;
+static ptrdiff_t before_command_echo_length;
/* For longjmp to where kbd input is being done. */
Lisp_Object unread_switch_frame;
/* Last size recorded for a current buffer which is not a minibuffer. */
-static EMACS_INT last_non_minibuf_size;
+static ptrdiff_t last_non_minibuf_size;
/* Total number of times read_char has returned, modulo UINTMAX_MAX + 1. */
uintmax_t num_input_events;
/* Value of num_nonmacro_input_events as of last auto save. */
-static int last_auto_save;
+static EMACS_INT last_auto_save;
/* This is like Vthis_command, except that commands never set it. */
Lisp_Object real_this_command;
/* The value of point when the last command was started. */
-static EMACS_INT last_point_position;
+static ptrdiff_t last_point_position;
/* The buffer that was current when the last command was started. */
static Lisp_Object last_point_position_buffer;
static void record_menu_key (Lisp_Object c);
static void echo_now (void);
-static int echo_length (void);
+static ptrdiff_t echo_length (void);
static Lisp_Object Qpolling_period;
Lisp_Object, Lisp_Object,
Time);
#endif
-static Lisp_Object modify_event_symbol (EMACS_INT, unsigned, Lisp_Object,
+static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object,
Lisp_Object, const char *const *,
- Lisp_Object *, EMACS_INT);
+ Lisp_Object *, ptrdiff_t);
static Lisp_Object make_lispy_switch_frame (Lisp_Object);
static int help_char_p (Lisp_Object);
static void save_getcjmp (jmp_buf);
{
if (!current_kboard->immediate_echo)
{
- int i;
+ ptrdiff_t i;
current_kboard->immediate_echo = 1;
for (i = 0; i < this_command_key_count; i++)
/* Return the length of the current echo string. */
-static int
+static ptrdiff_t
echo_length (void)
{
return (STRINGP (KVAR (current_kboard, echo_string))
switches frames while entering a key sequence. */
static void
-echo_truncate (EMACS_INT nchars)
+echo_truncate (ptrdiff_t nchars)
{
if (STRINGP (KVAR (current_kboard, echo_string)))
KVAR (current_kboard, echo_string)
#endif
if (this_command_key_count >= ASIZE (this_command_keys))
- this_command_keys = larger_vector (this_command_keys,
- 2 * ASIZE (this_command_keys),
- Qnil);
+ this_command_keys = larger_vector (this_command_keys, 1, -1);
ASET (this_command_keys, this_command_key_count, key);
++this_command_key_count;
Lisp_Object
recursive_edit_1 (void)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object val;
if (command_loop_level > 0)
This function is called by the editor initialization to begin editing. */)
(void)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object buffer;
/* If we enter while input is blocked, don't lock up here.
usage: (track-mouse BODY...) */)
(Lisp_Object args)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object val;
record_unwind_protect (tracking_off, do_mouse_tracking);
static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
int, int, int);
void safe_run_hooks (Lisp_Object);
-static void adjust_point_for_property (EMACS_INT, int);
+static void adjust_point_for_property (ptrdiff_t, int);
/* Cancel hourglass from protect_unwind.
ARG is not used. */
Lisp_Object cmd;
Lisp_Object keybuf[30];
int i;
- int prev_modiff = 0;
+ EMACS_INT prev_modiff = 0;
struct buffer *prev_buffer = NULL;
#if 0 /* This shouldn't be necessary anymore. --lorentey */
int was_locked = single_kboard;
{
/* Bind inhibit-quit to t so that C-g gets read in
rather than quitting back to the minibuffer. */
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, Qt);
sit_for (Vminibuffer_message_timeout, 0, 2);
/* Here for a command that isn't executed directly. */
#ifdef HAVE_WINDOW_SYSTEM
- int scount = SPECPDL_INDEX ();
+ ptrdiff_t scount = SPECPDL_INDEX ();
if (display_hourglass_p
&& NILP (Vexecuting_kbd_macro))
&& NILP (Fmemq (Vthis_command,
Vselection_inhibit_update_commands)))
{
- EMACS_INT beg =
+ ptrdiff_t beg =
XINT (Fmarker_position (BVAR (current_buffer, mark)));
- EMACS_INT end = PT;
+ ptrdiff_t end = PT;
if (beg < end)
call2 (Qx_set_selection, QPRIMARY,
make_buffer_string (beg, end, 0));
LAST_PT is the last position of point. */
static void
-adjust_point_for_property (EMACS_INT last_pt, int modified)
+adjust_point_for_property (ptrdiff_t last_pt, int modified)
{
- EMACS_INT beg, end;
+ ptrdiff_t beg, end;
Lisp_Object val, overlay, tmp;
/* When called after buffer modification, we should temporarily
suppress the point adjustment for automatic composition so that a
user can keep inserting another character at point or keep
deleting characters around point. */
int check_composition = ! modified, check_display = 1, check_invisible = 1;
- EMACS_INT orig_pt = PT;
+ ptrdiff_t orig_pt = PT;
/* FIXME: cycling is probably not necessary because these properties
can't be usefully combined anyway. */
/* FIXME: our `internal_condition_case' does not provide any way to pass data
to its body or to its handlers other than via globals such as
dynamically-bound variables ;-) */
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, hook);
run_hook_with_args (1, &hook, safe_run_hook_funcall);
int *used_mouse_menu, struct timeval *end_time)
{
volatile Lisp_Object c;
- int jmpcount;
+ ptrdiff_t jmpcount;
jmp_buf local_getcjmp;
jmp_buf save_jump;
volatile int key_already_recorded = 0;
if (INTERACTIVE && NILP (c))
{
int delay_level;
- EMACS_INT buffer_size;
+ ptrdiff_t buffer_size;
/* Slow down auto saves logarithmically in size of current buffer,
and garbage collect while we're at it. */
&& XINT (Vauto_save_timeout) > 0)
{
Lisp_Object tem0;
- int timeout = delay_level * XFASTINT (Vauto_save_timeout) / 4;
-
+ EMACS_INT timeout = (delay_level
+ * min (XFASTINT (Vauto_save_timeout) / 4,
+ MOST_POSITIVE_FIXNUM / delay_level));
save_getcjmp (save_jump);
restore_getcjmp (local_getcjmp);
tem0 = sit_for (make_number (timeout), 1, 1);
struct buffer *prev_buffer = current_buffer;
#if 0 /* This shouldn't be necessary anymore. --lorentey */
int was_locked = single_kboard;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
record_single_kboard_state ();
#endif
&& ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
{
Lisp_Object keys;
- int key_count, key_count_reset;
+ ptrdiff_t key_count;
+ int key_count_reset;
struct gcpro gcpro1;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
/* Save the echo status. */
int saved_immediate_echo = current_kboard->immediate_echo;
/* Process the help character specially if enabled */
if (!NILP (Vhelp_form) && help_char_p (c))
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
help_form_saved_window_configs
= Fcons (Fcurrent_window_configuration (Qnil),
if (!recorded)
{
- total_keys++;
+ total_keys += total_keys < NUM_RECENT_KEYS;
ASET (recent_keys, recent_keys_index, c);
if (++recent_keys_index >= NUM_RECENT_KEYS)
recent_keys_index = 0;
void
gen_help_event (Lisp_Object help, Lisp_Object frame, Lisp_Object window,
- Lisp_Object object, EMACS_INT pos)
+ Lisp_Object object, ptrdiff_t pos)
{
struct input_event event;
{
if (NILP (vector[0]))
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object old_deactivate_mark = Vdeactivate_mark;
/* Mark the timer as triggered to prevent problems if the lisp
/* It's a click in window WINDOW at frame coordinates (X,Y) */
struct window *w = XWINDOW (window);
Lisp_Object string_info = Qnil;
- EMACS_INT textpos = -1;
+ ptrdiff_t textpos = -1;
int col = -1, row = -1;
int dx = -1, dy = -1;
int width = -1, height = -1;
else if (part == ON_MODE_LINE || part == ON_HEADER_LINE)
{
Lisp_Object string;
- EMACS_INT charpos;
+ ptrdiff_t charpos;
posn = (part == ON_MODE_LINE) ? Qmode_line : Qheader_line;
/* Note that mode_line_string takes COL, ROW as pixels and
else if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
{
Lisp_Object string;
- EMACS_INT charpos;
+ ptrdiff_t charpos;
posn = (part == ON_LEFT_MARGIN) ? Qleft_margin : Qright_margin;
col = wx;
Qfunction_key,
KVAR (current_kboard, Vsystem_key_alist),
0, &KVAR (current_kboard, system_key_syms),
- TYPE_MAXIMUM (EMACS_INT));
+ PTRDIFF_MAX);
}
return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
if (button >= ASIZE (button_down_location))
{
+ ptrdiff_t incr = button - ASIZE (button_down_location) + 1;
button_down_location = larger_vector (button_down_location,
- button + 1, Qnil);
- mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
+ incr, -1);
+ mouse_syms = larger_vector (mouse_syms, incr, -1);
}
start_pos_ptr = &AREF (button_down_location, button);
event->modifiers &= ~up_modifier;
if (event->code >= ASIZE (mouse_syms))
- mouse_syms = larger_vector (mouse_syms, event->code + 1, Qnil);
+ mouse_syms = larger_vector (mouse_syms,
+ event->code - ASIZE (mouse_syms) + 1,
+ -1);
/* Get the symbol we should use for the mouse click. */
head = modify_event_symbol (event->code,
if (button >= ASIZE (button_down_location))
{
+ ptrdiff_t incr = button - ASIZE (button_down_location) + 1;
button_down_location = larger_vector (button_down_location,
- button + 1, Qnil);
- mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
+ incr, -1);
+ mouse_syms = larger_vector (mouse_syms, incr, -1);
}
start_pos_ptr = &AREF (button_down_location, button);
This doesn't use any caches. */
static int
-parse_modifiers_uncached (Lisp_Object symbol, EMACS_INT *modifier_end)
+parse_modifiers_uncached (Lisp_Object symbol, ptrdiff_t *modifier_end)
{
Lisp_Object name;
- EMACS_INT i;
+ ptrdiff_t i;
int modifiers;
CHECK_SYMBOL (symbol);
modifiers = 0;
name = SYMBOL_NAME (symbol);
- for (i = 0; i+2 <= SBYTES (name); )
+ for (i = 0; i < SBYTES (name) - 1; )
{
- EMACS_INT this_mod_end = 0;
+ ptrdiff_t this_mod_end = 0;
int this_mod = 0;
/* See if the name continues with a modifier word.
return elements;
else
{
- EMACS_INT end;
+ ptrdiff_t end;
int modifiers = parse_modifiers_uncached (symbol, &end);
Lisp_Object unmodified;
Lisp_Object mask;
in the symbol's name. */
static Lisp_Object
-modify_event_symbol (EMACS_INT symbol_num, unsigned int modifiers, Lisp_Object symbol_kind,
+modify_event_symbol (ptrdiff_t symbol_num, int modifiers, Lisp_Object symbol_kind,
Lisp_Object name_alist_or_stem, const char *const *name_table,
- Lisp_Object *symbol_table, EMACS_INT table_size)
+ Lisp_Object *symbol_table, ptrdiff_t table_size)
{
Lisp_Object value;
Lisp_Object symbol_int;
if (NILP (value))
{
char buf[sizeof "key-" + INT_STRLEN_BOUND (EMACS_INT)];
- sprintf (buf, "key-%"pI"d", symbol_num);
+ sprintf (buf, "key-%"pD"d", symbol_num);
value = intern (buf);
}
int i = menu_bar_items_index;
if (i + 4 > ASIZE (menu_bar_items_vector))
menu_bar_items_vector =
- larger_vector (menu_bar_items_vector, 2 * i, Qnil);
+ larger_vector (menu_bar_items_vector, 4, -1);
/* Add this item. */
XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
{
/* If vector is too small, get a bigger one. */
if (i + 4 > ASIZE (menu_bar_items_vector))
- menu_bar_items_vector = larger_vector (menu_bar_items_vector, 2 * i, Qnil);
+ menu_bar_items_vector = larger_vector (menu_bar_items_vector, 4, -1);
/* Add this item. */
XVECTOR (menu_bar_items_vector)->contents[i++] = key;
XVECTOR (menu_bar_items_vector)->contents[i++]
Lisp_Object
menu_item_eval_property (Lisp_Object sexpr)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object val;
specbind (Qinhibit_redisplay, Qt);
val = internal_condition_case_1 (eval_dyn, sexpr, Qerror,
append_tool_bar_item (void)
{
Lisp_Object *to, *from;
+ ptrdiff_t incr =
+ (ntool_bar_items
+ - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
/* Enlarge tool_bar_items_vector if necessary. */
- if (ntool_bar_items + TOOL_BAR_ITEM_NSLOTS
- >= ASIZE (tool_bar_items_vector))
+ if (0 < incr)
tool_bar_items_vector
- = larger_vector (tool_bar_items_vector,
- 2 * ASIZE (tool_bar_items_vector), Qnil);
+ = larger_vector (tool_bar_items_vector, incr, -1);
/* Append entries from tool_bar_item_properties to the end of
tool_bar_items_vector. */
int fix_current_buffer)
{
Lisp_Object from_string;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
/* How many keys there are in the current key sequence. */
int t;
/* The length of the echo buffer when we started reading, and
the length of this_command_keys when we started reading. */
- int echo_start IF_LINT (= 0);
- int keys_start;
+ ptrdiff_t echo_start IF_LINT (= 0);
+ ptrdiff_t keys_start;
/* The number of keymaps we're scanning right now, and the number of
keymaps we have allocated space for. */
while those allow us to restart the entire key sequence,
echo_local_start and keys_local_start allow us to throw away
just one key. */
- int echo_local_start IF_LINT (= 0);
+ ptrdiff_t echo_local_start IF_LINT (= 0);
int keys_local_start;
ptrdiff_t local_first_binding;
Lisp_Object keybuf[30];
register int i;
struct gcpro gcpro1;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
if (!NILP (prompt))
CHECK_STRING (prompt);
Lisp_Object keybuf[30];
register int i;
struct gcpro gcpro1;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
if (!NILP (prompt))
CHECK_STRING (prompt);
(Lisp_Object prefixarg)
{
Lisp_Object function;
- EMACS_INT saved_last_point_position;
+ ptrdiff_t saved_last_point_position;
Lisp_Object saved_keys, saved_last_point_position_buffer;
Lisp_Object bindings, value;
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object binding;
char *newmessage;
int message_p = push_message ();
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
ptrdiff_t newmessage_len, newmessage_alloc;
USE_SAFE_ALLOCA;
On such systems, Emacs starts a subshell instead of suspending. */)
(Lisp_Object stuffstring)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
int old_height, old_width;
int width, height;
struct gcpro gcpro1;
if (STRINGP (stuffstring))
{
- register EMACS_INT count;
+ register ptrdiff_t count;
p = SDATA (stuffstring);
count = SBYTES (stuffstring);