Mercurial > hg > xemacs-beta
comparison src/keymap.c @ 1204:e22b0213b713
[xemacs-hg @ 2003-01-12 11:07:58 by michaels]
modules/ChangeLog:
2002-12-16 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
remove ifdef USE_KKCC.
src/ChangeLog:
2003-01-08 Mike Sperber <mike@xemacs.org>
* console.h (CDFW_CONSOLE): Don't lead to a crash if we're dealing
with a dead window/frame/device/console.
2002-12-20 Mike Sperber <mike@xemacs.org>
* ui-gtk.c: Fix typo from Ben's patch: emacs_ffi_data is a
typedef, not a struct. emacs_gtk_object_data is a typedef, not a
struct.
* gtk-glue.c (gdk_event_to_emacs_event): Fix typos from Ben's
patch: le -> emacs_event + rearrange the code.
* event-gtk.c (gtk_event_to_emacs_event): Fix typos from Ben's
patch: ..._UNDERLYING_GDK_EVENT -> ..._GDK_EVENT, ev -> key_event.
* device-gtk.c: Fix typo from Ben's patch: x_keysym_map_hash_table
-> x_keysym_map_hashtable.
2002-12-19 Mike Sperber <mike@xemacs.org>
* menubar-x.c (set_frame_menubar): Initialize protect_me field of
popup_data.
2002-12-16 Ben Wing <ben@xemacs.org>
Major cleanup of KKCC, etc.
KKCC, pdump-related:
-- descriptions are written for all objects. this required some
changes in the format of some objects, e.g. extents, popup-data,
coding system, lstream, lcrecord-list.
-- KKCC now handles weakness in markers, hash tables, elsewhere
correctly (formerly, you'd eventually get a stack overflow due
to endlessly expanding markers).
-- textual changes: lrecord_description -> memory_description,
struct_description -> sized_memory_description.
-- extensive comment describing descriptions and pdump.
-- redo XD_UNION so it works inline and change its format to provide
sufficient info for pdump. implement XD_UNION in pdump. also add
XD_UNION_DYNAMIC_SIZE, which works like XD_UNION except for when
auto-computing structure sizes.
-- add support for XD_INDIRECT in description offsets (used by
extents).
-- add support for "description maps", allowing for indirect
descriptions that are retrieved from an object at run-time. this
generalizes XD_CODING_SYSTEM_END, XD_SPECIFIER_END, etc., which
have now been eliminated.
-- add a fifth field "flags" to memory_description, to support flags
that can be specified for this particular line. Currently defined
flags are XD_FLAG_NO_KKCC (KKCC should ignore this entry; useful
for the weakness above in markers, etc.), XD_FLAG_NO_PDUMP (pdump
should ignore this entry), XD_FLAG_UNION_DEFAULT_ENTRY (in
union maps, this specifies a "default" entry for all remaining
values), and XD_FLAG_FREE_LISP_OBJECT (for use with lcrecord-lists).
-- clean up the kkcc-itis in events, so that the differences
between event data as separate objects and as a union are now
minimized to a small number of places. with the new XD_UNION, we
no longer need event data as separate objects, so this code is no
longer ifdef USE_KKCC, but instead ifdef EVENT_DATA_AS_OBJECTS,
not used by default. make sure that we explicitly free the
separate event data objects when no longer in use, to maintain the
invariant the event processing causes no consing.
-- also remove other USE_KKCC ifdefs when not necessary.
-- allow for KKCC compilation under MS Windows.
-- fix README.kkcc.
-- dump_add_root_object -> dump_add_root_lisp_object.
-- implement dump_add_root_block and use this to handle
dump_add_opaque.
-- factor out some code duplicated in kkcc and pdump.
Other allocation/object-related:
-- change various *slots.h so MARKED_SLOT() call no longer
includes semicolon.
-- free_marker() takes a Lisp_Object not a direct pointer.
-- make bit vectors lcrecords, like vectors, and eliminate code
that essentially duplicated the lcrecord handling.
-- additional asserts in FREE_FIXED_TYPE, formerly duplicated in
the various callers of this.
-- all lcrecord allocation functions now zero out the returned
lcrecords. unnecessary calls to zero_lcrecord removed. add long
comment describing these functions.
-- extract out process and coding system slots, like for buffers,
frames, etc.
-- lcrecords now set the type of items sitting on the free list to
lcrecord_type_free.
-- changes to the way that gap arrays are allocated, for kkcc's
benefit -- now, one single memory block with a stretchy array on
the end, instead of a separate block holding the array.
Error-checking-related:
-- now can compile with C++ under MS Windows. clean up compile errors
discovered that way. (a few were real problems)
-- add C++ error-checking code to verify problems with mismatched
GCPRO/UNGCPRO. (there were a few in the kkcc code.) add long
comment about how to catch insufficient GCPRO (yes, it's possible
using C++).
-- add debug_p4(), a simple object printer, when debug_print()
doesn't work.
-- add dp() and db() as short synonyms of debug_print(),
debug_backtrace().
-- `print' tries EXTREMELY hard to avoid core dumping when printing
when crashing or from debug_print(), and tries as hard as it
reasonably can in other situations.
-- Correct the message output upon crashing to be more up-to-date.
Event-related:
-- document event-matches-key-specifier-p better.
-- generalize the dispatch queues formerly duplicated in the
various event implementations. add event methods to drain pending
events. generalize and clean up QUIT handling, removing
event-specific quit processing. allow arbitrary keystrokes, not
just ASCII, to be the QUIT char. among other things, this should
fix some longstanding bugs in X quit handling. long comment
describing the various event queues.
-- implement delaying of XFlush() if there are pending expose events.
SOMEONE PLEASE TRY THIS OUT.
-- Fix `xemacs -batch -l dunnet' under Cygwin. Try to fix under
MS Windows but not quite there yet.
Other:
-- class -> class_ and no more C++ games with this item.
new -> new_ in the lwlib code, so far not elsewhere.
-- use `struct htentry' not `struct hentry' in elhash.c to avoid
debugger confusion with hash.c.
-- new macros ALIST_LOOP_3, ALIST_LOOP_4.
* README.kkcc:
* alloc.c:
* alloc.c (deadbeef_memory):
* alloc.c (allocate_lisp_storage):
* alloc.c (copy_lisp_object):
* alloc.c (ALLOCATE_FIXED_TYPE_1):
* alloc.c (FREE_FIXED_TYPE):
* alloc.c (make_vector_internal):
* alloc.c (make_bit_vector_internal):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (struct string_chars_block):
* alloc.c (mark_lcrecord_list):
* alloc.c (make_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (alloc_automanaged_lcrecord):
* alloc.c (staticpro_1):
* alloc.c (staticpro):
* alloc.c (lispdesc_indirect_count_1):
* alloc.c (lispdesc_indirect_description_1):
* alloc.c (lispdesc_one_description_line_size):
* alloc.c (lispdesc_structure_size):
* alloc.c (mark_object_maybe_checking_free):
* alloc.c (mark_with_description):
* alloc.c (mark_struct_contents):
* alloc.c (mark_object):
* alloc.c (tick_lcrecord_stats):
* alloc.c (free_cons):
* alloc.c (free_key_data):
* alloc.c (free_button_data):
* alloc.c (free_motion_data):
* alloc.c (free_process_data):
* alloc.c (free_timeout_data):
* alloc.c (free_magic_data):
* alloc.c (free_magic_eval_data):
* alloc.c (free_eval_data):
* alloc.c (free_misc_user_data):
* alloc.c (free_marker):
* alloc.c (compact_string_chars):
* alloc.c (gc_sweep):
* alloc.c (garbage_collect_1):
* alloc.c (Fgarbage_collect):
* alloc.c (common_init_alloc_early):
* alloc.c (init_alloc_early):
* alloc.c (init_alloc_once_early):
* buffer.c:
* buffer.c (mark_buffer):
* buffer.c (MARKED_SLOT):
* buffer.c (cleanup_buffer_undo_lists):
* buffer.c (Fget_file_buffer):
* buffer.h (MARKED_SLOT):
* bufslots.h:
* bytecode.c:
* callint.c:
* casetab.c:
* chartab.c:
* chartab.c (symbol_to_char_table_type):
* cmdloop.c:
* cmdloop.c (Fcommand_loop_1):
* config.h.in (new):
* conslots.h:
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h:
* console-impl.h (struct console):
* console-impl.h (MARKED_SLOT):
* console-impl.h (CONSOLE_QUIT_EVENT):
* console-msw-impl.h (XM_BUMPQUEUE):
* console-msw.c (write_string_to_mswindows_debugging_output):
* console-msw.h:
* console-stream-impl.h:
* console-stream-impl.h (struct stream_console):
* console-stream.c:
* console-stream.c (stream_init_console):
* console-stream.h:
* console-tty.c:
* console-tty.h:
* console-x.h:
* console.c:
* console.c (mark_console):
* console.c (MARKED_SLOT):
* console.c (allocate_console):
* console.c (get_console_variant):
* console.c (create_console):
* console.c (delete_console_internal):
* console.c (Fset_input_mode):
* console.c (Fcurrent_input_mode):
* console.c (common_init_complex_vars_of_console):
* console.h:
* console.h (console_variant):
* console.h (device_metrics):
* data.c:
* data.c (Faref):
* data.c (Faset):
* data.c (decode_weak_list_type):
* database.c:
* debug.c (xemacs_debug_loop):
* debug.c (FROB):
* debug.c (Fadd_debug_class_to_check):
* debug.c (Fdelete_debug_class_to_check):
* debug.c (Fset_debug_classes_to_check):
* debug.c (Fset_debug_class_types_to_check):
* debug.c (Fdebug_types_being_checked):
* debug.h (DASSERT):
* device-gtk.c:
* device-impl.h (struct device):
* device-impl.h (MARKED_SLOT):
* device-msw.c:
* device-x.c:
* device-x.c (x_init_device_class):
* device-x.c (x_comp_visual_info):
* device-x.c (x_try_best_visual_class):
* device-x.c (x_init_device):
* device-x.c (construct_name_list):
* device-x.c (x_get_resource_prefix):
* device-x.c (Fx_get_resource):
* device-x.c (Fx_display_visual_class):
* device.c:
* device.c (MARKED_SLOT):
* device.c (allocate_device):
* device.c (Fmake_device):
* device.c (delete_device_internal):
* device.c (Fset_device_class):
* device.h:
* devslots.h:
* devslots.h (MARKED_SLOT):
* dialog-msw.c:
* dired-msw.c (mswindows_ls_sort_fcn):
* dired-msw.c (mswindows_get_files):
* dired-msw.c (mswindows_format_file):
* doprnt.c (parse_doprnt_spec):
* dumper.c:
* dumper.c (struct):
* dumper.c (dump_add_root_block):
* dumper.c (dump_add_root_struct_ptr):
* dumper.c (dump_add_root_lisp_object):
* dumper.c (pdump_struct_list_elt):
* dumper.c (pdump_get_entry_list):
* dumper.c (pdump_backtrace):
* dumper.c (pdump_bump_depth):
* dumper.c (pdump_register_sub):
* dumper.c (pdump_register_object):
* dumper.c (pdump_register_struct_contents):
* dumper.c (pdump_register_struct):
* dumper.c (pdump_store_new_pointer_offsets):
* dumper.c (pdump_dump_data):
* dumper.c (pdump_reloc_one):
* dumper.c (pdump_allocate_offset):
* dumper.c (pdump_scan_by_alignment):
* dumper.c (pdump_dump_root_blocks):
* dumper.c (pdump_dump_rtables):
* dumper.c (pdump_dump_root_lisp_objects):
* dumper.c (pdump):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_get):
* dumper.c (pdump_resource_get):
* dumper.c (pdump_load):
* editfns.c (save_excursion_restore):
* editfns.c (user_login_name):
* editfns.c (save_restriction_restore):
* elhash.c:
* elhash.c (htentry):
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (HTENTRY_CLEAR_P):
* elhash.c (LINEAR_PROBING_LOOP):
* elhash.c (check_hash_table_invariants):
* elhash.c (mark_hash_table):
* elhash.c (hash_table_equal):
* elhash.c (print_hash_table_data):
* elhash.c (free_hentries):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (decode_hash_table_weakness):
* elhash.c (decode_hash_table_test):
* elhash.c (Fcopy_hash_table):
* elhash.c (resize_hash_table):
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (find_htentry):
* elhash.c (Fgethash):
* elhash.c (Fputhash):
* elhash.c (remhash_1):
* elhash.c (Fremhash):
* elhash.c (Fclrhash):
* elhash.c (copy_compress_hentries):
* elhash.c (elisp_maphash_unsafe):
* elhash.c (finish_marking_weak_hash_tables):
* elhash.c (prune_weak_hash_tables):
* elhash.h:
* emacs.c:
* emacs.c (main_1):
* emacs.c (main):
* emacs.c (shut_down_emacs):
* emodules.h (dump_add_root_lisp_object):
* eval.c:
* eval.c (unwind_to_catch):
* eval.c (maybe_signal_error_1):
* eval.c (maybe_signal_continuable_error_1):
* eval.c (maybe_signal_error):
* eval.c (maybe_signal_continuable_error):
* eval.c (maybe_signal_error_2):
* eval.c (maybe_signal_continuable_error_2):
* eval.c (maybe_signal_ferror):
* eval.c (maybe_signal_continuable_ferror):
* eval.c (maybe_signal_ferror_with_frob):
* eval.c (maybe_signal_continuable_ferror_with_frob):
* eval.c (maybe_syntax_error):
* eval.c (maybe_sferror):
* eval.c (maybe_invalid_argument):
* eval.c (maybe_invalid_constant):
* eval.c (maybe_invalid_operation):
* eval.c (maybe_invalid_change):
* eval.c (maybe_invalid_state):
* eval.c (Feval):
* eval.c (call_trapping_problems):
* eval.c (call_with_suspended_errors):
* eval.c (warn_when_safe_lispobj):
* eval.c (warn_when_safe):
* eval.c (vars_of_eval):
* event-Xt.c:
* event-Xt.c (maybe_define_x_key_as_self_inserting_character):
* event-Xt.c (x_to_emacs_keysym):
* event-Xt.c (x_event_to_emacs_event):
* event-Xt.c (emacs_Xt_enqueue_focus_event):
* event-Xt.c (emacs_Xt_format_magic_event):
* event-Xt.c (emacs_Xt_compare_magic_event):
* event-Xt.c (emacs_Xt_hash_magic_event):
* event-Xt.c (emacs_Xt_handle_magic_event):
* event-Xt.c (Xt_timeout_to_emacs_event):
* event-Xt.c (Xt_process_to_emacs_event):
* event-Xt.c (signal_special_Xt_user_event):
* event-Xt.c (emacs_Xt_next_event):
* event-Xt.c (emacs_Xt_event_handler):
* event-Xt.c (emacs_Xt_drain_queue):
* event-Xt.c (emacs_Xt_event_pending_p):
* event-Xt.c (check_if_pending_expose_event):
* event-Xt.c (reinit_vars_of_event_Xt):
* event-Xt.c (vars_of_event_Xt):
* event-gtk.c:
* event-gtk.c (IS_MODIFIER_KEY):
* event-gtk.c (emacs_gtk_format_magic_event):
* event-gtk.c (emacs_gtk_compare_magic_event):
* event-gtk.c (emacs_gtk_hash_magic_event):
* event-gtk.c (emacs_gtk_handle_magic_event):
* event-gtk.c (gtk_to_emacs_keysym):
* event-gtk.c (gtk_timeout_to_emacs_event):
* event-gtk.c (gtk_process_to_emacs_event):
* event-gtk.c (dragndrop_data_received):
* event-gtk.c (signal_special_gtk_user_event):
* event-gtk.c (emacs_gtk_next_event):
* event-gtk.c (gtk_event_to_emacs_event):
* event-gtk.c (generic_event_handler):
* event-gtk.c (emacs_shell_event_handler):
* event-gtk.c (emacs_gtk_drain_queue):
* event-gtk.c (emacs_gtk_event_pending_p):
* event-gtk.c (reinit_vars_of_event_gtk):
* event-gtk.c (vars_of_event_gtk):
* event-msw.c:
* event-msw.c (struct winsock_stream):
* event-msw.c (winsock_reader):
* event-msw.c (winsock_writer):
* event-msw.c (mswindows_enqueue_dispatch_event):
* event-msw.c (mswindows_enqueue_misc_user_event):
* event-msw.c (mswindows_enqueue_magic_event):
* event-msw.c (mswindows_enqueue_process_event):
* event-msw.c (mswindows_enqueue_mouse_button_event):
* event-msw.c (mswindows_enqueue_keypress_event):
* event-msw.c (mswindows_dequeue_dispatch_event):
* event-msw.c (emacs_mswindows_drain_queue):
* event-msw.c (mswindows_need_event_in_modal_loop):
* event-msw.c (mswindows_need_event):
* event-msw.c (mswindows_wm_timer_callback):
* event-msw.c (dde_eval_string):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-msw.c (remove_timeout_mapper):
* event-msw.c (emacs_mswindows_remove_timeout):
* event-msw.c (emacs_mswindows_event_pending_p):
* event-msw.c (emacs_mswindows_format_magic_event):
* event-msw.c (emacs_mswindows_compare_magic_event):
* event-msw.c (emacs_mswindows_hash_magic_event):
* event-msw.c (emacs_mswindows_handle_magic_event):
* event-msw.c (emacs_mswindows_select_console):
* event-msw.c (emacs_mswindows_unselect_console):
* event-msw.c (reinit_vars_of_event_mswindows):
* event-msw.c (vars_of_event_mswindows):
* event-stream.c:
* event-stream.c (mark_command_builder):
* event-stream.c (reset_command_builder_event_chain):
* event-stream.c (allocate_command_builder):
* event-stream.c (copy_command_builder):
* event-stream.c (command_builder_append_event):
* event-stream.c (event_stream_event_pending_p):
* event-stream.c (event_stream_force_event_pending):
* event-stream.c (maybe_read_quit_event):
* event-stream.c (event_stream_drain_queue):
* event-stream.c (remove_quit_p_event):
* event-stream.c (event_stream_quit_p):
* event-stream.c (echo_key_event):
* event-stream.c (maybe_kbd_translate):
* event-stream.c (execute_help_form):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (enqueue_dispatch_event):
* event-stream.c (enqueue_magic_eval_event):
* event-stream.c (Fenqueue_eval_event):
* event-stream.c (enqueue_misc_user_event):
* event-stream.c (enqueue_misc_user_event_pos):
* event-stream.c (next_event_internal):
* event-stream.c (Fnext_event):
* event-stream.c (Faccept_process_output):
* event-stream.c (execute_internal_event):
* event-stream.c (munge_keymap_translate):
* event-stream.c (command_builder_find_leaf_no_mule_processing):
* event-stream.c (command_builder_find_leaf):
* event-stream.c (lookup_command_event):
* event-stream.c (is_scrollbar_event):
* event-stream.c (execute_command_event):
* event-stream.c (Fdispatch_event):
* event-stream.c (Fread_key_sequence):
* event-stream.c (dribble_out_event):
* event-stream.c (vars_of_event_stream):
* event-tty.c (tty_timeout_to_emacs_event):
* event-tty.c (emacs_tty_next_event):
* event-tty.c (emacs_tty_drain_queue):
* event-tty.c (reinit_vars_of_event_tty):
* event-unixoid.c:
* event-unixoid.c (find_tty_or_stream_console_from_fd):
* event-unixoid.c (read_event_from_tty_or_stream_desc):
* event-unixoid.c (drain_tty_devices):
* event-unixoid.c (poll_fds_for_input):
* events.c:
* events.c (deinitialize_event):
* events.c (zero_event):
* events.c (mark_event):
* events.c (print_event_1):
* events.c (print_event):
* events.c (event_equal):
* events.c (event_hash):
* events.c (Fmake_event):
* events.c (Fdeallocate_event):
* events.c (Fcopy_event):
* events.c (map_event_chain_remove):
* events.c (character_to_event):
* events.c (event_to_character):
* events.c (Fevent_to_character):
* events.c (format_event_object):
* events.c (upshift_event):
* events.c (downshift_event):
* events.c (event_upshifted_p):
* events.c (Fevent_live_p):
* events.c (Fevent_type):
* events.c (Fevent_timestamp):
* events.c (CHECK_EVENT_TYPE):
* events.c (CHECK_EVENT_TYPE2):
* events.c (CHECK_EVENT_TYPE3):
* events.c (Fevent_key):
* events.c (Fevent_button):
* events.c (Fevent_modifier_bits):
* events.c (event_x_y_pixel_internal):
* events.c (event_pixel_translation):
* events.c (Fevent_process):
* events.c (Fevent_function):
* events.c (Fevent_object):
* events.c (Fevent_properties):
* events.c (syms_of_events):
* events.c (vars_of_events):
* events.h:
* events.h (struct event_stream):
* events.h (struct Lisp_Key_Data):
* events.h (KEY_DATA_KEYSYM):
* events.h (EVENT_KEY_KEYSYM):
* events.h (struct Lisp_Button_Data):
* events.h (EVENT_BUTTON_BUTTON):
* events.h (struct Lisp_Motion_Data):
* events.h (EVENT_MOTION_X):
* events.h (struct Lisp_Process_Data):
* events.h (EVENT_PROCESS_PROCESS):
* events.h (struct Lisp_Timeout_Data):
* events.h (EVENT_TIMEOUT_INTERVAL_ID):
* events.h (struct Lisp_Eval_Data):
* events.h (EVENT_EVAL_FUNCTION):
* events.h (struct Lisp_Misc_User_Data):
* events.h (EVENT_MISC_USER_FUNCTION):
* events.h (struct Lisp_Magic_Eval_Data):
* events.h (EVENT_MAGIC_EVAL_INTERNAL_FUNCTION):
* events.h (struct Lisp_Magic_Data):
* events.h (EVENT_MAGIC_UNDERLYING):
* events.h (EVENT_MAGIC_GDK_EVENT):
* events.h (struct Lisp_Event):
* events.h (XEVENT_CHANNEL):
* events.h (SET_EVENT_TIMESTAMP_ZERO):
* events.h (SET_EVENT_CHANNEL):
* events.h (SET_EVENT_NEXT):
* events.h (XSET_EVENT_TYPE):
* events.h (struct command_builder):
* extents.c:
* extents.c (gap_array_adjust_markers):
* extents.c (gap_array_recompute_derived_values):
* extents.c (gap_array_move_gap):
* extents.c (gap_array_make_gap):
* extents.c (gap_array_insert_els):
* extents.c (gap_array_delete_els):
* extents.c (gap_array_make_marker):
* extents.c (gap_array_delete_marker):
* extents.c (gap_array_move_marker):
* extents.c (make_gap_array):
* extents.c (free_gap_array):
* extents.c (extent_list_num_els):
* extents.c (extent_list_insert):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (decode_extent_at_flag):
* extents.c (verify_extent_mapper):
* extents.c (symbol_to_glyph_layout):
* extents.c (syms_of_extents):
* faces.c:
* file-coding.c:
* file-coding.c (struct_detector_category_description =):
* file-coding.c (detector_category_dynarr_description_1):
* file-coding.c (struct_detector_description =):
* file-coding.c (detector_dynarr_description_1):
* file-coding.c (MARKED_SLOT):
* file-coding.c (mark_coding_system):
* file-coding.c (coding_system_extra_description_map):
* file-coding.c (coding_system_description):
* file-coding.c (allocate_coding_system):
* file-coding.c (symbol_to_eol_type):
* file-coding.c (Fcoding_system_aliasee):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (struct convert_eol_coding_system):
* file-coding.c (struct undecided_coding_system):
* file-coding.c (undecided_mark_coding_stream):
* file-coding.c (coding_category_symbol_to_id):
* file-coding.c (struct gzip_coding_system):
* file-coding.c (coding_system_type_create):
* file-coding.h:
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (CODING_SYSTEM_SLOT_DECLARATION):
* file-coding.h (coding_system_variant):
* file-coding.h (struct coding_system_methods):
* file-coding.h (DEFINE_CODING_SYSTEM_TYPE_WITH_DATA):
* file-coding.h (INITIALIZE_CODING_SYSTEM_TYPE_WITH_DATA):
* file-coding.h (struct coding_stream):
* fileio.c (Fsubstitute_in_file_name):
* floatfns.c:
* fns.c:
* fns.c (base64_encode_1):
* frame-gtk.c:
* frame-gtk.c (Fgtk_start_drag_internal):
* frame-impl.h (struct frame):
* frame-impl.h (MARKED_SLOT):
* frame-msw.c:
* frame-x.c:
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (Foffix_start_drag_internal):
* frame.c:
* frame.c (MARKED_SLOT):
* frame.c (allocate_frame_core):
* frame.c (delete_frame_internal):
* frame.c (Fmouse_position_as_motion_event):
* frameslots.h:
* frameslots.h (MARKED_SLOT_ARRAY):
* free-hook.c:
* glyphs-msw.c (mswindows_widget_instantiate):
* glyphs-x.c:
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs.c:
* glyphs.c (process_image_string_instantiator):
* glyphs.c (mark_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (unmap_subwindow):
* glyphs.c (map_subwindow):
* glyphs.c (syms_of_glyphs):
* glyphs.c (specifier_type_create_image):
* glyphs.h:
* glyphs.h (struct text_image_instance):
* glyphs.h (struct Lisp_Image_Instance):
* gmalloc.c:
* gmalloc.c ("C"):
* gpmevent.c (Freceive_gpm_event):
* gpmevent.c (gpm_next_event_cb):
* gpmevent.c (vars_of_gpmevent):
* gtk-glue.c (gdk_event_to_emacs_event):
* gtk-xemacs.c (gtk_xemacs_class_init):
* gui-msw.c:
* gui-msw.c (mswindows_handle_gui_wm_command):
* gui-msw.c (mswindows_translate_menu_or_dialog_item):
* gui-x.c:
* gui-x.c (mark_popup_data):
* gui-x.c (snarf_widget_value_mapper):
* gui-x.c (gcpro_popup_callbacks):
* gui-x.c (ungcpro_popup_callbacks):
* gui-x.c (free_popup_widget_value_tree):
* gui-x.c (popup_selection_callback):
* gui-x.h:
* gui-x.h (struct popup_data):
* gui.c:
* gui.c (allocate_gui_item):
* gutter.c (decode_gutter_position):
* hash.c (NULL_ENTRY):
* indent.c (vmotion_1):
* indent.c (vmotion_pixels):
* input-method-motif.c (res):
* input-method-xlib.c (IMInstantiateCallback):
* input-method-xlib.c (XIM_init_device):
* input-method-xlib.c (res):
* intl-encap-win32.c:
* intl-encap-win32.c (qxeSHGetDataFromIDList):
* intl-win32.c:
* intl-win32.c (mswindows_multibyte_cp_type):
* intl-win32.c (struct mswindows_multibyte_coding_system):
* keymap.c:
* keymap.c (make_key_description):
* keymap.c (keymap_store):
* keymap.c (get_keyelt):
* keymap.c (keymap_lookup_1):
* keymap.c (define_key_parser):
* keymap.c (key_desc_list_to_event):
* keymap.c (event_matches_key_specifier_p):
* keymap.c (meta_prefix_char_p):
* keymap.c (ensure_meta_prefix_char_keymapp):
* keymap.c (Fdefine_key):
* keymap.c (struct raw_lookup_key_mapper_closure):
* keymap.c (raw_lookup_key):
* keymap.c (raw_lookup_key_mapper):
* keymap.c (lookup_keys):
* keymap.c (lookup_events):
* keymap.c (Flookup_key):
* keymap.c (struct map_keymap_unsorted_closure):
* keymap.c (map_keymap_unsorted_mapper):
* keymap.c (map_keymap_sorted):
* keymap.c (map_keymap_mapper):
* keymap.c (map_keymap):
* keymap.c (accessible_keymaps_mapper_1):
* keymap.c (Faccessible_keymaps):
* keymap.c (Fsingle_key_description):
* keymap.c (raw_keys_to_keys):
* keymap.c (format_raw_keys):
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* keymap.c (describe_map_mapper_shadow_search):
* keymap.c (keymap_lookup_inherited_mapper):
* keymap.c (describe_map_mapper):
* keymap.h (event_matches_key_specifier_p):
* lisp.h:
* lisp.h (this):
* lisp.h (RETURN_NOT_REACHED):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (UNGCPRO_1):
* lisp.h (NUNGCPRO):
* lisp.h (NNUNGCPRO):
* lisp.h (DECLARE_INLINE_HEADER):
* lrecord.h:
* lrecord.h (struct lrecord_header):
* lrecord.h (struct lcrecord_header):
* lrecord.h (lrecord_type):
* lrecord.h (struct lrecord_implementation):
* lrecord.h (RECORD_DUMPABLE):
* lrecord.h (memory_description_type):
* lrecord.h (data_description_entry_flags):
* lrecord.h (struct memory_description):
* lrecord.h (struct sized_memory_description):
* lrecord.h (XD_INDIRECT):
* lrecord.h (XD_IS_INDIRECT):
* lrecord.h (XD_DYNARR_DESC):
* lrecord.h (DEFINE_BASIC_LRECORD_IMPLEMENTATION):
* lrecord.h (MAKE_LRECORD_IMPLEMENTATION):
* lrecord.h (MAKE_EXTERNAL_LRECORD_IMPLEMENTATION):
* lrecord.h (alloc_lcrecord_type):
* lstream.c:
* lstream.c (Lstream_new):
* lstream.c (lisp_buffer_marker):
* lstream.h:
* lstream.h (lstream_implementation):
* lstream.h (DEFINE_LSTREAM_IMPLEMENTATION):
* lstream.h (DEFINE_LSTREAM_IMPLEMENTATION_WITH_DATA):
* marker.c:
* marker.c (copy_marker_1):
* mem-limits.h:
* menubar-gtk.c:
* menubar-gtk.c (gtk_popup_menu):
* menubar-msw.c:
* menubar-msw.c (mswindows_popup_menu):
* menubar-x.c (make_dummy_xbutton_event):
* menubar-x.c (command_builder_operate_menu_accelerator):
* menubar-x.c (menu_accelerator_safe_compare):
* menubar-x.c (menu_accelerator_safe_mod_compare):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (Fcharset_property):
* mule-coding.c:
* mule-coding.c (ccs_description_1):
* mule-coding.c (ccs_description =):
* mule-coding.c (ccsd_description_1):
* mule-coding.c (ccsd_description =):
* nt.c (getpwnam):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_is_executable):
* nt.c (read_unc_volume):
* nt.c (mswindows_access):
* nt.c (mswindows_link):
* nt.c (mswindows_fstat):
* nt.c (mswindows_stat):
* nt.c (mswindows_executable_type):
* nt.c (Fmswindows_short_file_name):
* nt.c (Fmswindows_long_file_name):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty.c:
* objects-x.c (allocate_nearest_color):
* objects.c:
* objects.c (Fmake_color_instance):
* objects.c (Fmake_font_instance):
* objects.c (font_instantiate):
* opaque.c:
* opaque.c (make_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (reinit_opaque_early):
* opaque.c (init_opaque_once_early):
* print.c:
* print.c (printing_badness):
* print.c (printing_major_badness):
* print.c (print_internal):
* print.c (debug_p4):
* print.c (dp):
* print.c (debug_backtrace):
* process-nt.c (nt_create_process):
* process-nt.c (get_internet_address):
* process-unix.c:
* process-unix.c (struct unix_process_data):
* process-unix.c (get_internet_address):
* process-unix.c (unix_alloc_process_data):
* process-unix.c (unix_create_process):
* process-unix.c (try_to_initialize_subtty):
* process-unix.c (unix_kill_child_process):
* process-unix.c (process_type_create_unix):
* process.c:
* process.c (mark_process):
* process.c (MARKED_SLOT):
* process.c (make_process_internal):
* process.c (Fprocess_tty_name):
* process.c (decode_signal):
* process.h:
* procimpl.h:
* procimpl.h (struct process_methods):
* procimpl.h (struct Lisp_Process):
* rangetab.c:
* realpath.c (readlink_and_correct_case):
* redisplay-x.c (x_window_output_end):
* redisplay-x.c (x_redraw_exposed_area):
* redisplay-x.c (x_clear_frame):
* redisplay.c:
* redisplay.h:
* redisplay.h (struct rune_dglyph):
* redisplay.h (struct rune):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* specifier.c:
* specifier.c (specifier_empty_extra_description_1):
* specifier.c (make_specifier_internal):
* specifier.c (decode_locale_type):
* specifier.c (decode_how_to_add_specification):
* specifier.h:
* specifier.h (struct specifier_methods):
* specifier.h (DEFINE_SPECIFIER_TYPE_WITH_DATA):
* specifier.h (INITIALIZE_SPECIFIER_TYPE_WITH_DATA):
* symbols.c:
* symbols.c (Fsetplist):
* symbols.c (default_value):
* symbols.c (decode_magic_handler_type):
* symbols.c (handler_type_from_function_symbol):
* symbols.c (Fdefvaralias):
* symbols.c (init_symbols_once_early):
* symbols.c (reinit_symbols_early):
* symsinit.h:
* sysdep.c (sys_subshell):
* sysdep.c (tty_init_sys_modes_on_device):
* syswindows.h:
* text.c (dfc_convert_to_external_format):
* text.c (dfc_convert_to_internal_format):
* text.c (reinit_eistring_early):
* text.c (init_eistring_once_early):
* text.c (reinit_vars_of_text):
* text.h:
* text.h (INC_IBYTEPTR_FMT):
* text.h (DEC_IBYTEPTR_FMT):
* toolbar.c:
* toolbar.c (decode_toolbar_position):
* tooltalk.c:
* ui-gtk.c:
* unexnt.c:
* unexnt.c (_start):
* unexnt.c (unexec):
* unexnt.c (get_section_info):
* unicode.c:
* unicode.c (vars_of_unicode):
* window.c:
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (update_mirror_internal):
* winslots.h:
| author | michaels |
|---|---|
| date | Sun, 12 Jan 2003 11:08:22 +0000 |
| parents | 0dc7756a58c4 |
| children | a8d8f419b459 |
comparison
equal
deleted
inserted
replaced
| 1203:5f2f8dcbfb3e | 1204:e22b0213b713 |
|---|---|
| 267 } | 267 } |
| 268 write_fmt_string (printcharfun, "size %ld 0x%x>", | 268 write_fmt_string (printcharfun, "size %ld 0x%x>", |
| 269 (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid); | 269 (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid); |
| 270 } | 270 } |
| 271 | 271 |
| 272 static const struct lrecord_description keymap_description[] = { | 272 static const struct memory_description keymap_description[] = { |
| 273 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, parents) }, | 273 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, parents) }, |
| 274 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, prompt) }, | 274 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, prompt) }, |
| 275 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, table) }, | 275 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, table) }, |
| 276 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, inverse_table) }, | 276 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, inverse_table) }, |
| 277 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, default_binding) }, | 277 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, default_binding) }, |
| 279 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) }, | 279 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) }, |
| 280 { XD_END } | 280 { XD_END } |
| 281 }; | 281 }; |
| 282 | 282 |
| 283 /* No need for keymap_equal #### Why not? */ | 283 /* No need for keymap_equal #### Why not? */ |
| 284 #ifdef USE_KKCC | |
| 285 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap, | 284 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap, |
| 286 1, /*dumpable-flag*/ | 285 1, /*dumpable-flag*/ |
| 287 mark_keymap, print_keymap, 0, 0, 0, | 286 mark_keymap, print_keymap, 0, 0, 0, |
| 288 keymap_description, | 287 keymap_description, |
| 289 Lisp_Keymap); | 288 Lisp_Keymap); |
| 290 #else /* not USE_KKCC */ | |
| 291 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap, | |
| 292 mark_keymap, print_keymap, 0, 0, 0, | |
| 293 keymap_description, | |
| 294 Lisp_Keymap); | |
| 295 #endif /* not USE_KKCC */ | |
| 296 | 289 |
| 297 /************************************************************************/ | 290 /************************************************************************/ |
| 298 /* Traversing keymaps and their parents */ | 291 /* Traversing keymaps and their parents */ |
| 299 /************************************************************************/ | 292 /************************************************************************/ |
| 300 | 293 |
| 434 if (modifiers & XEMACS_MOD_META) frob = Fcons (Qmeta, frob); | 427 if (modifiers & XEMACS_MOD_META) frob = Fcons (Qmeta, frob); |
| 435 return frob; | 428 return frob; |
| 436 } | 429 } |
| 437 | 430 |
| 438 static Lisp_Object | 431 static Lisp_Object |
| 439 #ifdef USE_KKCC | |
| 440 make_key_description (const Lisp_Key_Data *key, int prettify) | 432 make_key_description (const Lisp_Key_Data *key, int prettify) |
| 441 { | 433 { |
| 442 Lisp_Object keysym = KEY_DATA_KEYSYM(key); | 434 Lisp_Object keysym = KEY_DATA_KEYSYM (key); |
| 443 int modifiers = KEY_DATA_MODIFIERS (key); | 435 int modifiers = KEY_DATA_MODIFIERS (key); |
| 444 #else /* not USE_KKCC */ | |
| 445 make_key_description (const struct key_data *key, int prettify) | |
| 446 { | |
| 447 Lisp_Object keysym = key->keysym; | |
| 448 int modifiers = key->modifiers; | |
| 449 #endif /* not USE_KKCC */ | |
| 450 if (prettify && CHARP (keysym)) | 436 if (prettify && CHARP (keysym)) |
| 451 { | 437 { |
| 452 /* This is a little slow, but (control a) is prettier than (control 65). | 438 /* This is a little slow, but (control a) is prettier than (control 65). |
| 453 It's now ok to do this for digit-chars too, since we've fixed the | 439 It's now ok to do this for digit-chars too, since we've fixed the |
| 454 bug where \9 read as the integer 9 instead of as the symbol with | 440 bug where \9 read as the integer 9 instead of as the symbol with |
| 468 /* Low-level keymap-store functions */ | 454 /* Low-level keymap-store functions */ |
| 469 /************************************************************************/ | 455 /************************************************************************/ |
| 470 | 456 |
| 471 static Lisp_Object | 457 static Lisp_Object |
| 472 raw_lookup_key (Lisp_Object keymap, | 458 raw_lookup_key (Lisp_Object keymap, |
| 473 #ifdef USE_KKCC | |
| 474 const Lisp_Key_Data *raw_keys, int raw_keys_count, | 459 const Lisp_Key_Data *raw_keys, int raw_keys_count, |
| 475 #else /* not USE_KKCC */ | |
| 476 const struct key_data *raw_keys, int raw_keys_count, | |
| 477 #endif /* not USE_KKCC */ | |
| 478 int keys_so_far, int accept_default); | 460 int keys_so_far, int accept_default); |
| 479 | 461 |
| 480 /* Relies on caller to gc-protect args */ | 462 /* Relies on caller to gc-protect args */ |
| 481 static Lisp_Object | 463 static Lisp_Object |
| 482 keymap_lookup_directly (Lisp_Object keymap, | 464 keymap_lookup_directly (Lisp_Object keymap, |
| 656 } | 638 } |
| 657 | 639 |
| 658 | 640 |
| 659 /* Relies on caller to gc-protect keymap, keysym, value */ | 641 /* Relies on caller to gc-protect keymap, keysym, value */ |
| 660 static void | 642 static void |
| 661 #ifdef USE_KKCC | |
| 662 keymap_store (Lisp_Object keymap, const Lisp_Key_Data *key, | 643 keymap_store (Lisp_Object keymap, const Lisp_Key_Data *key, |
| 663 #else /* not USE_KKCC */ | |
| 664 keymap_store (Lisp_Object keymap, const struct key_data *key, | |
| 665 #endif /* not USE_KKCC */ | |
| 666 Lisp_Object value) | 644 Lisp_Object value) |
| 667 { | 645 { |
| 668 #ifdef USE_KKCC | |
| 669 Lisp_Object keysym = KEY_DATA_KEYSYM (key); | 646 Lisp_Object keysym = KEY_DATA_KEYSYM (key); |
| 670 int modifiers = KEY_DATA_MODIFIERS (key); | 647 int modifiers = KEY_DATA_MODIFIERS (key); |
| 671 #else /* not USE_KKCC */ | |
| 672 Lisp_Object keysym = key->keysym; | |
| 673 int modifiers = key->modifiers; | |
| 674 #endif /* not USE_KKCC */ | |
| 675 Lisp_Keymap *k = XKEYMAP (keymap); | 648 Lisp_Keymap *k = XKEYMAP (keymap); |
| 676 | 649 |
| 677 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 | 650 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 |
| 678 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5); | 651 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5); |
| 679 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | 652 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META |
| 1077 } | 1050 } |
| 1078 /* If the contents are (KEYMAP . ELEMENT), go indirect. */ | 1051 /* If the contents are (KEYMAP . ELEMENT), go indirect. */ |
| 1079 if (!NILP (map)) | 1052 if (!NILP (map)) |
| 1080 { | 1053 { |
| 1081 Lisp_Object idx = Fcdr (object); | 1054 Lisp_Object idx = Fcdr (object); |
| 1082 #ifdef USE_KKCC | |
| 1083 Lisp_Key_Data indirection; | 1055 Lisp_Key_Data indirection; |
| 1084 #else /* not USE_KKCC */ | |
| 1085 struct key_data indirection; | |
| 1086 #endif /* not USE_KKCC */ | |
| 1087 if (CHARP (idx)) | 1056 if (CHARP (idx)) |
| 1088 { | 1057 { |
| 1089 #ifdef USE_KKCC | |
| 1090 Lisp_Object event = Fmake_event (Qnil, Qnil); | 1058 Lisp_Object event = Fmake_event (Qnil, Qnil); |
| 1091 struct gcpro gcpro1; | 1059 struct gcpro gcpro1; |
| 1092 GCPRO1 (event); | 1060 GCPRO1 (event); |
| 1093 XSET_EVENT_TYPE (event, empty_event); | |
| 1094 character_to_event (XCHAR (idx), XEVENT (event), | 1061 character_to_event (XCHAR (idx), XEVENT (event), |
| 1095 XCONSOLE (Vselected_console), 0, 0); | 1062 XCONSOLE (Vselected_console), 0, 0); |
| 1096 indirection = *XKEY_DATA (XEVENT_DATA (event)); | 1063 indirection.keysym = XEVENT_KEY_KEYSYM (event); |
| 1097 #else /* not USE_KKCC */ | 1064 indirection.modifiers = XEVENT_KEY_MODIFIERS (event); |
| 1098 Lisp_Event event; | 1065 UNGCPRO; |
| 1099 event.event_type = empty_event; | |
| 1100 character_to_event (XCHAR (idx), &event, | |
| 1101 XCONSOLE (Vselected_console), 0, 0); | |
| 1102 indirection = event.event.key; | |
| 1103 #endif /* not USE_KKCC */ | |
| 1104 } | 1066 } |
| 1105 else if (CONSP (idx)) | 1067 else if (CONSP (idx)) |
| 1106 { | 1068 { |
| 1107 if (!INTP (XCDR (idx))) | 1069 if (!INTP (XCDR (idx))) |
| 1108 return Qnil; | 1070 return Qnil; |
| 1110 indirection.modifiers = (unsigned char) XINT (XCDR (idx)); | 1072 indirection.modifiers = (unsigned char) XINT (XCDR (idx)); |
| 1111 } | 1073 } |
| 1112 else if (SYMBOLP (idx)) | 1074 else if (SYMBOLP (idx)) |
| 1113 { | 1075 { |
| 1114 indirection.keysym = idx; | 1076 indirection.keysym = idx; |
| 1115 #ifdef USE_KKCC | |
| 1116 SET_KEY_DATA_MODIFIERS (&indirection, XINT (XCDR (idx))); | 1077 SET_KEY_DATA_MODIFIERS (&indirection, XINT (XCDR (idx))); |
| 1117 #else /* not USE_KKCC */ | |
| 1118 indirection.modifiers = 0; | |
| 1119 #endif /* not USE_KKCC */ | |
| 1120 } | 1078 } |
| 1121 else | 1079 else |
| 1122 { | 1080 { |
| 1123 /* Random junk */ | 1081 /* Random junk */ |
| 1124 return Qnil; | 1082 return Qnil; |
| 1140 return object; | 1098 return object; |
| 1141 } | 1099 } |
| 1142 } | 1100 } |
| 1143 | 1101 |
| 1144 static Lisp_Object | 1102 static Lisp_Object |
| 1145 #ifdef USE_KKCC | |
| 1146 keymap_lookup_1 (Lisp_Object keymap, const Lisp_Key_Data *key, | 1103 keymap_lookup_1 (Lisp_Object keymap, const Lisp_Key_Data *key, |
| 1147 #else /* not USE_KKCC */ | |
| 1148 keymap_lookup_1 (Lisp_Object keymap, const struct key_data *key, | |
| 1149 #endif /* not USE_KKCC */ | |
| 1150 int accept_default) | 1104 int accept_default) |
| 1151 { | 1105 { |
| 1152 /* This function can GC */ | 1106 /* This function can GC */ |
| 1153 #ifdef USE_KKCC | |
| 1154 return get_keyelt (keymap_lookup_directly (keymap, | 1107 return get_keyelt (keymap_lookup_directly (keymap, |
| 1155 KEY_DATA_KEYSYM (key), | 1108 KEY_DATA_KEYSYM (key), |
| 1156 KEY_DATA_MODIFIERS (key)), | 1109 KEY_DATA_MODIFIERS (key)), |
| 1157 accept_default); | 1110 accept_default); |
| 1158 #else /* not USE_KKCC */ | |
| 1159 return get_keyelt (keymap_lookup_directly (keymap, | |
| 1160 key->keysym, key->modifiers), | |
| 1161 accept_default); | |
| 1162 #endif /* not USE_KKCC */ | |
| 1163 } | 1111 } |
| 1164 | 1112 |
| 1165 | 1113 |
| 1166 /************************************************************************/ | 1114 /************************************************************************/ |
| 1167 /* Copying keymaps */ | 1115 /* Copying keymaps */ |
| 1450 -- integers are converted into the equivalent characters. | 1398 -- integers are converted into the equivalent characters. |
| 1451 -- one-character strings are converted into the equivalent characters. | 1399 -- one-character strings are converted into the equivalent characters. |
| 1452 */ | 1400 */ |
| 1453 | 1401 |
| 1454 static void | 1402 static void |
| 1455 #ifdef USE_KKCC | |
| 1456 define_key_parser (Lisp_Object spec, Lisp_Key_Data *returned_value) | 1403 define_key_parser (Lisp_Object spec, Lisp_Key_Data *returned_value) |
| 1457 #else /* not USE_KKCC */ | |
| 1458 define_key_parser (Lisp_Object spec, struct key_data *returned_value) | |
| 1459 #endif /* not USE_KKCC */ | |
| 1460 { | 1404 { |
| 1461 if (CHAR_OR_CHAR_INTP (spec)) | 1405 if (CHAR_OR_CHAR_INTP (spec)) |
| 1462 { | 1406 { |
| 1463 #ifdef USE_KKCC | |
| 1464 Lisp_Object event = Fmake_event (Qnil, Qnil); | 1407 Lisp_Object event = Fmake_event (Qnil, Qnil); |
| 1465 struct gcpro gcpro1; | 1408 struct gcpro gcpro1; |
| 1466 GCPRO1 (event); | 1409 GCPRO1 (event); |
| 1467 XSET_EVENT_TYPE (event, empty_event); | |
| 1468 character_to_event (XCHAR_OR_CHAR_INT (spec), XEVENT (event), | 1410 character_to_event (XCHAR_OR_CHAR_INT (spec), XEVENT (event), |
| 1469 XCONSOLE (Vselected_console), 0, 0); | 1411 XCONSOLE (Vselected_console), 0, 0); |
| 1470 SET_KEY_DATA_KEYSYM (returned_value, XKEY_DATA_KEYSYM (XEVENT_DATA (event))); | 1412 SET_KEY_DATA_KEYSYM (returned_value, XEVENT_KEY_KEYSYM (event)); |
| 1471 SET_KEY_DATA_MODIFIERS (returned_value, | 1413 SET_KEY_DATA_MODIFIERS (returned_value, |
| 1472 XKEY_DATA_MODIFIERS (XEVENT_DATA (event))); | 1414 XEVENT_KEY_MODIFIERS (event)); |
| 1473 #else /* not USE_KKCC */ | 1415 UNGCPRO; |
| 1474 Lisp_Event event; | |
| 1475 event.event_type = empty_event; | |
| 1476 character_to_event (XCHAR_OR_CHAR_INT (spec), &event, | |
| 1477 XCONSOLE (Vselected_console), 0, 0); | |
| 1478 returned_value->keysym = event.event.key.keysym; | |
| 1479 returned_value->modifiers = event.event.key.modifiers; | |
| 1480 #endif /* not USE_KKCC */ | |
| 1481 } | 1416 } |
| 1482 else if (EVENTP (spec)) | 1417 else if (EVENTP (spec)) |
| 1483 { | 1418 { |
| 1484 #ifdef USE_KKCC | |
| 1485 switch (XEVENT_TYPE (spec)) | 1419 switch (XEVENT_TYPE (spec)) |
| 1486 #else /* not USE_KKCC */ | |
| 1487 switch (XEVENT (spec)->event_type) | |
| 1488 #endif /* not USE_KKCC */ | |
| 1489 { | 1420 { |
| 1490 case key_press_event: | 1421 case key_press_event: |
| 1491 { | 1422 { |
| 1492 #ifdef USE_KKCC | 1423 SET_KEY_DATA_KEYSYM (returned_value, XEVENT_KEY_KEYSYM (spec)); |
| 1493 SET_KEY_DATA_KEYSYM (returned_value, XKEY_DATA_KEYSYM (XEVENT_DATA (spec))); | 1424 SET_KEY_DATA_MODIFIERS (returned_value, XEVENT_KEY_MODIFIERS (spec)); |
| 1494 SET_KEY_DATA_MODIFIERS (returned_value, XKEY_DATA_MODIFIERS (XEVENT_DATA (spec))); | |
| 1495 #else /* not USE_KKCC */ | |
| 1496 returned_value->keysym = XEVENT (spec)->event.key.keysym; | |
| 1497 returned_value->modifiers = XEVENT (spec)->event.key.modifiers; | |
| 1498 #endif /* not USE_KKCC */ | |
| 1499 break; | 1425 break; |
| 1500 } | 1426 } |
| 1501 case button_press_event: | 1427 case button_press_event: |
| 1502 case button_release_event: | 1428 case button_release_event: |
| 1503 { | 1429 { |
| 1504 #ifdef USE_KKCC | |
| 1505 int down = (XEVENT_TYPE (spec) == button_press_event); | 1430 int down = (XEVENT_TYPE (spec) == button_press_event); |
| 1506 switch (XBUTTON_DATA_BUTTON (XEVENT_DATA (spec))) | 1431 switch (XEVENT_BUTTON_BUTTON (spec)) |
| 1507 { | 1432 { |
| 1508 case 1: | 1433 case 1: |
| 1509 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton1 : Qbutton1up)); | 1434 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton1 : Qbutton1up)); |
| 1510 break; | 1435 break; |
| 1511 case 2: | 1436 case 2: |
| 1528 break; | 1453 break; |
| 1529 default: | 1454 default: |
| 1530 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton0 : Qbutton0up)); | 1455 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton0 : Qbutton0up)); |
| 1531 break; | 1456 break; |
| 1532 } | 1457 } |
| 1533 SET_KEY_DATA_MODIFIERS (returned_value, XBUTTON_DATA_MODIFIERS (XEVENT_DATA (spec))); | 1458 SET_KEY_DATA_MODIFIERS (returned_value, XEVENT_BUTTON_MODIFIERS (spec)); |
| 1534 #else /* not USE_KKCC */ | |
| 1535 int down = (XEVENT (spec)->event_type == button_press_event); | |
| 1536 switch (XEVENT (spec)->event.button.button) | |
| 1537 { | |
| 1538 case 1: | |
| 1539 returned_value->keysym = (down ? Qbutton1 : Qbutton1up); break; | |
| 1540 case 2: | |
| 1541 returned_value->keysym = (down ? Qbutton2 : Qbutton2up); break; | |
| 1542 case 3: | |
| 1543 returned_value->keysym = (down ? Qbutton3 : Qbutton3up); break; | |
| 1544 case 4: | |
| 1545 returned_value->keysym = (down ? Qbutton4 : Qbutton4up); break; | |
| 1546 case 5: | |
| 1547 returned_value->keysym = (down ? Qbutton5 : Qbutton5up); break; | |
| 1548 case 6: | |
| 1549 returned_value->keysym = (down ? Qbutton6 : Qbutton6up); break; | |
| 1550 case 7: | |
| 1551 returned_value->keysym = (down ? Qbutton7 : Qbutton7up); break; | |
| 1552 default: | |
| 1553 returned_value->keysym = (down ? Qbutton0 : Qbutton0up); break; | |
| 1554 } | |
| 1555 returned_value->modifiers = XEVENT (spec)->event.button.modifiers; | |
| 1556 #endif /* not USE_KKCC */ | |
| 1557 break; | 1459 break; |
| 1558 } | 1460 } |
| 1559 default: | 1461 default: |
| 1560 wtaerror ("unable to bind this type of event", spec); | 1462 wtaerror ("unable to bind this type of event", spec); |
| 1561 } | 1463 } |
| 1564 { | 1466 { |
| 1565 /* Be nice, allow = to mean (=) */ | 1467 /* Be nice, allow = to mean (=) */ |
| 1566 if (bucky_sym_to_bucky_bit (spec) != 0) | 1468 if (bucky_sym_to_bucky_bit (spec) != 0) |
| 1567 invalid_argument ("Key is a modifier name", spec); | 1469 invalid_argument ("Key is a modifier name", spec); |
| 1568 define_key_check_and_coerce_keysym (spec, &spec, 0); | 1470 define_key_check_and_coerce_keysym (spec, &spec, 0); |
| 1569 #ifdef USE_KKCC | |
| 1570 SET_KEY_DATA_KEYSYM (returned_value, spec); | 1471 SET_KEY_DATA_KEYSYM (returned_value, spec); |
| 1571 SET_KEY_DATA_MODIFIERS (returned_value, 0); | 1472 SET_KEY_DATA_MODIFIERS (returned_value, 0); |
| 1572 #else /* not USE_KKCC */ | |
| 1573 returned_value->keysym = spec; | |
| 1574 returned_value->modifiers = 0; | |
| 1575 #endif /* not USE_KKCC */ | |
| 1576 } | 1473 } |
| 1577 else if (CONSP (spec)) | 1474 else if (CONSP (spec)) |
| 1578 { | 1475 { |
| 1579 int modifiers = 0; | 1476 int modifiers = 0; |
| 1580 Lisp_Object keysym = Qnil; | 1477 Lisp_Object keysym = Qnil; |
| 1605 if (!NILP (rest)) | 1502 if (!NILP (rest)) |
| 1606 signal_error (Qlist_formation_error, | 1503 signal_error (Qlist_formation_error, |
| 1607 "List must be nil-terminated", spec); | 1504 "List must be nil-terminated", spec); |
| 1608 | 1505 |
| 1609 define_key_check_and_coerce_keysym (spec, &keysym, modifiers); | 1506 define_key_check_and_coerce_keysym (spec, &keysym, modifiers); |
| 1610 #ifdef USE_KKCC | |
| 1611 SET_KEY_DATA_KEYSYM(returned_value, keysym); | 1507 SET_KEY_DATA_KEYSYM(returned_value, keysym); |
| 1612 SET_KEY_DATA_MODIFIERS (returned_value, modifiers); | 1508 SET_KEY_DATA_MODIFIERS (returned_value, modifiers); |
| 1613 #else /* not USE_KKCC */ | |
| 1614 returned_value->keysym = keysym; | |
| 1615 returned_value->modifiers = modifiers; | |
| 1616 #endif /* not USE_KKCC */ | |
| 1617 } | 1509 } |
| 1618 else | 1510 else |
| 1619 { | 1511 { |
| 1620 invalid_argument ("Unknown key-sequence specifier", | 1512 invalid_argument ("Unknown key-sequence specifier", |
| 1621 spec); | 1513 spec); |
| 1625 /* Used by character-to-event */ | 1517 /* Used by character-to-event */ |
| 1626 void | 1518 void |
| 1627 key_desc_list_to_event (Lisp_Object list, Lisp_Object event, | 1519 key_desc_list_to_event (Lisp_Object list, Lisp_Object event, |
| 1628 int allow_menu_events) | 1520 int allow_menu_events) |
| 1629 { | 1521 { |
| 1630 #ifdef USE_KKCC | |
| 1631 Lisp_Key_Data raw_key; | 1522 Lisp_Key_Data raw_key; |
| 1632 #else /* not USE_KKCC */ | |
| 1633 struct key_data raw_key; | |
| 1634 #endif /* not USE_KKCC */ | |
| 1635 | 1523 |
| 1636 if (allow_menu_events && | 1524 if (allow_menu_events && |
| 1637 CONSP (list) && | 1525 CONSP (list) && |
| 1638 /* #### where the hell does this come from? */ | 1526 /* #### where the hell does this come from? */ |
| 1639 EQ (XCAR (list), Qmenu_selection)) | 1527 EQ (XCAR (list), Qmenu_selection)) |
| 1644 arg = Fcar (Fcdr (list)); | 1532 arg = Fcar (Fcdr (list)); |
| 1645 if (SYMBOLP (arg)) | 1533 if (SYMBOLP (arg)) |
| 1646 fn = Qcall_interactively; | 1534 fn = Qcall_interactively; |
| 1647 else | 1535 else |
| 1648 fn = Qeval; | 1536 fn = Qeval; |
| 1649 #ifdef USE_KKCC | |
| 1650 XSET_EVENT_TYPE (event, misc_user_event); | 1537 XSET_EVENT_TYPE (event, misc_user_event); |
| 1651 XSET_EVENT_CHANNEL (event, wrap_frame (selected_frame)); | 1538 XSET_EVENT_CHANNEL (event, wrap_frame (selected_frame ())); |
| 1652 XSET_MISC_USER_DATA_FUNCTION (XEVENT_DATA (event), fn); | 1539 XSET_EVENT_MISC_USER_FUNCTION (event, fn); |
| 1653 XSET_MISC_USER_DATA_OBJECT (XEVENT_DATA (event), arg); | 1540 XSET_EVENT_MISC_USER_OBJECT (event, arg); |
| 1654 #else /* not USE_KKCC */ | |
| 1655 XEVENT (event)->channel = wrap_frame (selected_frame ()); | |
| 1656 XEVENT (event)->event_type = misc_user_event; | |
| 1657 XEVENT (event)->event.eval.function = fn; | |
| 1658 XEVENT (event)->event.eval.object = arg; | |
| 1659 #endif /* not USE_KKCC */ | |
| 1660 return; | 1541 return; |
| 1661 } | 1542 } |
| 1662 | 1543 |
| 1663 define_key_parser (list, &raw_key); | 1544 define_key_parser (list, &raw_key); |
| 1664 | 1545 |
| 1671 EQ (raw_key.keysym, Qbutton6) || EQ (raw_key.keysym, Qbutton6up) || | 1552 EQ (raw_key.keysym, Qbutton6) || EQ (raw_key.keysym, Qbutton6up) || |
| 1672 EQ (raw_key.keysym, Qbutton7) || EQ (raw_key.keysym, Qbutton7up)) | 1553 EQ (raw_key.keysym, Qbutton7) || EQ (raw_key.keysym, Qbutton7up)) |
| 1673 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros", | 1554 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros", |
| 1674 Qunbound); | 1555 Qunbound); |
| 1675 | 1556 |
| 1676 #ifdef USE_KKCC | |
| 1677 XSET_EVENT_CHANNEL (event, Vselected_console); | 1557 XSET_EVENT_CHANNEL (event, Vselected_console); |
| 1678 XSET_EVENT_TYPE (event, key_press_event); | 1558 XSET_EVENT_TYPE (event, key_press_event); |
| 1679 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), raw_key.keysym); | 1559 XSET_EVENT_KEY_KEYSYM (event, raw_key.keysym); |
| 1680 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (&raw_key)); | 1560 XSET_EVENT_KEY_MODIFIERS (event, KEY_DATA_MODIFIERS (&raw_key)); |
| 1681 #else /* not USE_KKCC */ | |
| 1682 XEVENT (event)->channel = Vselected_console; | |
| 1683 XEVENT (event)->event_type = key_press_event; | |
| 1684 XEVENT (event)->event.key.keysym = raw_key.keysym; | |
| 1685 XEVENT (event)->event.key.modifiers = raw_key.modifiers; | |
| 1686 #endif /* not USE_KKCC */ | |
| 1687 } | 1561 } |
| 1688 | 1562 |
| 1689 | 1563 |
| 1690 int | 1564 int |
| 1691 event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier) | 1565 event_matches_key_specifier_p (Lisp_Object event, Lisp_Object key_specifier) |
| 1692 { | 1566 { |
| 1693 Lisp_Object event2 = Qnil; | 1567 Lisp_Object event2 = Qnil; |
| 1694 int retval; | 1568 int retval; |
| 1695 struct gcpro gcpro1; | 1569 struct gcpro gcpro1; |
| 1696 | 1570 |
| 1697 if (event->event_type != key_press_event || NILP (key_specifier) || | 1571 if (XEVENT_TYPE (event) != key_press_event || NILP (key_specifier) || |
| 1698 (INTP (key_specifier) && !CHAR_INTP (key_specifier))) | 1572 (INTP (key_specifier) && !CHAR_INTP (key_specifier))) |
| 1699 return 0; | 1573 return 0; |
| 1700 | 1574 |
| 1701 /* if the specifier is an integer such as 27, then it should match | 1575 /* if the specifier is an integer such as 27, then it should match |
| 1702 both of the events 'escape' and 'control ['. Calling | 1576 both of the events 'escape' and 'control ['. Calling |
| 1714 is silently converted into 'escape' by the keyboard driver. | 1588 is silently converted into 'escape' by the keyboard driver. |
| 1715 In this case, ASCII is the only thing we know about, so we have | 1589 In this case, ASCII is the only thing we know about, so we have |
| 1716 to compare the ASCII values. */ | 1590 to compare the ASCII values. */ |
| 1717 | 1591 |
| 1718 GCPRO1 (event2); | 1592 GCPRO1 (event2); |
| 1719 event2 = Fmake_event (Qnil, Qnil); | 1593 if (EVENTP (key_specifier)) |
| 1720 Fcharacter_to_event (key_specifier, event2, Qnil, Qnil); | 1594 event2 = Fcopy_event (key_specifier, Qnil); |
| 1595 else | |
| 1596 event2 = Fcharacter_to_event (key_specifier, Qnil, Qnil, Qnil); | |
| 1721 if (XEVENT (event2)->event_type != key_press_event) | 1597 if (XEVENT (event2)->event_type != key_press_event) |
| 1722 retval = 0; | 1598 retval = 0; |
| 1723 else if (CONSOLE_TTY_P (XCONSOLE (EVENT_CHANNEL (event)))) | 1599 else if (CONSOLE_TTY_P (XCONSOLE (XEVENT_CHANNEL (event)))) |
| 1724 { | 1600 { |
| 1725 int ch1, ch2; | 1601 int ch1, ch2; |
| 1726 | 1602 |
| 1727 ch1 = event_to_character (event, 0, 0, 0); | 1603 ch1 = event_to_character (event, 0, 0, 0); |
| 1728 ch2 = event_to_character (XEVENT (event2), 0, 0, 0); | 1604 ch2 = event_to_character (event2, 0, 0, 0); |
| 1729 retval = (ch1 >= 0 && ch2 >= 0 && ch1 == ch2); | 1605 retval = (ch1 >= 0 && ch2 >= 0 && ch1 == ch2); |
| 1730 } | 1606 } |
| 1731 #ifdef USE_KKCC | 1607 else if (EQ (XEVENT_KEY_KEYSYM (event), XEVENT_KEY_KEYSYM (event2)) && |
| 1732 else if (EQ (XKEY_DATA_KEYSYM (EVENT_DATA (event)), XKEY_DATA_KEYSYM (XEVENT_DATA (event2))) && | 1608 XEVENT_KEY_MODIFIERS (event) == XEVENT_KEY_MODIFIERS (event2)) |
| 1733 XKEY_DATA_MODIFIERS (EVENT_DATA (event)) == XKEY_DATA_MODIFIERS (XEVENT_DATA (event2))) | |
| 1734 #else /* not USE_KKCC */ | |
| 1735 else if (EQ (event->event.key.keysym, XEVENT (event2)->event.key.keysym) && | |
| 1736 event->event.key.modifiers == XEVENT (event2)->event.key.modifiers) | |
| 1737 #endif /* not USE_KKCC */ | |
| 1738 retval = 1; | 1609 retval = 1; |
| 1739 else | 1610 else |
| 1740 retval = 0; | 1611 retval = 0; |
| 1741 Fdeallocate_event (event2); | 1612 Fdeallocate_event (event2); |
| 1742 UNGCPRO; | 1613 UNGCPRO; |
| 1743 return retval; | 1614 return retval; |
| 1744 } | 1615 } |
| 1745 | 1616 |
| 1746 static int | 1617 static int |
| 1747 #ifdef USE_KKCC | |
| 1748 meta_prefix_char_p (const Lisp_Key_Data *key) | 1618 meta_prefix_char_p (const Lisp_Key_Data *key) |
| 1749 #else /* not USE_KKCC */ | 1619 { |
| 1750 meta_prefix_char_p (const struct key_data *key) | |
| 1751 #endif /* not USE_KKCC */ | |
| 1752 { | |
| 1753 #ifdef USE_KKCC | |
| 1754 Lisp_Object event = Fmake_event (Qnil, Qnil); | 1620 Lisp_Object event = Fmake_event (Qnil, Qnil); |
| 1755 struct gcpro gcpro1; | 1621 struct gcpro gcpro1; |
| 1622 int retval; | |
| 1623 | |
| 1756 GCPRO1 (event); | 1624 GCPRO1 (event); |
| 1757 | 1625 |
| 1758 XSET_EVENT_TYPE (event, key_press_event); | 1626 XSET_EVENT_TYPE (event, key_press_event); |
| 1759 XSET_EVENT_CHANNEL (event, Vselected_console); | 1627 XSET_EVENT_CHANNEL (event, Vselected_console); |
| 1760 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), KEY_DATA_KEYSYM (key)); | 1628 XSET_EVENT_KEY_KEYSYM (event, KEY_DATA_KEYSYM (key)); |
| 1761 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (key)); | 1629 XSET_EVENT_KEY_MODIFIERS (event, KEY_DATA_MODIFIERS (key)); |
| 1762 return event_matches_key_specifier_p (XEVENT(event), Vmeta_prefix_char); | 1630 retval = event_matches_key_specifier_p (event, Vmeta_prefix_char); |
| 1763 #else /* not USE_KKCC */ | 1631 UNGCPRO; |
| 1764 Lisp_Event event; | 1632 return retval; |
| 1765 | |
| 1766 event.event_type = key_press_event; | |
| 1767 event.channel = Vselected_console; | |
| 1768 event.event.key.keysym = key->keysym; | |
| 1769 event.event.key.modifiers = key->modifiers; | |
| 1770 return event_matches_key_specifier_p (&event, Vmeta_prefix_char); | |
| 1771 #endif /* not USE_KKCC */ | |
| 1772 } | 1633 } |
| 1773 | 1634 |
| 1774 DEFUN ("event-matches-key-specifier-p", Fevent_matches_key_specifier_p, 2, 2, 0, /* | 1635 DEFUN ("event-matches-key-specifier-p", Fevent_matches_key_specifier_p, 2, 2, 0, /* |
| 1775 Return non-nil if EVENT matches KEY-SPECIFIER. | 1636 Return non-nil if EVENT matches KEY-SPECIFIER. |
| 1776 This can be useful, e.g., to determine if the user pressed `help-char' or | 1637 This can be useful, e.g., to determine if the user pressed `help-char' or |
| 1777 `quit-char'. | 1638 `quit-char'. |
| 1639 | |
| 1640 KEY-SPECIFIER can be a character, integer, a symbol, a list of modifiers | |
| 1641 and symbols, or an event. | |
| 1642 | |
| 1643 What this actually happens is this: | |
| 1644 | |
| 1645 \(1) Return no, if EVENT is not a key press event or if KEY-SPECIFIER is nil | |
| 1646 or an integer that cannot be converted to a character. | |
| 1647 | |
| 1648 \(2) If KEY-SPECIFIER is a character or integer, | |
| 1649 (event-to-character EVENT nil nil nil) is called, and the characters are | |
| 1650 compared to get the result. The reason for special-casing this and doing | |
| 1651 it this way is to ensure that, e.g., a KEY-SPECIFIER of 27 matches both | |
| 1652 a key-press `escape' and a key-press `control ['. #### Think about META | |
| 1653 argument to event-to-character. | |
| 1654 | |
| 1655 \(3) If KEY-SPECIFIER is an event, fine; else, convert to an event using | |
| 1656 \(character-to-event KEY-SPECIFIER nil nil nil). If EVENT is not on a TTY, | |
| 1657 we just compare keysyms and modifiers and return yes if both are equal. | |
| 1658 For TTY, we do character-level comparison by converting both to a character | |
| 1659 with (event-to-character ... nil nil nil) and comparing the characters. | |
| 1660 | |
| 1778 */ | 1661 */ |
| 1779 (event, key_specifier)) | 1662 (event, key_specifier)) |
| 1780 { | 1663 { |
| 1781 CHECK_LIVE_EVENT (event); | 1664 CHECK_LIVE_EVENT (event); |
| 1782 return (event_matches_key_specifier_p (XEVENT (event), key_specifier) | 1665 return (event_matches_key_specifier_p (event, key_specifier) ? Qt : Qnil); |
| 1783 ? Qt : Qnil); | 1666 } |
| 1784 } | 1667 #define MACROLET(k, m) do { \ |
| 1785 #ifdef USE_KKCC | 1668 SET_KEY_DATA_KEYSYM (returned_value, k); \ |
| 1786 #define MACROLET(k,m) do { \ | 1669 SET_KEY_DATA_MODIFIERS (returned_value, m); \ |
| 1787 SET_KEY_DATA_KEYSYM(returned_value, k); \ | 1670 RETURN_SANS_WARNINGS; \ |
| 1788 SET_KEY_DATA_MODIFIERS(returned_value, m); \ | |
| 1789 RETURN_SANS_WARNINGS; \ | |
| 1790 } while (0) | 1671 } while (0) |
| 1791 #else /* not USE_KKCC */ | |
| 1792 #define MACROLET(k,m) do { \ | |
| 1793 returned_value->keysym = (k); \ | |
| 1794 returned_value->modifiers = (m); \ | |
| 1795 RETURN_SANS_WARNINGS; \ | |
| 1796 } while (0) | |
| 1797 #endif /* not USE_KKCC */ | |
| 1798 /* ASCII grunge. | 1672 /* ASCII grunge. |
| 1799 Given a keysym, return another keysym/modifier pair which could be | 1673 Given a keysym, return another keysym/modifier pair which could be |
| 1800 considered the same key in an ASCII world. Backspace returns ^H, for | 1674 considered the same key in an ASCII world. Backspace returns ^H, for |
| 1801 example. | 1675 example. |
| 1802 */ | 1676 */ |
| 1803 static void | 1677 static void |
| 1804 #ifdef USE_KKCC | |
| 1805 define_key_alternate_name (Lisp_Key_Data *key, | 1678 define_key_alternate_name (Lisp_Key_Data *key, |
| 1806 Lisp_Key_Data *returned_value) | 1679 Lisp_Key_Data *returned_value) |
| 1807 #else /* not USE_KKCC */ | 1680 { |
| 1808 define_key_alternate_name (struct key_data *key, | |
| 1809 struct key_data *returned_value) | |
| 1810 #endif /* not USE_KKCC */ | |
| 1811 { | |
| 1812 #ifdef USE_KKCC | |
| 1813 Lisp_Object keysym = KEY_DATA_KEYSYM (key); | 1681 Lisp_Object keysym = KEY_DATA_KEYSYM (key); |
| 1814 int modifiers = KEY_DATA_MODIFIERS (key); | 1682 int modifiers = KEY_DATA_MODIFIERS (key); |
| 1815 #else /* not USE_KKCC */ | |
| 1816 Lisp_Object keysym = key->keysym; | |
| 1817 int modifiers = key->modifiers; | |
| 1818 #endif /* not USE_KKCC */ | |
| 1819 int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL)); | 1683 int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL)); |
| 1820 int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META)); | 1684 int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META)); |
| 1821 #ifdef USE_KKCC | |
| 1822 SET_KEY_DATA_KEYSYM (returned_value, Qnil); /* By default, no "alternate" key */ | 1685 SET_KEY_DATA_KEYSYM (returned_value, Qnil); /* By default, no "alternate" key */ |
| 1823 SET_KEY_DATA_MODIFIERS (returned_value, 0); | 1686 SET_KEY_DATA_MODIFIERS (returned_value, 0); |
| 1824 #else /* not USE_KKCC */ | |
| 1825 returned_value->keysym = Qnil; /* By default, no "alternate" key */ | |
| 1826 returned_value->modifiers = 0; | |
| 1827 #endif /* not USE_KKCC */ | |
| 1828 if (modifiers_sans_meta == XEMACS_MOD_CONTROL) | 1687 if (modifiers_sans_meta == XEMACS_MOD_CONTROL) |
| 1829 { | 1688 { |
| 1830 if (EQ (keysym, QKspace)) | 1689 if (EQ (keysym, QKspace)) |
| 1831 MACROLET (make_char ('@'), modifiers); | 1690 MACROLET (make_char ('@'), modifiers); |
| 1832 else if (!CHARP (keysym)) | 1691 else if (!CHARP (keysym)) |
| 1864 else | 1723 else |
| 1865 return; | 1724 return; |
| 1866 #undef MACROLET | 1725 #undef MACROLET |
| 1867 } | 1726 } |
| 1868 | 1727 |
| 1869 | |
| 1870 static void | 1728 static void |
| 1871 ensure_meta_prefix_char_keymapp (Lisp_Object keys, int indx, | 1729 ensure_meta_prefix_char_keymapp (Lisp_Object keys, int indx, |
| 1872 Lisp_Object keymap) | 1730 Lisp_Object keymap) |
| 1873 { | 1731 { |
| 1874 /* This function can GC */ | 1732 /* This function can GC */ |
| 1875 Lisp_Object new_keys; | 1733 Lisp_Object new_keys; |
| 1876 int i; | 1734 int i; |
| 1877 Lisp_Object mpc_binding; | 1735 Lisp_Object mpc_binding; |
| 1878 #ifdef USE_KKCC | |
| 1879 Lisp_Key_Data meta_key; | 1736 Lisp_Key_Data meta_key; |
| 1880 #else /* not USE_KKCC */ | |
| 1881 struct key_data meta_key; | |
| 1882 #endif /* not USE_KKCC */ | |
| 1883 if (NILP (Vmeta_prefix_char) || | 1737 if (NILP (Vmeta_prefix_char) || |
| 1884 (INTP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char))) | 1738 (INTP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char))) |
| 1885 return; | 1739 return; |
| 1886 | 1740 |
| 1887 define_key_parser (Vmeta_prefix_char, &meta_key); | 1741 define_key_parser (Vmeta_prefix_char, &meta_key); |
| 2078 | 1932 |
| 2079 idx = 0; | 1933 idx = 0; |
| 2080 while (1) | 1934 while (1) |
| 2081 { | 1935 { |
| 2082 Lisp_Object c; | 1936 Lisp_Object c; |
| 2083 #ifdef USE_KKCC | |
| 2084 Lisp_Key_Data raw_key1; | 1937 Lisp_Key_Data raw_key1; |
| 2085 Lisp_Key_Data raw_key2; | 1938 Lisp_Key_Data raw_key2; |
| 2086 #else /* not USE_KKCC */ | |
| 2087 struct key_data raw_key1; | |
| 2088 struct key_data raw_key2; | |
| 2089 #endif /* not USE_KKCC */ | |
| 2090 if (STRINGP (keys)) | 1939 if (STRINGP (keys)) |
| 2091 c = make_char (string_ichar (keys, idx)); | 1940 c = make_char (string_ichar (keys, idx)); |
| 2092 else | 1941 else |
| 2093 c = XVECTOR_DATA (keys) [idx]; | 1942 c = XVECTOR_DATA (keys) [idx]; |
| 2094 | 1943 |
| 2198 to make where-is-internal really fly. */ | 2047 to make where-is-internal really fly. */ |
| 2199 | 2048 |
| 2200 struct raw_lookup_key_mapper_closure | 2049 struct raw_lookup_key_mapper_closure |
| 2201 { | 2050 { |
| 2202 int remaining; | 2051 int remaining; |
| 2203 #ifdef USE_KKCC | |
| 2204 const Lisp_Key_Data *raw_keys; | 2052 const Lisp_Key_Data *raw_keys; |
| 2205 #else /* not USE_KKCC */ | |
| 2206 const struct key_data *raw_keys; | |
| 2207 #endif /* not USE_KKCC */ | |
| 2208 int raw_keys_count; | 2053 int raw_keys_count; |
| 2209 int keys_so_far; | 2054 int keys_so_far; |
| 2210 int accept_default; | 2055 int accept_default; |
| 2211 }; | 2056 }; |
| 2212 | 2057 |
| 2213 static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *); | 2058 static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *); |
| 2214 | 2059 |
| 2215 /* Caller should gc-protect args (keymaps may autoload) */ | 2060 /* Caller should gc-protect args (keymaps may autoload) */ |
| 2216 static Lisp_Object | 2061 static Lisp_Object |
| 2217 raw_lookup_key (Lisp_Object keymap, | 2062 raw_lookup_key (Lisp_Object keymap, |
| 2218 #ifdef USE_KKCC | |
| 2219 const Lisp_Key_Data *raw_keys, int raw_keys_count, | 2063 const Lisp_Key_Data *raw_keys, int raw_keys_count, |
| 2220 #else /* not USE_KKCC */ | |
| 2221 const struct key_data *raw_keys, int raw_keys_count, | |
| 2222 #endif /* not USE_KKCC */ | |
| 2223 int keys_so_far, int accept_default) | 2064 int keys_so_far, int accept_default) |
| 2224 { | 2065 { |
| 2225 /* This function can GC */ | 2066 /* This function can GC */ |
| 2226 struct raw_lookup_key_mapper_closure c; | 2067 struct raw_lookup_key_mapper_closure c; |
| 2227 c.remaining = raw_keys_count - 1; | 2068 c.remaining = raw_keys_count - 1; |
| 2240 struct raw_lookup_key_mapper_closure *c = | 2081 struct raw_lookup_key_mapper_closure *c = |
| 2241 (struct raw_lookup_key_mapper_closure *) arg; | 2082 (struct raw_lookup_key_mapper_closure *) arg; |
| 2242 int accept_default = c->accept_default; | 2083 int accept_default = c->accept_default; |
| 2243 int remaining = c->remaining; | 2084 int remaining = c->remaining; |
| 2244 int keys_so_far = c->keys_so_far; | 2085 int keys_so_far = c->keys_so_far; |
| 2245 #ifdef USE_KKCC | |
| 2246 const Lisp_Key_Data *raw_keys = c->raw_keys; | 2086 const Lisp_Key_Data *raw_keys = c->raw_keys; |
| 2247 #else /* not USE_KKCC */ | |
| 2248 const struct key_data *raw_keys = c->raw_keys; | |
| 2249 #endif /* not USE_KKCC */ | |
| 2250 Lisp_Object cmd; | 2087 Lisp_Object cmd; |
| 2251 | 2088 |
| 2252 if (! meta_prefix_char_p (&(raw_keys[0]))) | 2089 if (! meta_prefix_char_p (&(raw_keys[0]))) |
| 2253 { | 2090 { |
| 2254 /* Normal case: every case except the meta-hack (see below). */ | 2091 /* Normal case: every case except the meta-hack (see below). */ |
| 2297 if (!NILP (cmd)) | 2134 if (!NILP (cmd)) |
| 2298 cmd = raw_lookup_key (cmd, raw_keys + 1, remaining, | 2135 cmd = raw_lookup_key (cmd, raw_keys + 1, remaining, |
| 2299 keys_so_far + 1, accept_default); | 2136 keys_so_far + 1, accept_default); |
| 2300 else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0) | 2137 else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0) |
| 2301 { | 2138 { |
| 2302 #ifdef USE_KKCC | |
| 2303 Lisp_Key_Data metified; | 2139 Lisp_Key_Data metified; |
| 2304 #else /* not USE_KKCC */ | |
| 2305 struct key_data metified; | |
| 2306 #endif /* not USE_KKCC */ | |
| 2307 metified.keysym = raw_keys[1].keysym; | 2140 metified.keysym = raw_keys[1].keysym; |
| 2308 metified.modifiers = raw_keys[1].modifiers | | 2141 metified.modifiers = raw_keys[1].modifiers | |
| 2309 (unsigned char) XEMACS_MOD_META; | 2142 (unsigned char) XEMACS_MOD_META; |
| 2310 | 2143 |
| 2311 /* Search for meta-next-char sequence directly */ | 2144 /* Search for meta-next-char sequence directly */ |
| 2333 static Lisp_Object | 2166 static Lisp_Object |
| 2334 lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys, | 2167 lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys, |
| 2335 int accept_default) | 2168 int accept_default) |
| 2336 { | 2169 { |
| 2337 /* This function can GC */ | 2170 /* This function can GC */ |
| 2338 #ifdef USE_KKCC | |
| 2339 Lisp_Key_Data kkk[20]; | 2171 Lisp_Key_Data kkk[20]; |
| 2340 Lisp_Key_Data *raw_keys; | 2172 Lisp_Key_Data *raw_keys; |
| 2341 #else /* not USE_KKCC */ | |
| 2342 struct key_data kkk[20]; | |
| 2343 struct key_data *raw_keys; | |
| 2344 #endif /* not USE_KKCC */ | |
| 2345 int i; | 2173 int i; |
| 2346 | 2174 |
| 2347 if (nkeys == 0) | 2175 if (nkeys == 0) |
| 2348 return Qnil; | 2176 return Qnil; |
| 2349 | 2177 |
| 2350 if (nkeys < countof (kkk)) | 2178 if (nkeys < countof (kkk)) |
| 2351 raw_keys = kkk; | 2179 raw_keys = kkk; |
| 2352 else | 2180 else |
| 2353 #ifdef USE_KKCC | |
| 2354 raw_keys = alloca_array (Lisp_Key_Data, nkeys); | 2181 raw_keys = alloca_array (Lisp_Key_Data, nkeys); |
| 2355 #else /* not USE_KKCC */ | |
| 2356 raw_keys = alloca_array (struct key_data, nkeys); | |
| 2357 #endif /* not USE_KKCC */ | |
| 2358 | 2182 |
| 2359 for (i = 0; i < nkeys; i++) | 2183 for (i = 0; i < nkeys; i++) |
| 2360 { | 2184 { |
| 2361 define_key_parser (keys[i], &(raw_keys[i])); | 2185 define_key_parser (keys[i], &(raw_keys[i])); |
| 2362 } | 2186 } |
| 2366 static Lisp_Object | 2190 static Lisp_Object |
| 2367 lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[], | 2191 lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[], |
| 2368 int accept_default) | 2192 int accept_default) |
| 2369 { | 2193 { |
| 2370 /* This function can GC */ | 2194 /* This function can GC */ |
| 2371 #ifdef USE_KKCC | |
| 2372 Lisp_Key_Data kkk[20]; | 2195 Lisp_Key_Data kkk[20]; |
| 2373 #else /* not USE_KKCC */ | |
| 2374 struct key_data kkk[20]; | |
| 2375 #endif /* not USE_KKCC */ | |
| 2376 Lisp_Object event; | 2196 Lisp_Object event; |
| 2377 | 2197 |
| 2378 int nkeys; | 2198 int nkeys; |
| 2379 #ifdef USE_KKCC | |
| 2380 Lisp_Key_Data *raw_keys; | 2199 Lisp_Key_Data *raw_keys; |
| 2381 #else /* not USE_KKCC */ | |
| 2382 struct key_data *raw_keys; | |
| 2383 #endif /* not USE_KKCC */ | |
| 2384 Lisp_Object tem = Qnil; | 2200 Lisp_Object tem = Qnil; |
| 2385 struct gcpro gcpro1, gcpro2; | 2201 struct gcpro gcpro1, gcpro2; |
| 2386 int iii; | 2202 int iii; |
| 2387 | 2203 |
| 2388 CHECK_LIVE_EVENT (event_head); | 2204 CHECK_LIVE_EVENT (event_head); |
| 2390 nkeys = event_chain_count (event_head); | 2206 nkeys = event_chain_count (event_head); |
| 2391 | 2207 |
| 2392 if (nkeys < countof (kkk)) | 2208 if (nkeys < countof (kkk)) |
| 2393 raw_keys = kkk; | 2209 raw_keys = kkk; |
| 2394 else | 2210 else |
| 2395 #ifdef USE_KKCC | |
| 2396 raw_keys = alloca_array (Lisp_Key_Data, nkeys); | 2211 raw_keys = alloca_array (Lisp_Key_Data, nkeys); |
| 2397 #else /* not USE_KKCC */ | |
| 2398 raw_keys = alloca_array (struct key_data, nkeys); | |
| 2399 #endif /* not USE_KKCC */ | |
| 2400 | 2212 |
| 2401 nkeys = 0; | 2213 nkeys = 0; |
| 2402 EVENT_CHAIN_LOOP (event, event_head) | 2214 EVENT_CHAIN_LOOP (event, event_head) |
| 2403 define_key_parser (event, &(raw_keys[nkeys++])); | 2215 define_key_parser (event, &(raw_keys[nkeys++])); |
| 2404 GCPRO2 (keymaps[0], event_head); | 2216 GCPRO2 (keymaps[0], event_head); |
| 2443 return lookup_keys (keymap, 1, &keys, !NILP (accept_default)); | 2255 return lookup_keys (keymap, 1, &keys, !NILP (accept_default)); |
| 2444 else if (STRINGP (keys)) | 2256 else if (STRINGP (keys)) |
| 2445 { | 2257 { |
| 2446 int length = string_char_length (keys); | 2258 int length = string_char_length (keys); |
| 2447 int i; | 2259 int i; |
| 2448 #ifdef USE_KKCC | |
| 2449 Lisp_Key_Data *raw_keys = alloca_array (Lisp_Key_Data, length); | 2260 Lisp_Key_Data *raw_keys = alloca_array (Lisp_Key_Data, length); |
| 2450 #else /* not USE_KKCC */ | |
| 2451 struct key_data *raw_keys = alloca_array (struct key_data, length); | |
| 2452 #endif /* not USE_KKCC */ | |
| 2453 if (length == 0) | 2261 if (length == 0) |
| 2454 return Qnil; | 2262 return Qnil; |
| 2455 | 2263 |
| 2456 for (i = 0; i < length; i++) | 2264 for (i = 0; i < length; i++) |
| 2457 { | 2265 { |
| 3026 outside of this file doesn't need to know about. | 2834 outside of this file doesn't need to know about. |
| 3027 */ | 2835 */ |
| 3028 | 2836 |
| 3029 struct map_keymap_unsorted_closure | 2837 struct map_keymap_unsorted_closure |
| 3030 { | 2838 { |
| 3031 #ifdef USE_KKCC | |
| 3032 void (*fn) (const Lisp_Key_Data *, Lisp_Object binding, void *arg); | 2839 void (*fn) (const Lisp_Key_Data *, Lisp_Object binding, void *arg); |
| 3033 #else /* not USE_KKCC */ | |
| 3034 void (*fn) (const struct key_data *, Lisp_Object binding, void *arg); | |
| 3035 #endif /* not USE_KKCC */ | |
| 3036 void *arg; | 2840 void *arg; |
| 3037 int modifiers; | 2841 int modifiers; |
| 3038 }; | 2842 }; |
| 3039 | 2843 |
| 3040 /* used by map_keymap() */ | 2844 /* used by map_keymap() */ |
| 3058 map_keymap_unsorted_closure); | 2862 map_keymap_unsorted_closure); |
| 3059 closure->modifiers = omod; | 2863 closure->modifiers = omod; |
| 3060 } | 2864 } |
| 3061 else | 2865 else |
| 3062 { | 2866 { |
| 3063 #ifdef USE_KKCC | |
| 3064 Lisp_Key_Data key; | 2867 Lisp_Key_Data key; |
| 3065 #else /* not USE_KKCC */ | |
| 3066 struct key_data key; | |
| 3067 #endif /* not USE_KKCC */ | |
| 3068 key.keysym = keysym; | 2868 key.keysym = keysym; |
| 3069 key.modifiers = modifiers; | 2869 key.modifiers = modifiers; |
| 3070 ((*closure->fn) (&key, value, closure->arg)); | 2870 ((*closure->fn) (&key, value, closure->arg)); |
| 3071 } | 2871 } |
| 3072 return 0; | 2872 return 0; |
| 3169 | 2969 |
| 3170 /* used by map_keymap() */ | 2970 /* used by map_keymap() */ |
| 3171 static void | 2971 static void |
| 3172 map_keymap_sorted (Lisp_Object keymap_table, | 2972 map_keymap_sorted (Lisp_Object keymap_table, |
| 3173 int modifiers, | 2973 int modifiers, |
| 3174 #ifdef USE_KKCC | |
| 3175 void (*function) (const Lisp_Key_Data *key, | 2974 void (*function) (const Lisp_Key_Data *key, |
| 3176 #else /* not USE_KKCC */ | |
| 3177 void (*function) (const struct key_data *key, | |
| 3178 #endif /* not USE_KKCC */ | |
| 3179 Lisp_Object binding, | 2975 Lisp_Object binding, |
| 3180 void *map_keymap_sorted_closure), | 2976 void *map_keymap_sorted_closure), |
| 3181 void *map_keymap_sorted_closure) | 2977 void *map_keymap_sorted_closure) |
| 3182 { | 2978 { |
| 3183 /* This function can GC */ | 2979 /* This function can GC */ |
| 3206 (modifiers | sub_bits), | 3002 (modifiers | sub_bits), |
| 3207 function, | 3003 function, |
| 3208 map_keymap_sorted_closure); | 3004 map_keymap_sorted_closure); |
| 3209 else | 3005 else |
| 3210 { | 3006 { |
| 3211 #ifdef USE_KKCC | |
| 3212 Lisp_Key_Data k; | 3007 Lisp_Key_Data k; |
| 3213 #else /* not USE_KKCC */ | |
| 3214 struct key_data k; | |
| 3215 #endif /* not USE_KKCC */ | |
| 3216 k.keysym = keysym; | 3008 k.keysym = keysym; |
| 3217 k.modifiers = modifiers; | 3009 k.modifiers = modifiers; |
| 3218 ((*function) (&k, binding, map_keymap_sorted_closure)); | 3010 ((*function) (&k, binding, map_keymap_sorted_closure)); |
| 3219 } | 3011 } |
| 3220 } | 3012 } |
| 3222 } | 3014 } |
| 3223 | 3015 |
| 3224 | 3016 |
| 3225 /* used by Fmap_keymap() */ | 3017 /* used by Fmap_keymap() */ |
| 3226 static void | 3018 static void |
| 3227 #ifdef USE_KKCC | |
| 3228 map_keymap_mapper (const Lisp_Key_Data *key, | 3019 map_keymap_mapper (const Lisp_Key_Data *key, |
| 3229 #else /* not USE_KKCC */ | |
| 3230 map_keymap_mapper (const struct key_data *key, | |
| 3231 #endif /* not USE_KKCC */ | |
| 3232 Lisp_Object binding, | 3020 Lisp_Object binding, |
| 3233 void *function) | 3021 void *function) |
| 3234 { | 3022 { |
| 3235 /* This function can GC */ | 3023 /* This function can GC */ |
| 3236 Lisp_Object fn; | 3024 Lisp_Object fn; |
| 3239 } | 3027 } |
| 3240 | 3028 |
| 3241 | 3029 |
| 3242 static void | 3030 static void |
| 3243 map_keymap (Lisp_Object keymap_table, int sort_first, | 3031 map_keymap (Lisp_Object keymap_table, int sort_first, |
| 3244 #ifdef USE_KKCC | |
| 3245 void (*function) (const Lisp_Key_Data *key, | 3032 void (*function) (const Lisp_Key_Data *key, |
| 3246 #else /* not USE_KKCC */ | |
| 3247 void (*function) (const struct key_data *key, | |
| 3248 #endif /* not USE_KKCC */ | |
| 3249 Lisp_Object binding, | 3033 Lisp_Object binding, |
| 3250 void *fn_arg), | 3034 void *fn_arg), |
| 3251 void *fn_arg) | 3035 void *fn_arg) |
| 3252 { | 3036 { |
| 3253 /* This function can GC */ | 3037 /* This function can GC */ |
| 3342 Lisp_Object thisseq = Fcar (Fcar (closure->tail)); | 3126 Lisp_Object thisseq = Fcar (Fcar (closure->tail)); |
| 3343 Lisp_Object cmd = get_keyelt (contents, 1); | 3127 Lisp_Object cmd = get_keyelt (contents, 1); |
| 3344 Lisp_Object vec; | 3128 Lisp_Object vec; |
| 3345 int j; | 3129 int j; |
| 3346 int len; | 3130 int len; |
| 3347 #ifdef USE_KKCC | |
| 3348 Lisp_Key_Data key; | 3131 Lisp_Key_Data key; |
| 3349 #else /* not USE_KKCC */ | |
| 3350 struct key_data key; | |
| 3351 #endif /* not USE_KKCC */ | |
| 3352 key.keysym = keysym; | 3132 key.keysym = keysym; |
| 3353 key.modifiers = modifiers; | 3133 key.modifiers = modifiers; |
| 3354 | 3134 |
| 3355 if (NILP (cmd)) | 3135 if (NILP (cmd)) |
| 3356 abort (); | 3136 abort (); |
| 3434 keymap = def; | 3214 keymap = def; |
| 3435 p = make_vector (len, Qnil); | 3215 p = make_vector (len, Qnil); |
| 3436 NGCPRO1 (p); | 3216 NGCPRO1 (p); |
| 3437 for (iii = 0; iii < len; iii++) | 3217 for (iii = 0; iii < len; iii++) |
| 3438 { | 3218 { |
| 3439 #ifdef USE_KKCC | |
| 3440 Lisp_Key_Data key; | 3219 Lisp_Key_Data key; |
| 3441 #else /* not USE_KKCC */ | |
| 3442 struct key_data key; | |
| 3443 #endif /* not USE_KKCC */ | |
| 3444 define_key_parser (Faref (prefix, make_int (iii)), &key); | 3220 define_key_parser (Faref (prefix, make_int (iii)), &key); |
| 3445 XVECTOR_DATA (p)[iii] = make_key_description (&key, 1); | 3221 XVECTOR_DATA (p)[iii] = make_key_description (&key, 1); |
| 3446 } | 3222 } |
| 3447 NUNGCPRO; | 3223 NUNGCPRO; |
| 3448 prefix = p; | 3224 prefix = p; |
| 3534 DECLARE_EISTRING_MALLOC (buf); | 3310 DECLARE_EISTRING_MALLOC (buf); |
| 3535 Lisp_Object str; | 3311 Lisp_Object str; |
| 3536 | 3312 |
| 3537 if (!EVENTP (key)) | 3313 if (!EVENTP (key)) |
| 3538 { | 3314 { |
| 3539 #ifdef USE_KKCC | |
| 3540 Lisp_Object event = Fmake_event (Qnil, Qnil); | 3315 Lisp_Object event = Fmake_event (Qnil, Qnil); |
| 3541 XSET_EVENT_TYPE (event, empty_event); | |
| 3542 CHECK_CHAR_COERCE_INT (key); | 3316 CHECK_CHAR_COERCE_INT (key); |
| 3543 character_to_event (XCHAR (key), XEVENT(event), | 3317 character_to_event (XCHAR (key), XEVENT (event), |
| 3544 XCONSOLE (Vselected_console), 0, 1); | 3318 XCONSOLE (Vselected_console), 0, 1); |
| 3545 format_event_object (buf, event, 1); | 3319 format_event_object (buf, event, 1); |
| 3320 Fdeallocate_event (event); | |
| 3546 } | 3321 } |
| 3547 else | 3322 else |
| 3548 format_event_object (buf, key, 1); | 3323 format_event_object (buf, key, 1); |
| 3549 #else /* not USE_KKCC */ | |
| 3550 Lisp_Event event; | |
| 3551 event.event_type = empty_event; | |
| 3552 CHECK_CHAR_COERCE_INT (key); | |
| 3553 character_to_event (XCHAR (key), &event, | |
| 3554 XCONSOLE (Vselected_console), 0, 1); | |
| 3555 format_event_object (buf, &event, 1); | |
| 3556 } | |
| 3557 else | |
| 3558 format_event_object (buf, XEVENT (key), 1); | |
| 3559 #endif /* not USE_KKCC */ | |
| 3560 str = eimake_string (buf); | 3324 str = eimake_string (buf); |
| 3561 eifree (buf); | 3325 eifree (buf); |
| 3562 return str; | 3326 return str; |
| 3563 } | 3327 } |
| 3564 | 3328 |
| 3778 where_is_internal (definition, maps, nmaps, Qt, buffer); | 3542 where_is_internal (definition, maps, nmaps, Qt, buffer); |
| 3779 } | 3543 } |
| 3780 | 3544 |
| 3781 | 3545 |
| 3782 static Lisp_Object | 3546 static Lisp_Object |
| 3783 #ifdef USE_KKCC | |
| 3784 raw_keys_to_keys (Lisp_Key_Data *keys, int count) | 3547 raw_keys_to_keys (Lisp_Key_Data *keys, int count) |
| 3785 #else /* not USE_KKCC */ | |
| 3786 raw_keys_to_keys (struct key_data *keys, int count) | |
| 3787 #endif /* not USE_KKCC */ | |
| 3788 { | 3548 { |
| 3789 Lisp_Object result = make_vector (count, Qnil); | 3549 Lisp_Object result = make_vector (count, Qnil); |
| 3790 while (count--) | 3550 while (count--) |
| 3791 XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1); | 3551 XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1); |
| 3792 return result; | 3552 return result; |
| 3793 } | 3553 } |
| 3794 | 3554 |
| 3795 | 3555 |
| 3796 static void | 3556 static void |
| 3797 #ifdef USE_KKCC | |
| 3798 format_raw_keys (Lisp_Key_Data *keys, int count, Eistring *buf) | 3557 format_raw_keys (Lisp_Key_Data *keys, int count, Eistring *buf) |
| 3799 #else /* not USE_KKCC */ | |
| 3800 format_raw_keys (struct key_data *keys, int count, Eistring *buf) | |
| 3801 #endif /* not USE_KKCC */ | |
| 3802 { | 3558 { |
| 3803 int i; | 3559 int i; |
| 3804 #ifdef USE_KKCC | |
| 3805 Lisp_Object event = Fmake_event (Qnil, Qnil); | 3560 Lisp_Object event = Fmake_event (Qnil, Qnil); |
| 3806 XSET_EVENT_TYPE (event, key_press_event); | 3561 XSET_EVENT_TYPE (event, key_press_event); |
| 3807 XSET_EVENT_CHANNEL (event, Vselected_console); | 3562 XSET_EVENT_CHANNEL (event, Vselected_console); |
| 3808 #else /* not USE_KKCC */ | |
| 3809 Lisp_Event event; | |
| 3810 event.event_type = key_press_event; | |
| 3811 event.channel = Vselected_console; | |
| 3812 #endif /* not USE_KKCC */ | |
| 3813 for (i = 0; i < count; i++) | 3563 for (i = 0; i < count; i++) |
| 3814 { | 3564 { |
| 3815 #ifdef USE_KKCC | 3565 XSET_EVENT_KEY_KEYSYM (event, keys[i].keysym); |
| 3816 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), keys[i].keysym); | 3566 XSET_EVENT_KEY_MODIFIERS (event, KEY_DATA_MODIFIERS (&keys[i])); |
| 3817 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (&keys[i])); | |
| 3818 format_event_object (buf, event, 1); | 3567 format_event_object (buf, event, 1); |
| 3819 #else /* not USE_KKCC */ | |
| 3820 event.event.key.keysym = keys[i].keysym; | |
| 3821 event.event.key.modifiers = keys[i].modifiers; | |
| 3822 format_event_object (buf, &event, 1); | |
| 3823 #endif /* not USE_KKCC */ | |
| 3824 if (i < count - 1) | 3568 if (i < count - 1) |
| 3825 eicat_c (buf, " "); | 3569 eicat_c (buf, " "); |
| 3826 } | 3570 } |
| 3571 Fdeallocate_event (event); | |
| 3827 } | 3572 } |
| 3828 | 3573 |
| 3829 | 3574 |
| 3830 /* definition is the thing to look for. | 3575 /* definition is the thing to look for. |
| 3831 map is a keymap. | 3576 map is a keymap. |
| 3854 int shadow_count; | 3599 int shadow_count; |
| 3855 int firstonly; | 3600 int firstonly; |
| 3856 int keys_count; | 3601 int keys_count; |
| 3857 int modifiers_so_far; | 3602 int modifiers_so_far; |
| 3858 Eistring *target_buffer; | 3603 Eistring *target_buffer; |
| 3859 #ifdef USE_KKCC | |
| 3860 Lisp_Key_Data *keys_so_far; | 3604 Lisp_Key_Data *keys_so_far; |
| 3861 #else /* not USE_KKCC */ | |
| 3862 struct key_data *keys_so_far; | |
| 3863 #endif /* not USE_KKCC */ | |
| 3864 int keys_so_far_total_size; | 3605 int keys_so_far_total_size; |
| 3865 int keys_so_far_malloced; | 3606 int keys_so_far_malloced; |
| 3866 }; | 3607 }; |
| 3867 | 3608 |
| 3868 static Lisp_Object where_is_recursive_mapper (Lisp_Object map, void *arg); | 3609 static Lisp_Object where_is_recursive_mapper (Lisp_Object map, void *arg); |
| 3887 { | 3628 { |
| 3888 /* One or more keys in this map match the definition we're looking for. | 3629 /* One or more keys in this map match the definition we're looking for. |
| 3889 Verify that these bindings aren't shadowed by other bindings | 3630 Verify that these bindings aren't shadowed by other bindings |
| 3890 in the shadow maps. Either nil or number as value from | 3631 in the shadow maps. Either nil or number as value from |
| 3891 raw_lookup_key() means undefined. */ | 3632 raw_lookup_key() means undefined. */ |
| 3892 #ifdef USE_KKCC | |
| 3893 Lisp_Key_Data *so_far = c->keys_so_far; | 3633 Lisp_Key_Data *so_far = c->keys_so_far; |
| 3894 #else /* not USE_KKCC */ | |
| 3895 struct key_data *so_far = c->keys_so_far; | |
| 3896 #endif /* not USE_KKCC */ | |
| 3897 | 3634 |
| 3898 for (;;) /* loop over all keys that match */ | 3635 for (;;) /* loop over all keys that match */ |
| 3899 { | 3636 { |
| 3900 Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys; | 3637 Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys; |
| 3901 int i; | 3638 int i; |
| 3902 | 3639 |
| 3903 so_far [keys_count].keysym = k; | 3640 so_far [keys_count].keysym = k; |
| 3904 #ifdef USE_KKCC | |
| 3905 SET_KEY_DATA_MODIFIERS (&so_far [keys_count], modifiers_so_far); | 3641 SET_KEY_DATA_MODIFIERS (&so_far [keys_count], modifiers_so_far); |
| 3906 #else /* not USE_KKCC */ | |
| 3907 so_far [keys_count].modifiers = modifiers_so_far; | |
| 3908 #endif /* not USE_KKCC */ | |
| 3909 | 3642 |
| 3910 /* now loop over all shadow maps */ | 3643 /* now loop over all shadow maps */ |
| 3911 for (i = 0; i < c->shadow_count; i++) | 3644 for (i = 0; i < c->shadow_count; i++) |
| 3912 { | 3645 { |
| 3913 Lisp_Object shadowed = raw_lookup_key (c->shadow[i], | 3646 Lisp_Object shadowed = raw_lookup_key (c->shadow[i], |
| 3984 bucky = MODIFIER_HASH_KEY_BITS (key); | 3717 bucky = MODIFIER_HASH_KEY_BITS (key); |
| 3985 if (bucky != 0) | 3718 if (bucky != 0) |
| 3986 lower_modifiers = (modifiers_so_far | bucky); | 3719 lower_modifiers = (modifiers_so_far | bucky); |
| 3987 else | 3720 else |
| 3988 { | 3721 { |
| 3989 #ifdef USE_KKCC | |
| 3990 Lisp_Key_Data *so_far = c->keys_so_far; | 3722 Lisp_Key_Data *so_far = c->keys_so_far; |
| 3991 #else /* not USE_KKCC */ | |
| 3992 struct key_data *so_far = c->keys_so_far; | |
| 3993 #endif /* not USE_KKCC */ | |
| 3994 lower_modifiers = 0; | 3723 lower_modifiers = 0; |
| 3995 so_far [lower_keys_count].keysym = key; | 3724 so_far [lower_keys_count].keysym = key; |
| 3996 #ifdef USE_KKCC | |
| 3997 SET_KEY_DATA_MODIFIERS (&so_far [lower_keys_count], modifiers_so_far); | 3725 SET_KEY_DATA_MODIFIERS (&so_far [lower_keys_count], modifiers_so_far); |
| 3998 #else /* not USE_KKCC */ | |
| 3999 so_far [lower_keys_count].modifiers = modifiers_so_far; | |
| 4000 #endif /* not USE_KKCC */ | |
| 4001 lower_keys_count++; | 3726 lower_keys_count++; |
| 4002 } | 3727 } |
| 4003 | 3728 |
| 4004 if (lower_keys_count >= c->keys_so_far_total_size) | 3729 if (lower_keys_count >= c->keys_so_far_total_size) |
| 4005 { | 3730 { |
| 4006 int size = lower_keys_count + 50; | 3731 int size = lower_keys_count + 50; |
| 4007 if (! c->keys_so_far_malloced) | 3732 if (! c->keys_so_far_malloced) |
| 4008 { | 3733 { |
| 4009 #ifdef USE_KKCC | |
| 4010 Lisp_Key_Data *new = xnew_array (Lisp_Key_Data, size); | 3734 Lisp_Key_Data *new = xnew_array (Lisp_Key_Data, size); |
| 4011 #else /* not USE_KKCC */ | |
| 4012 struct key_data *new = xnew_array (struct key_data, size); | |
| 4013 #endif /* not USE_KKCC */ | |
| 4014 memcpy ((void *)new, (const void *)c->keys_so_far, | 3735 memcpy ((void *)new, (const void *)c->keys_so_far, |
| 4015 #ifdef USE_KKCC | |
| 4016 c->keys_so_far_total_size * sizeof (Lisp_Key_Data)); | 3736 c->keys_so_far_total_size * sizeof (Lisp_Key_Data)); |
| 4017 #else /* not USE_KKCC */ | |
| 4018 c->keys_so_far_total_size * sizeof (struct key_data)); | |
| 4019 #endif /* not USE_KKCC */ | |
| 4020 } | 3737 } |
| 4021 else | 3738 else |
| 4022 #ifdef USE_KKCC | |
| 4023 XREALLOC_ARRAY (c->keys_so_far, Lisp_Key_Data, size); | 3739 XREALLOC_ARRAY (c->keys_so_far, Lisp_Key_Data, size); |
| 4024 #else /* not USE_KKCC */ | |
| 4025 XREALLOC_ARRAY (c->keys_so_far, struct key_data, size); | |
| 4026 #endif /* not USE_KKCC */ | |
| 4027 | 3740 |
| 4028 c->keys_so_far_total_size = size; | 3741 c->keys_so_far_total_size = size; |
| 4029 c->keys_so_far_malloced = 1; | 3742 c->keys_so_far_malloced = 1; |
| 4030 } | 3743 } |
| 4031 | 3744 |
| 4055 Lisp_Object firstonly, Eistring *target_buffer) | 3768 Lisp_Object firstonly, Eistring *target_buffer) |
| 4056 { | 3769 { |
| 4057 /* This function can GC */ | 3770 /* This function can GC */ |
| 4058 Lisp_Object result = Qnil; | 3771 Lisp_Object result = Qnil; |
| 4059 int i; | 3772 int i; |
| 4060 #ifdef USE_KKCC | |
| 4061 Lisp_Key_Data raw[20]; | 3773 Lisp_Key_Data raw[20]; |
| 4062 #else /* not USE_KKCC */ | |
| 4063 struct key_data raw[20]; | |
| 4064 #endif /* not USE_KKCC */ | |
| 4065 struct where_is_closure c; | 3774 struct where_is_closure c; |
| 4066 | 3775 |
| 4067 c.definition = definition; | 3776 c.definition = definition; |
| 4068 c.shadow = maps; | 3777 c.shadow = maps; |
| 4069 c.firstonly = !NILP (firstonly); | 3778 c.firstonly = !NILP (firstonly); |
| 4274 int mice_only_p; /* whether we are to display only button bindings */ | 3983 int mice_only_p; /* whether we are to display only button bindings */ |
| 4275 }; | 3984 }; |
| 4276 | 3985 |
| 4277 struct describe_map_shadow_closure | 3986 struct describe_map_shadow_closure |
| 4278 { | 3987 { |
| 4279 #ifdef USE_KKCC | |
| 4280 const Lisp_Key_Data *raw_key; | 3988 const Lisp_Key_Data *raw_key; |
| 4281 #else /* not USE_KKCC */ | |
| 4282 const struct key_data *raw_key; | |
| 4283 #endif /* not USE_KKCC */ | |
| 4284 Lisp_Object self; | 3989 Lisp_Object self; |
| 4285 }; | 3990 }; |
| 4286 | 3991 |
| 4287 static Lisp_Object | 3992 static Lisp_Object |
| 4288 describe_map_mapper_shadow_search (Lisp_Object map, void *arg) | 3993 describe_map_mapper_shadow_search (Lisp_Object map, void *arg) |
| 4291 (struct describe_map_shadow_closure *) arg; | 3996 (struct describe_map_shadow_closure *) arg; |
| 4292 | 3997 |
| 4293 if (EQ (map, c->self)) | 3998 if (EQ (map, c->self)) |
| 4294 return Qzero; /* Not shadowed; terminate search */ | 3999 return Qzero; /* Not shadowed; terminate search */ |
| 4295 | 4000 |
| 4296 #ifdef USE_KKCC | |
| 4297 return !NILP (keymap_lookup_directly (map, | 4001 return !NILP (keymap_lookup_directly (map, |
| 4298 KEY_DATA_KEYSYM (c->raw_key), | 4002 KEY_DATA_KEYSYM (c->raw_key), |
| 4299 KEY_DATA_MODIFIERS (c->raw_key))) | 4003 KEY_DATA_MODIFIERS (c->raw_key))) |
| 4300 #else /* not USE_KKCC */ | |
| 4301 return !NILP (keymap_lookup_directly (map, | |
| 4302 c->raw_key->keysym, | |
| 4303 c->raw_key->modifiers)) | |
| 4304 #endif /* not USE_KKCC */ | |
| 4305 ? Qt : Qnil; | 4004 ? Qt : Qnil; |
| 4306 } | 4005 } |
| 4307 | 4006 |
| 4308 | 4007 |
| 4309 static Lisp_Object | 4008 static Lisp_Object |
| 4310 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg) | 4009 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg) |
| 4311 { | 4010 { |
| 4312 #ifdef USE_KKCC | |
| 4313 Lisp_Key_Data *k = (Lisp_Key_Data *) arg; | 4011 Lisp_Key_Data *k = (Lisp_Key_Data *) arg; |
| 4314 return keymap_lookup_directly (km, KEY_DATA_KEYSYM (k), KEY_DATA_MODIFIERS (k)); | 4012 return keymap_lookup_directly (km, KEY_DATA_KEYSYM (k), KEY_DATA_MODIFIERS (k)); |
| 4315 #else /* not USE_KKCC */ | |
| 4316 struct key_data *k = (struct key_data *) arg; | |
| 4317 return keymap_lookup_directly (km, k->keysym, k->modifiers); | |
| 4318 #endif /* not USE_KKCC */ | |
| 4319 } | 4013 } |
| 4320 | 4014 |
| 4321 | 4015 |
| 4322 static void | 4016 static void |
| 4323 #ifdef USE_KKCC | |
| 4324 describe_map_mapper (const Lisp_Key_Data *key, | 4017 describe_map_mapper (const Lisp_Key_Data *key, |
| 4325 #else /* not USE_KKCC */ | |
| 4326 describe_map_mapper (const struct key_data *key, | |
| 4327 #endif /* not USE_KKCC */ | |
| 4328 Lisp_Object binding, | 4018 Lisp_Object binding, |
| 4329 void *describe_map_closure) | 4019 void *describe_map_closure) |
| 4330 { | 4020 { |
| 4331 /* This function can GC */ | 4021 /* This function can GC */ |
| 4332 struct describe_map_closure *closure = | 4022 struct describe_map_closure *closure = |
| 4333 (struct describe_map_closure *) describe_map_closure; | 4023 (struct describe_map_closure *) describe_map_closure; |
| 4334 #ifdef USE_KKCC | |
| 4335 Lisp_Object keysym = KEY_DATA_KEYSYM (key); | 4024 Lisp_Object keysym = KEY_DATA_KEYSYM (key); |
| 4336 int modifiers = KEY_DATA_MODIFIERS (key); | 4025 int modifiers = KEY_DATA_MODIFIERS (key); |
| 4337 #else /* not USE_KKCC */ | |
| 4338 Lisp_Object keysym = key->keysym; | |
| 4339 int modifiers = key->modifiers; | |
| 4340 #endif /* not USE_KKCC */ | |
| 4341 | 4026 |
| 4342 /* Don't mention suppressed commands. */ | 4027 /* Don't mention suppressed commands. */ |
| 4343 if (SYMBOLP (binding) | 4028 if (SYMBOLP (binding) |
| 4344 && !NILP (closure->partial) | 4029 && !NILP (closure->partial) |
| 4345 && !NILP (Fget (binding, closure->partial, Qnil))) | 4030 && !NILP (Fget (binding, closure->partial, Qnil))) |