2012-10-10 Paul Eggert <eggert@cs.ucla.edu>
+ keyboard.c, keymap.c: Use bool for booleans.
+ * dispnew.c (sit_for): Distinguish between 3-way display_option
+ and boolean do_display.
+ * keyboard.c (single_kboard, this_command_key_count_reset)
+ (waiting_for_input, echoing, immediate_quit, input_pending)
+ (interrupt_input, interrupts_deferred, pop_kboard)
+ (temporarily_switch_to_single_kboard, ignore_mouse_drag_p)
+ (command_loop_1, adjust_point_for_property)
+ (safe_run_hooks_error, input_polling_used, read_char):
+ (help_char_p, readable_events, kbd_buffer_events_waiting)
+ (kbd_buffer_get_event, timer_check_2, make_lispy_event)
+ (lucid_event_type_list_p, get_input_pending):
+ (gobble_input, menu_separator_name_p, menu_bar_item)
+ (parse_menu_item, parse_tool_bar_item, read_char_x_menu_prompt)
+ (read_char_minibuf_menu_prompt, access_keymap_keyremap)
+ (keyremap_step, test_undefined, read_key_sequence)
+ (detect_input_pending, detect_input_pending_ignore_squeezables)
+ (detect_input_pending_run_timers, requeued_events_pending_p)
+ (quit_throw_to_read_char, Fset_input_interrupt_mode):
+ * keymap.c (get_keymap, keymap_parent, keymap_memberp)
+ (access_keymap_1, access_keymap, map_keymap, get_keyelt)
+ (Fdefine_key, Flookup_key, struct accessible_keymaps_data)
+ (accessible_keymaps_1, Fkey_description, push_key_description):
+ (shadow_lookup, struct where_is_internal_data)
+ (where_is_internal, Fwhere_is_internal, where_is_internal_1)
+ (Fdescribe_buffer_bindings, describe_map_tree, struct describe_map_elt)
+ (describe_map, describe_vector):
+ * menu.c (single_menu_item):
+ * nsmenu.m (ns_update_menubar):
+ * process.c (wait_reading_process_output):
+ * search.c (scan_buffer, scan_newline):
+ Use bool for boolean.
+ * keyboard.c (timers_run, swallow_events)
+ (detect_input_pending_run_timers):
+ * process.c (wait_reading_process_output):
+ Use unsigned for counter where wraparound-on-overflow is desired,
+ since unsigned is guaranteed to have that behavior and signed is not.
+ (read_char): Use ptrdiff_t for string length.
+ (get_input_pending): Remove first argument, since it was always
+ the same pointer-to-int (now pointer-to-boolean) &input_pending,
+ and behave as if it had that value. Return new value of
+ input_pending. All callers changed.
+ * keyboard.h (struct kboard): Use unsigned : 1 for boolean member
+ immediate_echo. Use ptrdiff_t for echo_after_prompt, since it's
+ a string length.
+ * keymap.c (push_key_description): Omit last arg, which was always 1.
+ All callers changed.
+
* regex.c (immediate_quit) [emacs]: Remove duplicate decl.
2012-10-10 Juanma Barranquero <lekktu@gmail.com>
TIMEOUT is number of seconds to wait (float or integer),
or t to wait forever.
READING is true if reading input.
- If DO_DISPLAY is >0 display process output while waiting.
- If DO_DISPLAY is >1 perform an initial redisplay before waiting.
+ If DISPLAY_OPTION is >0 display process output while waiting.
+ If DISPLAY_OPTION is >1 perform an initial redisplay before waiting.
*/
Lisp_Object
-sit_for (Lisp_Object timeout, bool reading, int do_display)
+sit_for (Lisp_Object timeout, bool reading, int display_option)
{
intmax_t sec;
int nsec;
+ bool do_display = display_option > 0;
swallow_events (do_display);
|| !NILP (Vexecuting_kbd_macro))
return Qnil;
- if (do_display >= 2)
+ if (display_option > 1)
redisplay_preserve_echo_area (2);
if (INTEGERP (timeout))
KBOARD *current_kboard;
KBOARD *all_kboards;
-/* Nonzero in the single-kboard state, 0 in the any-kboard state. */
-static int single_kboard;
+/* True in the single-kboard state, false in the any-kboard state. */
+static bool single_kboard;
/* Non-nil disable property on a command means
do not execute it; call disabled-command-function's value instead. */
Lisp_Object this_command_keys;
ptrdiff_t this_command_key_count;
-/* 1 after calling Freset_this_command_lengths.
- Usually it is 0. */
-static int this_command_key_count_reset;
+/* True after calling Freset_this_command_lengths.
+ Usually it is false. */
+static bool this_command_key_count_reset;
/* This vector is used as a buffer to record the events that were actually read
by read_key_sequence. */
static sys_jmp_buf getcjmp;
/* True while doing kbd input. */
-int waiting_for_input;
+bool waiting_for_input;
/* True while displaying for echoing. Delays C-g throwing. */
-static int echoing;
+static bool echoing;
/* Non-null means we can start echoing at the next input pause even
though there is something in the echo area. */
Lisp_Object echo_message_buffer;
-/* Nonzero means C-g should cause immediate error-signal. */
-int immediate_quit;
+/* True means C-g should cause immediate error-signal. */
+bool immediate_quit;
/* Character that causes a quit. Normally C-g.
static FILE *dribble;
/* Nonzero if input is available. */
-int input_pending;
+bool input_pending;
/* Circular buffer for pre-read keyboard input. */
static Lisp_Object Qpolling_period;
/* Incremented whenever a timer is run. */
-int timers_run;
+unsigned timers_run;
/* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
happens. */
EMACS_TIME *input_available_clear_time;
-/* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
- Default is 1 if INTERRUPT_INPUT is defined. */
-int interrupt_input;
+/* True means use SIGIO interrupts; false means use CBREAK mode.
+ Default is true if INTERRUPT_INPUT is defined. */
+bool interrupt_input;
/* Nonzero while interrupts are temporarily deferred during redisplay. */
-int interrupts_deferred;
+bool interrupts_deferred;
/* 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. */
/* Function for init_keyboard to call with no args (if nonzero). */
static void (*keyboard_init_hook) (void);
-static void get_input_pending (int *, int);
-static int readable_events (int);
+static bool get_input_pending (int);
+static bool readable_events (int);
static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
- Lisp_Object, int *);
+ Lisp_Object, bool *);
static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
Lisp_Object *);
static Lisp_Object make_lispy_event (struct input_event *);
Lisp_Object, const char *const *,
Lisp_Object *, ptrdiff_t);
static Lisp_Object make_lispy_switch_frame (Lisp_Object);
-static int help_char_p (Lisp_Object);
+static bool help_char_p (Lisp_Object);
static void save_getcjmp (sys_jmp_buf);
static void restore_getcjmp (sys_jmp_buf);
static Lisp_Object apply_modifiers (int, Lisp_Object);
static void deliver_input_available_signal (int signo);
#endif
static void handle_interrupt (bool);
-static _Noreturn void quit_throw_to_read_char (int);
+static _Noreturn void quit_throw_to_read_char (bool);
static void process_special_events (void);
static void timer_start_idle (void);
static void timer_stop_idle (void);
if (INTEGERP (c))
{
- ptr = push_key_description (XINT (c), ptr, 1);
+ ptr = push_key_description (XINT (c), ptr);
}
else if (SYMBOLP (c))
{
{
struct terminal *t;
struct kboard_stack *p = kboard_stack;
- int found = 0;
+ bool found = 0;
for (t = terminal_list; t; t = t->next_terminal)
{
if (t->kboard == p->kboard)
void
temporarily_switch_to_single_kboard (struct frame *f)
{
- int was_locked = single_kboard;
+ bool was_locked = single_kboard;
if (was_locked)
{
if (f != NULL && FRAME_KBOARD (f) != current_kboard)
Vprint_length = old_length;
Vquit_flag = Qnil;
-
Vinhibit_quit = Qnil;
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- if (command_loop_level == 0 && minibuf_level == 0)
- any_kboard_state ();
-#endif
return make_number (0);
}
while (1)
{
internal_catch (Qtop_level, top_level_1, Qnil);
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- /* Reset single_kboard in case top-level set it while
- evaluating an -f option, or we are stuck there for some
- other reason. */
- any_kboard_state ();
-#endif
internal_catch (Qtop_level, command_loop_2, Qnil);
executing_kbd_macro = Qnil;
if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW))
{
redisplay_preserve_echo_area (6);
- get_input_pending (&input_pending,
- READABLE_EVENTS_DO_TIMERS_NOW);
+ get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
}
}
return Qnil;
#if !defined HAVE_WINDOW_SYSTEM || defined USE_GTK || defined HAVE_NS
static
#endif
-int ignore_mouse_drag_p;
+bool ignore_mouse_drag_p;
static FRAME_PTR
some_mouse_moved (void)
sans error-handling encapsulation. */
static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
- int, int, int);
+ bool, bool, bool);
void safe_run_hooks (Lisp_Object);
-static void adjust_point_for_property (ptrdiff_t, int);
+static void adjust_point_for_property (ptrdiff_t, bool);
/* Cancel hourglass from protect_unwind.
ARG is not used. */
int i;
EMACS_INT prev_modiff = 0;
struct buffer *prev_buffer = NULL;
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- int was_locked = single_kboard;
-#endif
- int already_adjusted = 0;
+ bool already_adjusted = 0;
kset_prefix_arg (current_kboard, Qnil);
kset_last_prefix_arg (current_kboard, Qnil);
if (!NILP (KVAR (current_kboard, defining_kbd_macro))
&& NILP (KVAR (current_kboard, Vprefix_arg)))
finalize_kbd_macro_chars ();
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- if (!was_locked)
- any_kboard_state ();
-#endif
}
}
LAST_PT is the last position of point. */
static void
-adjust_point_for_property (ptrdiff_t last_pt, int modified)
+adjust_point_for_property (ptrdiff_t last_pt, bool modified)
{
ptrdiff_t beg, end;
Lisp_Object val, overlay, tmp;
suppress the point adjustment for automatic composition so that a
user can keep inserting another character at point or keep
deleting characters around point. */
- int check_composition = ! modified, check_display = 1, check_invisible = 1;
+ bool check_composition = ! modified, check_display = 1, check_invisible = 1;
ptrdiff_t orig_pt = PT;
/* FIXME: cycling is probably not necessary because these properties
check_display = 0;
if (check_invisible && PT > BEGV && PT < ZV)
{
- int inv, ellipsis = 0;
+ int inv;
+ bool ellipsis = 0;
beg = end = PT;
/* Find boundaries `beg' and `end' of the invisible area, if any. */
if (SYMBOLP (hook))
{
Lisp_Object val;
- int found = 0;
+ bool found = 0;
Lisp_Object newval = Qnil;
for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
if (EQ (fun, XCAR (val)))
#endif
}
-/* Nonzero if we are using polling to handle input asynchronously. */
+/* True if we are using polling to handle input asynchronously. */
-int
+bool
input_polling_used (void)
{
#ifdef POLL_FOR_INPUT
\f
/* Input of single characters from keyboard */
-static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu,
+static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
EMACS_TIME *end_time);
static void record_char (Lisp_Object c);
not to run input methods, but in other respects to act as if
not reading a key sequence.
- If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
- if we used a mouse menu to read the input, or zero otherwise. If
- USED_MOUSE_MENU is null, we don't dereference it.
+ If USED_MOUSE_MENU is non-null, then set *USED_MOUSE_MENU to true
+ if we used a mouse menu to read the input, or false otherwise. If
+ USED_MOUSE_MENU is null, don't dereference it.
Value is -2 when we find input on another keyboard. A second call
to read_char will read it.
Lisp_Object
read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
Lisp_Object prev_event,
- int *used_mouse_menu, EMACS_TIME *end_time)
+ bool *used_mouse_menu, EMACS_TIME *end_time)
{
Lisp_Object c;
ptrdiff_t jmpcount;
Lisp_Object tem, save;
volatile Lisp_Object previous_echo_area_message;
volatile Lisp_Object also_record;
- volatile int reread;
+ volatile bool reread;
struct gcpro gcpro1, gcpro2;
- int volatile polling_stopped_here = 0;
+ bool volatile polling_stopped_here = 0;
struct kboard *orig_kboard = current_kboard;
also_record = Qnil;
if (CONSP (Vunread_command_events))
{
- int was_disabled = 0;
+ bool was_disabled = 0;
c = XCAR (Vunread_command_events);
Vunread_command_events = XCDR (Vunread_command_events);
/* if redisplay was requested */
if (commandflag >= 0)
{
- int echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
+ bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
/* If there is pending input, process any events which are not
user-visible, such as X selection_request events. */
if (!NILP (tem))
{
struct buffer *prev_buffer = current_buffer;
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- int was_locked = single_kboard;
- ptrdiff_t count = SPECPDL_INDEX ();
- record_single_kboard_state ();
-#endif
-
last_input_event = c;
Fcommand_execute (tem, Qnil, Fvector (1, &last_input_event), Qt);
example banishing the mouse under mouse-avoidance-mode. */
timer_resume_idle ();
-#if 0 /* This shouldn't be necessary anymore. --lorentey */
- /* Resume allowing input from any kboard, if that was true before. */
- if (!was_locked)
- any_kboard_state ();
- unbind_to (count, Qnil);
-#endif
-
if (current_buffer != prev_buffer)
{
/* The command may have changed the keymaps. Pretend there
{
Lisp_Object keys;
ptrdiff_t key_count;
- int key_count_reset;
+ bool key_count_reset;
struct gcpro gcpro1;
ptrdiff_t count = SPECPDL_INDEX ();
/* Save the echo status. */
- int saved_immediate_echo = current_kboard->immediate_echo;
+ bool saved_immediate_echo = current_kboard->immediate_echo;
struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
- int saved_echo_after_prompt = current_kboard->echo_after_prompt;
+ ptrdiff_t saved_echo_after_prompt = current_kboard->echo_after_prompt;
#if 0
if (before_command_restore_flag)
num_input_events++;
}
-/* Return 1 if should recognize C as "the help character". */
+/* Return true if should recognize C as "the help character". */
-static int
+static bool
help_char_p (Lisp_Object c)
{
Lisp_Object tail;
/* 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
+static bool
readable_events (int flags)
{
if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
}
-/* Return non-zero if there are any real events waiting in the event
+/* Return true if there are any real events waiting in the event
buffer, not counting `NO_EVENT's.
- 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. */
+ Discard NO_EVENT events at the front of the input queue, possibly
+ leaving the input queue empty if there are no real input events. */
-int
-kbd_buffer_events_waiting (int discard)
+bool
+kbd_buffer_events_waiting (void)
{
struct input_event *sp;
sp = kbd_buffer;
}
- if (discard)
- kbd_fetch_ptr = sp;
-
+ kbd_fetch_ptr = sp;
return sp != kbd_store_ptr && sp->kind != NO_EVENT;
}
static Lisp_Object
kbd_buffer_get_event (KBOARD **kbp,
- int *used_mouse_menu,
+ bool *used_mouse_menu,
EMACS_TIME *end_time)
{
Lisp_Object obj;
are ripe, and return, without reading any user-visible events. */
void
-swallow_events (int do_display)
+swallow_events (bool do_display)
{
- int old_timers_run;
+ unsigned old_timers_run;
process_special_events ();
old_timers_run = timers_run;
- get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+ get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
if (timers_run != old_timers_run && do_display)
redisplay_preserve_echo_area (7);
EMACS_TIME difference;
EMACS_TIME timer_difference = invalid_emacs_time ();
EMACS_TIME idle_timer_difference = invalid_emacs_time ();
- int ripe, timer_ripe = 0, idle_timer_ripe = 0;
+ bool ripe, timer_ripe = 0, idle_timer_ripe = 0;
/* Set TIMER and TIMER_DIFFERENCE
based on the next ordinary timer.
#endif
{
int button = event->code;
- int is_double;
+ bool is_double;
Lisp_Object position;
Lisp_Object *start_pos_ptr;
Lisp_Object start_pos;
struct frame *fr;
int fuzz;
int symbol_num;
- int is_double;
+ bool is_double;
if (WINDOWP (event->frame_or_window))
fr = XFRAME (XWINDOW (event->frame_or_window)->frame);
return 0;
}
-/* Return 1 if EVENT is a list whose elements are all integers or symbols.
+/* Return true if EVENT is a list whose elements are all integers or symbols.
Such a list is not valid as an event,
but it can be a Lucid-style event type list. */
-int
+bool
lucid_event_type_list_p (Lisp_Object object)
{
Lisp_Object tail;
return NILP (tail);
}
\f
-/* Store into *addr a value nonzero if terminal input chars are available.
- Serves the purpose of ioctl (0, FIONREAD, addr)
+/* Return true if terminal input chars are available.
+ Also, store the return value into INPUT_PENDING.
+
+ Serves the purpose of ioctl (0, FIONREAD, ...)
but works even if FIONREAD does not exist.
(In fact, this may actually read some input.)
If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
movements and toolkit scroll bar thumb drags. */
-static void
-get_input_pending (int *addr, int flags)
+static bool
+get_input_pending (int flags)
{
/* First of all, have we already counted some input? */
- *addr = (!NILP (Vquit_flag) || readable_events (flags));
+ input_pending = (!NILP (Vquit_flag) || readable_events (flags));
/* If input is being read as it arrives, and we have none, there is none. */
- if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
- return;
+ if (!input_pending && (!interrupt_input || interrupts_deferred))
+ {
+ /* Try to read some input and see how much we get. */
+ gobble_input ();
+ input_pending = (!NILP (Vquit_flag) || readable_events (flags));
+ }
- /* Try to read some input and see how much we get. */
- gobble_input ();
- *addr = (!NILP (Vquit_flag) || readable_events (flags));
+ return input_pending;
}
/* Put a BUFFER_SWITCH_EVENT in the buffer
gobble_input (void)
{
int nread = 0;
- int err = 0;
+ bool err = 0;
struct terminal *t;
/* Store pending user signal events, if any. */
0,
};
-/* Return non-zero if LABEL specifies a separator. */
+/* Return true if LABEL specifies a separator. */
-int
+bool
menu_separator_name_p (const char *label)
{
if (!label)
{
struct gcpro gcpro1;
int i;
+ bool parsed;
Lisp_Object tem;
if (EQ (item, Qundefined))
parse_menu_item, so that if it turns out it wasn't a menu item,
it still correctly hides any further menu item. */
GCPRO1 (key);
- i = parse_menu_item (item, 1);
+ parsed = parse_menu_item (item, 1);
UNGCPRO;
- if (!i)
+ if (!parsed)
return;
item = AREF (item_properties, ITEM_PROPERTY_DEF);
parse_menu_item returns true if the item is a menu item and false
otherwise. */
-int
+bool
parse_menu_item (Lisp_Object item, int inmenubar)
{
Lisp_Object def, tem, item_string, start;
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 bool parse_tool_bar_item (Lisp_Object, Lisp_Object);
static void append_tool_bar_item (void);
/* Parse a tool bar item specification ITEM for key KEY and return the
- result in tool_bar_item_properties. Value is zero if ITEM is
+ result in tool_bar_item_properties. Value is false if ITEM is
invalid.
ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
A text label to show with the tool bar button if labels are enabled. */
-static int
+static bool
parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
{
Lisp_Object filter = Qnil;
Lisp_Object caption;
- int i, have_label = 0;
+ int i;
+ bool have_label = 0;
/* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
Rule out items that aren't lists, don't start with
PREV_EVENT is the previous input event, or nil if we are reading
the first event of a key sequence.
- If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
- if we used a mouse menu to read the input, or zero otherwise. If
- USED_MOUSE_MENU is null, we don't dereference it.
+ If USED_MOUSE_MENU is non-null, set *USED_MOUSE_MENU to true
+ if we used a mouse menu to read the input, or false otherwise. If
+ USED_MOUSE_MENU is null, don't dereference it.
The prompting is done based on the prompt-string of the map
and the strings associated with various map elements.
static Lisp_Object
read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
- Lisp_Object prev_event, int *used_mouse_menu)
+ Lisp_Object prev_event, bool *used_mouse_menu)
{
#ifdef HAVE_MENUS
ptrdiff_t mapno;
/* FIXME: Use the minibuffer's frame width. */
ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
ptrdiff_t idx = -1;
- int nobindings = 1;
+ bool nobindings = 1;
Lisp_Object rest, vector;
char *menu;
/* Present the documented bindings, a line at a time. */
while (1)
{
- int notfirst = 0;
+ bool notfirst = 0;
ptrdiff_t i = nlength;
Lisp_Object obj;
Lisp_Object orig_defn_macro;
/* Ignore the element if it has no prompt string. */
if (INTEGERP (event) && parse_menu_item (elt, -1))
{
- /* 1 if the char to type matches the string. */
- int char_matches;
+ /* True if the char to type matches the string. */
+ bool char_matches;
Lisp_Object upcased_event, downcased_event;
Lisp_Object desc = Qnil;
Lisp_Object s
i += 2;
}
notfirst = 1;
- nobindings = 0 ;
+ nobindings = 0;
/* If the char to type doesn't match the string's
first char, explicitly show what char to type. */
/* Lookup KEY in MAP.
MAP is a keymap mapping keys to key vectors or functions.
- If the mapping is a function and DO_FUNCTION is non-zero, then
+ If the mapping is a function and DO_FUNCALL is true,
the function is called with PROMPT as parameter and its return
value is used as the return value of this function (after checking
that it is indeed a vector). */
static Lisp_Object
access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
- int do_funcall)
+ bool do_funcall)
{
Lisp_Object next;
BUFSIZE is its maximum size.
FKEY is a pointer to the keyremap structure to use.
INPUT is the index of the last element in KEYBUF.
- DOIT if non-zero says that the remapping can actually take place.
+ DOIT if true says that the remapping can actually take place.
DIFF is used to return the number of keys added/removed by the remapping.
PARENT is the root of the keymap.
PROMPT is the prompt to use if the remapping happens through a function.
- The return value is non-zero if the remapping actually took place. */
+ Return true if the remapping actually took place. */
-static int
+static bool
keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
- int input, int doit, int *diff, Lisp_Object prompt)
+ int input, bool doit, int *diff, Lisp_Object prompt)
{
Lisp_Object next, key;
return 0;
}
-static int
+static bool
test_undefined (Lisp_Object binding)
{
return (EQ (binding, Qundefined)
off the switch-frame event until later; the next call to
read_char will return it.
- If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
+ If FIX_CURRENT_BUFFER, we restore current_buffer
from the selected window's buffer. */
static int
read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
- int dont_downcase_last, int can_return_switch_frame,
- int fix_current_buffer)
+ bool dont_downcase_last, bool can_return_switch_frame,
+ bool fix_current_buffer)
{
Lisp_Object from_string;
ptrdiff_t count = SPECPDL_INDEX ();
key sequence. */
Lisp_Object orig_keymap;
- /* 1 if we have already considered switching to the local-map property
+ /* Positive if we have already considered switching to the local-map property
of the place where a mouse click occurred. */
int localized_local_map = 0;
/* Likewise, for key_translation_map and input-decode-map. */
keyremap keytran, indec;
- /* Non-zero if we are trying to map a key by changing an upper-case
+ /* True if we are trying to map a key by changing an upper-case
letter to lower case, or a shifted function key to an unshifted
one. */
- int shift_translated = 0;
+ bool shift_translated = 0;
/* If we receive a `switch-frame' or `select-window' event in the middle of
a key sequence, we put it off for later.
int original_uppercase_position = -1;
/* Gets around Microsoft compiler limitations. */
- int dummyflag = 0;
+ bool dummyflag = 0;
struct buffer *starting_buffer;
: (/* indec.start < t || fkey.start < t || */ keytran.start < t))
{
Lisp_Object key;
- int used_mouse_menu = 0;
+ bool used_mouse_menu = 0;
/* Where the last real key started. If we need to throw away a
key that has expanded into more than one element of keybuf
return. Any better way to fix this? -- cyd */
|| (interrupted_kboard != current_kboard))
{
- int found = 0;
+ bool found = 0;
struct kboard *k;
for (k = all_kboards; k; k = k->next_kboard)
while (indec.end < t)
{
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
- int done, diff;
+ bool done;
+ int diff;
GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
done = keyremap_step (keybuf, bufsize, &indec, max (t, mock_input),
while (fkey.end < indec.start)
{
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
- int done, diff;
+ bool done;
+ int diff;
GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
done = keyremap_step (keybuf, bufsize, &fkey,
while (keytran.end < fkey.start)
{
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
- int done, diff;
+ bool done;
+ int diff;
GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
done = keyremap_step (keybuf, bufsize, &keytran, max (t, mock_input),
\f
-/* Return nonzero if input events are pending. */
+/* Return true if input events are pending. */
-int
+bool
detect_input_pending (void)
{
- if (!input_pending)
- get_input_pending (&input_pending, 0);
-
- return input_pending;
+ return input_pending || get_input_pending (0);
}
-/* Return nonzero if input events other than mouse movements are
+/* Return true if input events other than mouse movements are
pending. */
-int
+bool
detect_input_pending_ignore_squeezables (void)
{
- if (!input_pending)
- get_input_pending (&input_pending, READABLE_EVENTS_IGNORE_SQUEEZABLES);
-
- return input_pending;
+ return input_pending || get_input_pending (READABLE_EVENTS_IGNORE_SQUEEZABLES);
}
-/* Return nonzero if input events are pending, and run any pending timers. */
+/* Return true if input events are pending, and run any pending timers. */
-int
-detect_input_pending_run_timers (int do_display)
+bool
+detect_input_pending_run_timers (bool do_display)
{
- int old_timers_run = timers_run;
+ unsigned old_timers_run = timers_run;
if (!input_pending)
- get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+ get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
if (old_timers_run != timers_run && do_display)
{
input_pending = 0;
}
-/* Return nonzero if there are pending requeued events.
+/* Return true if there are pending requeued events.
This isn't used yet. The hope is to make wait_reading_process_output
call it, and return if it runs Lisp code that unreads something.
The problem is, kbd_buffer_get_event needs to be fixed to know what
to do in that case. It isn't trivial. */
-int
+bool
requeued_events_pending_p (void)
{
return (!NILP (Vunread_command_events));
/* Process non-user-visible events (Bug#10195). */
process_special_events ();
- get_input_pending (&input_pending,
- READABLE_EVENTS_DO_TIMERS_NOW
- | READABLE_EVENTS_FILTER_EVENTS);
- return input_pending > 0 ? Qt : Qnil;
+ return (get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW
+ | READABLE_EVENTS_FILTER_EVENTS)
+ ? Qt : Qnil);
}
DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
/* Handle a C-g by making read_char return C-g. */
static void
-quit_throw_to_read_char (int from_signal)
+quit_throw_to_read_char (bool from_signal)
{
/* When not called from a signal handler it is safe to call
Lisp. */
See also `current-input-mode'. */)
(Lisp_Object interrupt)
{
- int new_interrupt_input;
+ bool new_interrupt_input;
#ifdef USABLE_SIGIO
#ifdef HAVE_X_WINDOWS
if (x_display_list != NULL)
reading from this KBOARD again until more input arrives. */
char kbd_queue_has_data;
- /* Nonzero means echo each character as typed. */
- char immediate_echo;
+ /* True means echo each character as typed. */
+ unsigned immediate_echo : 1;
/* If we have echoed a prompt string specified by the user,
this is its length in characters. Otherwise this is -1. */
- char echo_after_prompt;
+ ptrdiff_t echo_after_prompt;
};
KEYBOARD_INLINE void
extern Lisp_Object Qmode_line, Qvertical_line, Qheader_line;
/* True while doing kbd input. */
-extern int waiting_for_input;
+extern bool waiting_for_input;
/* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
happens. */
extern EMACS_TIME *input_available_clear_time;
#if defined HAVE_WINDOW_SYSTEM && !defined USE_GTK && !defined HAVE_NS
-extern int ignore_mouse_drag_p;
+extern bool ignore_mouse_drag_p;
#endif
/* The primary selection. */
extern Lisp_Object parse_modifiers (Lisp_Object);
extern Lisp_Object reorder_modifiers (Lisp_Object);
extern Lisp_Object read_char (int, ptrdiff_t, Lisp_Object *, Lisp_Object,
- int *, EMACS_TIME *);
+ bool *, EMACS_TIME *);
extern int parse_solitary_modifier (Lisp_Object symbol);
extern int quit_char;
-extern int timers_run;
+extern unsigned int timers_run;
-extern int menu_separator_name_p (const char *);
-extern int parse_menu_item (Lisp_Object, int);
+extern bool menu_separator_name_p (const char *);
+extern bool parse_menu_item (Lisp_Object, int);
extern void init_kboard (KBOARD *);
extern void delete_kboard (KBOARD *);
extern void stop_polling (void);
extern void set_poll_suppress_count (int);
extern int gobble_input (void);
-extern int input_polling_used (void);
+extern bool input_polling_used (void);
extern void clear_input_pending (void);
-extern int requeued_events_pending_p (void);
+extern bool requeued_events_pending_p (void);
extern void bind_polling_period (int);
extern int make_ctrl_char (int) ATTRIBUTE_CONST;
extern void stuff_buffered_input (Lisp_Object);
extern void clear_waiting_for_input (void);
-extern void swallow_events (int);
-extern int lucid_event_type_list_p (Lisp_Object);
+extern void swallow_events (bool);
+extern bool lucid_event_type_list_p (Lisp_Object);
extern void kbd_buffer_store_event (struct input_event *);
extern void kbd_buffer_store_event_hold (struct input_event *,
struct input_event *);
Lisp_Object, ptrdiff_t);
extern void kbd_buffer_store_help_event (Lisp_Object, Lisp_Object);
extern Lisp_Object menu_item_eval_property (Lisp_Object);
-extern int kbd_buffer_events_waiting (int);
+extern bool kbd_buffer_events_waiting (void);
extern void add_user_signal (int, const char *);
extern int tty_read_avail_input (struct terminal *, struct input_event *);
static void describe_translation (Lisp_Object, Lisp_Object);
static void describe_map (Lisp_Object, Lisp_Object,
void (*) (Lisp_Object, Lisp_Object),
- int, Lisp_Object, Lisp_Object*, int, int);
+ bool, Lisp_Object, Lisp_Object*, bool, bool);
static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
- void (*) (Lisp_Object, Lisp_Object), int,
- Lisp_Object, Lisp_Object, int, int);
+ void (*) (Lisp_Object, Lisp_Object), bool,
+ Lisp_Object, Lisp_Object, bool, bool);
static void silly_event_symbol_error (Lisp_Object);
-static Lisp_Object get_keyelt (Lisp_Object, int);
+static Lisp_Object get_keyelt (Lisp_Object, bool);
\f
/* Keymap object support - constructors and predicates. */
/* Check that OBJECT is a keymap (after dereferencing through any
symbols). If it is, return it.
- If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
+ If AUTOLOAD and if OBJECT is a symbol whose function value
is an autoload form, do the autoload and try again.
- If AUTOLOAD is nonzero, callers must assume GC is possible.
-
- If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
- is zero as well), return Qt.
+ If AUTOLOAD, callers must assume GC is possible.
ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
- If ERROR_IF_NOT_KEYMAP is non-zero, signal an error; otherwise,
+ If ERROR_IF_NOT_KEYMAP, signal an error; otherwise,
just return Qnil.
Note that most of the time, we don't want to pursue autoloads.
but it seems to me that only read_key_sequence, Flookup_key, and
Fdefine_key should cause keymaps to be autoloaded.
- This function can GC when AUTOLOAD is non-zero, because it calls
+ This function can GC when AUTOLOAD is true, because it calls
Fautoload_do_load which can GC. */
Lisp_Object
-get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
+get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
{
Lisp_Object tem;
We assume that KEYMAP is a valid keymap. */
static Lisp_Object
-keymap_parent (Lisp_Object keymap, int autoload)
+keymap_parent (Lisp_Object keymap, bool autoload)
{
Lisp_Object list;
}
/* Check whether MAP is one of MAPS parents. */
-static int
+static bool
keymap_memberp (Lisp_Object map, Lisp_Object maps)
{
if (NILP (map)) return 0;
MAP must be a keymap or a list of keymaps.
- If T_OK is non-zero, bindings for Qt are treated as default
+ If T_OK, bindings for Qt are treated as default
bindings; any key left unmentioned by other tables and bindings is
given the binding of Qt.
- If T_OK is zero, bindings for Qt are not treated specially.
+ If not T_OK, bindings for Qt are not treated specially.
If NOINHERIT, don't accept a subkeymap found in an inherited keymap.
- Returns Qunbound if no binding was found (and returns Qnil if a nil
+ Return Qunbound if no binding was found (and return Qnil if a nil
binding was found). */
static Lisp_Object
-access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
+access_keymap_1 (Lisp_Object map, Lisp_Object idx,
+ bool t_ok, bool noinherit, bool autoload)
{
/* If idx is a list (some sort of mouse click, perhaps?),
the index we want to use is the car of the list, which
Lisp_Object
access_keymap (Lisp_Object map, Lisp_Object idx,
- int t_ok, int noinherit, int autoload)
+ bool t_ok, bool noinherit, bool autoload)
{
Lisp_Object val = access_keymap_1 (map, idx, t_ok, noinherit, autoload);
return EQ (val, Qunbound) ? Qnil : val;
}
/* Same as map_keymap_internal, but traverses parent keymaps as well.
- A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
+ AUTOLOAD indicates that autoloaded keymaps should be loaded. */
void
-map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
+map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args,
+ void *data, bool autoload)
{
struct gcpro gcpro1;
GCPRO1 (args);
Also if OBJECT has a menu string as the first element,
remove that. Also remove a menu help string as second element.
- If AUTOLOAD is nonzero, load autoloadable keymaps
+ If AUTOLOAD, load autoloadable keymaps
that are referred to with indirection.
This can GC because menu_item_eval_property calls Feval. */
static Lisp_Object
-get_keyelt (Lisp_Object object, int autoload)
+get_keyelt (Lisp_Object object, bool autoload)
{
while (1)
{
binding KEY to DEF is added at the front of KEYMAP. */)
(Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
{
- register ptrdiff_t idx;
- register Lisp_Object c;
- register Lisp_Object cmd;
- int metized = 0;
+ ptrdiff_t idx;
+ Lisp_Object c;
+ Lisp_Object cmd;
+ bool metized = 0;
int meta_bit;
ptrdiff_t length;
struct gcpro gcpro1, gcpro2, gcpro3;
recognize the default bindings, just as `read-key-sequence' does. */)
(Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
{
- register ptrdiff_t idx;
- register Lisp_Object cmd;
- register Lisp_Object c;
+ ptrdiff_t idx;
+ Lisp_Object cmd;
+ Lisp_Object c;
ptrdiff_t length;
- int t_ok = !NILP (accept_default);
+ bool t_ok = !NILP (accept_default);
struct gcpro gcpro1, gcpro2;
GCPRO2 (keymap, key);
struct accessible_keymaps_data {
Lisp_Object maps, tail, thisseq;
/* Does the current sequence end in the meta-prefix-char? */
- int is_metized;
+ bool is_metized;
};
static void
Lisp_Object maps = d->maps;
Lisp_Object tail = d->tail;
Lisp_Object thisseq = d->thisseq;
- int is_metized = d->is_metized && INTEGERP (key);
+ bool is_metized = d->is_metized && INTEGERP (key);
Lisp_Object tem;
cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
Lisp_Object sep = build_string (" ");
Lisp_Object key;
Lisp_Object result;
- int add_meta = 0;
+ bool add_meta = 0;
USE_SAFE_ALLOCA;
if (!NILP (prefix))
char *
-push_key_description (EMACS_INT ch, char *p, int force_multibyte)
+push_key_description (EMACS_INT ch, char *p)
{
- int c, c2, tab_as_ci;
+ int c, c2;
+ bool tab_as_ci;
/* Clear all the meaningless bits above the meta bit. */
c = ch & (meta_modifier | ~ - meta_modifier);
*p++ = 'P';
*p++ = 'C';
}
- else if (c < 128
- || (NILP (BVAR (current_buffer, enable_multibyte_characters))
- && SINGLE_BYTE_CHAR_P (c)
- && !force_multibyte))
- {
- *p++ = c;
- }
+ else if (c < 128)
+ *p++ = c;
else
{
/* Now we are sure that C is a valid character code. */
- if (NILP (BVAR (current_buffer, enable_multibyte_characters))
- && ! force_multibyte)
- *p++ = multibyte_char_to_unibyte (c);
- else
- p += CHAR_STRING (c, (unsigned char *) p);
+ p += CHAR_STRING (c, (unsigned char *) p);
}
return p;
if (INTEGERP (key)) /* Normal character. */
{
- char tem[KEY_DESCRIPTION_SIZE], *p;
-
- p = push_key_description (XINT (key), tem, 1);
+ char tem[KEY_DESCRIPTION_SIZE];
+ char *p = push_key_description (XINT (key), tem);
*p = 0;
return make_specified_string (tem, -1, p - tem, 1);
}
static Lisp_Object
shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
- int remap)
+ bool remap)
{
Lisp_Object tail, value;
struct where_is_internal_data {
Lisp_Object definition, this, last;
- int last_is_meta, noindirect;
+ bool last_is_meta, noindirect;
Lisp_Object sequences;
};
static Lisp_Object
where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
- int noindirect, int nomenus)
+ bool noindirect, bool nomenus)
{
Lisp_Object maps = Qnil;
Lisp_Object found;
[M-CHAR] sequences, check if last character of the sequence
is the meta-prefix char. */
Lisp_Object last;
- int last_is_meta;
+ bool last_is_meta;
this = Fcar (XCAR (maps));
map = Fcdr (XCAR (maps));
/* Actually relevant bindings. */
Lisp_Object found = Qnil;
/* 1 means ignore all menu bindings entirely. */
- int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
+ bool nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
/* List of sequences found via remapping. Keep them in a separate
variable, so as to push them later, since we prefer
/* Whether or not we're handling remapped sequences. This is needed
because remapping is not done recursively by Fcommand_remapping: you
can't remap a remapped command. */
- int remapped = 0;
+ bool remapped = 0;
Lisp_Object tem = Qnil;
/* Refresh the C version of the modifier preference. */
{
struct where_is_internal_data *d = data; /* Cast! */
Lisp_Object definition = d->definition;
- int noindirect = d->noindirect;
+ bool noindirect = d->noindirect;
Lisp_Object this = d->this;
Lisp_Object last = d->last;
- int last_is_meta = d->last_is_meta;
+ bool last_is_meta = d->last_is_meta;
Lisp_Object sequence;
/* Search through indirections unless that's not wanted. */
(Lisp_Object buffer, Lisp_Object prefix, Lisp_Object menus)
{
Lisp_Object outbuf, shadow;
- int nomenu = NILP (menus);
- register Lisp_Object start1;
+ bool nomenu = NILP (menus);
+ Lisp_Object start1;
struct gcpro gcpro1;
const char *alternate_heading
alternate_heading = 0;
}
- bufend = push_key_description (translate[c], buf, 1);
+ bufend = push_key_description (translate[c], buf);
insert (buf, bufend - buf);
Findent_to (make_number (16), make_number (1));
- bufend = push_key_description (c, buf, 1);
+ bufend = push_key_description (c, buf);
insert (buf, bufend - buf);
insert ("\n", 1);
/* Insert a description of the key bindings in STARTMAP,
followed by those of all maps reachable through STARTMAP.
- If PARTIAL is nonzero, omit certain "uninteresting" commands
+ If PARTIAL, omit certain "uninteresting" commands
(such as `undefined').
If SHADOW is non-nil, it is a list of maps;
don't mention keys which would be shadowed by any of them.
PREFIX, if non-nil, says mention only keys that start with PREFIX.
TITLE, if not 0, is a string to insert at the beginning.
TITLE should not end with a colon or a newline; we supply that.
- If NOMENU is not 0, then omit menu-bar commands.
+ If NOMENU, then omit menu-bar commands.
- If TRANSL is nonzero, the definitions are actually key translations
+ If TRANSL, the definitions are actually key translations
so print strings and vectors differently.
- If ALWAYS_TITLE is nonzero, print the title even if there are no maps
+ If ALWAYS_TITLE, print the title even if there are no maps
to look through.
- If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
+ If MENTION_SHADOW, then when something is shadowed by SHADOW,
don't omit it; instead, mention it but say it is shadowed.
Any inserted text ends in two newlines (used by `help-make-xrefs'). */
void
-describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
- Lisp_Object prefix, const char *title, int nomenu, int transl,
- int always_title, int mention_shadow)
+describe_map_tree (Lisp_Object startmap, bool partial, Lisp_Object shadow,
+ Lisp_Object prefix, const char *title, bool nomenu,
+ bool transl, bool always_title, bool mention_shadow)
{
Lisp_Object maps, orig_maps, seen, sub_shadows;
struct gcpro gcpro1, gcpro2, gcpro3;
- int something = 0;
+ bool something = 0;
const char *key_heading
= "\
key binding\n\
into an array of `struct describe_map_elt',
then sorts them by the events. */
-struct describe_map_elt { Lisp_Object event; Lisp_Object definition; int shadowed; };
+struct describe_map_elt
+{
+ Lisp_Object event;
+ Lisp_Object definition;
+ bool shadowed;
+};
/* qsort comparison function for sorting `struct describe_map_elt' by
the event field. */
static void
describe_map (Lisp_Object map, Lisp_Object prefix,
void (*elt_describer) (Lisp_Object, Lisp_Object),
- int partial, Lisp_Object shadow,
- Lisp_Object *seen, int nomenu, int mention_shadow)
+ bool partial, Lisp_Object shadow,
+ Lisp_Object *seen, bool nomenu, bool mention_shadow)
{
Lisp_Object tail, definition, event;
Lisp_Object tem;
Lisp_Object suppress;
Lisp_Object kludge;
- int first = 1;
+ bool first = 1;
struct gcpro gcpro1, gcpro2, gcpro3;
/* These accumulate the values from sparse keymap bindings,
1, mention_shadow);
else if (CONSP (XCAR (tail)))
{
- int this_shadowed = 0;
+ bool this_shadowed = 0;
event = XCAR (XCAR (tail));
of bytes that lead to the character set or portion of a character
set described by this chartable.
- If PARTIAL is nonzero, it means do not mention suppressed commands
+ If PARTIAL, it means do not mention suppressed commands
(that assumes the vector is in a keymap).
SHADOW is a list of keymaps that shadow this map.
static void
describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
void (*elt_describer) (Lisp_Object, Lisp_Object),
- int partial, Lisp_Object shadow, Lisp_Object entire_map,
- int keymap_p, int mention_shadow)
+ bool partial, Lisp_Object shadow, Lisp_Object entire_map,
+ bool keymap_p, bool mention_shadow)
{
Lisp_Object definition;
Lisp_Object tem2;
int i;
Lisp_Object suppress;
Lisp_Object kludge;
- int first = 1;
+ bool first = 1;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
/* Range of elements to be handled. */
int from, to, stop;
for (i = from; ; i++)
{
- int this_shadowed = 0;
+ bool this_shadowed = 0;
int range_beg, range_end;
Lisp_Object val;
extern Lisp_Object Qremap;
extern Lisp_Object Qmenu_item;
extern Lisp_Object current_global_map;
-extern char *push_key_description (EMACS_INT, char *, int);
-extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, int, int, int);
-extern Lisp_Object get_keymap (Lisp_Object, int, int);
-extern void describe_map_tree (Lisp_Object, int, Lisp_Object, Lisp_Object,
- const char *, int, int, int, int);
+extern char *push_key_description (EMACS_INT, char *);
+extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, bool, bool, bool);
+extern Lisp_Object get_keymap (Lisp_Object, bool, bool);
+extern void describe_map_tree (Lisp_Object, bool, Lisp_Object, Lisp_Object,
+ const char *, bool, bool, bool, bool);
extern ptrdiff_t current_minor_maps (Lisp_Object **, Lisp_Object **);
extern void initial_define_key (Lisp_Object, int, const char *);
extern void initial_define_lispy_key (Lisp_Object, const char *, const char *);
typedef void (*map_keymap_function_t)
(Lisp_Object key, Lisp_Object val, Lisp_Object args, void* data);
-extern void map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object largs, void* cargs, int autoload);
+extern void map_keymap (Lisp_Object, map_keymap_function_t, Lisp_Object,
+ void *, bool);
extern void map_keymap_canonical (Lisp_Object map,
map_keymap_function_t fun,
Lisp_Object args, void *data);
extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
ptrdiff_t, ptrdiff_t, Lisp_Object);
extern ptrdiff_t scan_buffer (int, ptrdiff_t, ptrdiff_t, ptrdiff_t,
- ptrdiff_t *, int);
+ ptrdiff_t *, bool);
extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
- EMACS_INT, int);
+ EMACS_INT, bool);
extern ptrdiff_t find_next_newline (ptrdiff_t, int);
extern ptrdiff_t find_next_newline_no_quit (ptrdiff_t, ptrdiff_t);
extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t);
extern Lisp_Object Qup, Qdown, Qbottom;
extern Lisp_Object Qtop;
extern Lisp_Object last_undo_boundary;
-extern int input_pending;
+extern bool input_pending;
extern Lisp_Object menu_bar_items (Lisp_Object);
extern Lisp_Object tool_bar_items (Lisp_Object, int *);
extern void discard_mouse_events (void);
void handle_input_available_signal (int);
#endif
extern Lisp_Object pending_funcalls;
-extern int detect_input_pending (void);
-extern int detect_input_pending_ignore_squeezables (void);
-extern int detect_input_pending_run_timers (int);
+extern bool detect_input_pending (void);
+extern bool detect_input_pending_ignore_squeezables (void);
+extern bool detect_input_pending_run_timers (bool);
extern void safe_run_hooks (Lisp_Object);
extern void cmd_error_internal (Lisp_Object, const char *);
extern Lisp_Object command_loop_1 (void);
extern Lisp_Object QCtype, Qlocal;
extern Lisp_Object Qprocessp;
extern void kill_buffer_processes (Lisp_Object);
-extern int wait_reading_process_output (intmax_t, int, int, int,
+extern int wait_reading_process_output (intmax_t, int, int, bool,
Lisp_Object,
struct Lisp_Process *,
int);
Used during startup to detect startup of dumped Emacs. */
extern bool initialized;
-extern int immediate_quit; /* Nonzero means ^G can quit instantly. */
+/* True means ^G can quit instantly. */
+extern bool immediate_quit;
extern void *xmalloc (size_t);
extern void *xzalloc (size_t);
{
Lisp_Object map, item_string, enabled;
struct gcpro gcpro1, gcpro2;
- int res;
+ bool res;
struct skp *skp = skp_v;
/* Parse the menu item and leave the result in item_properties. */
BOOL needsSet = NO;
const char *submenuTitle = [[submenu title] UTF8String];
extern int waiting_for_input;
- int owfi;
+ bool owfi;
Lisp_Object items;
widget_value *wv, *first_wv, *prev_wv = 0;
int i;
-1 meaning caller will actually read the input, so don't throw to
the quit handler, or
- DO_DISPLAY != 0 means redisplay should be done to show subprocess
+ DO_DISPLAY means redisplay should be done to show subprocess
output that arrives.
If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
int
wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
- int do_display,
+ bool do_display,
Lisp_Object wait_for_cell,
struct Lisp_Process *wait_proc, int just_wait_proc)
{
do
{
- int old_timers_run = timers_run;
+ unsigned old_timers_run = timers_run;
struct buffer *old_buffer = current_buffer;
Lisp_Object old_window = selected_window;
if (read_kbd != 0)
{
- int old_timers_run = timers_run;
+ unsigned old_timers_run = timers_run;
struct buffer *old_buffer = current_buffer;
Lisp_Object old_window = selected_window;
int leave = 0;
see full version for other parameters. We know that wait_proc will
always be NULL, since `subprocesses' isn't defined.
- DO_DISPLAY != 0 means redisplay should be done to show subprocess
+ DO_DISPLAY means redisplay should be done to show subprocess
output that arrives.
Return true if we received input from any process. */
int
wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
- int do_display,
+ bool do_display,
Lisp_Object wait_for_cell,
struct Lisp_Process *wait_proc, int just_wait_proc)
{
do
{
- int old_timers_run = timers_run;
+ unsigned old_timers_run = timers_run;
timer_delay = timer_check ();
if (timers_run != old_timers_run && do_display)
/* We must retry, since a timer may have requeued itself
If we don't find COUNT instances before reaching END, set *SHORTAGE
to the number of TARGETs left unfound, and return END.
- If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
+ If ALLOW_QUIT, set immediate_quit. That's good to do
except when inside redisplay. */
ptrdiff_t
-scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
- ptrdiff_t count, ptrdiff_t *shortage, int allow_quit)
+scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
+ ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
{
struct region_cache *newline_cache;
int direction;
the number of line boundaries left unfound, and position at
the limit we bumped up against.
- If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
+ If ALLOW_QUIT, set immediate_quit. That's good to do
except in special cases. */
EMACS_INT
scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
ptrdiff_t limit, ptrdiff_t limit_byte,
- register EMACS_INT count, int allow_quit)
+ EMACS_INT count, bool allow_quit)
{
int direction = ((count > 0) ? 1 : -1);
- register unsigned char *cursor;
+ unsigned char *cursor;
unsigned char *base;
ptrdiff_t ceiling;
- register unsigned char *ceiling_addr;
+ unsigned char *ceiling_addr;
- int old_immediate_quit = immediate_quit;
+ bool old_immediate_quit = immediate_quit;
/* The code that follows is like scan_buffer
but checks for either newline or carriage return. */
/* Nonzero means use interrupt-driven input. */
-extern int interrupt_input;
+extern bool interrupt_input;
/* Nonzero while interrupts are temporarily deferred during redisplay. */
-extern int interrupts_deferred;
+extern bool interrupts_deferred;
projects / emacs.git / commitdiff