/* Last size recorded for a current buffer which is not a minibuffer. */
static EMACS_INT last_non_minibuf_size;
-/* Total number of times read_char has returned. */
-int num_input_events;
+/* Total number of times read_char has returned, modulo SIZE_MAX + 1. */
+size_t num_input_events;
/* Value of num_nonmacro_input_events as of last auto save. */
/* Hooks to run before and after each command. */
Lisp_Object Qpre_command_hook;
Lisp_Object Qpost_command_hook;
-Lisp_Object Qcommand_hook_internal;
Lisp_Object Qdeferred_action_function;
Lisp_Object recursive_edit_unwind (Lisp_Object buffer), command_loop (void);
Lisp_Object Fthis_command_keys (void);
Lisp_Object Qextended_command_history;
-EMACS_TIME timer_check (int do_it_now);
+EMACS_TIME timer_check (void);
static void record_menu_key (Lisp_Object c);
static int echo_length (void);
static Lisp_Object apply_modifiers (int, Lisp_Object);
static void clear_event (struct input_event *);
static Lisp_Object restore_kboard_configuration (Lisp_Object);
-static SIGTYPE interrupt_signal (int signalnum);
+static void interrupt_signal (int signalnum);
#ifdef SIGIO
-static SIGTYPE input_available_signal (int signo);
+static void input_available_signal (int signo);
#endif
static void handle_interrupt (void);
static void timer_start_idle (void);
static void timer_stop_idle (void);
static void timer_resume_idle (void);
-static SIGTYPE handle_user_signal (int);
+static void handle_user_signal (int);
static char *find_user_signal_name (int);
static int store_user_signal_events (void);
C can be a character, which is printed prettily ("M-C-x" and all that
jazz), or a symbol, whose name is printed. */
-void
+static void
echo_char (Lisp_Object c)
{
if (current_kboard->immediate_echo)
char *ptr = buffer;
Lisp_Object echo_string;
- echo_string = current_kboard->echo_string;
+ echo_string = KVAR (current_kboard, echo_string);
/* If someone has passed us a composite event, use its head symbol. */
c = EVENT_HEAD (c);
else if (STRINGP (echo_string))
echo_string = concat2 (echo_string, build_string (" "));
- current_kboard->echo_string
+ KVAR (current_kboard, echo_string)
= concat2 (echo_string, make_string (buffer, ptr - buffer));
echo_now ();
/* Temporarily add a dash to the end of the echo string if it's not
empty, so that it serves as a mini-prompt for the very next character. */
-void
+static void
echo_dash (void)
{
/* Do nothing if not echoing at all. */
- if (NILP (current_kboard->echo_string))
+ if (NILP (KVAR (current_kboard, echo_string)))
return;
if (this_command_key_count == 0)
return;
if (!current_kboard->immediate_echo
- && SCHARS (current_kboard->echo_string) == 0)
+ && SCHARS (KVAR (current_kboard, echo_string)) == 0)
return;
/* Do nothing if we just printed a prompt. */
if (current_kboard->echo_after_prompt
- == SCHARS (current_kboard->echo_string))
+ == SCHARS (KVAR (current_kboard, echo_string)))
return;
/* Do nothing if we have already put a dash at the end. */
- if (SCHARS (current_kboard->echo_string) > 1)
+ if (SCHARS (KVAR (current_kboard, echo_string)) > 1)
{
Lisp_Object last_char, prev_char, idx;
- idx = make_number (SCHARS (current_kboard->echo_string) - 2);
- prev_char = Faref (current_kboard->echo_string, idx);
+ idx = make_number (SCHARS (KVAR (current_kboard, echo_string)) - 2);
+ prev_char = Faref (KVAR (current_kboard, echo_string), idx);
- idx = make_number (SCHARS (current_kboard->echo_string) - 1);
- last_char = Faref (current_kboard->echo_string, idx);
+ idx = make_number (SCHARS (KVAR (current_kboard, echo_string)) - 1);
+ last_char = Faref (KVAR (current_kboard, echo_string), idx);
if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
return;
/* Put a dash at the end of the buffer temporarily,
but make it go away when the next character is added. */
- current_kboard->echo_string = concat2 (current_kboard->echo_string,
+ KVAR (current_kboard, echo_string) = concat2 (KVAR (current_kboard, echo_string),
build_string ("-"));
echo_now ();
}
}
echoing = 1;
- message3_nolog (current_kboard->echo_string,
- SBYTES (current_kboard->echo_string),
- STRING_MULTIBYTE (current_kboard->echo_string));
+ message3_nolog (KVAR (current_kboard, echo_string),
+ SBYTES (KVAR (current_kboard, echo_string)),
+ STRING_MULTIBYTE (KVAR (current_kboard, echo_string)));
echoing = 0;
/* Record in what buffer we echoed, and from which kboard. */
{
current_kboard->immediate_echo = 0;
current_kboard->echo_after_prompt = -1;
- current_kboard->echo_string = Qnil;
+ KVAR (current_kboard, echo_string) = Qnil;
ok_to_echo_at_next_pause = NULL;
echo_kboard = NULL;
echo_message_buffer = Qnil;
static int
echo_length (void)
{
- return (STRINGP (current_kboard->echo_string)
- ? SCHARS (current_kboard->echo_string)
+ return (STRINGP (KVAR (current_kboard, echo_string))
+ ? SCHARS (KVAR (current_kboard, echo_string))
: 0);
}
static void
echo_truncate (EMACS_INT nchars)
{
- if (STRINGP (current_kboard->echo_string))
- current_kboard->echo_string
- = Fsubstring (current_kboard->echo_string,
+ if (STRINGP (KVAR (current_kboard, echo_string)))
+ KVAR (current_kboard, echo_string)
+ = Fsubstring (KVAR (current_kboard, echo_string),
make_number (0), make_number (nchars));
truncate_echo_area (nchars);
}
/* Handle errors that are not handled at inner levels
by printing an error message and returning to the editor command loop. */
-Lisp_Object
+static Lisp_Object
cmd_error (Lisp_Object data)
{
Lisp_Object old_level, old_length;
Vstandard_input = Qt;
Vexecuting_kbd_macro = Qnil;
executing_kbd_macro = Qnil;
- current_kboard->Vprefix_arg = Qnil;
- current_kboard->Vlast_prefix_arg = Qnil;
+ KVAR (current_kboard, Vprefix_arg) = Qnil;
+ KVAR (current_kboard, Vlast_prefix_arg) = Qnil;
cancel_echoing ();
/* Avoid unquittable loop if data contains a circular list. */
return Qnil;
}
-Lisp_Object
+static Lisp_Object
top_level_2 (void)
{
- return Feval (Vtop_level);
+ return Feval (Vtop_level, Qnil);
}
Lisp_Object
Fthrow (Qtop_level, Qnil);
}
+Lisp_Object Fexit_recursive_edit (void) NO_RETURN;
DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
doc: /* Exit from the innermost recursive edit or minibuffer. */)
(void)
error ("No recursive edit is in progress");
}
+Lisp_Object Fabort_recursive_edit (void) NO_RETURN;
DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
doc: /* Abort the command that requested this recursive edit or minibuffer input. */)
(void)
/* This is the actual command reading loop,
sans error-handling encapsulation. */
-static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
+static int read_key_sequence (Lisp_Object *, size_t, Lisp_Object,
int, int, int);
void safe_run_hooks (Lisp_Object);
static void adjust_point_for_property (EMACS_INT, int);
#endif
int already_adjusted = 0;
- current_kboard->Vprefix_arg = Qnil;
- current_kboard->Vlast_prefix_arg = Qnil;
+ KVAR (current_kboard, Vprefix_arg) = Qnil;
+ KVAR (current_kboard, Vlast_prefix_arg) = Qnil;
Vdeactivate_mark = Qnil;
waiting_for_input = 0;
cancel_echoing ();
}
/* Do this after running Vpost_command_hook, for consistency. */
- current_kboard->Vlast_command = Vthis_command;
- current_kboard->Vreal_last_command = real_this_command;
+ KVAR (current_kboard, Vlast_command) = Vthis_command;
+ KVAR (current_kboard, Vreal_last_command) = real_this_command;
if (!CONSP (last_command_event))
- current_kboard->Vlast_repeatable_command = real_this_command;
+ KVAR (current_kboard, Vlast_repeatable_command) = real_this_command;
while (1)
{
Vthis_command = cmd;
real_this_command = cmd;
- /* Note that the value cell will never directly contain nil
- if the symbol is a local variable. */
- if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
- safe_run_hooks (Qpre_command_hook);
+ safe_run_hooks (Qpre_command_hook);
already_adjusted = 0;
keys = Fkey_description (keys, Qnil);
bitch_at_user ();
message_with_string ("%s is undefined", keys, 0);
- current_kboard->defining_kbd_macro = Qnil;
+ KVAR (current_kboard, defining_kbd_macro) = Qnil;
update_mode_lines = 1;
- current_kboard->Vprefix_arg = Qnil;
+ KVAR (current_kboard, Vprefix_arg) = Qnil;
}
else
{
}
#endif
- if (NILP (current_kboard->Vprefix_arg)) /* FIXME: Why? --Stef */
+ if (NILP (KVAR (current_kboard, Vprefix_arg))) /* FIXME: Why? --Stef */
Fundo_boundary ();
Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
unbind_to (scount, Qnil);
#endif
}
- current_kboard->Vlast_prefix_arg = Vcurrent_prefix_arg;
+ KVAR (current_kboard, Vlast_prefix_arg) = Vcurrent_prefix_arg;
- /* Note that the value cell will never directly contain nil
- if the symbol is a local variable. */
- if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
- safe_run_hooks (Qpost_command_hook);
+ safe_run_hooks (Qpost_command_hook);
/* If displaying a message, resize the echo area window to fit
that message's size exactly. */
if (!NILP (echo_area_buffer[0]))
resize_echo_area_exactly ();
- if (!NILP (Vdeferred_action_list))
- safe_run_hooks (Qdeferred_action_function);
+ safe_run_hooks (Qdeferred_action_function);
/* If there is a prefix argument,
1) We don't want Vlast_command to be ``universal-argument''
If the command didn't actually create a prefix arg,
but is merely a frame event that is transparent to prefix args,
then the above doesn't apply. */
- if (NILP (current_kboard->Vprefix_arg) || CONSP (last_command_event))
+ if (NILP (KVAR (current_kboard, Vprefix_arg)) || CONSP (last_command_event))
{
- current_kboard->Vlast_command = Vthis_command;
- current_kboard->Vreal_last_command = real_this_command;
+ KVAR (current_kboard, Vlast_command) = Vthis_command;
+ KVAR (current_kboard, Vreal_last_command) = real_this_command;
if (!CONSP (last_command_event))
- current_kboard->Vlast_repeatable_command = real_this_command;
+ KVAR (current_kboard, Vlast_repeatable_command) = real_this_command;
cancel_echoing ();
this_command_key_count = 0;
this_command_key_count_reset = 0;
this_single_command_key_start = 0;
}
- if (!NILP (B_ (current_buffer, mark_active))
+ if (!NILP (BVAR (current_buffer, mark_active))
&& !NILP (Vrun_hooks))
{
/* In Emacs 22, setting transient-mark-mode to `only' was a
if (!NILP (Fwindow_system (Qnil))
/* Even if mark_active is non-nil, the actual buffer
marker may not have been set yet (Bug#7044). */
- && XMARKER (B_ (current_buffer, mark))->buffer
+ && XMARKER (BVAR (current_buffer, mark))->buffer
&& (EQ (Vselect_active_regions, Qonly)
? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
: (!NILP (Vselect_active_regions)
&& !EQ (Vthis_command, Qhandle_switch_frame))
{
EMACS_INT beg =
- XINT (Fmarker_position (B_ (current_buffer, mark)));
+ XINT (Fmarker_position (BVAR (current_buffer, mark)));
EMACS_INT end = PT;
if (beg < end)
call2 (Qx_set_selection, QPRIMARY,
}
if (current_buffer != prev_buffer || MODIFF != prev_modiff)
- call1 (Vrun_hooks, intern ("activate-mark-hook"));
+ {
+ Lisp_Object hook = intern ("activate-mark-hook");
+ Frun_hooks (1, &hook);
+ }
}
Vsaved_region_selection = Qnil;
/* Install chars successfully executed in kbd macro. */
- if (!NILP (current_kboard->defining_kbd_macro)
- && NILP (current_kboard->Vprefix_arg))
+ if (!NILP (KVAR (current_kboard, defining_kbd_macro))
+ && NILP (KVAR (current_kboard, Vprefix_arg)))
finalize_kbd_macro_chars ();
#if 0 /* This shouldn't be necessary anymore. --lorentey */
if (!was_locked)
static Lisp_Object
safe_run_hooks_1 (void)
{
- if (NILP (Vrun_hooks))
- return Qnil;
- return call1 (Vrun_hooks, Vinhibit_quit);
+ eassert (CONSP (Vinhibit_quit));
+ return call0 (XCDR (Vinhibit_quit));
}
-/* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
+/* Subroutine for safe_run_hooks: handle an error by clearing out the function
+ from the hook. */
static Lisp_Object
-safe_run_hooks_error (Lisp_Object data)
+safe_run_hooks_error (Lisp_Object error_data)
+{
+ Lisp_Object hook
+ = CONSP (Vinhibit_quit) ? XCAR (Vinhibit_quit) : Vinhibit_quit;
+ Lisp_Object fun = CONSP (Vinhibit_quit) ? XCDR (Vinhibit_quit) : Qnil;
+ Lisp_Object args[4];
+ args[0] = build_string ("Error in %s (%s): %s");
+ args[1] = hook;
+ args[2] = fun;
+ args[3] = error_data;
+ Fmessage (4, args);
+ if (SYMBOLP (hook))
+ {
+ Lisp_Object val;
+ int found = 0;
+ Lisp_Object newval = Qnil;
+ for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
+ if (EQ (fun, XCAR (val)))
+ found = 1;
+ else
+ newval = Fcons (XCAR (val), newval);
+ if (found)
+ return Fset (hook, Fnreverse (newval));
+ /* Not found in the local part of the hook. Let's look at the global
+ part. */
+ newval = Qnil;
+ for (val = (NILP (Fdefault_boundp (hook)) ? Qnil
+ : Fdefault_value (hook));
+ CONSP (val); val = XCDR (val))
+ if (EQ (fun, XCAR (val)))
+ found = 1;
+ else
+ newval = Fcons (XCAR (val), newval);
+ if (found)
+ return Fset_default (hook, Fnreverse (newval));
+ }
+ return Qnil;
+}
+
+static Lisp_Object
+safe_run_hook_funcall (size_t nargs, Lisp_Object *args)
{
- Lisp_Object args[3];
- args[0] = build_string ("Error in %s: %s");
- args[1] = Vinhibit_quit;
- args[2] = data;
- Fmessage (3, args);
- return Fset (Vinhibit_quit, Qnil);
+ eassert (nargs == 1);
+ if (CONSP (Vinhibit_quit))
+ XSETCDR (Vinhibit_quit, args[0]);
+ else
+ Vinhibit_quit = Fcons (Vinhibit_quit, args[0]);
+
+ return internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
}
/* If we get an error while running the hook, cause the hook variable
void
safe_run_hooks (Lisp_Object hook)
{
+ /* 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 ();
specbind (Qinhibit_quit, hook);
- internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
+ run_hook_with_args (1, &hook, safe_run_hook_funcall);
unbind_to (count, Qnil);
}
/* Timer callback function for poll_timer. TIMER is equal to
poll_timer. */
-void
+static void
poll_for_input (struct atimer *timer)
{
if (poll_suppress_count == 0)
the `display' property). POS is the position in that string under
the mouse.
- OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
- echo overwrites a keystroke echo currently displayed in the echo
- area.
-
Note: this function may only be called with HELP nil or a string
from X code running asynchronously. */
void
show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
- Lisp_Object pos, int ok_to_overwrite_keystroke_echo)
+ Lisp_Object pos)
{
if (!NILP (help) && !STRINGP (help))
{
int *used_mouse_menu, struct timeval *end_time)
{
volatile Lisp_Object c;
- int count, jmpcount;
+ int jmpcount;
jmp_buf local_getcjmp;
jmp_buf save_jump;
volatile int key_already_recorded = 0;
KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
if (kb != current_kboard)
{
- Lisp_Object link = kb->kbd_queue;
+ Lisp_Object last = KVAR (kb, kbd_queue);
/* We shouldn't get here if we were in single-kboard mode! */
if (single_kboard)
abort ();
- if (CONSP (link))
+ if (CONSP (last))
{
- while (CONSP (XCDR (link)))
- link = XCDR (link);
- if (!NILP (XCDR (link)))
+ while (CONSP (XCDR (last)))
+ last = XCDR (last);
+ if (!NILP (XCDR (last)))
abort ();
}
- if (!CONSP (link))
- kb->kbd_queue = Fcons (c, Qnil);
+ if (!CONSP (last))
+ KVAR (kb, kbd_queue) = Fcons (c, Qnil);
else
- XSETCDR (link, Fcons (c, Qnil));
+ XSETCDR (last, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
current_kboard = kb;
/* This is going to exit from read_char
{
if (current_kboard->kbd_queue_has_data)
{
- if (!CONSP (current_kboard->kbd_queue))
+ if (!CONSP (KVAR (current_kboard, kbd_queue)))
abort ();
- c = XCAR (current_kboard->kbd_queue);
- current_kboard->kbd_queue
- = XCDR (current_kboard->kbd_queue);
- if (NILP (current_kboard->kbd_queue))
+ c = XCAR (KVAR (current_kboard, kbd_queue));
+ KVAR (current_kboard, kbd_queue)
+ = XCDR (KVAR (current_kboard, kbd_queue));
+ if (NILP (KVAR (current_kboard, kbd_queue)))
current_kboard->kbd_queue_has_data = 0;
input_pending = readable_events (0);
if (EVENT_HAS_PARAMETERS (c)
if (NILP (c))
{
- KBOARD *kb;
+ KBOARD *kb IF_LINT (= NULL);
if (end_time)
{
if (! NILP (c) && (kb != current_kboard))
{
- Lisp_Object link = kb->kbd_queue;
- if (CONSP (link))
+ Lisp_Object last = KVAR (kb, kbd_queue);
+ if (CONSP (last))
{
- while (CONSP (XCDR (link)))
- link = XCDR (link);
- if (!NILP (XCDR (link)))
+ while (CONSP (XCDR (last)))
+ last = XCDR (last);
+ if (!NILP (XCDR (last)))
abort ();
}
- if (!CONSP (link))
- kb->kbd_queue = Fcons (c, Qnil);
+ if (!CONSP (last))
+ KVAR (kb, kbd_queue) = Fcons (c, Qnil);
else
- XSETCDR (link, Fcons (c, Qnil));
+ XSETCDR (last, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
c = Qnil;
if (single_kboard)
if (XINT (c) == -1)
goto exit;
- if ((STRINGP (current_kboard->Vkeyboard_translate_table)
- && SCHARS (current_kboard->Vkeyboard_translate_table) > (unsigned) XFASTINT (c))
- || (VECTORP (current_kboard->Vkeyboard_translate_table)
- && XVECTOR (current_kboard->Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
- || (CHAR_TABLE_P (current_kboard->Vkeyboard_translate_table)
+ if ((STRINGP (KVAR (current_kboard, Vkeyboard_translate_table))
+ && SCHARS (KVAR (current_kboard, Vkeyboard_translate_table)) > (unsigned) XFASTINT (c))
+ || (VECTORP (KVAR (current_kboard, Vkeyboard_translate_table))
+ && XVECTOR (KVAR (current_kboard, Vkeyboard_translate_table))->size > (unsigned) XFASTINT (c))
+ || (CHAR_TABLE_P (KVAR (current_kboard, Vkeyboard_translate_table))
&& CHARACTERP (c)))
{
Lisp_Object d;
- d = Faref (current_kboard->Vkeyboard_translate_table, c);
+ d = Faref (KVAR (current_kboard, Vkeyboard_translate_table), c);
/* nil in keyboard-translate-table means no translation. */
if (!NILP (d))
c = d;
{
Lisp_Object keys;
int key_count, key_count_reset;
- struct gcpro gcpro1;
+ struct gcpro inner_gcpro1;
int count = SPECPDL_INDEX ();
/* Save the echo status. */
int saved_immediate_echo = current_kboard->immediate_echo;
struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
- Lisp_Object saved_echo_string = current_kboard->echo_string;
+ Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
int saved_echo_after_prompt = current_kboard->echo_after_prompt;
#if 0
keys = Fcopy_sequence (this_command_keys);
else
keys = Qnil;
- GCPRO1 (keys);
+ GCPRO1_VAR (keys, inner_gcpro);
/* Clear out this_command_keys. */
this_command_key_count = 0;
cancel_echoing ();
ok_to_echo_at_next_pause = saved_ok_to_echo;
- current_kboard->echo_string = saved_echo_string;
+ KVAR (current_kboard, echo_string) = saved_echo_string;
current_kboard->echo_after_prompt = saved_echo_after_prompt;
if (saved_immediate_echo)
echo_now ();
- UNGCPRO;
+ UNGCPRO_VAR (inner_gcpro);
/* The input method can return no events. */
if (! CONSP (tem))
if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
{
/* (help-echo FRAME HELP WINDOW OBJECT POS). */
- Lisp_Object help, object, position, window, tem;
+ Lisp_Object help, object, position, window, htem;
- tem = Fcdr (XCDR (c));
- help = Fcar (tem);
- tem = Fcdr (tem);
- window = Fcar (tem);
- tem = Fcdr (tem);
- object = Fcar (tem);
- tem = Fcdr (tem);
- position = Fcar (tem);
+ htem = Fcdr (XCDR (c));
+ help = Fcar (htem);
+ htem = Fcdr (htem);
+ window = Fcar (htem);
+ htem = Fcdr (htem);
+ object = Fcar (htem);
+ htem = Fcdr (htem);
+ position = Fcar (htem);
- show_help_echo (help, window, object, position, 0);
+ show_help_echo (help, window, object, position);
/* We stopped being idle for this event; undo that. */
if (!end_time)
if (!NILP (Vhelp_form) && help_char_p (c))
{
Lisp_Object tem0;
- count = SPECPDL_INDEX ();
+ int count = SPECPDL_INDEX ();
help_form_saved_window_configs
= Fcons (Fcurrent_window_configuration (Qnil),
help_form_saved_window_configs);
record_unwind_protect (read_char_help_form_unwind, Qnil);
- tem0 = Feval (Vhelp_form);
+ tem0 = Feval (Vhelp_form, Qnil);
if (STRINGP (tem0))
internal_with_output_to_temp_buffer ("*Help*", print_help, tem0);
readable_events (int flags)
{
if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
- timer_check (1);
+ timer_check ();
/* If the buffer contains only FOCUS_IN_EVENT events, and
READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
if (single_kboard && kb != current_kboard)
{
- kb->kbd_queue
+ KVAR (kb, kbd_queue)
= Fcons (make_lispy_switch_frame (event->frame_or_window),
Fcons (make_number (c), Qnil));
kb->kbd_queue_has_data = 1;
Lisp_Object bar_window;
enum scroll_bar_part part;
Lisp_Object x, y;
- unsigned long time;
+ unsigned long t;
*kbp = current_kboard;
/* Note that this uses F to determine which terminal to look at.
/* XXX Can f or mouse_position_hook be NULL here? */
if (f && FRAME_TERMINAL (f)->mouse_position_hook)
(*FRAME_TERMINAL (f)->mouse_position_hook) (&f, 0, &bar_window,
- &part, &x, &y, &time);
+ &part, &x, &y, &t);
obj = Qnil;
/* If we didn't decide to make a switch-frame event, go ahead and
return a mouse-motion event. */
if (!NILP (x) && NILP (obj))
- obj = make_lispy_movement (f, bar_window, part, x, y, time);
+ obj = make_lispy_movement (f, bar_window, part, x, y, t);
}
#endif /* HAVE_MOUSE || HAVE GPM */
else
Returns the time to wait until the next timer fires.
If no timer is active, return -1.
- As long as any timer is ripe, we run it.
-
- DO_IT_NOW is now ignored. It used to mean that we should
- run the timer directly instead of queueing a timer-event.
- Now we always run timers directly. */
+ As long as any timer is ripe, we run it. */
EMACS_TIME
-timer_check (int do_it_now)
+timer_check (void)
{
EMACS_TIME nexttime;
static Lisp_Object
make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
- unsigned long time)
+ unsigned long t)
{
enum window_part part;
Lisp_Object posn = Qnil;
Fcons (posn,
Fcons (Fcons (make_number (xret),
make_number (yret)),
- Fcons (make_number (time),
+ Fcons (make_number (t),
extra_info))));
}
{
/* We need to use an alist rather than a vector as the cache
since we can't make a vector long enuf. */
- if (NILP (current_kboard->system_key_syms))
- current_kboard->system_key_syms = Fcons (Qnil, Qnil);
+ if (NILP (KVAR (current_kboard, system_key_syms)))
+ KVAR (current_kboard, system_key_syms) = Fcons (Qnil, Qnil);
return modify_event_symbol (event->code,
event->modifiers,
Qfunction_key,
- current_kboard->Vsystem_key_alist,
- 0, ¤t_kboard->system_key_syms,
+ KVAR (current_kboard, Vsystem_key_alist),
+ 0, &KVAR (current_kboard, system_key_syms),
(unsigned) -1);
}
&& (event->modifiers & down_modifier))
{
Lisp_Object items, item;
- int hpos;
int i;
/* Find the menu bar item under `column'. */
/* On window-system frames, use the value of
double-click-fuzz as is. On other frames, interpret it
as a multiple of 1/8 characters. */
- struct frame *f;
+ struct frame *fr;
int fuzz;
int symbol_num;
int is_double;
if (WINDOWP (event->frame_or_window))
- f = XFRAME (XWINDOW (event->frame_or_window)->frame);
+ fr = XFRAME (XWINDOW (event->frame_or_window)->frame);
else if (FRAMEP (event->frame_or_window))
- f = XFRAME (event->frame_or_window);
+ fr = XFRAME (event->frame_or_window);
else
abort ();
- fuzz = FRAME_WINDOW_P (f)
+ fuzz = FRAME_WINDOW_P (fr)
? double_click_fuzz : double_click_fuzz / 8;
if (event->modifiers & up_modifier)
static Lisp_Object
make_lispy_movement (FRAME_PTR frame, Lisp_Object bar_window, enum scroll_bar_part part,
- Lisp_Object x, Lisp_Object y, unsigned long time)
+ Lisp_Object x, Lisp_Object y, unsigned long t)
{
/* Is it a scroll bar movement? */
if (frame && ! NILP (bar_window))
Fcons (list5 (bar_window,
Qvertical_scroll_bar,
Fcons (x, y),
- make_number (time),
+ make_number (t),
part_sym),
Qnil));
}
else
{
Lisp_Object position;
- position = make_lispy_position (frame, x, y, time);
+ position = make_lispy_position (frame, x, y, t);
return list2 (Qmouse_movement, position);
}
}
This doesn't use any caches. */
static int
-parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
+parse_modifiers_uncached (Lisp_Object symbol, EMACS_INT *modifier_end)
{
Lisp_Object name;
- int i;
+ EMACS_INT i;
int modifiers;
CHECK_SYMBOL (symbol);
for (i = 0; i+2 <= SBYTES (name); )
{
- int this_mod_end = 0;
+ EMACS_INT this_mod_end = 0;
int this_mod = 0;
/* See if the name continues with a modifier word.
return elements;
else
{
- int end;
+ EMACS_INT end;
int modifiers = parse_modifiers_uncached (symbol, &end);
Lisp_Object unmodified;
Lisp_Object mask;
static Lisp_Object
apply_modifiers (int modifiers, Lisp_Object base)
{
- Lisp_Object cache, index, entry, new_symbol;
+ Lisp_Object cache, idx, entry, new_symbol;
/* Mask out upper bits. We don't know where this value's been. */
modifiers &= INTMASK;
/* The click modifier never figures into cache indices. */
cache = Fget (base, Qmodifier_cache);
- XSETFASTINT (index, (modifiers & ~click_modifier));
- entry = assq_no_quit (index, cache);
+ XSETFASTINT (idx, (modifiers & ~click_modifier));
+ entry = assq_no_quit (idx, cache);
if (CONSP (entry))
new_symbol = XCDR (entry);
SBYTES (SYMBOL_NAME (base)));
/* Add the new symbol to the base's cache. */
- entry = Fcons (index, new_symbol);
+ entry = Fcons (idx, new_symbol);
Fput (base, Qmodifier_cache, Fcons (entry, cache));
/* We have the parsing info now for free, so we could add it to
the caches:
- XSETFASTINT (index, modifiers);
+ XSETFASTINT (idx, modifiers);
Fput (new_symbol, Qevent_symbol_element_mask,
- Fcons (base, Fcons (index, Qnil)));
+ Fcons (base, Fcons (idx, Qnil)));
Fput (new_symbol, Qevent_symbol_elements,
Fcons (base, lispy_modifier_list (modifiers)));
Sadly, this is only correct if `base' is indeed a base event,
return;
for (i = 0, p = coding->destination; i < coding->produced_char; i++)
{
- struct input_event buf;
+ struct input_event event_buf;
- EVENT_INIT (buf);
- buf.code = STRING_CHAR_ADVANCE (p);
- buf.kind = (ASCII_CHAR_P (buf.code)
- ? ASCII_KEYSTROKE_EVENT : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
+ EVENT_INIT (event_buf);
+ event_buf.code = STRING_CHAR_ADVANCE (p);
+ event_buf.kind =
+ (ASCII_CHAR_P (event_buf.code)
+ ? ASCII_KEYSTROKE_EVENT : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
/* See the comment in tty_read_avail_input. */
- buf.frame_or_window = tty->top_frame;
- buf.arg = Qnil;
- kbd_buffer_store_event (&buf);
+ event_buf.frame_or_window = tty->top_frame;
+ event_buf.arg = Qnil;
+ kbd_buffer_store_event (&event_buf);
}
}
if (gpm_tty == tty)
{
Gpm_Event event;
- struct input_event hold_quit;
+ struct input_event gpm_hold_quit;
int gpm, fd = gpm_fd;
- EVENT_INIT (hold_quit);
- hold_quit.kind = NO_EVENT;
+ EVENT_INIT (gpm_hold_quit);
+ gpm_hold_quit.kind = NO_EVENT;
/* gpm==1 if event received.
gpm==0 if the GPM daemon has closed the connection, in which case
select masks.
gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
while (gpm = Gpm_GetEvent (&event), gpm == 1) {
- nread += handle_one_term_event (tty, &event, &hold_quit);
+ nread += handle_one_term_event (tty, &event, &gpm_hold_quit);
}
if (gpm == 0)
/* Presumably the GPM daemon has closed the connection. */
close_gpm (fd);
- if (hold_quit.kind != NO_EVENT)
- kbd_buffer_store_event (&hold_quit);
+ if (gpm_hold_quit.kind != NO_EVENT)
+ kbd_buffer_store_event (&gpm_hold_quit);
if (nread)
return nread;
}
return nread;
}
\f
-void
+static void
handle_async_input (void)
{
interrupt_input_pending = 0;
#ifdef SIGIO /* for entire page */
/* Note SIGIO has been undef'd if FIONREAD is missing. */
-static SIGTYPE
+static void
input_available_signal (int signo)
{
/* Must preserve main program's value of errno. */
signal (sig, handle_user_signal);
}
-static SIGTYPE
+static void
handle_user_signal (int sig)
{
int old_errno = errno;
int mapno;
Lisp_Object oquit;
- int i;
-
/* In order to build the menus, we need to call the keymap
accessors. They all call QUIT. But this function is called
during redisplay, during which a quit is fatal. So inhibit
/* Yes, use them (if non-nil) as well as the global map. */
maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
+ if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
+ maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
if (!NILP (Voverriding_local_map))
maps[nmaps++] = Voverriding_local_map;
}
}
/* Add nil, nil, nil, nil at the end. */
- i = menu_bar_items_index;
- if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
- menu_bar_items_vector = larger_vector (menu_bar_items_vector, 2 * i, Qnil);
- /* Add this item. */
- XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
- XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
- XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
- XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
- menu_bar_items_index = i;
+ {
+ int i = menu_bar_items_index;
+ if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
+ menu_bar_items_vector =
+ larger_vector (menu_bar_items_vector, 2 * i, Qnil);
+ /* Add this item. */
+ XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
+ XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
+ XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
+ XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
+ menu_bar_items_index = i;
+ }
Vinhibit_quit = oquit;
return menu_bar_items_vector;
return Qnil;
}
+static Lisp_Object
+eval_dyn (Lisp_Object form)
+{
+ return Feval (form, Qnil);
+}
+
/* Evaluate an expression and return the result (or nil if something
went wrong). Used to evaluate dynamic parts of menu items. */
Lisp_Object
int count = SPECPDL_INDEX ();
Lisp_Object val;
specbind (Qinhibit_redisplay, Qt);
- val = internal_condition_case_1 (Feval, sexpr, Qerror,
+ val = internal_condition_case_1 (eval_dyn, sexpr, Qerror,
menu_item_eval_property_1);
return unbind_to (count, val);
}
/* Yes, use them (if non-nil) as well as the global map. */
maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
+ if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
+ maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
if (!NILP (Voverriding_local_map))
maps[nmaps++] = Voverriding_local_map;
}
/* Process the rest of the properties. */
for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
{
- Lisp_Object key, value;
+ Lisp_Object ikey, value;
- key = XCAR (item);
+ ikey = XCAR (item);
value = XCAR (XCDR (item));
- if (EQ (key, QCenable))
+ if (EQ (ikey, QCenable))
{
/* `:enable FORM'. */
if (!NILP (Venable_disabled_menus_and_buttons))
else
PROP (TOOL_BAR_ITEM_ENABLED_P) = value;
}
- else if (EQ (key, QCvisible))
+ else if (EQ (ikey, QCvisible))
{
/* `:visible FORM'. If got a visible property and that
evaluates to nil then ignore this item. */
if (NILP (menu_item_eval_property (value)))
return 0;
}
- else if (EQ (key, QChelp))
+ else if (EQ (ikey, QChelp))
/* `:help HELP-STRING'. */
PROP (TOOL_BAR_ITEM_HELP) = value;
- else if (EQ (key, QCvert_only))
+ else if (EQ (ikey, QCvert_only))
/* `:vert-only t/nil'. */
PROP (TOOL_BAR_ITEM_VERT_ONLY) = value;
- else if (EQ (key, QClabel))
+ else if (EQ (ikey, QClabel))
{
const char *bad_label = "!!?GARBLED ITEM?!!";
/* `:label LABEL-STRING'. */
: make_string (bad_label, strlen (bad_label));
have_label = 1;
}
- else if (EQ (key, QCfilter))
+ else if (EQ (ikey, QCfilter))
/* ':filter FORM'. */
filter = value;
- else if (EQ (key, QCbutton) && CONSP (value))
+ else if (EQ (ikey, QCbutton) && CONSP (value))
{
/* `:button (TYPE . SELECTED)'. */
Lisp_Object type, selected;
PROP (TOOL_BAR_ITEM_TYPE) = type;
}
}
- else if (EQ (key, QCimage)
+ else if (EQ (ikey, QCimage)
&& (CONSP (value)
|| (VECTORP (value) && XVECTOR (value)->size == 4)))
/* Value is either a single image specification or a vector
of 4 such specifications for the different button states. */
PROP (TOOL_BAR_ITEM_IMAGES) = value;
- else if (EQ (key, Qrtl))
+ else if (EQ (ikey, Qrtl))
/* ':rtl STRING' */
PROP (TOOL_BAR_ITEM_RTL_IMAGE) = value;
}
if (!have_label)
{
/* Try to make one from caption and key. */
- Lisp_Object key = PROP (TOOL_BAR_ITEM_KEY);
- Lisp_Object capt = PROP (TOOL_BAR_ITEM_CAPTION);
- const char *label = SYMBOLP (key) ? SSDATA (SYMBOL_NAME (key)) : "";
- const char *caption = STRINGP (capt) ? SSDATA (capt) : "";
+ Lisp_Object tkey = PROP (TOOL_BAR_ITEM_KEY);
+ Lisp_Object tcapt = PROP (TOOL_BAR_ITEM_CAPTION);
+ const char *label = SYMBOLP (tkey) ? SSDATA (SYMBOL_NAME (tkey)) : "";
+ const char *capt = STRINGP (tcapt) ? SSDATA (tcapt) : "";
EMACS_INT max_lbl = 2 * tool_bar_max_label_size;
char *buf = (char *) xmalloc (max_lbl + 1);
Lisp_Object new_lbl;
- size_t caption_len = strlen (caption);
+ size_t caption_len = strlen (capt);
- if (caption_len <= max_lbl && caption[0] != '\0')
+ if (caption_len <= max_lbl && capt[0] != '\0')
{
- strcpy (buf, caption);
+ strcpy (buf, capt);
while (caption_len > 0 && buf[caption_len - 1] == '.')
caption_len--;
buf[caption_len] = '\0';
- label = caption = buf;
+ label = capt = buf;
}
if (strlen (label) <= max_lbl && label[0] != '\0')
{
- int i;
+ int j;
if (label != buf)
strcpy (buf, label);
- for (i = 0; buf[i] != '\0'; ++i)
- if (buf[i] == '-')
- buf[i] = ' ';
+ for (j = 0; buf[j] != '\0'; ++j)
+ if (buf[j] == '-')
+ buf[j] = ' ';
label = buf;
-
}
else
label = "";
/* Prompt with that and read response. */
message2_nolog (menu, strlen (menu),
- ! NILP (B_ (current_buffer, enable_multibyte_characters)));
+ ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
/* Make believe its not a keyboard macro in case the help char
is pressed. Help characters are not recorded because menu prompting
is not used on replay.
*/
- orig_defn_macro = current_kboard->defining_kbd_macro;
- current_kboard->defining_kbd_macro = Qnil;
+ orig_defn_macro = KVAR (current_kboard, defining_kbd_macro);
+ KVAR (current_kboard, defining_kbd_macro) = Qnil;
do
obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
while (BUFFERP (obj));
- current_kboard->defining_kbd_macro = orig_defn_macro;
+ KVAR (current_kboard, defining_kbd_macro) = orig_defn_macro;
if (!INTEGERP (obj))
return obj;
&& (!INTEGERP (menu_prompt_more_char)
|| ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
{
- if (!NILP (current_kboard->defining_kbd_macro))
+ if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
store_kbd_macro_char (obj);
return obj;
}
The return value is non-zero if the remapping actually took place. */
static int
-keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
+keyremap_step (Lisp_Object *keybuf, size_t bufsize, volatile keyremap *fkey,
int input, int doit, int *diff, Lisp_Object prompt)
{
Lisp_Object next, key;
from the selected window's buffer. */
static int
-read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
+read_key_sequence (Lisp_Object *keybuf, size_t bufsize, Lisp_Object prompt,
int dont_downcase_last, int can_return_switch_frame,
int fix_current_buffer)
{
/* The length of the echo buffer when we started reading, and
the length of this_command_keys when we started reading. */
- int echo_start;
+ int echo_start IF_LINT (= 0);
int keys_start;
/* The number of keymaps we're scanning right now, and the number of
Lisp_Object first_event;
#endif
- Lisp_Object original_uppercase;
+ Lisp_Object original_uppercase IF_LINT (= Qnil);
int original_uppercase_position = -1;
/* Gets around Microsoft compiler limitations. */
int junk;
#endif
- struct gcpro gcpro1;
+ struct gcpro outer_gcpro1;
- GCPRO1 (fake_prefixed_keys);
+ GCPRO1_VAR (fake_prefixed_keys, outer_gcpro);
raw_keybuf_count = 0;
last_nonmenu_event = Qnil;
/* Install the string STR as the beginning of the string of
echoing, so that it serves as a prompt for the next
character. */
- current_kboard->echo_string = prompt;
+ KVAR (current_kboard, echo_string) = prompt;
current_kboard->echo_after_prompt = SCHARS (prompt);
echo_now ();
}
happens if we switch keyboards between rescans. */
replay_entire_sequence:
- indec.map = indec.parent = current_kboard->Vinput_decode_map;
- fkey.map = fkey.parent = current_kboard->Vlocal_function_key_map;
+ indec.map = indec.parent = KVAR (current_kboard, Vinput_decode_map);
+ fkey.map = fkey.parent = KVAR (current_kboard, Vlocal_function_key_map);
keytran.map = keytran.parent = Vkey_translation_map;
indec.start = indec.end = 0;
fkey.start = fkey.end = 0;
the initial keymaps from the current buffer. */
nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
+ if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
{
if (2 > nmaps_allocated)
{
defs = (Lisp_Object *) alloca (2 * sizeof (defs[0]));
nmaps_allocated = 2;
}
- submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
+ submaps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
}
else if (!NILP (Voverriding_local_map))
{
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, keys_local_start, local_first_binding;
+ int echo_local_start IF_LINT (= 0);
+ int keys_local_start, local_first_binding;
eassert (indec.end == t || (indec.end > t && indec.end <= mock_input));
eassert (indec.start <= indec.end);
if (!NILP (delayed_switch_frame))
{
- interrupted_kboard->kbd_queue
+ KVAR (interrupted_kboard, kbd_queue)
= Fcons (delayed_switch_frame,
- interrupted_kboard->kbd_queue);
+ KVAR (interrupted_kboard, kbd_queue));
delayed_switch_frame = Qnil;
}
while (t > 0)
- interrupted_kboard->kbd_queue
- = Fcons (keybuf[--t], interrupted_kboard->kbd_queue);
+ KVAR (interrupted_kboard, kbd_queue)
+ = Fcons (keybuf[--t], KVAR (interrupted_kboard, kbd_queue));
/* If the side queue is non-empty, ensure it begins with a
switch-frame, so we'll replay it in the right context. */
- if (CONSP (interrupted_kboard->kbd_queue)
- && (key = XCAR (interrupted_kboard->kbd_queue),
+ if (CONSP (KVAR (interrupted_kboard, kbd_queue))
+ && (key = XCAR (KVAR (interrupted_kboard, kbd_queue)),
!(EVENT_HAS_PARAMETERS (key)
&& EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)),
Qswitch_frame))))
{
Lisp_Object frame;
XSETFRAME (frame, interrupted_frame);
- interrupted_kboard->kbd_queue
+ KVAR (interrupted_kboard, kbd_queue)
= Fcons (make_lispy_switch_frame (frame),
- interrupted_kboard->kbd_queue);
+ KVAR (interrupted_kboard, kbd_queue));
}
mock_input = 0;
orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
if (EQ (key, Qt))
{
unbind_to (count, Qnil);
- UNGCPRO;
+ UNGCPRO_VAR (outer_gcpro);
return -1;
}
last_real_key_start = t - 1;
}
- /* Key sequences beginning with mouse clicks are
- read using the keymaps in the buffer clicked on,
- not the current buffer. If we're at the
- beginning of a key sequence, switch buffers. */
- if (last_real_key_start == 0
- && WINDOWP (window)
- && BUFFERP (XWINDOW (window)->buffer)
- && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+ if (last_real_key_start == 0)
{
- XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
- keybuf[t] = key;
- mock_input = t + 1;
-
- /* Arrange to go back to the original buffer once we're
- done reading the key sequence. Note that we can't
- use save_excursion_{save,restore} here, because they
- save point as well as the current buffer; we don't
- want to save point, because redisplay may change it,
- to accommodate a Fset_window_start or something. We
- don't want to do this at the top of the function,
- because we may get input from a subprocess which
- wants to change the selected window and stuff (say,
- emacsclient). */
- record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
-
- if (! FRAME_LIVE_P (XFRAME (selected_frame)))
- Fkill_emacs (Qnil);
- set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
- orig_local_map = get_local_map (PT, current_buffer,
- Qlocal_map);
- orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
- goto replay_sequence;
- }
+ /* Key sequences beginning with mouse clicks are
+ read using the keymaps in the buffer clicked on,
+ not the current buffer. If we're at the
+ beginning of a key sequence, switch buffers. */
+ if (WINDOWP (window)
+ && BUFFERP (XWINDOW (window)->buffer)
+ && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+ {
+ XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
+ keybuf[t] = key;
+ mock_input = t + 1;
+
+ /* Arrange to go back to the original buffer once we're
+ done reading the key sequence. Note that we can't
+ use save_excursion_{save,restore} here, because they
+ save point as well as the current buffer; we don't
+ want to save point, because redisplay may change it,
+ to accommodate a Fset_window_start or something. We
+ don't want to do this at the top of the function,
+ because we may get input from a subprocess which
+ wants to change the selected window and stuff (say,
+ emacsclient). */
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
+ if (! FRAME_LIVE_P (XFRAME (selected_frame)))
+ Fkill_emacs (Qnil);
+ set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+ orig_local_map = get_local_map (PT, current_buffer,
+ Qlocal_map);
+ orig_keymap = get_local_map (PT, current_buffer,
+ Qkeymap);
+ goto replay_sequence;
+ }
- /* For a mouse click, get the local text-property keymap
- of the place clicked on, rather than point. */
- if (last_real_key_start == 0
- && CONSP (XCDR (key))
- && ! localized_local_map)
- {
- Lisp_Object map_here, start, pos;
+ /* For a mouse click, get the local text-property keymap
+ of the place clicked on, rather than point. */
+ if (CONSP (XCDR (key))
+ && ! localized_local_map)
+ {
+ Lisp_Object map_here, start, pos;
- localized_local_map = 1;
- start = EVENT_START (key);
+ localized_local_map = 1;
+ start = EVENT_START (key);
- if (CONSP (start) && POSN_INBUFFER_P (start))
- {
- pos = POSN_BUFFER_POSN (start);
- if (INTEGERP (pos)
- && XINT (pos) >= BEGV
- && XINT (pos) <= ZV)
+ if (CONSP (start) && POSN_INBUFFER_P (start))
{
- map_here = get_local_map (XINT (pos),
- current_buffer, Qlocal_map);
- if (!EQ (map_here, orig_local_map))
+ pos = POSN_BUFFER_POSN (start);
+ if (INTEGERP (pos)
+ && XINT (pos) >= BEGV
+ && XINT (pos) <= ZV)
{
- orig_local_map = map_here;
- ++localized_local_map;
- }
+ map_here = get_local_map (XINT (pos),
+ current_buffer,
+ Qlocal_map);
+ if (!EQ (map_here, orig_local_map))
+ {
+ orig_local_map = map_here;
+ ++localized_local_map;
+ }
- map_here = get_local_map (XINT (pos),
- current_buffer, Qkeymap);
- if (!EQ (map_here, orig_keymap))
- {
- orig_keymap = map_here;
- ++localized_local_map;
- }
+ map_here = get_local_map (XINT (pos),
+ current_buffer,
+ Qkeymap);
+ if (!EQ (map_here, orig_keymap))
+ {
+ orig_keymap = map_here;
+ ++localized_local_map;
+ }
- if (localized_local_map > 1)
- {
- keybuf[t] = key;
- mock_input = t + 1;
+ if (localized_local_map > 1)
+ {
+ keybuf[t] = key;
+ mock_input = t + 1;
- goto replay_sequence;
+ goto replay_sequence;
+ }
}
}
}
&& /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
&& INTEGERP (key)
&& ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
- && UPPERCASEP (XINT (key) & ~CHAR_MODIFIER_MASK))
+ && uppercasep (XINT (key) & ~CHAR_MODIFIER_MASK))
|| (XINT (key) & shift_modifier)))
{
Lisp_Object new_key;
if (XINT (key) & shift_modifier)
XSETINT (new_key, XINT (key) & ~shift_modifier);
else
- XSETINT (new_key, (DOWNCASE (XINT (key) & ~CHAR_MODIFIER_MASK)
+ XSETINT (new_key, (downcase (XINT (key) & ~CHAR_MODIFIER_MASK)
| (XINT (key) & CHAR_MODIFIER_MASK)));
/* We have to do this unconditionally, regardless of whether
/* Treat uppercase keys as shifted. */
|| (INTEGERP (key)
&& (KEY_TO_CHAR (key)
- < XCHAR_TABLE (B_ (current_buffer, downcase_table))->size)
- && UPPERCASEP (KEY_TO_CHAR (key))))
+ < XCHAR_TABLE (BVAR (current_buffer, downcase_table))->size)
+ && uppercasep (KEY_TO_CHAR (key))))
{
Lisp_Object new_key
= (modifiers & shift_modifier
? apply_modifiers (modifiers & ~shift_modifier,
XCAR (breakdown))
- : make_number (DOWNCASE (KEY_TO_CHAR (key)) | modifiers));
+ : make_number (downcase (KEY_TO_CHAR (key)) | modifiers));
original_uppercase = key;
original_uppercase_position = t - 1;
add_command_key (keybuf[t]);
}
- UNGCPRO;
+ UNGCPRO_VAR (outer_gcpro);
return t;
}
sequences, where they wouldn't conflict with ordinary bindings. See
`function-key-map' for more details.
-The optional fifth argument COMMAND-LOOP, if non-nil, means
+The optional fifth argument CMD-LOOP, if non-nil, means
that this key sequence is being read by something that will
read commands one after another. It should be nil if the caller
will read just one key sequence. */)
- (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object command_loop)
+ (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
{
Lisp_Object keybuf[30];
register int i;
QUIT;
specbind (Qinput_method_exit_on_first_char,
- (NILP (command_loop) ? Qt : Qnil));
+ (NILP (cmd_loop) ? Qt : Qnil));
specbind (Qinput_method_use_echo_area,
- (NILP (command_loop) ? Qt : Qnil));
+ (NILP (cmd_loop) ? Qt : Qnil));
memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
Sread_key_sequence_vector, 1, 5, 0,
doc: /* Like `read-key-sequence' but always return a vector. */)
- (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object command_loop)
+ (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
{
Lisp_Object keybuf[30];
register int i;
QUIT;
specbind (Qinput_method_exit_on_first_char,
- (NILP (command_loop) ? Qt : Qnil));
+ (NILP (cmd_loop) ? Qt : Qnil));
specbind (Qinput_method_use_echo_area,
- (NILP (command_loop) ? Qt : Qnil));
+ (NILP (cmd_loop) ? Qt : Qnil));
memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
if (NILP (special))
{
- prefixarg = current_kboard->Vprefix_arg;
+ prefixarg = KVAR (current_kboard, Vprefix_arg);
Vcurrent_prefix_arg = prefixarg;
- current_kboard->Vprefix_arg = Qnil;
+ KVAR (current_kboard, Vprefix_arg) = Qnil;
}
else
prefixarg = Qnil;
if (SYMBOLP (cmd))
{
tem = Fget (cmd, Qdisabled);
- if (!NILP (tem) && !NILP (Vrun_hooks))
+ if (!NILP (tem))
{
tem = Fsymbol_value (Qdisabled_command_function);
if (!NILP (tem))
- return call1 (Vrun_hooks, Qdisabled_command_function);
+ return Frun_hooks (1, &Qdisabled_command_function);
}
}
UNGCPRO;
function = Fintern (function, Qnil);
- current_kboard->Vprefix_arg = prefixarg;
+ KVAR (current_kboard, Vprefix_arg) = prefixarg;
Vthis_command = function;
real_this_command = function;
sprintf (newmessage, "You can run the command `%s' with %s",
SDATA (SYMBOL_NAME (function)),
SDATA (binding));
- message2_nolog (newmessage,
- strlen (newmessage),
- STRING_MULTIBYTE (binding));
+ message2 (newmessage,
+ strlen (newmessage),
+ STRING_MULTIBYTE (binding));
if (NUMBERP (Vsuggest_key_bindings))
waited = sit_for (Vsuggest_key_bindings, 0, 2);
else
Also end any kbd macro being defined. */)
(void)
{
- if (!NILP (current_kboard->defining_kbd_macro))
+ if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
{
/* Discard the last command from the macro. */
Fcancel_kbd_macro_events ();
int old_height, old_width;
int width, height;
struct gcpro gcpro1;
+ Lisp_Object hook;
if (tty_list && tty_list->next)
error ("There are other tty frames open; close them before suspending Emacs");
CHECK_STRING (stuffstring);
/* Run the functions in suspend-hook. */
- if (!NILP (Vrun_hooks))
- call1 (Vrun_hooks, intern ("suspend-hook"));
+ hook = intern ("suspend-hook");
+ Frun_hooks (1, &hook);
GCPRO1 (stuffstring);
get_tty_size (fileno (CURTTY ()->input), &old_width, &old_height);
change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
/* Run suspend-resume-hook. */
- if (!NILP (Vrun_hooks))
- call1 (Vrun_hooks, intern ("suspend-resume-hook"));
+ hook = intern ("suspend-resume-hook");
+ Frun_hooks (1, &hook);
UNGCPRO;
return Qnil;
SIGINT was generated by C-g, so we call handle_interrupt.
Otherwise, the handler kills Emacs. */
-static SIGTYPE
+static void
interrupt_signal (int signalnum) /* If we don't have an argument, some */
/* compilers complain in signal calls. */
{
void
init_kboard (KBOARD *kb)
{
- kb->Voverriding_terminal_local_map = Qnil;
- kb->Vlast_command = Qnil;
- kb->Vreal_last_command = Qnil;
- kb->Vkeyboard_translate_table = Qnil;
- kb->Vlast_repeatable_command = Qnil;
- kb->Vprefix_arg = Qnil;
- kb->Vlast_prefix_arg = Qnil;
- kb->kbd_queue = Qnil;
+ KVAR (kb, Voverriding_terminal_local_map) = Qnil;
+ KVAR (kb, Vlast_command) = Qnil;
+ KVAR (kb, Vreal_last_command) = Qnil;
+ KVAR (kb, Vkeyboard_translate_table) = Qnil;
+ KVAR (kb, Vlast_repeatable_command) = Qnil;
+ KVAR (kb, Vprefix_arg) = Qnil;
+ KVAR (kb, Vlast_prefix_arg) = Qnil;
+ KVAR (kb, kbd_queue) = Qnil;
kb->kbd_queue_has_data = 0;
kb->immediate_echo = 0;
- kb->echo_string = Qnil;
+ KVAR (kb, echo_string) = Qnil;
kb->echo_after_prompt = -1;
kb->kbd_macro_buffer = 0;
kb->kbd_macro_bufsize = 0;
- kb->defining_kbd_macro = Qnil;
- kb->Vlast_kbd_macro = Qnil;
+ KVAR (kb, defining_kbd_macro) = Qnil;
+ KVAR (kb, Vlast_kbd_macro) = Qnil;
kb->reference_count = 0;
- kb->Vsystem_key_alist = Qnil;
- kb->system_key_syms = Qnil;
- kb->Vwindow_system = Qt; /* Unset. */
- kb->Vinput_decode_map = Fmake_sparse_keymap (Qnil);
- kb->Vlocal_function_key_map = Fmake_sparse_keymap (Qnil);
- Fset_keymap_parent (kb->Vlocal_function_key_map, Vfunction_key_map);
- kb->Vdefault_minibuffer_frame = Qnil;
+ KVAR (kb, Vsystem_key_alist) = Qnil;
+ KVAR (kb, system_key_syms) = Qnil;
+ KVAR (kb, Vwindow_system) = Qt; /* Unset. */
+ KVAR (kb, Vinput_decode_map) = Fmake_sparse_keymap (Qnil);
+ KVAR (kb, Vlocal_function_key_map) = Fmake_sparse_keymap (Qnil);
+ Fset_keymap_parent (KVAR (kb, Vlocal_function_key_map), Vfunction_key_map);
+ KVAR (kb, Vdefault_minibuffer_frame) = Qnil;
}
/*
init_kboard (current_kboard);
/* A value of nil for Vwindow_system normally means a tty, but we also use
it for the initial terminal since there is no window system there. */
- current_kboard->Vwindow_system = Qnil;
+ KVAR (current_kboard, Vwindow_system) = Qnil;
if (!noninteractive)
{
Qdeferred_action_function = intern_c_string ("deferred-action-function");
staticpro (&Qdeferred_action_function);
- Qcommand_hook_internal = intern_c_string ("command-hook-internal");
- staticpro (&Qcommand_hook_internal);
-
Qfunction_key = intern_c_string ("function-key");
staticpro (&Qfunction_key);
Qmouse_click = intern_c_string ("mouse-click");
last_point_position_window = Qnil;
{
- const struct event_head *p;
+ int i;
+ int len = sizeof (head_table) / sizeof (head_table[0]);
- for (p = head_table;
- p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
- p++)
+ for (i = 0; i < len; i++)
{
+ const struct event_head *p = &head_table[i];
*p->var = intern_c_string (p->name);
staticpro (p->var);
Fput (*p->var, Qevent_kind, *p->kind);
Qdeactivate_mark = intern_c_string ("deactivate-mark");
staticpro (&Qdeactivate_mark);
- DEFVAR_LISP ("command-hook-internal", Vcommand_hook_internal,
- doc: /* Temporary storage of `pre-command-hook' or `post-command-hook'. */);
- Vcommand_hook_internal = Qnil;
-
DEFVAR_LISP ("pre-command-hook", Vpre_command_hook,
doc: /* Normal hook run before each command is executed.
If an unhandled error happens in running this hook,
-the hook value is set to nil, since otherwise the error
-might happen repeatedly and make Emacs nonfunctional. */);
+the function in which the error occurred is unconditionally removed, since
+otherwise the error might happen repeatedly and make Emacs nonfunctional. */);
Vpre_command_hook = Qnil;
DEFVAR_LISP ("post-command-hook", Vpost_command_hook,
doc: /* Normal hook run after each command is executed.
If an unhandled error happens in running this hook,
-the hook value is set to nil, since otherwise the error
-might happen repeatedly and make Emacs nonfunctional. */);
+the function in which the error occurred is unconditionally removed, since
+otherwise the error might happen repeatedly and make Emacs nonfunctional. */);
Vpost_command_hook = Qnil;
#if 0
if (kb->kbd_macro_buffer)
for (p = kb->kbd_macro_buffer; p < kb->kbd_macro_ptr; p++)
mark_object (*p);
- mark_object (kb->Voverriding_terminal_local_map);
- mark_object (kb->Vlast_command);
- mark_object (kb->Vreal_last_command);
- mark_object (kb->Vkeyboard_translate_table);
- mark_object (kb->Vlast_repeatable_command);
- mark_object (kb->Vprefix_arg);
- mark_object (kb->Vlast_prefix_arg);
- mark_object (kb->kbd_queue);
- mark_object (kb->defining_kbd_macro);
- mark_object (kb->Vlast_kbd_macro);
- mark_object (kb->Vsystem_key_alist);
- mark_object (kb->system_key_syms);
- mark_object (kb->Vwindow_system);
- mark_object (kb->Vinput_decode_map);
- mark_object (kb->Vlocal_function_key_map);
- mark_object (kb->Vdefault_minibuffer_frame);
- mark_object (kb->echo_string);
+ mark_object (KVAR (kb, Voverriding_terminal_local_map));
+ mark_object (KVAR (kb, Vlast_command));
+ mark_object (KVAR (kb, Vreal_last_command));
+ mark_object (KVAR (kb, Vkeyboard_translate_table));
+ mark_object (KVAR (kb, Vlast_repeatable_command));
+ mark_object (KVAR (kb, Vprefix_arg));
+ mark_object (KVAR (kb, Vlast_prefix_arg));
+ mark_object (KVAR (kb, kbd_queue));
+ mark_object (KVAR (kb, defining_kbd_macro));
+ mark_object (KVAR (kb, Vlast_kbd_macro));
+ mark_object (KVAR (kb, Vsystem_key_alist));
+ mark_object (KVAR (kb, system_key_syms));
+ mark_object (KVAR (kb, Vwindow_system));
+ mark_object (KVAR (kb, Vinput_decode_map));
+ mark_object (KVAR (kb, Vlocal_function_key_map));
+ mark_object (KVAR (kb, Vdefault_minibuffer_frame));
+ mark_object (KVAR (kb, echo_string));
}
{
struct input_event *event;
HCoop / bpt / emacs.git / blobdiff