From 9fa1de305acd530060062a1470f3018de7937bb1 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 10 Oct 2012 13:09:47 -0700 Subject: [PATCH] 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. --- src/ChangeLog | 48 ++++++++ src/dispnew.c | 9 +- src/keyboard.c | 312 ++++++++++++++++++++++--------------------------- src/keyboard.h | 28 ++--- src/keymap.c | 159 ++++++++++++------------- src/keymap.h | 13 ++- src/lisp.h | 17 +-- src/menu.c | 2 +- src/nsmenu.m | 2 +- src/process.c | 14 +-- src/search.c | 16 +-- src/termopts.h | 4 +- 12 files changed, 319 insertions(+), 305 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index a05c426a452..daa370105ee 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,5 +1,53 @@ 2012-10-10 Paul Eggert + 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 diff --git a/src/dispnew.c b/src/dispnew.c index fd4985452ae..0956e3f2905 100644 --- a/src/dispnew.c +++ b/src/dispnew.c @@ -5918,15 +5918,16 @@ additional wait period, in milliseconds; this is for backwards compatibility. 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); @@ -5934,7 +5935,7 @@ sit_for (Lisp_Object timeout, bool reading, int do_display) || !NILP (Vexecuting_kbd_macro)) return Qnil; - if (do_display >= 2) + if (display_option > 1) redisplay_preserve_echo_area (2); if (INTEGERP (timeout)) diff --git a/src/keyboard.c b/src/keyboard.c index 61481c5f0f6..d58178b7561 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -86,8 +86,8 @@ KBOARD *initial_kboard; 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. */ @@ -113,9 +113,9 @@ static Lisp_Object recent_keys; 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. */ @@ -140,11 +140,11 @@ static ptrdiff_t before_command_echo_length; 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. */ @@ -163,8 +163,8 @@ struct kboard *echo_kboard; 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. @@ -270,7 +270,7 @@ static Lisp_Object Qhelp_form_show; static FILE *dribble; /* Nonzero if input is available. */ -int input_pending; +bool input_pending; /* Circular buffer for pre-read keyboard input. */ @@ -372,18 +372,18 @@ static ptrdiff_t echo_length (void); 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. */ @@ -411,10 +411,10 @@ static EMACS_TIME timer_last_idleness_start_time; /* 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 *); @@ -428,7 +428,7 @@ static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object, 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); @@ -438,7 +438,7 @@ static Lisp_Object restore_kboard_configuration (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); @@ -516,7 +516,7 @@ echo_char (Lisp_Object c) if (INTEGERP (c)) { - ptr = push_key_description (XINT (c), ptr, 1); + ptr = push_key_description (XINT (c), ptr); } else if (SYMBOLP (c)) { @@ -925,7 +925,7 @@ pop_kboard (void) { 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) @@ -958,7 +958,7 @@ pop_kboard (void) 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) @@ -1057,12 +1057,7 @@ cmd_error (Lisp_Object data) 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); } @@ -1149,12 +1144,6 @@ command_loop (void) 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; @@ -1265,8 +1254,7 @@ tracking_off (Lisp_Object old_value) 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; @@ -1301,7 +1289,7 @@ usage: (track-mouse BODY...) */) #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) @@ -1329,9 +1317,9 @@ 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. */ @@ -1359,10 +1347,7 @@ command_loop_1 (void) 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); @@ -1731,10 +1716,6 @@ command_loop_1 (void) 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 } } @@ -1744,7 +1725,7 @@ command_loop_1 (void) 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; @@ -1752,7 +1733,7 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified) 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 @@ -1791,7 +1772,8 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified) 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. */ @@ -1920,7 +1902,7 @@ safe_run_hooks_error (Lisp_Object error_data) 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))) @@ -2050,9 +2032,9 @@ start_polling (void) #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 @@ -2228,7 +2210,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object, /* 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); @@ -2265,9 +2247,9 @@ do { if (polling_stopped_here) start_polling (); \ 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. @@ -2281,7 +2263,7 @@ do { if (polling_stopped_here) start_polling (); \ 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; @@ -2290,9 +2272,9 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, 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; @@ -2328,7 +2310,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, 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); @@ -2430,7 +2412,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, /* 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. */ @@ -2862,12 +2844,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, 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); @@ -2878,13 +2854,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, 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 @@ -2992,15 +2961,15 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps, { 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) @@ -3201,9 +3170,9 @@ record_menu_key (Lisp_Object c) 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; @@ -3375,7 +3344,7 @@ restore_getcjmp (sys_jmp_buf temp) /* 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) @@ -3714,15 +3683,14 @@ discard_mouse_events (void) } -/* 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; @@ -3734,9 +3702,7 @@ kbd_buffer_events_waiting (int discard) sp = kbd_buffer; } - if (discard) - kbd_fetch_ptr = sp; - + kbd_fetch_ptr = sp; return sp != kbd_store_ptr && sp->kind != NO_EVENT; } @@ -3758,7 +3724,7 @@ clear_event (struct input_event *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; @@ -4203,14 +4169,14 @@ process_special_events (void) 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); @@ -4337,7 +4303,7 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers) 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. @@ -5441,7 +5407,7 @@ make_lispy_event (struct input_event *event) #endif { int button = event->code; - int is_double; + bool is_double; Lisp_Object position; Lisp_Object *start_pos_ptr; Lisp_Object start_pos; @@ -5722,7 +5688,7 @@ make_lispy_event (struct input_event *event) 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); @@ -6664,11 +6630,11 @@ parse_solitary_modifier (Lisp_Object symbol) 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; @@ -6693,8 +6659,10 @@ lucid_event_type_list_p (Lisp_Object object) return NILP (tail); } -/* 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.) @@ -6705,19 +6673,21 @@ lucid_event_type_list_p (Lisp_Object object) 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 @@ -6767,7 +6737,7 @@ int gobble_input (void) { int nread = 0; - int err = 0; + bool err = 0; struct terminal *t; /* Store pending user signal events, if any. */ @@ -7337,9 +7307,9 @@ static const char* separator_names[] = { 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) @@ -7514,6 +7484,7 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm { struct gcpro gcpro1; int i; + bool parsed; Lisp_Object tem; if (EQ (item, Qundefined)) @@ -7545,9 +7516,9 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm 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); @@ -7623,7 +7594,7 @@ menu_item_eval_property (Lisp_Object sexpr) 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; @@ -7923,7 +7894,7 @@ static Lisp_Object QCrtl; 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); @@ -8056,7 +8027,7 @@ set_prop (ptrdiff_t idx, Lisp_Object val) /* 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...)'. @@ -8101,12 +8072,13 @@ set_prop (ptrdiff_t idx, Lisp_Object val) 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 @@ -8363,9 +8335,9 @@ append_tool_bar_item (void) 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. @@ -8378,7 +8350,7 @@ append_tool_bar_item (void) 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; @@ -8472,7 +8444,7 @@ read_char_minibuf_menu_prompt (int commandflag, /* 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; @@ -8520,7 +8492,7 @@ read_char_minibuf_menu_prompt (int commandflag, /* 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; @@ -8576,8 +8548,8 @@ read_char_minibuf_menu_prompt (int commandflag, /* 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 @@ -8629,7 +8601,7 @@ read_char_minibuf_menu_prompt (int commandflag, 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. */ @@ -8763,14 +8735,14 @@ typedef struct keyremap /* 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; @@ -8809,15 +8781,15 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt, 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; @@ -8871,7 +8843,7 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey, return 0; } -static int +static bool test_undefined (Lisp_Object binding) { return (EQ (binding, Qundefined) @@ -8913,13 +8885,13 @@ test_undefined (Lisp_Object binding) 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 (); @@ -8952,7 +8924,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, 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; @@ -8992,10 +8964,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, /* 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. @@ -9011,7 +8983,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, int original_uppercase_position = -1; /* Gets around Microsoft compiler limitations. */ - int dummyflag = 0; + bool dummyflag = 0; struct buffer *starting_buffer; @@ -9173,7 +9145,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, : (/* 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 @@ -9267,7 +9239,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, 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) @@ -9821,7 +9793,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, 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), @@ -9855,7 +9828,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, 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, @@ -9884,7 +9858,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt, 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), @@ -10270,38 +10245,32 @@ a special event, so ignore the prefix argument and don't clear it. */) -/* 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) { @@ -10332,13 +10301,13 @@ clear_input_pending (void) 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)); @@ -10359,10 +10328,9 @@ if there is a doubt, the value is t. */) /* 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, @@ -10868,7 +10836,7 @@ handle_interrupt (bool in_signal_handler) /* 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. */ @@ -10898,7 +10866,7 @@ otherwise Emacs uses CBREAK mode. 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) diff --git a/src/keyboard.h b/src/keyboard.h index d78c27fbf9b..e57c8cc7193 100644 --- a/src/keyboard.h +++ b/src/keyboard.h @@ -169,12 +169,12 @@ struct kboard 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 @@ -463,14 +463,14 @@ extern Lisp_Object Qhelp_echo; 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. */ @@ -482,7 +482,7 @@ struct input_event; 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); @@ -506,10 +506,10 @@ extern Time last_event_timestamp; 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 *); @@ -524,15 +524,15 @@ extern void start_polling (void); 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 *); @@ -544,7 +544,7 @@ extern void gen_help_event (Lisp_Object, Lisp_Object, Lisp_Object, 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 *); diff --git a/src/keymap.c b/src/keymap.c index 6ea142651bf..fbdd31e0de3 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -99,12 +99,12 @@ static void describe_command (Lisp_Object, Lisp_Object); 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); /* Keymap object support - constructors and predicates. */ @@ -207,15 +207,12 @@ when reading a key-sequence to be looked-up in this keymap. */) /* 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. @@ -224,11 +221,11 @@ when reading a key-sequence to be looked-up in this keymap. */) 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; @@ -280,7 +277,7 @@ get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload) 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; @@ -307,7 +304,7 @@ If KEYMAP has no parent, return nil. */) } /* 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; @@ -365,19 +362,20 @@ Return PARENT. PARENT should be nil or another keymap. */) 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 @@ -547,7 +545,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int 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; @@ -630,9 +628,10 @@ map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy) } /* 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); @@ -711,13 +710,13 @@ usage: (map-keymap FUNCTION KEYMAP) */) 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) { @@ -1114,10 +1113,10 @@ binding is altered. If there is no binding for KEY, the new pair 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; @@ -1271,11 +1270,11 @@ third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will 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); @@ -1887,7 +1886,7 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_ 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 @@ -1898,7 +1897,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, 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); @@ -2060,7 +2059,7 @@ The `kbd' macro is an approximate inverse of this. */) 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)) @@ -2155,9 +2154,10 @@ The `kbd' macro is an approximate inverse of this. */) 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); @@ -2256,21 +2256,12 @@ push_key_description (EMACS_INT ch, char *p, int force_multibyte) *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; @@ -2299,9 +2290,8 @@ around function keys and event symbols. */) 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); } @@ -2429,7 +2419,7 @@ static void where_is_internal_1 (Lisp_Object key, Lisp_Object binding, static Lisp_Object shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag, - int remap) + bool remap) { Lisp_Object tail, value; @@ -2461,7 +2451,7 @@ static Lisp_Object Vmouse_events; struct where_is_internal_data { Lisp_Object definition, this, last; - int last_is_meta, noindirect; + bool last_is_meta, noindirect; Lisp_Object sequences; }; @@ -2474,7 +2464,7 @@ struct where_is_internal_data { 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; @@ -2523,7 +2513,7 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps, [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)); @@ -2606,7 +2596,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled: /* 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 @@ -2615,7 +2605,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled: /* 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. */ @@ -2767,10 +2757,10 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi { 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. */ @@ -2821,8 +2811,8 @@ The optional argument MENUS, if non-nil, says to mention menu bindings. (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 @@ -2857,10 +2847,10 @@ You type Translation\n\ 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); @@ -2977,34 +2967,34 @@ You type Translation\n\ /* 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\ @@ -3179,7 +3169,12 @@ describe_translation (Lisp_Object definition, Lisp_Object args) 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. */ @@ -3209,14 +3204,14 @@ describe_map_compare (const void *aa, const void *bb) 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, @@ -3258,7 +3253,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix, 1, mention_shadow); else if (CONSP (XCAR (tail))) { - int this_shadowed = 0; + bool this_shadowed = 0; event = XCAR (XCAR (tail)); @@ -3428,7 +3423,7 @@ DESCRIBER is the output function used; nil means use `princ'. */) 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. @@ -3448,8 +3443,8 @@ DESCRIBER is the output function used; nil means use `princ'. */) 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; @@ -3457,7 +3452,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args, 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; @@ -3497,7 +3492,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args, for (i = from; ; i++) { - int this_shadowed = 0; + bool this_shadowed = 0; int range_beg, range_end; Lisp_Object val; diff --git a/src/keymap.h b/src/keymap.h index 5ed70c67b85..c704ee0b050 100644 --- a/src/keymap.h +++ b/src/keymap.h @@ -34,11 +34,11 @@ extern Lisp_Object Qkeymap, Qmenu_bar; 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 *); @@ -47,7 +47,8 @@ extern void keys_of_keymap (void); 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); diff --git a/src/lisp.h b/src/lisp.h index 71e542cc769..1de9ec74d9f 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -3198,9 +3198,9 @@ extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object); 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); @@ -3243,7 +3243,7 @@ extern Lisp_Object Qdisabled, QCfilter; 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); @@ -3251,9 +3251,9 @@ 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); @@ -3332,7 +3332,7 @@ extern bool running_asynch_code; 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); @@ -3559,7 +3559,8 @@ extern char *emacs_root_dir (void); 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); diff --git a/src/menu.c b/src/menu.c index 835267b2f0c..6e052dc65a9 100644 --- a/src/menu.c +++ b/src/menu.c @@ -331,7 +331,7 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk { 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. */ diff --git a/src/nsmenu.m b/src/nsmenu.m index 9af732c6c45..df8b3ea3e54 100644 --- a/src/nsmenu.m +++ b/src/nsmenu.m @@ -129,7 +129,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu) 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; diff --git a/src/process.c b/src/process.c index c941a196539..2cbce9d28ea 100644 --- a/src/process.c +++ b/src/process.c @@ -4302,7 +4302,7 @@ wait_reading_process_output_1 (void) -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 @@ -4322,7 +4322,7 @@ wait_reading_process_output_1 (void) 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) { @@ -4419,7 +4419,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd, 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; @@ -4753,7 +4753,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd, 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; @@ -6821,14 +6821,14 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *, 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) { @@ -6904,7 +6904,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd, 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 diff --git a/src/search.c b/src/search.c index 7c084c62e28..aacdbe33eef 100644 --- a/src/search.c +++ b/src/search.c @@ -636,12 +636,12 @@ newline_cache_on_off (struct buffer *buf) 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; @@ -837,23 +837,23 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end, 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. */ diff --git a/src/termopts.h b/src/termopts.h index 49588ef0cbd..05fa0a52eee 100644 --- a/src/termopts.h +++ b/src/termopts.h @@ -18,7 +18,7 @@ along with GNU Emacs. If not, see . */ /* 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; -- 2.39.2