Key bound to string does not handle some chars in string correctly

Question

(I ask this question after reading this one.)

---

The form

(global-set-key (kbd "M-e") "e")

is, as far as I can tell, equivalent to

(global-set-key (kbd "M-e") (lambda () (interactive) (insert "e")))

However, after evaluating

(global-set-key (kbd "M-e") "abcdeéfghij")

pressing M-e inserts

abcde   fghij

(3 spaces instead of é). Looking up the keybinding, it appears that M-e is not really bound to (insert ...), but rather to a keyboard macro inserting all these chars... except that the é became a M-i. With a ê it's a linefeed (M-j). With a à it enters some menu (M-backtick), and so on.

But there isn't any problem if I create a macro using the keys for these characters.

---

So, the question is simple: what is going on here?

Answer 1

What is going on is that string in Emacs have historically been used in this context for 2 different purposes:

• sequence of characters.
• sequence of events.

In your case, you're writing what you think as a sequence of characters, but it's used in a context where Emacs expects a sequence of events.

Since Emacs-19 added support for GUIs, events have become a lot more complex, so sequences of events can also be represented as vectors rather than as strings. And this is usually the better option since it avoids this whole issue. IOW I'd recommend you write:

(global-set-key (kbd "M-e") [?a ?b ?c ?d ?e ?é ?f ?g ?h ?i ?j])

or

(global-set-key (kbd "M-e") (kbd "abcdeéfghij"))

or even

(global-set-key [?\M-e] [?a ?b ?c ?d ?e ?é ?f ?g ?h ?i ?j])

Since kbd is a function that turns a "human readable" string representation of events into an actual vector of events.

You could also M-x report-emacs-bug arguing that Emacs should figure out that the é (character code 233 (which is 128 + 105 where 105 is the code of i and 128 is the 7th bit that's used as the meta modifier in some contexts)) is really just a character and not the \M-i event, but it's probably difficult to fix this case without breaking existing code, since a lot of code still (mis)uses strings to represent sequences of events as if GUIs didn't exist.

Answer 2

global-set-key is just a thin wrapper around define-key, ignoring some error checking it is

(defun global-set-key (key def)
   (define-key (current-global-map) key def))

The documentation for define-key says that the "def" can be a number of things, including

a string (treated as a keyboard macro),

So then there is the question about what something like ê is stored as. This typically has a character code of 0xea or 0x80+0x6a. 0x6a is the character code for j. The meta modifier is typically encoded as setting the top bit (0x80), hence ê being the same as M-j, and as a keyboard macro running something like comment-indent-newline.