From 9d70a3fc8ee03ee1eb9add17ef6ae04aedce9653 Mon Sep 17 00:00:00 2001 From: Andreas Schwab Date: Mon, 5 Jul 2010 19:16:59 +0200 Subject: [PATCH] Remove obsolete volatile * keyboard.c: Remove duplicate . (read_key_sequence): Remove volatile qualifiers. --- src/ChangeLog | 5 +++++ src/keyboard.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 29 insertions(+), 25 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index ce190e745e0..9ca8ac29dd8 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,8 @@ +2010-07-05 Andreas Schwab + + * keyboard.c: Remove duplicate . + (read_key_sequence): Remove volatile qualifiers. + 2010-07-05 YAMAMOTO Mitsuharu * dispextern.h (FRINGE_HEIGHT_BITS): New define. diff --git a/src/keyboard.c b/src/keyboard.c index 836fc183eac..056e379a44a 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -42,7 +42,6 @@ along with GNU Emacs. If not, see . */ #include "puresize.h" #include "systime.h" #include "atimer.h" -#include #include #ifdef HAVE_GTK_AND_PTHREAD @@ -9182,48 +9181,48 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last, int can_return_switch_frame; int fix_current_buffer; { - volatile Lisp_Object from_string; - volatile int count = SPECPDL_INDEX (); + Lisp_Object from_string; + int count = SPECPDL_INDEX (); /* How many keys there are in the current key sequence. */ - volatile int t; + int t; /* The length of the echo buffer when we started reading, and the length of this_command_keys when we started reading. */ - volatile int echo_start; - volatile int keys_start; + int echo_start; + int keys_start; /* The number of keymaps we're scanning right now, and the number of keymaps we have allocated space for. */ - volatile int nmaps; - volatile int nmaps_allocated = 0; + int nmaps; + int nmaps_allocated = 0; /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in the current keymaps. */ - Lisp_Object *volatile defs = NULL; + Lisp_Object *defs = NULL; /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1] in the current keymaps, or nil where it is not a prefix. */ - Lisp_Object *volatile submaps = NULL; + Lisp_Object *submaps = NULL; /* The local map to start out with at start of key sequence. */ - volatile Lisp_Object orig_local_map; + Lisp_Object orig_local_map; /* The map from the `keymap' property to start out with at start of key sequence. */ - volatile Lisp_Object orig_keymap; + Lisp_Object orig_keymap; /* 1 if we have already considered switching to the local-map property of the place where a mouse click occurred. */ - volatile int localized_local_map = 0; + int localized_local_map = 0; /* The index in submaps[] of the first keymap that has a binding for this key sequence. In other words, the lowest i such that submaps[i] is non-nil. */ - volatile int first_binding; + int first_binding; /* Index of the first key that has no binding. It is useless to try fkey.start larger than that. */ - volatile int first_unbound; + int first_unbound; /* If t < mock_input, then KEYBUF[t] should be read as the next input key. @@ -9238,7 +9237,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last, restart_sequence; the loop will read keys from keybuf up until mock_input, thus rebuilding the state; and then it will resume reading characters from the keyboard. */ - volatile int mock_input = 0; + int mock_input = 0; /* If the sequence is unbound in submaps[], then keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map, @@ -9248,28 +9247,28 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last, should hold off until t reaches them. We do this when we've just recognized a function key, to avoid searching for the function key's again in Vfunction_key_map. */ - volatile keyremap fkey; + keyremap fkey; /* Likewise, for key_translation_map and input-decode-map. */ - volatile keyremap keytran, indec; + keyremap keytran, indec; /* Non-zero 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. */ - volatile int shift_translated = 0; + int 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. While we're reading, we keep the event here. */ - volatile Lisp_Object delayed_switch_frame; + Lisp_Object delayed_switch_frame; /* See the comment below... */ #if defined (GOBBLE_FIRST_EVENT) Lisp_Object first_event; #endif - volatile Lisp_Object original_uppercase; - volatile int original_uppercase_position = -1; + Lisp_Object original_uppercase; + int original_uppercase_position = -1; /* Gets around Microsoft compiler limitations. */ int dummyflag = 0; @@ -9277,7 +9276,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last, struct buffer *starting_buffer; /* List of events for which a fake prefix key has been generated. */ - volatile Lisp_Object fake_prefixed_keys = Qnil; + Lisp_Object fake_prefixed_keys = Qnil; #if defined (GOBBLE_FIRST_EVENT) int junk; @@ -9435,13 +9434,13 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last, (say, a mouse click on the mode line which is being treated as [mode-line (mouse-...)], then we backtrack to this point of keybuf. */ - volatile int last_real_key_start; + int last_real_key_start; /* These variables are analogous to echo_start and keys_start; while those allow us to restart the entire key sequence, echo_local_start and keys_local_start allow us to throw away just one key. */ - volatile int echo_local_start, keys_local_start, local_first_binding; + int echo_local_start, keys_local_start, local_first_binding; eassert (indec.end == t || (indec.end > t && indec.end <= mock_input)); eassert (indec.start <= indec.end); -- 2.39.2