Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 4959:bd169a24a554

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Ben Wing <ben@xemacs.org>
date Thu, 28 Jan 2010 04:27:30 -0600
parents 304aebb79cd3
children e813cf16c015
comparison
equal deleted inserted replaced
4893:99f2102552d7 4959:bd169a24a554
288 { 288 {
289 /* This function can GC */ 289 /* This function can GC */
290 Lisp_Keymap *keymap = XKEYMAP (obj); 290 Lisp_Keymap *keymap = XKEYMAP (obj);
291 if (print_readably) 291 if (print_readably)
292 printing_unreadable_lcrecord (obj, 0); 292 printing_unreadable_lcrecord (obj, 0);
293 write_c_string (printcharfun, "#<keymap "); 293 write_ascstring (printcharfun, "#<keymap ");
294 if (!NILP (keymap->name)) 294 if (!NILP (keymap->name))
295 { 295 {
296 write_fmt_string_lisp (printcharfun, "%S ", 1, keymap->name); 296 write_fmt_string_lisp (printcharfun, "%S ", 1, keymap->name);
297 } 297 }
298 write_fmt_string (printcharfun, "size %ld 0x%x>", 298 write_fmt_string (printcharfun, "size %ld 0x%x>",
472 */ 472 */
473 /* !!#### I'm not sure how correct this is. */ 473 /* !!#### I'm not sure how correct this is. */
474 Ibyte str [1 + MAX_ICHAR_LEN]; 474 Ibyte str [1 + MAX_ICHAR_LEN];
475 Bytecount count = set_itext_ichar (str, XCHAR (keysym)); 475 Bytecount count = set_itext_ichar (str, XCHAR (keysym));
476 str[count] = 0; 476 str[count] = 0;
477 keysym = intern_int (str); 477 keysym = intern_istring (str);
478 } 478 }
479 return control_meta_superify (keysym, modifiers); 479 return control_meta_superify (keysym, modifiers);
480 } 480 }
481 481
482 482
1958 } 1958 }
1959 1959
1960 if (EQ (keys, new_keys)) 1960 if (EQ (keys, new_keys))
1961 signal_ferror_with_frob (Qinvalid_operation, mpc_binding, 1961 signal_ferror_with_frob (Qinvalid_operation, mpc_binding,
1962 "can't bind %s: %s has a non-keymap binding", 1962 "can't bind %s: %s has a non-keymap binding",
1963 (char *) XSTRING_DATA (Fkey_description (keys)), 1963 (CIbyte *) XSTRING_DATA (Fkey_description (keys)),
1964 (char *) XSTRING_DATA (Fsingle_key_description 1964 (CIbyte *) XSTRING_DATA (Fsingle_key_description
1965 (Vmeta_prefix_char))); 1965 (Vmeta_prefix_char)));
1966 else 1966 else
1967 signal_ferror_with_frob (Qinvalid_operation, mpc_binding, 1967 signal_ferror_with_frob (Qinvalid_operation, mpc_binding,
1968 "can't bind %s: %s %s has a non-keymap binding", 1968 "can't bind %s: %s %s has a non-keymap binding",
1969 (char *) XSTRING_DATA (Fkey_description (keys)), 1969 (CIbyte *) XSTRING_DATA (Fkey_description (keys)),
1970 (char *) XSTRING_DATA (Fkey_description 1970 (CIbyte *) XSTRING_DATA (Fkey_description
1971 (new_keys)), 1971 (new_keys)),
1972 (char *) XSTRING_DATA (Fsingle_key_description 1972 (CIbyte *) XSTRING_DATA (Fsingle_key_description
1973 (Vmeta_prefix_char))); 1973 (Vmeta_prefix_char)));
1974 } 1974 }
1975 1975
1976 DEFUN ("define-key", Fdefine_key, 3, 3, 0, /* 1976 DEFUN ("define-key", Fdefine_key, 3, 3, 0, /*
1977 Define key sequence KEYS, in KEYMAP, as DEF. 1977 Define key sequence KEYS, in KEYMAP, as DEF.
1978 KEYMAP is a keymap object. 1978 KEYMAP is a keymap object.
3495 3495
3496 if (i == 0) 3496 if (i == 0)
3497 string = s2; 3497 string = s2;
3498 else 3498 else
3499 { 3499 {
3500 /* if (NILP (sep)) Lisp_Object sep = build_string (" ") */; 3500 /* if (NILP (sep)) Lisp_Object sep = build_ascstring (" ") */;
3501 string = concat2 (string, concat2 (Vsingle_space_string, s2)); 3501 string = concat2 (string, concat2 (Vsingle_space_string, s2));
3502 } 3502 }
3503 } 3503 }
3504 return string; 3504 return string;
3505 } 3505 }
3653 { 3653 {
3654 p += set_itext_ichar (p, c); 3654 p += set_itext_ichar (p, c);
3655 } 3655 }
3656 3656
3657 *p = 0; 3657 *p = 0;
3658 return build_string ((char *) buf); 3658 return build_istring (buf);
3659 } 3659 }
3660 3660
3661 3661
3662 /************************************************************************/ 3662 /************************************************************************/
3663 /* where-is (mapping bindings to keys) */ 3663 /* where-is (mapping bindings to keys) */
4148 struct gcpro gcpro1; 4148 struct gcpro gcpro1;
4149 GCPRO1 (definition); 4149 GCPRO1 (definition);
4150 4150
4151 Findent_to (make_int (16), make_int (3), buffer); 4151 Findent_to (make_int (16), make_int (3), buffer);
4152 if (keymapp) 4152 if (keymapp)
4153 buffer_insert_c_string (XBUFFER (buffer), "<< "); 4153 buffer_insert_ascstring (XBUFFER (buffer), "<< ");
4154 4154
4155 if (SYMBOLP (definition)) 4155 if (SYMBOLP (definition))
4156 { 4156 {
4157 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (definition)); 4157 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (definition));
4158 } 4158 }
4159 else if (STRINGP (definition) || VECTORP (definition)) 4159 else if (STRINGP (definition) || VECTORP (definition))
4160 { 4160 {
4161 buffer_insert_c_string (XBUFFER (buffer), "Kbd Macro: "); 4161 buffer_insert_ascstring (XBUFFER (buffer), "Kbd Macro: ");
4162 buffer_insert1 (XBUFFER (buffer), Fkey_description (definition)); 4162 buffer_insert1 (XBUFFER (buffer), Fkey_description (definition));
4163 } 4163 }
4164 else if (COMPILED_FUNCTIONP (definition)) 4164 else if (COMPILED_FUNCTIONP (definition))
4165 buffer_insert_c_string (XBUFFER (buffer), "Anonymous Compiled Function"); 4165 buffer_insert_ascstring (XBUFFER (buffer), "Anonymous Compiled Function");
4166 else if (CONSP (definition) && EQ (XCAR (definition), Qlambda)) 4166 else if (CONSP (definition) && EQ (XCAR (definition), Qlambda))
4167 buffer_insert_c_string (XBUFFER (buffer), "Anonymous Lambda"); 4167 buffer_insert_ascstring (XBUFFER (buffer), "Anonymous Lambda");
4168 else if (KEYMAPP (definition)) 4168 else if (KEYMAPP (definition))
4169 { 4169 {
4170 Lisp_Object name = XKEYMAP (definition)->name; 4170 Lisp_Object name = XKEYMAP (definition)->name;
4171 if (STRINGP (name) || (SYMBOLP (name) && !NILP (name))) 4171 if (STRINGP (name) || (SYMBOLP (name) && !NILP (name)))
4172 { 4172 {
4173 buffer_insert_c_string (XBUFFER (buffer), "Prefix command "); 4173 buffer_insert_ascstring (XBUFFER (buffer), "Prefix command ");
4174 if (SYMBOLP (name) 4174 if (SYMBOLP (name)
4175 && EQ (find_symbol_value (name), definition)) 4175 && EQ (find_symbol_value (name), definition))
4176 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (name)); 4176 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (name));
4177 else 4177 else
4178 { 4178 {
4179 buffer_insert1 (XBUFFER (buffer), Fprin1_to_string (name, Qnil)); 4179 buffer_insert1 (XBUFFER (buffer), Fprin1_to_string (name, Qnil));
4180 } 4180 }
4181 } 4181 }
4182 else 4182 else
4183 buffer_insert_c_string (XBUFFER (buffer), "Prefix Command"); 4183 buffer_insert_ascstring (XBUFFER (buffer), "Prefix Command");
4184 } 4184 }
4185 else 4185 else
4186 buffer_insert_c_string (XBUFFER (buffer), "??"); 4186 buffer_insert_ascstring (XBUFFER (buffer), "??");
4187 4187
4188 if (keymapp) 4188 if (keymapp)
4189 buffer_insert_c_string (XBUFFER (buffer), " >>"); 4189 buffer_insert_ascstring (XBUFFER (buffer), " >>");
4190 buffer_insert_c_string (XBUFFER (buffer), "\n"); 4190 buffer_insert_ascstring (XBUFFER (buffer), "\n");
4191 UNGCPRO; 4191 UNGCPRO;
4192 } 4192 }
4193 4193
4194 struct describe_map_closure 4194 struct describe_map_closure
4195 { 4195 {
4468 describe_map_parent_mapper, &describe_map_closure); 4468 describe_map_parent_mapper, &describe_map_closure);
4469 4469
4470 if (!NILP (list)) 4470 if (!NILP (list))
4471 { 4471 {
4472 list = list_sort (list, Qnil, describe_map_sort_predicate); 4472 list = list_sort (list, Qnil, describe_map_sort_predicate);
4473 buffer_insert_c_string (buf, "\n"); 4473 buffer_insert_ascstring (buf, "\n");
4474 while (!NILP (list)) 4474 while (!NILP (list))
4475 { 4475 {
4476 Lisp_Object elt = XCAR (XCAR (list)); 4476 Lisp_Object elt = XCAR (XCAR (list));
4477 Lisp_Object keysym = XCAR (elt); 4477 Lisp_Object keysym = XCAR (elt);
4478 int modifiers = XINT (XCDR (elt)); 4478 int modifiers = XINT (XCDR (elt));
4479 4479
4480 if (!NILP (elt_prefix)) 4480 if (!NILP (elt_prefix))
4481 buffer_insert_lisp_string (buf, elt_prefix); 4481 buffer_insert_lisp_string (buf, elt_prefix);
4482 4482
4483 if (modifiers & XEMACS_MOD_META) 4483 if (modifiers & XEMACS_MOD_META)
4484 buffer_insert_c_string (buf, "M-"); 4484 buffer_insert_ascstring (buf, "M-");
4485 if (modifiers & XEMACS_MOD_CONTROL) 4485 if (modifiers & XEMACS_MOD_CONTROL)
4486 buffer_insert_c_string (buf, "C-"); 4486 buffer_insert_ascstring (buf, "C-");
4487 if (modifiers & XEMACS_MOD_SUPER) 4487 if (modifiers & XEMACS_MOD_SUPER)
4488 buffer_insert_c_string (buf, "S-"); 4488 buffer_insert_ascstring (buf, "S-");
4489 if (modifiers & XEMACS_MOD_HYPER) 4489 if (modifiers & XEMACS_MOD_HYPER)
4490 buffer_insert_c_string (buf, "H-"); 4490 buffer_insert_ascstring (buf, "H-");
4491 if (modifiers & XEMACS_MOD_ALT) 4491 if (modifiers & XEMACS_MOD_ALT)
4492 buffer_insert_c_string (buf, "Alt-"); 4492 buffer_insert_ascstring (buf, "Alt-");
4493 if (modifiers & XEMACS_MOD_SHIFT) 4493 if (modifiers & XEMACS_MOD_SHIFT)
4494 buffer_insert_c_string (buf, "Sh-"); 4494 buffer_insert_ascstring (buf, "Sh-");
4495 if (SYMBOLP (keysym)) 4495 if (SYMBOLP (keysym))
4496 { 4496 {
4497 Lisp_Object code = Fget (keysym, Qcharacter_of_keysym, Qnil); 4497 Lisp_Object code = Fget (keysym, Qcharacter_of_keysym, Qnil);
4498 Ichar c = (CHAR_OR_CHAR_INTP (code) 4498 Ichar c = (CHAR_OR_CHAR_INTP (code)
4499 ? XCHAR_OR_CHAR_INT (code) : (Ichar) -1); 4499 ? XCHAR_OR_CHAR_INT (code) : (Ichar) -1);
4500 /* Calling Fsingle_key_description() would cons more */ 4500 /* Calling Fsingle_key_description() would cons more */
4501 #if 0 /* This is bogus */ 4501 #if 0 /* This is bogus */
4502 if (EQ (keysym, QKlinefeed)) 4502 if (EQ (keysym, QKlinefeed))
4503 buffer_insert_c_string (buf, "LFD"); 4503 buffer_insert_ascstring (buf, "LFD");
4504 else if (EQ (keysym, QKtab)) 4504 else if (EQ (keysym, QKtab))
4505 buffer_insert_c_string (buf, "TAB"); 4505 buffer_insert_ascstring (buf, "TAB");
4506 else if (EQ (keysym, QKreturn)) 4506 else if (EQ (keysym, QKreturn))
4507 buffer_insert_c_string (buf, "RET"); 4507 buffer_insert_ascstring (buf, "RET");
4508 else if (EQ (keysym, QKescape)) 4508 else if (EQ (keysym, QKescape))
4509 buffer_insert_c_string (buf, "ESC"); 4509 buffer_insert_ascstring (buf, "ESC");
4510 else if (EQ (keysym, QKdelete)) 4510 else if (EQ (keysym, QKdelete))
4511 buffer_insert_c_string (buf, "DEL"); 4511 buffer_insert_ascstring (buf, "DEL");
4512 else if (EQ (keysym, QKspace)) 4512 else if (EQ (keysym, QKspace))
4513 buffer_insert_c_string (buf, "SPC"); 4513 buffer_insert_ascstring (buf, "SPC");
4514 else if (EQ (keysym, QKbackspace)) 4514 else if (EQ (keysym, QKbackspace))
4515 buffer_insert_c_string (buf, "BS"); 4515 buffer_insert_ascstring (buf, "BS");
4516 else 4516 else
4517 #endif 4517 #endif
4518 if (c >= printable_min) 4518 if (c >= printable_min)
4519 buffer_insert_emacs_char (buf, c); 4519 buffer_insert_emacs_char (buf, c);
4520 else buffer_insert1 (buf, Fsymbol_name (keysym)); 4520 else buffer_insert1 (buf, Fsymbol_name (keysym));
4521 } 4521 }
4522 else if (CHARP (keysym)) 4522 else if (CHARP (keysym))
4523 buffer_insert_emacs_char (buf, XCHAR (keysym)); 4523 buffer_insert_emacs_char (buf, XCHAR (keysym));
4524 else 4524 else
4525 buffer_insert_c_string (buf, "---bad keysym---"); 4525 buffer_insert_ascstring (buf, "---bad keysym---");
4526 4526
4527 if (elided) 4527 if (elided)
4528 elided = 0; 4528 elided = 0;
4529 else 4529 else
4530 { 4530 {
4536 list = XCDR (list); 4536 list = XCDR (list);
4537 } 4537 }
4538 if (k != 0) 4538 if (k != 0)
4539 { 4539 {
4540 if (k == 1) 4540 if (k == 1)
4541 buffer_insert_c_string (buf, ", "); 4541 buffer_insert_ascstring (buf, ", ");
4542 else 4542 else
4543 buffer_insert_c_string (buf, " .. "); 4543 buffer_insert_ascstring (buf, " .. ");
4544 elided = 1; 4544 elided = 1;
4545 continue; 4545 continue;
4546 } 4546 }
4547 } 4547 }
4548 4548