extern Lisp_Object Qleft_fringe, Qright_fringe;
extern Lisp_Object QCmap;
-Lisp_Object recursive_edit_unwind (), command_loop ();
-Lisp_Object Fthis_command_keys ();
+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 ();
+EMACS_TIME timer_check (int do_it_now);
extern Lisp_Object Vhistory_length, Vtranslation_table_for_input;
-extern char *x_get_keysym_name ();
-
-static void record_menu_key ();
-static int echo_length ();
+static void record_menu_key (Lisp_Object c);
+static int echo_length (void);
Lisp_Object Qpolling_period;
#define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
/* Function for init_keyboard to call with no args (if nonzero). */
-void (*keyboard_init_hook) ();
-
-static int read_avail_input P_ ((int));
-static void get_input_pending P_ ((int *, int));
-static int readable_events P_ ((int));
-static Lisp_Object read_char_x_menu_prompt P_ ((int, Lisp_Object *,
- Lisp_Object, int *));
-static Lisp_Object read_char_x_menu_prompt ();
-static Lisp_Object read_char_minibuf_menu_prompt P_ ((int, int,
- Lisp_Object *));
-static Lisp_Object make_lispy_event P_ ((struct input_event *));
+void (*keyboard_init_hook) (void);
+
+static int read_avail_input (int);
+static void get_input_pending (int *, int);
+static int readable_events (int);
+static Lisp_Object read_char_x_menu_prompt (int, Lisp_Object *,
+ Lisp_Object, int *);
+static Lisp_Object read_char_minibuf_menu_prompt (int, int,
+ Lisp_Object *);
+static Lisp_Object make_lispy_event (struct input_event *);
#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
-static Lisp_Object make_lispy_movement P_ ((struct frame *, Lisp_Object,
- enum scroll_bar_part,
- Lisp_Object, Lisp_Object,
- unsigned long));
-#endif
-static Lisp_Object modify_event_symbol P_ ((int, unsigned, Lisp_Object,
- Lisp_Object, char **,
- Lisp_Object *, unsigned));
-static Lisp_Object make_lispy_switch_frame P_ ((Lisp_Object));
-static void save_getcjmp P_ ((jmp_buf));
-static void save_getcjmp ();
-static void restore_getcjmp P_ ((jmp_buf));
-static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
-static void clear_event P_ ((struct input_event *));
-static Lisp_Object restore_kboard_configuration P_ ((Lisp_Object));
-static SIGTYPE interrupt_signal P_ ((int signalnum));
-static void handle_interrupt P_ ((void));
-static void timer_start_idle P_ ((void));
-static void timer_stop_idle P_ ((void));
-static void timer_resume_idle P_ ((void));
-static SIGTYPE handle_user_signal P_ ((int));
-static char *find_user_signal_name P_ ((int));
-static int store_user_signal_events P_ ((void));
+static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
+ enum scroll_bar_part,
+ Lisp_Object, Lisp_Object,
+ unsigned long);
+#endif
+static Lisp_Object modify_event_symbol (int, unsigned, Lisp_Object,
+ Lisp_Object, char **,
+ Lisp_Object *, unsigned);
+static Lisp_Object make_lispy_switch_frame (Lisp_Object);
+static void save_getcjmp (jmp_buf);
+static void restore_getcjmp (jmp_buf);
+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 SIGTYPE input_available_signal (int signo);
+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 char *find_user_signal_name (int);
+static int store_user_signal_events (void);
/* Nonzero means don't try to suspend even if the operating system seems
to support it. */
Also start echoing. */
void
-echo_prompt (str)
- Lisp_Object str;
+echo_prompt (Lisp_Object str)
{
current_kboard->echo_string = str;
current_kboard->echo_after_prompt = SCHARS (str);
jazz), or a symbol, whose name is printed. */
void
-echo_char (c)
- Lisp_Object c;
+echo_char (Lisp_Object c)
{
if (current_kboard->immediate_echo)
{
ptr = buffer + offset;
}
- bcopy (text, ptr, len);
+ memcpy (ptr, text, len);
ptr += len;
}
empty, so that it serves as a mini-prompt for the very next character. */
void
-echo_dash ()
+echo_dash (void)
{
/* Do nothing if not echoing at all. */
if (NILP (current_kboard->echo_string))
doing so. */
void
-echo_now ()
+echo_now (void)
{
if (!current_kboard->immediate_echo)
{
/* Turn off echoing, for the start of a new command. */
void
-cancel_echoing ()
+cancel_echoing (void)
{
current_kboard->immediate_echo = 0;
current_kboard->echo_after_prompt = -1;
/* Return the length of the current echo string. */
static int
-echo_length ()
+echo_length (void)
{
return (STRINGP (current_kboard->echo_string)
? SCHARS (current_kboard->echo_string)
switches frames while entering a key sequence. */
static void
-echo_truncate (nchars)
- int nchars;
+echo_truncate (int nchars)
{
if (STRINGP (current_kboard->echo_string))
current_kboard->echo_string
\f
/* Functions for manipulating this_command_keys. */
static void
-add_command_key (key)
- Lisp_Object key;
+add_command_key (Lisp_Object key)
{
#if 0 /* Not needed after we made Freset_this_command_lengths
do the job immediately. */
\f
Lisp_Object
-recursive_edit_1 ()
+recursive_edit_1 (void)
{
int count = SPECPDL_INDEX ();
Lisp_Object val;
/* When an auto-save happens, record the "time", and don't do again soon. */
void
-record_auto_save ()
+record_auto_save (void)
{
last_auto_save = num_nonmacro_input_events;
}
/* Make an auto save happen as soon as possible at command level. */
void
-force_auto_save_soon ()
+force_auto_save_soon (void)
{
last_auto_save = - auto_save_interval - 1;
that tells this function to return.
Alternatively, `(throw 'exit t)' makes this function signal an error.
This function is called by the editor initialization to begin editing. */)
- ()
+ (void)
{
int count = SPECPDL_INDEX ();
Lisp_Object buffer;
}
Lisp_Object
-recursive_edit_unwind (buffer)
- Lisp_Object buffer;
+recursive_edit_unwind (Lisp_Object buffer)
{
if (BUFFERP (buffer))
Fset_buffer (buffer);
get out of it. */
void
-not_single_kboard_state (kboard)
- KBOARD *kboard;
+not_single_kboard_state (KBOARD *kboard)
{
if (kboard == current_kboard)
single_kboard = 0;
static struct kboard_stack *kboard_stack;
void
-push_kboard (k)
- struct kboard *k;
+push_kboard (struct kboard *k)
{
struct kboard_stack *p
= (struct kboard_stack *) xmalloc (sizeof (struct kboard_stack));
}
void
-pop_kboard ()
+pop_kboard (void)
{
struct terminal *t;
struct kboard_stack *p = kboard_stack;
locked, then this function will throw an errow. */
void
-temporarily_switch_to_single_kboard (f)
- struct frame *f;
+temporarily_switch_to_single_kboard (struct frame *f)
{
int was_locked = single_kboard;
if (was_locked)
#endif
static Lisp_Object
-restore_kboard_configuration (was_locked)
- Lisp_Object was_locked;
+restore_kboard_configuration (Lisp_Object was_locked)
{
if (NILP (was_locked))
single_kboard = 0;
by printing an error message and returning to the editor command loop. */
Lisp_Object
-cmd_error (data)
- Lisp_Object data;
+cmd_error (Lisp_Object data)
{
Lisp_Object old_level, old_length;
char macroerror[50];
string. */
void
-cmd_error_internal (data, context)
- Lisp_Object data;
- char *context;
+cmd_error_internal (Lisp_Object data, char *context)
{
struct frame *sf = SELECTED_FRAME ();
Vsignaling_function = Qnil;
}
\f
-Lisp_Object command_loop_1 ();
-Lisp_Object command_loop_2 ();
-Lisp_Object top_level_1 ();
+Lisp_Object command_loop_1 (void);
+Lisp_Object command_loop_2 (Lisp_Object);
+Lisp_Object top_level_1 (Lisp_Object);
/* Entry to editor-command-loop.
This level has the catches for exiting/returning to editor command loop.
It returns nil to exit recursive edit, t to abort it. */
Lisp_Object
-command_loop ()
+command_loop (void)
{
if (command_loop_level > 0 || minibuf_level > 0)
{
returned due to end of file (or end of kbd macro). */
Lisp_Object
-command_loop_2 ()
+command_loop_2 (Lisp_Object ignore)
{
register Lisp_Object val;
}
Lisp_Object
-top_level_2 ()
+top_level_2 (void)
{
return Feval (Vtop_level);
}
Lisp_Object
-top_level_1 ()
+top_level_1 (Lisp_Object ignore)
{
/* On entry to the outer level, run the startup file */
if (!NILP (Vtop_level))
DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
doc: /* Exit all recursive editing levels.
This also exits all active minibuffers. */)
- ()
+ (void)
{
#ifdef HAVE_WINDOW_SYSTEM
if (display_hourglass_p)
DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
doc: /* Exit from the innermost recursive edit or minibuffer. */)
- ()
+ (void)
{
if (command_loop_level > 0 || minibuf_level > 0)
Fthrow (Qexit, Qnil);
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)
{
if (command_loop_level > 0 || minibuf_level > 0)
Fthrow (Qexit, Qt);
of this function. */
static Lisp_Object
-tracking_off (old_value)
- Lisp_Object old_value;
+tracking_off (Lisp_Object old_value)
{
do_mouse_tracking = old_value;
if (NILP (old_value))
you can read with `read-event'.
Normally, mouse motion is ignored.
usage: (track-mouse BODY...) */)
- (args)
- Lisp_Object args;
+ (Lisp_Object args)
{
int count = SPECPDL_INDEX ();
Lisp_Object val;
int ignore_mouse_drag_p;
static FRAME_PTR
-some_mouse_moved ()
+some_mouse_moved (void)
{
Lisp_Object tail, frame;
/* This is the actual command reading loop,
sans error-handling encapsulation. */
-static int read_key_sequence P_ ((Lisp_Object *, int, Lisp_Object,
- int, int, int));
-void safe_run_hooks P_ ((Lisp_Object));
-static void adjust_point_for_property P_ ((int, int));
+static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
+ int, int, int);
+void safe_run_hooks (Lisp_Object);
+static void adjust_point_for_property (int, int);
/* Cancel hourglass from protect_unwind.
ARG is not used. */
#ifdef HAVE_WINDOW_SYSTEM
static Lisp_Object
-cancel_hourglass_unwind (arg)
- Lisp_Object arg;
+cancel_hourglass_unwind (Lisp_Object arg)
{
cancel_hourglass ();
return Qnil;
#endif
Lisp_Object
-command_loop_1 ()
+command_loop_1 (void)
{
Lisp_Object cmd;
Lisp_Object keybuf[30];
LAST_PT is the last position of point. */
extern Lisp_Object Qafter_string, Qbefore_string;
-extern Lisp_Object get_pos_property P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+extern Lisp_Object get_pos_property (Lisp_Object, Lisp_Object, Lisp_Object);
static void
-adjust_point_for_property (last_pt, modified)
- int last_pt;
- int modified;
+adjust_point_for_property (int last_pt, int modified)
{
EMACS_INT beg, end;
Lisp_Object val, overlay, tmp;
/* Subroutine for safe_run_hooks: run the hook HOOK. */
static Lisp_Object
-safe_run_hooks_1 (hook)
- Lisp_Object hook;
+safe_run_hooks_1 (void)
{
if (NILP (Vrun_hooks))
return Qnil;
/* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
static Lisp_Object
-safe_run_hooks_error (data)
- Lisp_Object data;
+safe_run_hooks_error (Lisp_Object data)
{
Lisp_Object args[3];
args[0] = build_string ("Error in %s: %s");
to mysteriously evaporate. */
void
-safe_run_hooks (hook)
- Lisp_Object hook;
+safe_run_hooks (Lisp_Object hook)
{
int count = SPECPDL_INDEX ();
specbind (Qinhibit_quit, hook);
there. */
void
-poll_for_input_1 ()
+poll_for_input_1 (void)
{
/* Tell ns_read_socket() it is being called asynchronously so it can avoid
doing anything dangerous. */
poll_timer. */
void
-poll_for_input (timer)
- struct atimer *timer;
+poll_for_input (struct atimer *timer)
{
if (poll_suppress_count == 0)
{
This function is called unconditionally from various places. */
void
-start_polling ()
+start_polling (void)
{
#ifdef POLL_FOR_INPUT
/* XXX This condition was (read_socket_hook && !interrupt_input),
/* Nonzero if we are using polling to handle input asynchronously. */
int
-input_polling_used ()
+input_polling_used (void)
{
#ifdef POLL_FOR_INPUT
/* XXX This condition was (read_socket_hook && !interrupt_input),
/* Turn off polling. */
void
-stop_polling ()
+stop_polling (void)
{
#ifdef POLL_FOR_INPUT
/* XXX This condition was (read_socket_hook && !interrupt_input),
and start or stop polling accordingly. */
void
-set_poll_suppress_count (count)
- int count;
+set_poll_suppress_count (int count)
{
#ifdef POLL_FOR_INPUT
if (count == 0 && poll_suppress_count != 0)
But don't decrease it. */
void
-bind_polling_period (n)
- int n;
+bind_polling_period (int n)
{
#ifdef POLL_FOR_INPUT
int new = polling_period;
/* Apply the control modifier to CHARACTER. */
int
-make_ctrl_char (c)
- int c;
+make_ctrl_char (int c)
{
/* Save the upper bits here. */
int upper = c & ~0177;
from X code running asynchronously. */
void
-show_help_echo (help, window, object, pos, ok_to_overwrite_keystroke_echo)
- Lisp_Object help, window, object, pos;
- int ok_to_overwrite_keystroke_echo;
+show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
+ Lisp_Object pos, int ok_to_overwrite_keystroke_echo)
{
if (!NILP (help) && !STRINGP (help))
{
\f
/* Input of single characters from keyboard */
-Lisp_Object print_help ();
-static Lisp_Object kbd_buffer_get_event ();
-static void record_char ();
+Lisp_Object print_help (Lisp_Object object);
+static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu,
+ struct timeval *end_time);
+static void record_char (Lisp_Object c);
static Lisp_Object help_form_saved_window_configs;
static Lisp_Object
Value is t if we showed a menu and the user rejected it. */
Lisp_Object
-read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu, end_time)
- int commandflag;
- int nmaps;
- Lisp_Object *maps;
- Lisp_Object prev_event;
- int *used_mouse_menu;
- EMACS_TIME *end_time;
+read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event,
+ int *used_mouse_menu, struct timeval *end_time)
{
volatile Lisp_Object c;
int count, jmpcount;
Record it for echoing, for this-command-keys, and so on. */
static void
-record_menu_key (c)
- Lisp_Object c;
+record_menu_key (Lisp_Object c)
{
/* Wipe the echo area. */
clear_message (1, 0);
/* Return 1 if should recognize C as "the help character". */
int
-help_char_p (c)
- Lisp_Object c;
+help_char_p (Lisp_Object c)
{
Lisp_Object tail;
/* Record the input event C in various ways. */
static void
-record_char (c)
- Lisp_Object c;
+record_char (Lisp_Object c)
{
int recorded = 0;
}
Lisp_Object
-print_help (object)
- Lisp_Object object;
+print_help (Lisp_Object object)
{
struct buffer *old = current_buffer;
Fprinc (object, Qnil);
See read_process_output. */
static void
-save_getcjmp (temp)
- jmp_buf temp;
+save_getcjmp (jmp_buf temp)
{
- bcopy (getcjmp, temp, sizeof getcjmp);
+ memcpy (temp, getcjmp, sizeof getcjmp);
}
static void
-restore_getcjmp (temp)
- jmp_buf temp;
+restore_getcjmp (jmp_buf temp)
{
- bcopy (temp, getcjmp, sizeof getcjmp);
+ memcpy (getcjmp, temp, sizeof getcjmp);
}
\f
/* Low level keyboard/mouse input.
/* Return true if 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 (flags)
- int flags;
+readable_events (int flags)
{
#ifdef HAVE_DBUS
/* Check whether a D-Bus message has arrived. */
int stop_character;
static KBOARD *
-event_to_kboard (event)
- struct input_event *event;
+event_to_kboard (struct input_event *event)
{
Lisp_Object frame;
frame = event->frame_or_window;
return FRAME_KBOARD (XFRAME (frame));
}
+/* Return the number of slots occupied in kbd_buffer. */
+
+static int
+kbd_buffer_nr_stored ()
+{
+ return kbd_fetch_ptr == kbd_store_ptr
+ ? 0
+ : (kbd_fetch_ptr < kbd_store_ptr
+ ? kbd_store_ptr - kbd_fetch_ptr
+ : ((kbd_buffer + KBD_BUFFER_SIZE) - kbd_fetch_ptr
+ + (kbd_store_ptr - kbd_buffer)));
+}
Lisp_Object Vthrow_on_input;
/* Store an event obtained at interrupt level into kbd_buffer, fifo */
void
-kbd_buffer_store_event (event)
- register struct input_event *event;
+kbd_buffer_store_event (register struct input_event *event)
{
kbd_buffer_store_event_hold (event, 0);
}
*/
void
-kbd_buffer_store_event_hold (event, hold_quit)
- register struct input_event *event;
- struct input_event *hold_quit;
+kbd_buffer_store_event_hold (register struct input_event *event,
+ struct input_event *hold_quit)
{
if (event->kind == NO_EVENT)
abort ();
if (hold_quit)
{
- bcopy (event, (char *) hold_quit, sizeof (*event));
+ memcpy (hold_quit, event, sizeof (*event));
return;
}
{
*kbd_store_ptr = *event;
++kbd_store_ptr;
+ if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE/2 && ! kbd_on_hold_p ())
+ {
+ /* Don't read keyboard input until we have processed kbd_buffer.
+ This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
+ hold_keyboard_input ();
+#ifdef SIGIO
+ if (!noninteractive)
+ signal (SIGIO, SIG_IGN);
+#endif
+ stop_polling ();
+ }
}
/* If we're inside while-no-input, and this event qualifies
/* Put an input event back in the head of the event queue. */
void
-kbd_buffer_unget_event (event)
- register struct input_event *event;
+kbd_buffer_unget_event (register struct input_event *event)
{
if (kbd_fetch_ptr == kbd_buffer)
kbd_fetch_ptr = kbd_buffer + KBD_BUFFER_SIZE;
Value is the number of input_events generated. */
void
-gen_help_event (help, frame, window, object, pos)
- Lisp_Object help, frame, object, window;
- int pos;
+gen_help_event (Lisp_Object help, Lisp_Object frame, Lisp_Object window,
+ Lisp_Object object, int pos)
{
struct input_event event;
/* Store HELP_EVENTs for HELP on FRAME in the input queue. */
void
-kbd_buffer_store_help_event (frame, help)
- Lisp_Object frame, help;
+kbd_buffer_store_help_event (Lisp_Object frame, Lisp_Object help)
{
struct input_event event;
/* Discard any mouse events in the event buffer by setting them to
NO_EVENT. */
void
-discard_mouse_events ()
+discard_mouse_events (void)
{
struct input_event *sp;
for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
are no real input events. */
int
-kbd_buffer_events_waiting (discard)
- int discard;
+kbd_buffer_events_waiting (int discard)
{
struct input_event *sp;
/* Clear input event EVENT. */
static INLINE void
-clear_event (event)
- struct input_event *event;
+clear_event (struct input_event *event)
{
event->kind = NO_EVENT;
}
We always read and discard one event. */
static Lisp_Object
-kbd_buffer_get_event (kbp, used_mouse_menu, end_time)
- KBOARD **kbp;
- int *used_mouse_menu;
- EMACS_TIME *end_time;
+kbd_buffer_get_event (KBOARD **kbp,
+ int *used_mouse_menu,
+ struct timeval *end_time)
{
register int c;
Lisp_Object obj;
+
+ if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE/4)
+ {
+ /* Start reading input again, we have processed enough so we can
+ accept new events again. */
+ unhold_keyboard_input ();
+#ifdef SIGIO
+ if (!noninteractive)
+ signal (SIGIO, input_available_signal);
+#endif /* SIGIO */
+ start_polling ();
+ }
if (noninteractive
/* In case we are running as a daemon, only do this before
then return, without reading any user-visible events. */
void
-swallow_events (do_display)
- int do_display;
+swallow_events (int do_display)
{
int old_timers_run;
for the sake of running idle-time timers. */
static void
-timer_start_idle ()
+timer_start_idle (void)
{
Lisp_Object timers;
/* Record that Emacs is no longer idle, so stop running idle-time timers. */
static void
-timer_stop_idle ()
+timer_stop_idle (void)
{
EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
}
/* Resume idle timer from last idle start time. */
static void
-timer_resume_idle ()
+timer_resume_idle (void)
{
if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
return;
should be done. */
static EMACS_TIME
-timer_check_2 ()
+timer_check_2 (void)
{
EMACS_TIME nexttime;
EMACS_TIME now, idleness_now;
Now we always run timers directly. */
EMACS_TIME
-timer_check (do_it_now)
- int do_it_now;
+timer_check (int do_it_now)
{
EMACS_TIME nexttime;
- do
+ do
{
nexttime = timer_check_2 ();
}
The microsecond count is zero on systems that do not provide
resolution finer than a second. */)
- ()
+ (void)
{
if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
{
/* Return position of a mouse click or wheel event */
static Lisp_Object
-make_lispy_position (f, x, y, time)
- struct frame *f;
- Lisp_Object *x, *y;
- unsigned long time;
+make_lispy_position (struct frame *f, Lisp_Object *x, Lisp_Object *y,
+ unsigned long time)
{
Lisp_Object window;
enum window_part part;
in order to build drag events when the button is released. */
static Lisp_Object
-make_lispy_event (event)
- struct input_event *event;
+make_lispy_event (struct input_event *event)
{
int i;
#if defined(HAVE_MOUSE) || defined(HAVE_GPM)
static Lisp_Object
-make_lispy_movement (frame, bar_window, part, x, y, time)
- FRAME_PTR frame;
- Lisp_Object bar_window;
- enum scroll_bar_part part;
- Lisp_Object x, y;
- unsigned long time;
+make_lispy_movement (FRAME_PTR frame, Lisp_Object bar_window, enum scroll_bar_part part,
+ Lisp_Object x, Lisp_Object y, unsigned long time)
{
/* Is it a scroll bar movement? */
if (frame && ! NILP (bar_window))
/* Construct a switch frame event. */
static Lisp_Object
-make_lispy_switch_frame (frame)
- Lisp_Object frame;
+make_lispy_switch_frame (Lisp_Object frame)
{
return Fcons (Qswitch_frame, Fcons (frame, Qnil));
}
This doesn't use any caches. */
static int
-parse_modifiers_uncached (symbol, modifier_end)
- Lisp_Object symbol;
- int *modifier_end;
+parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
{
Lisp_Object name;
int i;
prepended to the string BASE[0..BASE_LEN-1].
This doesn't use any caches. */
static Lisp_Object
-apply_modifiers_uncached (modifiers, base, base_len, base_len_byte)
- int modifiers;
- char *base;
- int base_len, base_len_byte;
+apply_modifiers_uncached (int modifiers, char *base, int base_len, int base_len_byte)
{
/* Since BASE could contain nulls, we can't use intern here; we have
to use Fintern, which expects a genuine Lisp_String, and keeps a
new_name = make_uninit_multibyte_string (mod_len + base_len,
mod_len + base_len_byte);
- bcopy (new_mods, SDATA (new_name), mod_len);
- bcopy (base, SDATA (new_name) + mod_len, base_len_byte);
+ memcpy (SDATA (new_name), new_mods, mod_len);
+ memcpy (SDATA (new_name) + mod_len, base, base_len_byte);
return Fintern (new_name, Qnil);
}
/* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
static Lisp_Object
-lispy_modifier_list (modifiers)
- int modifiers;
+lispy_modifier_list (int modifiers)
{
Lisp_Object modifier_list;
int i;
#define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
Lisp_Object
-parse_modifiers (symbol)
- Lisp_Object symbol;
+parse_modifiers (Lisp_Object symbol)
{
Lisp_Object elements;
DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers,
Sevent_symbol_parse_modifiers, 1, 1, 0,
doc: /* Parse the event symbol. For internal use. */)
- (symbol)
- Lisp_Object symbol;
+ (Lisp_Object symbol)
{
/* Fill the cache if needed. */
parse_modifiers (symbol);
apply_modifiers copies the value of BASE's Qevent_kind property to
the modified symbol. */
static Lisp_Object
-apply_modifiers (modifiers, base)
- int modifiers;
- Lisp_Object base;
+apply_modifiers (int modifiers, Lisp_Object base)
{
Lisp_Object cache, index, entry, new_symbol;
and M-C-foo end up being equivalent in the keymap. */
Lisp_Object
-reorder_modifiers (symbol)
- Lisp_Object symbol;
+reorder_modifiers (Lisp_Object symbol)
{
/* It's hopefully okay to write the code this way, since everything
will soon be in caches, and no consing will be done at all. */
in the symbol's name. */
static Lisp_Object
-modify_event_symbol (symbol_num, modifiers, symbol_kind, name_alist_or_stem,
- name_table, symbol_table, table_size)
- int symbol_num;
- unsigned modifiers;
- Lisp_Object symbol_kind;
- Lisp_Object name_alist_or_stem;
- char **name_table;
- Lisp_Object *symbol_table;
- unsigned int table_size;
+modify_event_symbol (int symbol_num, unsigned int modifiers, Lisp_Object symbol_kind,
+ Lisp_Object name_alist_or_stem, char **name_table,
+ Lisp_Object *symbol_table, unsigned int table_size)
{
Lisp_Object value;
Lisp_Object symbol_int;
drag, down, double or triple). The base must be last.
The return value is an event type (a character or symbol) which
has the same base event type and all the specified modifiers. */)
- (event_desc)
- Lisp_Object event_desc;
+ (Lisp_Object event_desc)
{
Lisp_Object base;
int modifiers = 0;
but it can be a Lucid-style event type list. */
int
-lucid_event_type_list_p (object)
- Lisp_Object object;
+lucid_event_type_list_p (Lisp_Object object)
{
Lisp_Object tail;
movements and toolkit scroll bar thumb drags. */
static void
-get_input_pending (addr, flags)
- int *addr;
- int flags;
+get_input_pending (int *addr, int flags)
{
/* First of all, have we already counted some input? */
*addr = (!NILP (Vquit_flag) || readable_events (flags));
/* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
void
-gobble_input (expected)
- int expected;
+gobble_input (int expected)
{
#ifdef HAVE_DBUS
/* Read D-Bus messages. */
so that read_key_sequence will notice the new current buffer. */
void
-record_asynch_buffer_change ()
+record_asynch_buffer_change (void)
{
struct input_event event;
Lisp_Object tem;
this is a bad time to try to read input. */
static int
-read_avail_input (expected)
- int expected;
+read_avail_input (int expected)
{
int nread = 0;
int err = 0;
int n_to_read, i;
struct tty_display_info *tty = terminal->display_info.tty;
int nread = 0;
+ int buffer_free = KBD_BUFFER_SIZE - kbd_buffer_nr_stored () - 1;
+
+ if (kbd_on_hold_p () || buffer_free <= 0)
+ return 0;
if (!terminal->name) /* Don't read from a dead terminal. */
return 0;
#endif
#endif
+ /* Don't read more than we can store. */
+ if (n_to_read > buffer_free)
+ n_to_read = buffer_free;
+
/* Now read; for one reason or another, this will not block.
NREAD is set to the number of chars read. */
do
}
\f
void
-handle_async_input ()
+handle_async_input (void)
{
interrupt_input_pending = 0;
#ifdef SYNC_INPUT
}
void
-process_pending_signals ()
+process_pending_signals (void)
{
if (interrupt_input_pending)
handle_async_input ();
/* Note SIGIO has been undef'd if FIONREAD is missing. */
static SIGTYPE
-input_available_signal (signo)
- int signo;
+input_available_signal (int signo)
{
/* Must preserve main program's value of errno. */
int old_errno = errno;
dealing with, without assuming that every file which uses
UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
void
-reinvoke_input_signal ()
+reinvoke_input_signal (void)
{
#ifdef SIGIO
handle_async_input ();
static struct user_signal_info *user_signals = NULL;
void
-add_user_signal (sig, name)
- int sig;
- const char *name;
+add_user_signal (int sig, const char *name)
{
struct user_signal_info *p;
}
static SIGTYPE
-handle_user_signal (sig)
- int sig;
+handle_user_signal (int sig)
{
int old_errno = errno;
struct user_signal_info *p;
}
static char *
-find_user_signal_name (sig)
- int sig;
+find_user_signal_name (int sig)
{
struct user_signal_info *p;
}
static int
-store_user_signal_events ()
+store_user_signal_events (void)
{
struct user_signal_info *p;
struct input_event buf;
if (nstored == 0)
{
- bzero (&buf, sizeof buf);
+ memset (&buf, 0, sizeof buf);
buf.kind = USER_SIGNAL_EVENT;
buf.frame_or_window = selected_frame;
}
}
\f
-static void menu_bar_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object, void*));
+static void menu_bar_item (Lisp_Object, Lisp_Object, Lisp_Object, void*);
static Lisp_Object menu_bar_one_keymap_changed_items;
/* These variables hold the vector under construction within
OLD is an old vector we can optionally reuse, or nil. */
Lisp_Object
-menu_bar_items (old)
- Lisp_Object old;
+menu_bar_items (Lisp_Object old)
{
/* The number of keymaps we're scanning right now, and the number of
keymaps we have allocated space for. */
nmaps = 0;
if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
maps[nmaps++] = tem;
- bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+ memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
if (end > i + 4)
- bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
- &XVECTOR (menu_bar_items_vector)->contents[i],
- (end - i - 4) * sizeof (Lisp_Object));
+ memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
+ &XVECTOR (menu_bar_items_vector)->contents[i + 4],
+ (end - i - 4) * sizeof (Lisp_Object));
XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
Lisp_Object item_properties;
static void
-menu_bar_item (key, item, dummy1, dummy2)
- Lisp_Object key, item, dummy1;
- void *dummy2;
+menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dummy2)
{
struct gcpro gcpro1;
int i;
if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
{
if (menu_bar_items_index > i + 4)
- bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
- &XVECTOR (menu_bar_items_vector)->contents[i],
- (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
+ memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
+ &XVECTOR (menu_bar_items_vector)->contents[i + 4],
+ (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
menu_bar_items_index -= 4;
}
}
\f
/* This is used as the handler when calling menu_item_eval_property. */
static Lisp_Object
-menu_item_eval_property_1 (arg)
- Lisp_Object arg;
+menu_item_eval_property_1 (Lisp_Object arg)
{
/* If we got a quit from within the menu computation,
quit all the way out of it. This takes care of C-] in the debugger. */
/* Evaluate an expression and return the result (or nil if something
went wrong). Used to evaluate dynamic parts of menu items. */
Lisp_Object
-menu_item_eval_property (sexpr)
- Lisp_Object sexpr;
+menu_item_eval_property (Lisp_Object sexpr)
{
int count = SPECPDL_INDEX ();
Lisp_Object val;
otherwise. */
int
-parse_menu_item (item, inmenubar)
- Lisp_Object item;
- int inmenubar;
+parse_menu_item (Lisp_Object item, int inmenubar)
{
Lisp_Object def, tem, item_string, start;
Lisp_Object filter;
/* Function prototypes. */
-static void init_tool_bar_items P_ ((Lisp_Object));
-static void process_tool_bar_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object, void*));
-static int parse_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
-static void append_tool_bar_item P_ ((void));
+static void init_tool_bar_items (Lisp_Object);
+static void process_tool_bar_item (Lisp_Object, Lisp_Object, Lisp_Object, void*);
+static int parse_tool_bar_item (Lisp_Object, Lisp_Object);
+static void append_tool_bar_item (void);
/* Return a vector of tool bar items for keymaps currently in effect.
tool bar items found. */
Lisp_Object
-tool_bar_items (reuse, nitems)
- Lisp_Object reuse;
- int *nitems;
+tool_bar_items (Lisp_Object reuse, int *nitems)
{
Lisp_Object *maps;
int nmaps, i;
nmaps = 0;
if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
maps[nmaps++] = tem;
- bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+ memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
/* Process the definition of KEY which is DEF. */
static void
-process_tool_bar_item (key, def, data, args)
- Lisp_Object key, def, data;
- void *args;
+process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void *args)
{
int i;
extern Lisp_Object Qundefined;
if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
{
if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
- bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
- ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
- * sizeof (Lisp_Object)));
+ memmove (v, v + TOOL_BAR_ITEM_NSLOTS,
+ ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
+ * sizeof (Lisp_Object)));
ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
break;
}
A text label to show with the tool bar button if labels are enabled. */
static int
-parse_tool_bar_item (key, item)
- Lisp_Object key, item;
+parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
{
/* Access slot with index IDX of vector tool_bar_item_properties. */
#define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
EMACS_INT max_lbl = 2*tool_bar_max_label_size;
Lisp_Object new_lbl;
- if (strlen (caption) < max_lbl && caption[0] != '\0')
+ if (strlen (caption) < max_lbl && caption[0] != '\0')
{
strcpy (buf, caption);
while (buf[0] != '\0' && buf[strlen (buf) -1] == '.')
if (strlen (caption) <= max_lbl)
label = caption;
- if (strlen (label) <= max_lbl && label[0] != '\0')
+ if (strlen (label) <= max_lbl && label[0] != '\0')
{
int i;
if (label != buf) strcpy (buf, label);
- for (i = 0; i < strlen (buf); ++i)
+ for (i = 0; i < strlen (buf); ++i)
{
if (buf[i] == '-') buf[i] = ' ';
}
label = buf;
-
+
}
else label = "";
that can be reused. */
static void
-init_tool_bar_items (reuse)
- Lisp_Object reuse;
+init_tool_bar_items (Lisp_Object reuse)
{
if (VECTORP (reuse))
tool_bar_items_vector = reuse;
tool_bar_item_properties */
static void
-append_tool_bar_item ()
+append_tool_bar_item (void)
{
Lisp_Object *to, *from;
tool_bar_items_vector. */
to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
from = XVECTOR (tool_bar_item_properties)->contents;
- bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
+ memcpy (to, from, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
}
and do auto-saving in the inner call of read_char. */
static Lisp_Object
-read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
- int nmaps;
- Lisp_Object *maps;
- Lisp_Object prev_event;
- int *used_mouse_menu;
+read_char_x_menu_prompt (int nmaps, Lisp_Object *maps, Lisp_Object prev_event,
+ int *used_mouse_menu)
{
int mapno;
static int read_char_minibuf_menu_width;
static Lisp_Object
-read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
- int commandflag ;
- int nmaps;
- Lisp_Object *maps;
+read_char_minibuf_menu_prompt (int commandflag, int nmaps, Lisp_Object *maps)
{
int mapno;
register Lisp_Object name;
thiswidth = SCHARS (desc);
if (thiswidth + i > width)
thiswidth = width - i;
- bcopy (SDATA (desc), menu + i, thiswidth);
+ memcpy (menu + i, SDATA (desc), thiswidth);
i += thiswidth;
strcpy (menu + i, " = ");
i += 3;
thiswidth = SCHARS (s);
if (thiswidth + i > width)
thiswidth = width - i;
- bcopy (SDATA (s), menu + i, thiswidth);
+ memcpy (menu + i, SDATA (s), thiswidth);
i += thiswidth;
menu[i] = 0;
}
NEXT may be the same array as CURRENT. */
static int
-follow_key (key, nmaps, current, defs, next)
- Lisp_Object key;
- Lisp_Object *current, *defs, *next;
- int nmaps;
+follow_key (Lisp_Object key, int nmaps, Lisp_Object *current, Lisp_Object *defs,
+ Lisp_Object *next)
{
int i, first_binding;
that it is indeed a vector). */
static Lisp_Object
-access_keymap_keyremap (map, key, prompt, do_funcall)
- Lisp_Object map, key, prompt;
- int do_funcall;
+access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
+ int do_funcall)
{
Lisp_Object next;
The return value is non-zero if the remapping actually took place. */
static int
-keyremap_step (keybuf, bufsize, fkey, input, doit, diff, prompt)
- Lisp_Object *keybuf, prompt;
- keyremap *fkey;
- int input, doit, *diff, bufsize;
+keyremap_step (Lisp_Object *keybuf, int 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 (keybuf, bufsize, prompt, dont_downcase_last,
- can_return_switch_frame, fix_current_buffer)
- Lisp_Object *keybuf;
- int bufsize;
- Lisp_Object prompt;
- int dont_downcase_last;
- int can_return_switch_frame;
- int fix_current_buffer;
+read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
+ int dont_downcase_last, int can_return_switch_frame,
+ int fix_current_buffer)
{
volatile Lisp_Object from_string;
volatile int count = SPECPDL_INDEX ();
if (!NILP (orig_keymap))
submaps[nmaps++] = orig_keymap;
- bcopy (maps, (void *) (submaps + nmaps),
- nminor * sizeof (submaps[0]));
+ memcpy (submaps + nmaps, maps, nminor * sizeof (submaps[0]));
nmaps += nminor;
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. */)
- (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
- command_loop)
- Lisp_Object prompt, continue_echo, dont_downcase_last;
- Lisp_Object can_return_switch_frame, command_loop;
+ (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object command_loop)
{
Lisp_Object keybuf[30];
register int i;
specbind (Qinput_method_use_echo_area,
(NILP (command_loop) ? Qt : Qnil));
- bzero (keybuf, sizeof keybuf);
+ memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
gcpro1.nvars = (sizeof keybuf/sizeof (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. */)
- (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
- command_loop)
- Lisp_Object prompt, continue_echo, dont_downcase_last;
- Lisp_Object can_return_switch_frame, command_loop;
+ (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object command_loop)
{
Lisp_Object keybuf[30];
register int i;
specbind (Qinput_method_use_echo_area,
(NILP (command_loop) ? Qt : Qnil));
- bzero (keybuf, sizeof keybuf);
+ memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
when reading the arguments; if it is nil, (this-command-keys) is used.
The argument SPECIAL, if non-nil, means that this command is executing
a special event, so ignore the prefix argument and don't clear it. */)
- (cmd, record_flag, keys, special)
- Lisp_Object cmd, record_flag, keys, special;
+ (Lisp_Object cmd, Lisp_Object record_flag, Lisp_Object keys, Lisp_Object special)
{
register Lisp_Object final;
register Lisp_Object tem;
Noninteractively, the argument PREFIXARG is the prefix argument to
give to the command you invoke, if it asks for an argument. */)
- (prefixarg)
- Lisp_Object prefixarg;
+ (Lisp_Object prefixarg)
{
Lisp_Object function;
char buf[40];
/* Return nonzero if input events are pending. */
int
-detect_input_pending ()
+detect_input_pending (void)
{
if (!input_pending)
get_input_pending (&input_pending, 0);
pending. */
int
-detect_input_pending_ignore_squeezables ()
+detect_input_pending_ignore_squeezables (void)
{
if (!input_pending)
get_input_pending (&input_pending, READABLE_EVENTS_IGNORE_SQUEEZABLES);
/* Return nonzero if input events are pending, and run any pending timers. */
int
-detect_input_pending_run_timers (do_display)
- int do_display;
+detect_input_pending_run_timers (int do_display)
{
int old_timers_run = timers_run;
So calling this function unnecessarily can't do any harm. */
void
-clear_input_pending ()
+clear_input_pending (void)
{
input_pending = 0;
}
to do in that case. It isn't trivial. */
int
-requeued_events_pending_p ()
+requeued_events_pending_p (void)
{
return (!NILP (Vunread_command_events) || unread_command_char != -1);
}
doc: /* Return t if command input is currently available with no wait.
Actually, the value is nil only if we can be sure that no input is available;
if there is a doubt, the value is t. */)
- ()
+ (void)
{
if (!NILP (Vunread_command_events) || unread_command_char != -1
|| !NILP (Vunread_post_input_method_events)
DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
doc: /* Return vector of last 300 events, not counting those from keyboard macros. */)
- ()
+ (void)
{
Lisp_Object *keys = XVECTOR (recent_keys)->contents;
Lisp_Object val;
else
{
val = Fvector (NUM_RECENT_KEYS, keys);
- bcopy (keys + recent_keys_index,
- XVECTOR (val)->contents,
- (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
- bcopy (keys,
- XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
- recent_keys_index * sizeof (Lisp_Object));
+ memcpy (XVECTOR (val)->contents, keys + recent_keys_index,
+ (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
+ memcpy (XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
+ keys, recent_keys_index * sizeof (Lisp_Object));
return val;
}
}
The value is a string or a vector.
See also `this-command-keys-vector'. */)
- ()
+ (void)
{
return make_event_array (this_command_key_count,
XVECTOR (this_command_keys)->contents);
the last key sequence that has been read.
See also `this-command-keys'. */)
- ()
+ (void)
{
return Fvector (this_command_key_count,
XVECTOR (this_command_keys)->contents);
Unlike `this-command-keys', this function's value
does not include prefix arguments.
The value is always a vector. */)
- ()
+ (void)
{
return Fvector (this_command_key_count
- this_single_command_key_start,
Unlike `this-single-command-keys', this function's value
shows the events before all translations (except for input methods).
The value is always a vector. */)
- ()
+ (void)
{
return Fvector (raw_keybuf_count,
(XVECTOR (raw_keybuf)->contents));
To achieve this, `universal-argument-other-key' calls
`reset-this-command-lengths', which discards the record of reading
these events the first time. */)
- ()
+ (void)
{
this_command_key_count = before_command_key_count;
if (this_command_key_count < this_single_command_key_start)
doc: /* Clear out the vector that `this-command-keys' returns.
Also clear the record of the last 100 events, unless optional arg
KEEP-RECORD is non-nil. */)
- (keep_record)
- Lisp_Object keep_record;
+ (Lisp_Object keep_record)
{
int i;
DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
doc: /* Return the current depth in recursive edits. */)
- ()
+ (void)
{
Lisp_Object temp;
XSETFASTINT (temp, command_loop_level + minibuf_level);
"FOpen dribble file: ",
doc: /* Start writing all keyboard characters to a dribble file called FILE.
If FILE is nil, close any open dribble file. */)
- (file)
- Lisp_Object file;
+ (Lisp_Object file)
{
if (dribble)
{
DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
doc: /* Discard the contents of the terminal input buffer.
Also end any kbd macro being defined. */)
- ()
+ (void)
{
if (!NILP (current_kboard->defining_kbd_macro))
{
Some operating systems cannot stop the Emacs process and resume it later.
On such systems, Emacs starts a subshell instead of suspending. */)
- (stuffstring)
- Lisp_Object stuffstring;
+ (Lisp_Object stuffstring)
{
int count = SPECPDL_INDEX ();
int old_height, old_width;
reset_all_sys_modes ();
/* sys_suspend can get an error if it tries to fork a subshell
and the system resources aren't available for that. */
- record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_all_sys_modes,
+ record_unwind_protect ((Lisp_Object (*) (Lisp_Object)) init_all_sys_modes,
Qnil);
stuff_buffered_input (stuffstring);
if (cannot_suspend)
Then in any case stuff anything Emacs has read ahead and not used. */
void
-stuff_buffered_input (stuffstring)
- Lisp_Object stuffstring;
+stuff_buffered_input (Lisp_Object stuffstring)
{
#ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
register unsigned char *p;
}
\f
void
-set_waiting_for_input (time_to_clear)
- EMACS_TIME *time_to_clear;
+set_waiting_for_input (struct timeval *time_to_clear)
{
input_available_clear_time = time_to_clear;
}
void
-clear_waiting_for_input ()
+clear_waiting_for_input (void)
{
/* Tell handle_interrupt not to throw back to read_char, */
waiting_for_input = 0;
Otherwise, the handler kills Emacs. */
static SIGTYPE
-interrupt_signal (signalnum) /* If we don't have an argument, */
- int signalnum; /* some compilers complain in signal calls. */
+interrupt_signal (int signalnum) /* If we don't have an argument, some */
+ /* compilers complain in signal calls. */
{
/* Must preserve main program's value of errno. */
int old_errno = errno;
non-nil, it stops the job right away. */
static void
-handle_interrupt ()
+handle_interrupt (void)
{
char c;
/* Handle a C-g by making read_char return C-g. */
void
-quit_throw_to_read_char ()
+quit_throw_to_read_char (void)
{
sigfree ();
/* Prevent another signal from doing this before we finish. */
otherwise Emacs uses CBREAK mode.
See also `current-input-mode'. */)
- (interrupt)
- Lisp_Object interrupt;
+ (Lisp_Object interrupt)
{
int new_interrupt_input;
#ifdef SIGIO
Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
See also `current-input-mode'. */)
- (flow, terminal)
- Lisp_Object flow, terminal;
+ (Lisp_Object flow, Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
struct tty_display_info *tty;
the currently selected frame.
See also `current-input-mode'. */)
- (meta, terminal)
- Lisp_Object meta, terminal;
+ (Lisp_Object meta, Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
struct tty_display_info *tty;
process.
See also `current-input-mode'. */)
- (quit)
- Lisp_Object quit;
+ (Lisp_Object quit)
{
struct terminal *t = get_named_tty ("/dev/tty");
struct tty_display_info *tty;
Otherwise, accept 8-bit input and don't use the top bit for Meta.
Optional fourth arg QUIT if non-nil specifies character to use for quitting.
See also `current-input-mode'. */)
- (interrupt, flow, meta, quit)
- Lisp_Object interrupt, flow, meta, quit;
+ (Lisp_Object interrupt, Lisp_Object flow, Lisp_Object meta, Lisp_Object quit)
{
Fset_input_interrupt_mode (interrupt);
Fset_output_flow_control (flow, Qnil);
QUIT is the character Emacs currently uses to quit.
The elements of this list correspond to the arguments of
`set-input-mode'. */)
- ()
+ (void)
{
Lisp_Object val[4];
struct frame *sf = XFRAME (selected_frame);
(WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
IMAGE (DX . DY) (WIDTH . HEIGHT))
The `posn-' functions access elements of such lists. */)
- (x, y, frame_or_window, whole)
- Lisp_Object x, y, frame_or_window, whole;
+ (Lisp_Object x, Lisp_Object y, Lisp_Object frame_or_window, Lisp_Object whole)
{
CHECK_NATNUM (x);
CHECK_NATNUM (y);
(WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
IMAGE (DX . DY) (WIDTH . HEIGHT))
The `posn-' functions access elements of such lists. */)
- (pos, window)
- Lisp_Object pos, window;
+ (Lisp_Object pos, Lisp_Object window)
{
Lisp_Object tem;
* Set up a new kboard object with reasonable initial values.
*/
void
-init_kboard (kb)
- KBOARD *kb;
+init_kboard (KBOARD *kb)
{
kb->Voverriding_terminal_local_map = Qnil;
kb->Vlast_command = Qnil;
* it a second time.
*/
static void
-wipe_kboard (kb)
- KBOARD *kb;
+wipe_kboard (KBOARD *kb)
{
xfree (kb->kbd_macro_buffer);
}
/* Free KB and memory referenced from it. */
void
-delete_kboard (kb)
- KBOARD *kb;
+delete_kboard (KBOARD *kb)
{
KBOARD **kbp;
}
void
-init_keyboard ()
+init_keyboard (void)
{
/* This is correct before outermost invocation of the editor loop */
command_loop_level = -1;
};
void
-syms_of_keyboard ()
+syms_of_keyboard (void)
{
pending_funcalls = Qnil;
staticpro (&pending_funcalls);
}
void
-keys_of_keyboard ()
+keys_of_keyboard (void)
{
initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
/* Mark the pointers in the kboard objects.
Called by the Fgarbage_collector. */
void
-mark_kboards ()
+mark_kboards (void)
{
KBOARD *kb;
Lisp_Object *p;
HCoop / bpt / emacs.git / blobdiff