/* Keyboard and mouse input; editor command loop.
- Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 2001
+ Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 01, 02
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "w32term.h"
#endif /* HAVE_NTGUI */
-#ifdef macintosh
+#ifdef MAC_OS
#include "macterm.h"
#endif
#ifdef HAVE_WINDOW_SYSTEM
/* Make all keyboard buffers much bigger when using X windows. */
-#ifdef macintosh
-/* But not too big (local data > 32K error) if on macintosh. */
+#ifdef MAC_OS8
+/* But not too big (local data > 32K error) if on Mac OS Classic. */
#define KBD_BUFFER_SIZE 512
#else
#define KBD_BUFFER_SIZE 4096
queue. That way, they'll be dequeued as dead frames or windows,
but still valid Lisp objects.
- If kbd_buffer[i].kind != no_event, then
+ If kbd_buffer[i].kind != NO_EVENT, then
AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
/* Symbols to denote kinds of events. */
Lisp_Object Qfunction_key;
Lisp_Object Qmouse_click;
-#ifdef WINDOWSNT
+#if defined(WINDOWSNT) || defined(MAC_OSX)
Lisp_Object Qmouse_wheel;
+#endif
+#ifdef WINDOWSNT
Lisp_Object Qlanguage_change;
#endif
Lisp_Object Qdrag_n_drop;
/* If we support a window system, turn on the code to poll periodically
to detect C-g. It isn't actually used when doing interrupt input. */
-#ifdef HAVE_WINDOW_SYSTEM
+#if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
#define POLL_FOR_INPUT
#endif
static EMACS_TIME timer_idleness_start_time;
+/* After Emacs stops being idle, this saves the last value
+ of timer_idleness_start_time from when it was idle. */
+
+static EMACS_TIME timer_last_idleness_start_time;
+
\f
/* Global variable declarations. */
static int read_avail_input P_ ((int));
static void get_input_pending P_ ((int *, int));
+static void get_filtered_input_pending P_ ((int *, int, int));
static int readable_events P_ ((int));
+static int readable_filtered_events P_ ((int, int));
static Lisp_Object read_char_x_menu_prompt P_ ((int, Lisp_Object *,
Lisp_Object, int *));
static Lisp_Object read_char_x_menu_prompt ();
}
else if (SYMBOLP (c))
{
- struct Lisp_String *name = XSYMBOL (c)->name;
- int nbytes = STRING_BYTES (name);
+ Lisp_Object name = SYMBOL_NAME (c);
+ int nbytes = SBYTES (name);
if (size - (ptr - buffer) < nbytes)
{
ptr = buffer + offset;
}
- ptr += copy_text (name->data, ptr, nbytes,
- name->size_byte >= 0, 1);
+ ptr += copy_text (SDATA (name), ptr, nbytes,
+ STRING_MULTIBYTE (name), 1);
}
if ((NILP (echo_string) || SCHARS (echo_string) == 0)
echoing = 1;
message3_nolog (current_kboard->echo_string,
SBYTES (current_kboard->echo_string),
- SMBP (current_kboard->echo_string));
+ STRING_MULTIBYTE (current_kboard->echo_string));
echoing = 0;
/* Record in what buffer we echoed, and from which kboard. */
Lisp_Object
recursive_edit_1 ()
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object val;
if (command_loop_level > 0)
This function is called by the editor initialization to begin editing. */)
()
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object buffer;
command_loop_level++;
Lisp_Object old_level, old_length;
char macroerror[50];
+#ifdef HAVE_X_WINDOWS
+ if (display_hourglass_p)
+ cancel_hourglass ();
+#endif
+
if (!NILP (executing_macro))
{
if (executing_macro_iterations == 1)
else
{
Fdiscard_input ();
+ message_log_maybe_newline ();
bitch_at_user ();
stream = Qt;
}
- if (context != 0)
- write_string_1 (context, -1, stream);
+ /* The immediate context is not interesting for Quits,
+ since they are asyncronous. */
+ if (EQ (XCAR (data), Qquit))
+ Vsignaling_function = Qnil;
+
+ print_error_message (data, stream, context, Vsignaling_function);
- print_error_message (data, stream);
+ Vsignaling_function = Qnil;
/* If the window system or terminal frame hasn't been initialized
yet, or we're in -batch mode, this error should cause Emacs to exit. */
this_command_key_count = 0;
this_single_command_key_start = 0;
- /* Make sure this hook runs after commands that get errors and
- throw to top level. */
- /* 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);
+ if (NILP (Vmemory_full))
+ {
+ /* Make sure this hook runs after commands that get errors and
+ throw to top level. */
+ /* 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);
- /* 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 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))
- call0 (Vdeferred_action_function);
+ if (!NILP (Vdeferred_action_list))
+ call0 (Vdeferred_action_function);
- if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
- {
- if (NILP (Vunread_command_events)
- && NILP (Vunread_input_method_events)
- && NILP (Vunread_post_input_method_events)
- && NILP (Vexecuting_macro)
- && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
- safe_run_hooks (Qpost_command_idle_hook);
+ if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
+ {
+ if (NILP (Vunread_command_events)
+ && NILP (Vunread_input_method_events)
+ && NILP (Vunread_post_input_method_events)
+ && NILP (Vexecuting_macro)
+ && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
+ safe_run_hooks (Qpost_command_idle_hook);
+ }
}
+ Vmemory_full = Qnil;
+
/* Do this after running Vpost_command_hook, for consistency. */
current_kboard->Vlast_command = Vthis_command;
current_kboard->Vreal_last_command = real_this_command;
{
/* Bind inhibit-quit to t so that C-g gets read in
rather than quitting back to the minibuffer. */
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, Qt);
Fsit_for (Vminibuffer_message_timeout, Qnil, Qnil);
/* Here for a command that isn't executed directly */
#ifdef HAVE_X_WINDOWS
- if (display_hourglass_p)
+ if (display_hourglass_p
+ && NILP (Vexecuting_macro))
start_hourglass ();
#endif
#ifdef HAVE_X_WINDOWS
/* Do not check display_hourglass_p here, because
Fcommand_execute could change it, but we should cancel
- hourglass cursor anyway. */
- cancel_hourglass ();
+ hourglass cursor anyway.
+ But don't cancel the hourglass within a macro
+ just because a command in the macro finishes. */
+ if (NILP (Vexecuting_macro))
+ cancel_hourglass ();
#endif
}
directly_done: ;
safe_run_hooks (hook)
Lisp_Object hook;
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, hook);
internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
{
if (STRINGP (help))
{
- int count = BINDING_STACK_SIZE ();
+ int count = SPECPDL_INDEX ();
if (!help_echo_showing_p)
Vpre_help_message = current_message ();
specbind (Qmessage_truncate_lines, Qt);
- message3_nolog (help, STRING_BYTES (XSTRING (help)),
+ message3_nolog (help, SBYTES (help),
STRING_MULTIBYTE (help));
unbind_to (count, Qnil);
}
else if (STRINGP (Vpre_help_message))
{
message3_nolog (Vpre_help_message,
- STRING_BYTES (XSTRING (Vpre_help_message)),
+ SBYTES (Vpre_help_message),
STRING_MULTIBYTE (Vpre_help_message));
Vpre_help_message = Qnil;
}
static jmp_buf wrong_kboard_jmpbuf;
#endif
+#define STOP_POLLING \
+do { if (! polling_stopped_here) stop_polling (); \
+ polling_stopped_here = 1; } while (0)
+
+#define RESUME_POLLING \
+do { if (polling_stopped_here) start_polling (); \
+ polling_stopped_here = 0; } while (0)
+
/* read a character from the keyboard; call the redisplay if needed */
/* commandflag 0 means do not do auto-saving, but do do redisplay.
-1 means do not do redisplay, but do do autosaving.
volatile int reread;
struct gcpro gcpro1, gcpro2;
EMACS_TIME last_idle_start;
+ int polling_stopped_here = 0;
also_record = Qnil;
|| executing_macro_index >= XFASTINT (Flength (Vexecuting_macro)))
{
XSETINT (c, -1);
- RETURN_UNGCPRO (c);
+ goto exit;
}
c = Faref (Vexecuting_macro, make_number (executing_macro_index));
/* Now that we have read an event, Emacs is not idle. */
timer_stop_idle ();
- RETURN_UNGCPRO (c);
+ goto exit;
}
/* Maybe autosave and/or garbage collect due to idleness. */
wrong_kboard:
- stop_polling ();
+ STOP_POLLING;
/* Finally, we read from the main queue,
and if that gives us something we can't use yet, we put it on the
should the next event read be a help-echo. */
last_idle_start = timer_idleness_start_time;
timer_stop_idle ();
- start_polling ();
+ RESUME_POLLING;
if (NILP (c))
{
so don't show them to the user.
Also, don't record a key if we already did. */
if (BUFFERP (c) || key_already_recorded)
- RETURN_UNGCPRO (c);
+ goto exit;
/* Process special events within read_char
and loop around to read another event. */
{
/* If kbd_buffer_get_event gave us an EOF, return that. */
if (XINT (c) == -1)
- RETURN_UNGCPRO (c);
+ goto exit;
if ((STRINGP (Vkeyboard_translate_table)
- && XSTRING (Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
+ && SCHARS (Vkeyboard_translate_table) > (unsigned) XFASTINT (c))
|| (VECTORP (Vkeyboard_translate_table)
&& XVECTOR (Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
|| (CHAR_TABLE_P (Vkeyboard_translate_table)
Lisp_Object keys;
int key_count;
struct gcpro gcpro1;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
/* Save the echo status. */
int saved_immediate_echo = current_kboard->immediate_echo;
if (!NILP (Vhelp_form) && help_char_p (c))
{
Lisp_Object tem0;
- count = specpdl_ptr - specpdl;
+ count = SPECPDL_INDEX ();
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
}
}
+ exit:
+ RESUME_POLLING;
RETURN_UNGCPRO (c);
}
if (SYMBOLP (dribblee))
{
putc ('<', dribble);
- fwrite (XSYMBOL (dribblee)->name->data, sizeof (char),
- STRING_BYTES (XSYMBOL (dribblee)->name),
+ fwrite (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
+ SBYTES (SYMBOL_NAME (dribblee)),
dribble);
putc ('>', dribble);
}
(args)
Lisp_Object args;
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object val;
record_unwind_protect (tracking_off, do_mouse_tracking);
/* Return true iff there are any events in the queue that read-char
would return. If this returns false, a read-char would block. */
static int
-readable_events (do_timers_now)
+readable_filtered_events (do_timers_now, filter_events)
int do_timers_now;
+ int filter_events;
{
if (do_timers_now)
timer_check (do_timers_now);
+ /* If the buffer contains only FOCUS_IN_EVENT events,
+ and FILTER_EVENTS is nonzero, report it as empty. */
if (kbd_fetch_ptr != kbd_store_ptr)
- return 1;
+ {
+ int have_live_event = 1;
+
+ if (filter_events)
+ {
+ struct input_event *event;
+
+ event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
+ ? kbd_fetch_ptr
+ : kbd_buffer);
+
+ while (have_live_event && event->kind == FOCUS_IN_EVENT)
+ {
+ event++;
+ if (event == kbd_buffer + KBD_BUFFER_SIZE)
+ event = kbd_buffer;
+ if (event == kbd_store_ptr)
+ have_live_event = 0;
+ }
+ }
+ if (have_live_event) return 1;
+ }
+
#ifdef HAVE_MOUSE
if (!NILP (do_mouse_tracking) && some_mouse_moved ())
return 1;
return 0;
}
+/* Return true iff there are any events in the queue that read-char
+ would return. If this returns false, a read-char would block. */
+static int
+readable_events (do_timers_now)
+ int do_timers_now;
+{
+ return readable_filtered_events (do_timers_now, 0);
+}
+
/* Set this for debugging, to have a way to get out */
int stop_character;
kbd_buffer_store_event (event)
register struct input_event *event;
{
- if (event->kind == no_event)
+ if (event->kind == NO_EVENT)
abort ();
- if (event->kind == ascii_keystroke)
+ if (event->kind == ASCII_KEYSTROKE_EVENT)
{
register int c = event->code & 0377;
if (c == quit_char)
{
- static SIGTYPE interrupt_signal (int);
+ static SIGTYPE interrupt_signal P_ ((int));
#ifdef MULTI_KBOARD
KBOARD *kb;
struct input_event *sp;
if (event_to_kboard (sp) == kb)
{
- sp->kind = no_event;
+ sp->kind = NO_EVENT;
sp->frame_or_window = Qnil;
sp->arg = Qnil;
}
return;
}
}
- /* Don't insert two buffer_switch_event's in a row.
+ /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
Just ignore the second one. */
- else if (event->kind == buffer_switch_event
+ else if (event->kind == BUFFER_SWITCH_EVENT
&& kbd_fetch_ptr != kbd_store_ptr
- && kbd_store_ptr->kind == buffer_switch_event)
+ && kbd_store_ptr->kind == BUFFER_SWITCH_EVENT)
return;
if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
{
int idx;
-#if 0 /* The selection_request_event case looks bogus, and it's error
+#if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
prone to assign individual members for other events, in case
the input_event structure is changed. --2000-07-13, gerd. */
struct input_event *sp = kbd_store_ptr;
sp->kind = event->kind;
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
/* We must not use the ordinary copying code for this case,
since `part' is an enum and copying it might not copy enough
\f
/* Discard any mouse events in the event buffer by setting them to
- no_event. */
+ NO_EVENT. */
void
discard_mouse_events ()
{
if (sp == kbd_buffer + KBD_BUFFER_SIZE)
sp = kbd_buffer;
- if (sp->kind == mouse_click
+ if (sp->kind == MOUSE_CLICK_EVENT
#ifdef WINDOWSNT
- || sp->kind == w32_scroll_bar_click
+ || sp->kind == W32_SCROLL_BAR_CLICK_EVENT
#endif
- || sp->kind == scroll_bar_click)
+ || sp->kind == SCROLL_BAR_CLICK_EVENT)
{
- sp->kind = no_event;
+ sp->kind = NO_EVENT;
}
}
}
/* Return non-zero if there are any real events waiting in the event
- buffer, not counting `no_event's.
+ buffer, not counting `NO_EVENT's.
- If DISCARD is non-zero, discard no_event events at the front of
+ If DISCARD is non-zero, discard NO_EVENT events at the front of
the input queue, possibly leaving the input queue empty if there
are no real input events. */
struct input_event *sp;
for (sp = kbd_fetch_ptr;
- sp != kbd_store_ptr && sp->kind == no_event;
+ sp != kbd_store_ptr && sp->kind == NO_EVENT;
++sp)
{
if (sp == kbd_buffer + KBD_BUFFER_SIZE)
if (discard)
kbd_fetch_ptr = sp;
- return sp != kbd_store_ptr && sp->kind != no_event;
+ return sp != kbd_store_ptr && sp->kind != NO_EVENT;
}
\f
int idx = 2 * (event - kbd_buffer);
ASET (kbd_buffer_gcpro, idx, Qnil);
ASET (kbd_buffer_gcpro, idx + 1, Qnil);
- event->kind = no_event;
+ event->kind = NO_EVENT;
}
/* These two kinds of events get special handling
and don't actually appear to the command loop.
We return nil for them. */
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
#endif
}
- else if (event->kind == selection_clear_event)
+ else if (event->kind == SELECTION_CLEAR_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
abort ();
#endif
}
-#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (macintosh)
- else if (event->kind == delete_window_event)
+#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
+ else if (event->kind == DELETE_WINDOW_EVENT)
{
/* Make an event (delete-frame (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
}
#endif
#if defined (HAVE_X11) || defined (HAVE_NTGUI)
- else if (event->kind == iconify_event)
+ else if (event->kind == ICONIFY_EVENT)
{
/* Make an event (iconify-frame (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
obj = Fcons (Qiconify_frame, Fcons (obj, Qnil));
kbd_fetch_ptr = event + 1;
}
- else if (event->kind == deiconify_event)
+ else if (event->kind == DEICONIFY_EVENT)
{
/* Make an event (make-frame-visible (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
kbd_fetch_ptr = event + 1;
}
#endif
- else if (event->kind == buffer_switch_event)
+ else if (event->kind == BUFFER_SWITCH_EVENT)
{
/* The value doesn't matter here; only the type is tested. */
XSETBUFFER (obj, current_buffer);
kbd_fetch_ptr = event + 1;
}
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
- else if (event->kind == menu_bar_activate_event)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
+ else if (event->kind == MENU_BAR_ACTIVATE_EVENT)
{
kbd_fetch_ptr = event + 1;
input_pending = readable_events (0);
}
#endif
#ifdef WINDOWSNT
- else if (event->kind == language_change_event)
+ else if (event->kind == LANGUAGE_CHANGE_EVENT)
{
/* Make an event (language-change (FRAME CHARSET LCID)). */
obj = Fcons (event->modifiers, Qnil);
kbd_fetch_ptr = event + 1;
}
#endif
- else if (event->kind == save_session_event)
+ else if (event->kind == SAVE_SESSION_EVENT)
{
obj = Fcons (Qsave_session, Qnil);
kbd_fetch_ptr = event + 1;
(They shouldn't otherwise be found in the buffer,
but on some machines it appears they do show up
even without MULTI_KBOARD.) */
- /* On Windows NT/9X, no_event is used to delete extraneous
+ /* On Windows NT/9X, NO_EVENT is used to delete extraneous
mouse events during a popup-menu call. */
- else if (event->kind == no_event)
+ else if (event->kind == NO_EVENT)
kbd_fetch_ptr = event + 1;
else if (event->kind == HELP_EVENT)
{
{
obj = make_lispy_event (event);
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS)
/* If this was a menu selection, then set the flag to inhibit
writing to last_nonmenu_event. Don't do this if the event
we're returning is (menu-bar), though; that indicates the
/* These two kinds of events get special handling
and don't actually appear to the command loop. */
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
#endif
}
- else if (event->kind == selection_clear_event)
+ else if (event->kind == SELECTION_CLEAR_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
EMACS_GET_TIME (timer_idleness_start_time);
+ timer_last_idleness_start_time = timer_idleness_start_time;
+
/* Mark all idle-time timers as once again candidates for running. */
for (timers = Vtimer_idle_list; CONSP (timers); timers = XCDR (timers))
{
if (NILP (vector[0]))
{
int was_locked = single_kboard;
- int count = BINDING_STACK_SIZE ();
+ int count = SPECPDL_INDEX ();
Lisp_Object old_deactivate_mark = Vdeactivate_mark;
/* Mark the timer as triggered to prevent problems if the lisp
static Lisp_Object accent_key_syms;
static Lisp_Object func_key_syms;
static Lisp_Object mouse_syms;
-#ifdef WINDOWSNT
+#if defined(WINDOWSNT) || defined(MAC_OSX)
static Lisp_Object mouse_wheel_syms;
#endif
static Lisp_Object drag_n_drop_syms;
Lisp_Object Vlispy_mouse_stem;
-#ifdef WINDOWSNT
+#if defined(WINDOWSNT) || defined(MAC_OSX)
/* mouse-wheel events are generated by the wheel on devices such as
the MS Intellimouse. The wheel sits in between the left and right
mouse buttons, and is typically used to scroll or zoom the window
switch (SWITCH_ENUM_CAST (event->kind))
{
/* A simple keystroke. */
- case ascii_keystroke:
+ case ASCII_KEYSTROKE_EVENT:
{
Lisp_Object lispy_c;
int c = event->code & 0377;
return lispy_c;
}
- case multibyte_char_keystroke:
+ case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
{
Lisp_Object lispy_c;
/* A function key. The symbol may need to have modifier prefixes
tacked onto it. */
- case non_ascii_keystroke:
+ case NON_ASCII_KEYSTROKE_EVENT:
button_down_time = 0;
for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
#ifdef HAVE_MOUSE
/* A mouse click. Figure out where it is, decide whether it's
a press, click or drag, and build the appropriate structure. */
- case mouse_click:
+ case MOUSE_CLICK_EVENT:
#ifndef USE_TOOLKIT_SCROLL_BARS
- case scroll_bar_click:
+ case SCROLL_BAR_CLICK_EVENT:
#endif
{
int button = event->code;
position = Qnil;
/* Build the position as appropriate for this mouse click. */
- if (event->kind == mouse_click)
+ if (event->kind == MOUSE_CLICK_EVENT)
{
int part;
struct frame *f = XFRAME (event->frame_or_window);
if (NILP (string))
break;
if (column >= XINT (pos)
- && column < XINT (pos) + XSTRING (string)->size)
+ && column < XINT (pos) + SCHARS (string))
{
item = AREF (items, i);
break;
}
}
-#if USE_TOOLKIT_SCROLL_BARS
+#ifdef USE_TOOLKIT_SCROLL_BARS
/* We don't have down and up events if using toolkit scroll bars,
so make this always a click event. Store in the `part' of
index of type `enum scroll_bar_part' which we can use as an
index in scroll_bar_parts to get the appropriate symbol. */
- case scroll_bar_click:
+ case SCROLL_BAR_CLICK_EVENT:
{
Lisp_Object position, head, window, portion_whole, part;
/* Always treat scroll bar events as clicks. */
event->modifiers |= click_modifier;
+ event->modifiers &= ~up_modifier;
/* Get the symbol we should use for the mouse click. */
head = modify_event_symbol (event->code,
#endif /* USE_TOOLKIT_SCROLL_BARS */
#ifdef WINDOWSNT
- case w32_scroll_bar_click:
+ case W32_SCROLL_BAR_CLICK_EVENT:
{
int button = event->code;
int is_double;
Qnil));
}
}
- case mouse_wheel:
+#endif /* WINDOWSNT */
+#if defined(WINDOWSNT) || defined(MAC_OSX)
+ case MOUSE_WHEEL_EVENT:
{
int part;
FRAME_PTR f = XFRAME (event->frame_or_window);
&mouse_wheel_syms, 1);
return Fcons (head,
Fcons (position,
- Fcons (make_number (event->code),
- Qnil)));
+ /* Insert 1 here so event-click-count works. */
+ Fcons (make_number (1),
+ Fcons (make_number (event->code),
+ Qnil))));
}
}
-#endif /* WINDOWSNT */
+#endif /* WINDOWSNT || MAC_OSX */
- case drag_n_drop:
+ case DRAG_N_DROP_EVENT:
{
int part;
FRAME_PTR f;
}
#endif /* HAVE_MOUSE */
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
case MENU_BAR_EVENT:
if (EQ (event->arg, event->frame_or_window))
/* This is the prefix key. We translate this to
/* A user signal. */
return *lispy_user_signals[event->code];
- case save_session_event:
+ case SAVE_SESSION_EVENT:
return Qsave_session;
/* The 'kind' field of the event is something we don't recognize. */
Lisp_Object symbol;
int *modifier_end;
{
- struct Lisp_String *name;
+ Lisp_Object name;
int i;
int modifiers;
CHECK_SYMBOL (symbol);
modifiers = 0;
- name = XSYMBOL (symbol)->name;
+ name = SYMBOL_NAME (symbol);
- for (i = 0; i+2 <= STRING_BYTES (name); )
+ for (i = 0; i+2 <= SBYTES (name); )
{
int this_mod_end = 0;
int this_mod = 0;
Check that the word appears, but don't check what follows it.
Set this_mod and this_mod_end to record what we find. */
- switch (name->data[i])
+ switch (SREF (name, i))
{
#define SINGLE_LETTER_MOD(BIT) \
(this_mod_end = i + 1, this_mod = BIT)
/* Check there is a dash after the modifier, so that it
really is a modifier. */
- if (this_mod_end >= STRING_BYTES (name)
- || name->data[this_mod_end] != '-')
+ if (this_mod_end >= SBYTES (name)
+ || SREF (name, this_mod_end) != '-')
break;
/* This modifier is real; look for another. */
/* Should we include the `click' modifier? */
if (! (modifiers & (down_modifier | drag_modifier
| double_modifier | triple_modifier))
- && i + 7 == STRING_BYTES (name)
- && strncmp (name->data + i, "mouse-", 6) == 0
- && ('0' <= name->data[i + 6] && name->data[i + 6] <= '9'))
+ && i + 7 == SBYTES (name)
+ && strncmp (SDATA (name) + i, "mouse-", 6) == 0
+ && ('0' <= SREF (name, i + 6) && SREF (name, i + 6) <= '9'))
modifiers |= click_modifier;
if (modifier_end)
new_name = make_uninit_multibyte_string (mod_len + base_len,
mod_len + base_len_byte);
- bcopy (new_mods, XSTRING (new_name)->data, mod_len);
- bcopy (base, XSTRING (new_name)->data + mod_len, base_len_byte);
+ bcopy (new_mods, SDATA (new_name), mod_len);
+ bcopy (base, SDATA (new_name) + mod_len, base_len_byte);
return Fintern (new_name, Qnil);
}
Lisp_Object unmodified;
Lisp_Object mask;
- unmodified = Fintern (make_string (XSYMBOL (symbol)->name->data + end,
- STRING_BYTES (XSYMBOL (symbol)->name) - end),
+ unmodified = Fintern (make_string (SDATA (SYMBOL_NAME (symbol)) + end,
+ SBYTES (SYMBOL_NAME (symbol)) - end),
Qnil);
if (modifiers & ~VALMASK)
{
/* We have to create the symbol ourselves. */
new_symbol = apply_modifiers_uncached (modifiers,
- XSYMBOL (base)->name->data,
- XSYMBOL (base)->name->size,
- STRING_BYTES (XSYMBOL (base)->name));
+ SDATA (SYMBOL_NAME (base)),
+ SCHARS (SYMBOL_NAME (base)),
+ SBYTES (SYMBOL_NAME (base)));
/* Add the new symbol to the base's cache. */
entry = Fcons (index, new_symbol);
value = Fcdr_safe (Fassq (symbol_int, name_alist_or_stem));
else if (STRINGP (name_alist_or_stem))
{
- int len = STRING_BYTES (XSTRING (name_alist_or_stem));
+ int len = SBYTES (name_alist_or_stem);
char *buf = (char *) alloca (len + 50);
- sprintf (buf, "%s-%d", XSTRING (name_alist_or_stem)->data,
+ sprintf (buf, "%s-%d", SDATA (name_alist_or_stem),
XINT (symbol_int) + 1);
value = intern (buf);
}
}
/* Let the symbol A refer to the character A. */
- if (SYMBOLP (base) && XSYMBOL (base)->name->size == 1)
- XSETINT (base, XSYMBOL (base)->name->data[0]);
+ if (SYMBOLP (base) && SCHARS (SYMBOL_NAME (base)) == 1)
+ XSETINT (base, SREF (SYMBOL_NAME (base), 0));
if (INTEGERP (base))
{
parse_solitary_modifier (symbol)
Lisp_Object symbol;
{
- struct Lisp_String *name = XSYMBOL (symbol)->name;
+ Lisp_Object name = SYMBOL_NAME (symbol);
- switch (name->data[0])
+ switch (SREF (name, 0))
{
#define SINGLE_LETTER_MOD(BIT) \
- if (STRING_BYTES (name) == 1) \
+ if (SBYTES (name) == 1) \
return BIT;
#define MULTI_LETTER_MOD(BIT, NAME, LEN) \
- if (LEN == STRING_BYTES (name) \
- && ! strncmp (name->data, NAME, LEN)) \
+ if (LEN == SBYTES (name) \
+ && ! strncmp (SDATA (name), NAME, LEN)) \
return BIT;
case 'A':
but works even if FIONREAD does not exist.
(In fact, this may actually read some input.)
- If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
+ If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
+ If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
static void
-get_input_pending (addr, do_timers_now)
+get_filtered_input_pending (addr, do_timers_now, filter_events)
int *addr;
int do_timers_now;
+ int filter_events;
{
/* First of all, have we already counted some input? */
- *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
+ *addr = (!NILP (Vquit_flag)
+ || readable_filtered_events (do_timers_now, filter_events));
/* If input is being read as it arrives, and we have none, there is none. */
if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
/* Try to read some input and see how much we get. */
gobble_input (0);
- *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
+ *addr = (!NILP (Vquit_flag)
+ || readable_filtered_events (do_timers_now, filter_events));
+}
+
+/* Store into *addr a value nonzero if terminal input chars are available.
+ Serves the purpose of ioctl (0, FIONREAD, addr)
+ but works even if FIONREAD does not exist.
+ (In fact, this may actually read some input.)
+
+ If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
+
+static void
+get_input_pending (addr, do_timers_now)
+ int *addr;
+ int do_timers_now;
+{
+ get_filtered_input_pending (addr, do_timers_now, 0);
}
/* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
#endif
}
-/* Put a buffer_switch_event in the buffer
+/* Put a BUFFER_SWITCH_EVENT in the buffer
so that read_key_sequence will notice the new current buffer. */
void
struct input_event event;
Lisp_Object tem;
- event.kind = buffer_switch_event;
+ event.kind = BUFFER_SWITCH_EVENT;
event.frame_or_window = Qnil;
event.arg = Qnil;
#endif /* no FIONREAD */
for (i = 0; i < nread; i++)
{
- buf[i].kind = ascii_keystroke;
+ buf[i].kind = ASCII_KEYSTROKE_EVENT;
buf[i].modifiers = 0;
if (meta_key == 1 && (cbuf[i] & 0x80))
buf[i].modifiers = meta_modifier;
kbd_buffer_store_event (&buf[i]);
/* Don't look at input that follows a C-g too closely.
This reduces lossage due to autorepeat on C-g. */
- if (buf[i].kind == ascii_keystroke
+ if (buf[i].kind == ASCII_KEYSTROKE_EVENT
&& buf[i].code == quit_char)
break;
}
menu_item_eval_property (sexpr)
Lisp_Object sexpr;
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object val;
specbind (Qinhibit_redisplay, Qt);
val = internal_condition_case_1 (Feval, sexpr, Qerror,
}
/* If we don't have any menus, just read a character normally. */
- if (mapno >= nmaps)
+ if (!STRINGP (name))
return Qnil;
#ifdef HAVE_MENUS
}
/* If we don't have any menus, just read a character normally. */
- if (!STRINGP (name));
+ if (!STRINGP (name))
return Qnil;
/* Prompt string always starts with map's prompt, and a space. */
- strcpy (menu, XSTRING (name)->data);
- nlength = STRING_BYTES (XSTRING (name));
+ strcpy (menu, SDATA (name));
+ nlength = SBYTES (name);
menu[nlength++] = ':';
menu[nlength++] = ' ';
menu[nlength] = 0;
upcased_event = Fupcase (event);
downcased_event = Fdowncase (event);
- char_matches = (XINT (upcased_event) == XSTRING (s)->data[0]
- || XINT (downcased_event) == XSTRING (s)->data[0]);
+ char_matches = (XINT (upcased_event) == SREF (s, 0)
+ || XINT (downcased_event) == SREF (s, 0));
if (! char_matches)
desc = Fsingle_key_description (event, Qnil);
+#if 0 /* It is redundant to list the equivalent key bindings because
+ the prefix is what the user has already typed. */
tem
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
if (!NILP (tem))
/* Insert equivalent keybinding. */
s = concat2 (s, tem);
-
+#endif
tem
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
/* If we have room for the prompt string, add it to this line.
If this is the first on the line, always add it. */
- if ((XSTRING (s)->size + i + 2
- + (char_matches ? 0 : XSTRING (desc)->size + 3))
+ if ((SCHARS (s) + i + 2
+ + (char_matches ? 0 : SCHARS (desc) + 3))
< width
|| !notfirst)
{
if (! char_matches)
{
/* Add as much of string as fits. */
- thiswidth = XSTRING (desc)->size;
+ thiswidth = SCHARS (desc);
if (thiswidth + i > width)
thiswidth = width - i;
- bcopy (XSTRING (desc)->data, menu + i, thiswidth);
+ bcopy (SDATA (desc), menu + i, thiswidth);
i += thiswidth;
strcpy (menu + i, " = ");
i += 3;
}
/* Add as much of string as fits. */
- thiswidth = XSTRING (s)->size;
+ thiswidth = SCHARS (s);
if (thiswidth + i > width)
thiswidth = width - i;
- bcopy (XSTRING (s)->data, menu + i, thiswidth);
+ bcopy (SDATA (s), menu + i, thiswidth);
i += thiswidth;
menu[i] = 0;
}
int fix_current_buffer;
{
volatile Lisp_Object from_string;
- volatile int count = specpdl_ptr - specpdl;
+ volatile int count = SPECPDL_INDEX ();
/* How many keys there are in the current key sequence. */
volatile int t;
struct buffer *starting_buffer;
- /* Nonzero if we seem to have got the beginning of a binding
- in function_key_map. */
- volatile int function_key_possible = 0;
- volatile int key_translation_possible = 0;
-
/* List of events for which a fake prefix key has been generated. */
volatile Lisp_Object fake_prefixed_keys = Qnil;
- /* Save the status of key translation before each step,
- so that we can restore this after downcasing. */
- Lisp_Object prev_fkey_map;
- int prev_fkey_start;
- int prev_fkey_end;
-
- Lisp_Object prev_keytran_map;
- int prev_keytran_start;
- int prev_keytran_end;
-
#if defined (GOBBLE_FIRST_EVENT)
int junk;
#endif
replay_sequence:
starting_buffer = current_buffer;
- function_key_possible = 0;
- key_translation_possible = 0;
first_unbound = bufsize + 1;
/* Build our list of keymaps.
we may be looking at a function key's escape sequence, keep on
reading. */
while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
- || (first_binding >= nmaps
- && fkey_start < t)
- || (first_binding >= nmaps
- && keytran_start < t && key_translation_possible)
+ || (first_binding >= nmaps && fkey_start < t)
+ || (first_binding >= nmaps && keytran_start < t)
/* Don't return in the middle of a possible function key sequence,
if the only bindings we found were via case conversion.
Thus, if ESC O a has a function-key-map translation
just one key. */
volatile int echo_local_start, keys_local_start, local_first_binding;
+ /* key-translation-map is applied *after* function-key-map. */
+ eassert (keytran_end <= fkey_start);
if (first_unbound < fkey_start && first_unbound < keytran_start)
{ /* The prefix upto first_unbound has no binding and has
keymap may have changed, so replay the sequence. */
if (BUFFERP (key))
{
+ EMACS_TIME initial_idleness_start_time;
+ EMACS_SET_SECS_USECS (initial_idleness_start_time,
+ EMACS_SECS (timer_last_idleness_start_time),
+ EMACS_USECS (timer_last_idleness_start_time));
+
+ /* Resume idle state, using the same start-time as before. */
+ timer_start_idle ();
+ timer_idleness_start_time = initial_idleness_start_time;
+
mock_input = t;
/* Reset the current buffer from the selected window
in case something changed the former and not the latter.
/* Record that a fake prefix key has been generated
for KEY. Don't modify the event; this would
prevent proper action when the event is pushed
- back tino unread-command-events. */
+ back into unread-command-events. */
fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
/* If on a mode line string with a local keymap,
pos = XCDR (string);
string = XCAR (string);
if (XINT (pos) >= 0
- && XINT (pos) < XSTRING (string)->size)
+ && XINT (pos) < SCHARS (string))
{
map = Fget_text_property (pos, Qlocal_map, string);
if (!NILP (map))
pos = XCDR (string);
string = XCAR (string);
if (XINT (pos) >= 0
- && XINT (pos) < XSTRING (string)->size)
+ && XINT (pos) < SCHARS (string))
{
map = Fget_text_property (pos, Qlocal_map, string);
if (!NILP (map))
+ first_binding);
/* If KEY wasn't bound, we'll try some fallbacks. */
- if (first_binding >= nmaps)
+ if (first_binding < nmaps)
+ /* This is needed for the following scenario:
+ event 0: a down-event that gets dropped by calling replay_key.
+ event 1: some normal prefix like C-h.
+ After event 0, first_unbound is 0, after event 1 fkey_start
+ and keytran_start are both 1, so when we see that C-h is bound,
+ we need to update first_unbound. */
+ first_unbound = max (t + 1, first_unbound);
+ else
{
Lisp_Object head;
generate mouse events, so it's okay to zero
mock_input in that case too.
+ FIXME: The above paragraph seems just plain
+ wrong, if you consider things like
+ xterm-mouse-mode. -stef
+
Isn't this just the most wonderful code ever? */
if (t == last_real_key_start)
{
/* Record what part of this_command_keys is the current key sequence. */
this_single_command_key_start = this_command_key_count - t;
- prev_fkey_map = fkey_map;
- prev_fkey_start = fkey_start;
- prev_fkey_end = fkey_end;
-
- prev_keytran_map = keytran_map;
- prev_keytran_start = keytran_start;
- prev_keytran_end = keytran_end;
-
- /* If the sequence is unbound, see if we can hang a function key
- off the end of it. We only want to scan real keyboard input
- for function key sequences, so if mock_input says that we're
- re-reading old events, don't examine it. */
- if (first_binding >= nmaps
- && t >= mock_input)
+ if (first_binding < nmaps && NILP (submaps[first_binding]))
+ /* There is a binding and it's not a prefix.
+ There is thus no function-key in this sequence.
+ Moving fkey.start is important in this case to allow keytran.start
+ to go over the sequence before we return (since we keep the
+ invariant that keytran.end <= fkey.start). */
+ {
+ if (fkey_start < t)
+ (fkey_start = fkey_end = t, fkey_map = Vfunction_key_map);
+ }
+ else
+ /* If the sequence is unbound, see if we can hang a function key
+ off the end of it. */
{
Lisp_Object fkey_next;
/* Continue scan from fkey_end until we find a bound suffix.
- If we fail, increment fkey_start
- and start fkey_end from there. */
+ If we fail, increment fkey_start and start over from there. */
while (fkey_end < t)
{
Lisp_Object key;
key = keybuf[fkey_end++];
- fkey_next
- = access_keymap (fkey_map, key, 1, 0, 1);
+ fkey_next = access_keymap (fkey_map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
array, then call the function with no args and use
its value instead. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
- && fkey_end == t)
+ /* If there's a binding (i.e. first_binding >= nmaps)
+ we don't want to apply this function-key-mapping. */
+ && fkey_end == t && first_binding >= nmaps)
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
error ("Function in key-translation-map returns invalid key sequence");
}
- function_key_possible = ! NILP (fkey_next);
-
/* If keybuf[fkey_start..fkey_end] is bound in the
function key map and it's a suffix of the current
sequence (i.e. fkey_end == t), replace it with
the binding and restart with fkey_start at the end. */
if ((VECTORP (fkey_next) || STRINGP (fkey_next))
- && fkey_end == t)
+ /* If there's a binding (i.e. first_binding >= nmaps)
+ we don't want to apply this function-key-mapping. */
+ && fkey_end == t && first_binding >= nmaps)
{
int len = XFASTINT (Flength (fkey_next));
for (i = 0; i < len; i++)
XSETFASTINT (keybuf[fkey_start + i],
- XSTRING (fkey_next)->data[i]);
+ SREF (fkey_next, i));
}
mock_input = t;
{
fkey_end = ++fkey_start;
fkey_map = Vfunction_key_map;
- function_key_possible = 0;
}
}
}
Lisp_Object keytran_next;
/* Scan from keytran_end until we find a bound suffix. */
- while (keytran_end < t)
+ while (keytran_end < fkey_start)
{
Lisp_Object key;
/* If the key translation map gives a function, not an
array, then call the function with one arg and use
its value instead. */
- if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
- && keytran_end == t)
+ if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next)))
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
error ("Function in key-translation-map returns invalid key sequence");
}
- key_translation_possible = ! NILP (keytran_next);
-
/* If keybuf[keytran_start..keytran_end] is bound in the
key translation map and it's a suffix of the current
sequence (i.e. keytran_end == t), replace it with
the binding and restart with keytran_start at the end. */
- if ((VECTORP (keytran_next) || STRINGP (keytran_next))
- && keytran_end == t)
+ if ((VECTORP (keytran_next) || STRINGP (keytran_next)))
{
int len = XFASTINT (Flength (keytran_next));
+ int i, diff = len - (keytran_end - keytran_start);
- t = keytran_start + len;
- if (t >= bufsize)
+ mock_input = max (t, mock_input);
+ if (mock_input + diff >= bufsize)
error ("Key sequence too long");
- if (VECTORP (keytran_next))
- bcopy (XVECTOR (keytran_next)->contents,
- keybuf + keytran_start,
- (t - keytran_start) * sizeof (keybuf[0]));
- else if (STRINGP (keytran_next))
- {
- int i;
-
- for (i = 0; i < len; i++)
- XSETFASTINT (keybuf[keytran_start + i],
- XSTRING (keytran_next)->data[i]);
- }
-
- mock_input = t;
- keytran_start = keytran_end = t;
+ /* Shift the keys that are after keytran_end. */
+ if (diff < 0)
+ for (i = keytran_end; i < mock_input; i++)
+ keybuf[i + diff] = keybuf[i];
+ else if (diff > 0)
+ for (i = mock_input - 1; i >= keytran_end; i--)
+ keybuf[i + diff] = keybuf[i];
+ /* Replace the keys between keytran_start and keytran_end
+ with those from keytran_next. */
+ for (i = 0; i < len; i++)
+ keybuf[keytran_start + i]
+ = Faref (keytran_next, make_number (i));
+
+ mock_input += diff;
+ keytran_start = keytran_end += diff;
keytran_map = Vkey_translation_map;
- /* Don't pass the results of key-translation-map
- through function-key-map. */
- fkey_start = fkey_end = t;
- fkey_map = Vfunction_key_map;
+ /* Adjust the function-key-map counters. */
+ fkey_start += diff;
+ fkey_end += diff;
goto replay_sequence;
}
{
keytran_end = ++keytran_start;
keytran_map = Vkey_translation_map;
- key_translation_possible = 0;
}
}
}
and cannot be part of a function key or translation,
and is an upper case letter
use the corresponding lower-case letter instead. */
- if (first_binding == nmaps && ! function_key_possible
- && ! key_translation_possible
+ if (first_binding >= nmaps
+ && fkey_start >= t && keytran_start >= t
&& INTEGERP (key)
&& ((((XINT (key) & 0x3ffff)
< XCHAR_TABLE (current_buffer->downcase_table)->size)
the lower-case char is defined in the keymaps, because they
might get translated through function-key-map. */
keybuf[t - 1] = new_key;
- mock_input = t;
-
- fkey_map = prev_fkey_map;
- fkey_start = prev_fkey_start;
- fkey_end = prev_fkey_end;
-
- keytran_map = prev_keytran_map;
- keytran_start = prev_keytran_start;
- keytran_end = prev_keytran_end;
+ mock_input = max (t, mock_input);
goto replay_sequence;
}
and cannot be part of a function key or translation,
and is a shifted function key,
use the corresponding unshifted function key instead. */
- if (first_binding == nmaps && ! function_key_possible
- && ! key_translation_possible
+ if (first_binding >= nmaps
+ && fkey_start >= t && keytran_start >= t
&& SYMBOLP (key))
{
Lisp_Object breakdown;
XCAR (breakdown));
keybuf[t - 1] = new_key;
- mock_input = t;
-
- fkey_map = prev_fkey_map;
- fkey_start = prev_fkey_start;
- fkey_end = prev_fkey_end;
-
- keytran_map = prev_keytran_map;
- keytran_start = prev_keytran_start;
- keytran_end = prev_keytran_end;
+ mock_input = max (t, mock_input);
goto replay_sequence;
}
Lisp_Object keybuf[30];
register int i;
struct gcpro gcpro1;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
if (!NILP (prompt))
CHECK_STRING (prompt);
Lisp_Object keybuf[30];
register int i;
struct gcpro gcpro1;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
if (!NILP (prompt))
CHECK_STRING (prompt);
}
}
- return Fexecute_kbd_macro (final, prefixarg);
+ return Fexecute_kbd_macro (final, prefixarg, Qnil);
}
if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
Qt, Qnil, Qextended_command_history, Qnil,
Qnil);
- if (STRINGP (function) && XSTRING (function)->size == 0)
+ if (STRINGP (function) && SCHARS (function) == 0)
error ("No command name given");
/* Set this_command_keys to the concatenation of saved_keys and
function, followed by a RET. */
{
- struct Lisp_String *str;
Lisp_Object *keys;
int i;
for (i = 0; i < XVECTOR (saved_keys)->size; i++)
add_command_key (keys[i]);
- str = XSTRING (function);
- for (i = 0; i < str->size; i++)
+ for (i = 0; i < SCHARS (function); i++)
add_command_key (Faref (function, make_number (i)));
add_command_key (make_number ('\015'));
Lisp_Object binding;
char *newmessage;
int message_p = push_message ();
- int count = BINDING_STACK_SIZE ();
+ int count = SPECPDL_INDEX ();
- record_unwind_protect (push_message_unwind, Qnil);
+ record_unwind_protect (pop_message_unwind, Qnil);
binding = Fkey_description (bindings);
newmessage
- = (char *) alloca (XSYMBOL (function)->name->size
- + STRING_BYTES (XSTRING (binding))
+ = (char *) alloca (SCHARS (SYMBOL_NAME (function))
+ + SBYTES (binding)
+ 100);
sprintf (newmessage, "You can run the command `%s' with %s",
- XSYMBOL (function)->name->data,
- XSTRING (binding)->data);
+ SDATA (SYMBOL_NAME (function)),
+ SDATA (binding));
message2_nolog (newmessage,
strlen (newmessage),
STRING_MULTIBYTE (binding));
if (!NILP (Vunread_command_events) || unread_command_char != -1)
return (Qt);
- get_input_pending (&input_pending, 1);
+ get_filtered_input_pending (&input_pending, 1, 1);
return input_pending > 0 ? Qt : Qnil;
}
DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
doc: /* Return the key sequence that invoked this command.
However, if the command has called `read-key-sequence', it returns
-the the last key sequence that has been read.
+the last key sequence that has been read.
The value is a string or a vector. */)
()
{
DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
doc: /* Return the key sequence that invoked this command, as a vector.
However, if the command has called `read-key-sequence', it returns
-the the last key sequence that has been read. */)
+the last key sequence that has been read. */)
()
{
return Fvector (this_command_key_count,
}
DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
- Sclear_this_command_keys, 0, 0, 0,
+ Sclear_this_command_keys, 0, 1, 0,
doc: /* Clear out the vector that `this-command-keys' returns.
-Also clear the record of the last 100 events. */)
- ()
+Also clear the record of the last 100 events, unless optional arg
+KEEP-RECORD is non-nil. */)
+ (keep_record)
+ Lisp_Object keep_record;
{
int i;
this_command_key_count = 0;
- for (i = 0; i < XVECTOR (recent_keys)->size; ++i)
- XVECTOR (recent_keys)->contents[i] = Qnil;
- total_keys = 0;
- recent_keys_index = 0;
+ if (NILP (keep_record))
+ {
+ for (i = 0; i < XVECTOR (recent_keys)->size; ++i)
+ XVECTOR (recent_keys)->contents[i] = Qnil;
+ total_keys = 0;
+ recent_keys_index = 0;
+ }
return Qnil;
}
if (!NILP (file))
{
file = Fexpand_file_name (file, Qnil);
- dribble = fopen (XSTRING (file)->data, "w");
+ dribble = fopen (SDATA (file), "w");
if (dribble == 0)
report_file_error ("Opening dribble", Fcons (file, Qnil));
}
DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
doc: /* Discard the contents of the terminal input buffer.
-Also cancel any kbd macro being defined. */)
+Also end any kbd macro being defined. */)
()
{
- current_kboard->defining_kbd_macro = Qnil;
+ if (!NILP (current_kboard->defining_kbd_macro))
+ {
+ /* Discard the last command from the macro. */
+ Fcancel_kbd_macro_events ();
+ end_kbd_macro ();
+ }
+
update_mode_lines++;
Vunread_command_events = Qnil;
(stuffstring)
Lisp_Object stuffstring;
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
int old_height, old_width;
int width, height;
struct gcpro gcpro1;
{
register int count;
- p = XSTRING (stuffstring)->data;
- count = STRING_BYTES (XSTRING (stuffstring));
+ p = SDATA (stuffstring);
+ count = SBYTES (stuffstring);
while (count-- > 0)
stuff_char (*p++);
stuff_char ('\n');
if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
kbd_fetch_ptr = kbd_buffer;
- if (kbd_fetch_ptr->kind == ascii_keystroke)
+ if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
stuff_char (kbd_fetch_ptr->code);
- kbd_fetch_ptr->kind = no_event;
+ kbd_fetch_ptr->kind = NO_EVENT;
idx = 2 * (kbd_fetch_ptr - kbd_buffer);
ASET (kbd_buffer_gcpro, idx, Qnil);
ASET (kbd_buffer_gcpro, idx + 1, Qnil);
staticpro (&Qfunction_key);
Qmouse_click = intern ("mouse-click");
staticpro (&Qmouse_click);
-#ifdef WINDOWSNT
+#if defined(WINDOWSNT) || defined(MAC_OSX)
Qmouse_wheel = intern ("mouse-wheel");
staticpro (&Qmouse_wheel);
+#endif
+#ifdef WINDOWSNT
Qlanguage_change = intern ("language-change");
staticpro (&Qlanguage_change);
#endif
func_key_syms = Qnil;
staticpro (&func_key_syms);
-#ifdef WINDOWSNT
+#if defined(WINDOWSNT) || defined(MAC_OSX)
mouse_wheel_syms = Qnil;
staticpro (&mouse_wheel_syms);
-
drag_n_drop_syms = Qnil;
staticpro (&drag_n_drop_syms);
#endif
DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook,
doc: /* Normal hook run after each command is executed, if idle.
-Errors running the hook are caught and ignored.
-This feature is obsolete; use idle timers instead. See `etc/NEWS'. */);
+Errors running the hook are caught and ignored. */);
Vpost_command_idle_hook = Qnil;
DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay,
HCoop / bpt / emacs.git / blobdiff