Mercurial > hg > xemacs-beta
annotate src/rangetab.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 | c925bacdda60 |
| children | 04bc9d2f42c7 |
| rev | line source |
|---|---|
| 428 | 1 /* XEmacs routines to deal with range tables. |
| 2 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 800 | 3 Copyright (C) 1995, 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 24 /* Written by Ben Wing, August 1995. */ | |
| 25 | |
| 26 #include <config.h> | |
| 27 #include "lisp.h" | |
| 28 #include "rangetab.h" | |
| 29 | |
| 30 Lisp_Object Qrange_tablep; | |
| 31 Lisp_Object Qrange_table; | |
| 32 | |
| 33 | |
| 34 /************************************************************************/ | |
| 35 /* Range table object */ | |
| 36 /************************************************************************/ | |
| 37 | |
| 38 /* We use a sorted array of ranges. | |
| 39 | |
| 40 #### We should be using the gap array stuff from extents.c. This | |
| 41 is not hard but just requires moving that stuff out of that file. */ | |
| 42 | |
| 43 static Lisp_Object | |
| 44 mark_range_table (Lisp_Object obj) | |
| 45 { | |
| 440 | 46 Lisp_Range_Table *rt = XRANGE_TABLE (obj); |
| 428 | 47 int i; |
| 48 | |
| 49 for (i = 0; i < Dynarr_length (rt->entries); i++) | |
| 50 mark_object (Dynarr_at (rt->entries, i).val); | |
| 51 return Qnil; | |
| 52 } | |
| 53 | |
| 54 static void | |
| 55 print_range_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) | |
| 56 { | |
| 440 | 57 Lisp_Range_Table *rt = XRANGE_TABLE (obj); |
| 428 | 58 int i; |
| 59 | |
| 826 | 60 write_c_string (printcharfun, "#s(range-table data ("); |
| 428 | 61 for (i = 0; i < Dynarr_length (rt->entries); i++) |
| 62 { | |
| 63 struct range_table_entry *rte = Dynarr_atp (rt->entries, i); | |
| 64 if (i > 0) | |
| 826 | 65 write_c_string (printcharfun, " "); |
| 428 | 66 if (rte->first == rte->last) |
| 800 | 67 write_fmt_string (printcharfun, "%ld ", (long) (rte->first)); |
| 428 | 68 else |
| 800 | 69 write_fmt_string (printcharfun, "(%ld %ld) ", (long) (rte->first), |
| 70 (long) (rte->last)); | |
| 428 | 71 print_internal (rte->val, printcharfun, 1); |
| 72 } | |
| 826 | 73 write_c_string (printcharfun, "))"); |
| 428 | 74 } |
| 75 | |
| 76 static int | |
| 77 range_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) | |
| 78 { | |
| 440 | 79 Lisp_Range_Table *rt1 = XRANGE_TABLE (obj1); |
| 80 Lisp_Range_Table *rt2 = XRANGE_TABLE (obj2); | |
| 428 | 81 int i; |
| 82 | |
| 83 if (Dynarr_length (rt1->entries) != Dynarr_length (rt2->entries)) | |
| 84 return 0; | |
| 85 | |
| 86 for (i = 0; i < Dynarr_length (rt1->entries); i++) | |
| 87 { | |
| 88 struct range_table_entry *rte1 = Dynarr_atp (rt1->entries, i); | |
| 89 struct range_table_entry *rte2 = Dynarr_atp (rt2->entries, i); | |
| 90 | |
| 91 if (rte1->first != rte2->first | |
| 92 || rte1->last != rte2->last | |
| 93 || !internal_equal (rte1->val, rte2->val, depth + 1)) | |
| 94 return 0; | |
| 95 } | |
| 96 | |
| 97 return 1; | |
| 98 } | |
| 99 | |
| 100 static unsigned long | |
| 101 range_table_entry_hash (struct range_table_entry *rte, int depth) | |
| 102 { | |
| 103 return HASH3 (rte->first, rte->last, internal_hash (rte->val, depth + 1)); | |
| 104 } | |
| 105 | |
| 106 static unsigned long | |
| 107 range_table_hash (Lisp_Object obj, int depth) | |
| 108 { | |
| 440 | 109 Lisp_Range_Table *rt = XRANGE_TABLE (obj); |
| 428 | 110 int i; |
| 111 int size = Dynarr_length (rt->entries); | |
| 112 unsigned long hash = size; | |
| 113 | |
| 114 /* approach based on internal_array_hash(). */ | |
| 115 if (size <= 5) | |
| 116 { | |
| 117 for (i = 0; i < size; i++) | |
| 118 hash = HASH2 (hash, | |
| 119 range_table_entry_hash (Dynarr_atp (rt->entries, i), | |
| 120 depth)); | |
| 121 return hash; | |
| 122 } | |
| 123 | |
| 124 /* just pick five elements scattered throughout the array. | |
| 125 A slightly better approach would be to offset by some | |
| 126 noise factor from the points chosen below. */ | |
| 127 for (i = 0; i < 5; i++) | |
| 128 hash = HASH2 (hash, range_table_entry_hash (Dynarr_atp (rt->entries, | |
| 129 i*size/5), | |
| 130 depth)); | |
| 131 return hash; | |
| 132 } | |
| 133 | |
| 1204 | 134 static const struct memory_description rte_description_1[] = { |
| 440 | 135 { XD_LISP_OBJECT, offsetof (range_table_entry, val) }, |
| 428 | 136 { XD_END } |
| 137 }; | |
| 138 | |
| 1204 | 139 static const struct sized_memory_description rte_description = { |
| 440 | 140 sizeof (range_table_entry), |
| 428 | 141 rte_description_1 |
| 142 }; | |
| 143 | |
| 1204 | 144 static const struct memory_description rted_description_1[] = { |
| 440 | 145 XD_DYNARR_DESC (range_table_entry_dynarr, &rte_description), |
| 428 | 146 { XD_END } |
| 147 }; | |
| 148 | |
| 1204 | 149 static const struct sized_memory_description rted_description = { |
| 440 | 150 sizeof (range_table_entry_dynarr), |
| 428 | 151 rted_description_1 |
| 152 }; | |
| 153 | |
| 1204 | 154 static const struct memory_description range_table_description[] = { |
| 440 | 155 { XD_STRUCT_PTR, offsetof (Lisp_Range_Table, entries), 1, &rted_description }, |
| 428 | 156 { XD_END } |
| 157 }; | |
| 158 | |
| 934 | 159 DEFINE_LRECORD_IMPLEMENTATION ("range-table", range_table, |
| 160 1, /*dumpable-flag*/ | |
| 161 mark_range_table, print_range_table, 0, | |
| 162 range_table_equal, range_table_hash, | |
| 163 range_table_description, | |
| 164 Lisp_Range_Table); | |
| 428 | 165 |
| 166 /************************************************************************/ | |
| 167 /* Range table operations */ | |
| 168 /************************************************************************/ | |
| 169 | |
| 800 | 170 #ifdef ERROR_CHECK_STRUCTURES |
| 428 | 171 |
| 172 static void | |
| 440 | 173 verify_range_table (Lisp_Range_Table *rt) |
| 428 | 174 { |
| 175 int i; | |
| 176 | |
| 177 for (i = 0; i < Dynarr_length (rt->entries); i++) | |
| 178 { | |
| 179 struct range_table_entry *rte = Dynarr_atp (rt->entries, i); | |
| 180 assert (rte->last >= rte->first); | |
| 181 if (i > 0) | |
| 182 assert (Dynarr_at (rt->entries, i - 1).last < rte->first); | |
| 183 } | |
| 184 } | |
| 185 | |
| 186 #else | |
| 187 | |
| 188 #define verify_range_table(rt) | |
| 189 | |
| 190 #endif | |
| 191 | |
| 192 /* Look up in a range table without the Dynarr wrapper. | |
| 193 Used also by the unified range table format. */ | |
| 194 | |
| 195 static Lisp_Object | |
| 196 get_range_table (EMACS_INT pos, int nentries, struct range_table_entry *tab, | |
| 197 Lisp_Object default_) | |
| 198 { | |
| 199 int left = 0, right = nentries; | |
| 200 | |
| 201 /* binary search for the entry. Based on similar code in | |
| 202 extent_list_locate(). */ | |
| 203 while (left != right) | |
| 204 { | |
| 205 /* RIGHT might not point to a valid entry (i.e. it's at the end | |
| 206 of the list), so NEWPOS must round down. */ | |
| 647 | 207 int newpos = (left + right) >> 1; |
| 428 | 208 struct range_table_entry *entry = tab + newpos; |
| 209 if (pos > entry->last) | |
| 210 left = newpos+1; | |
| 211 else if (pos < entry->first) | |
| 212 right = newpos; | |
| 213 else | |
| 214 return entry->val; | |
| 215 } | |
| 216 | |
| 217 return default_; | |
| 218 } | |
| 219 | |
| 220 DEFUN ("range-table-p", Frange_table_p, 1, 1, 0, /* | |
| 221 Return non-nil if OBJECT is a range table. | |
| 222 */ | |
| 223 (object)) | |
| 224 { | |
| 225 return RANGE_TABLEP (object) ? Qt : Qnil; | |
| 226 } | |
| 227 | |
| 228 DEFUN ("make-range-table", Fmake_range_table, 0, 0, 0, /* | |
| 229 Return a new, empty range table. | |
| 230 You can manipulate it using `put-range-table', `get-range-table', | |
| 231 `remove-range-table', and `clear-range-table'. | |
| 232 */ | |
| 233 ()) | |
| 234 { | |
| 440 | 235 Lisp_Range_Table *rt = alloc_lcrecord_type (Lisp_Range_Table, |
| 236 &lrecord_range_table); | |
| 428 | 237 rt->entries = Dynarr_new (range_table_entry); |
| 793 | 238 return wrap_range_table (rt); |
| 428 | 239 } |
| 240 | |
| 241 DEFUN ("copy-range-table", Fcopy_range_table, 1, 1, 0, /* | |
| 444 | 242 Return a new range table which is a copy of RANGE-TABLE. |
| 243 It will contain the same values for the same ranges as RANGE-TABLE. | |
| 244 The values will not themselves be copied. | |
| 428 | 245 */ |
| 444 | 246 (range_table)) |
| 428 | 247 { |
| 440 | 248 Lisp_Range_Table *rt, *rtnew; |
| 428 | 249 |
| 444 | 250 CHECK_RANGE_TABLE (range_table); |
| 251 rt = XRANGE_TABLE (range_table); | |
| 428 | 252 |
| 440 | 253 rtnew = alloc_lcrecord_type (Lisp_Range_Table, &lrecord_range_table); |
| 428 | 254 rtnew->entries = Dynarr_new (range_table_entry); |
| 255 | |
| 256 Dynarr_add_many (rtnew->entries, Dynarr_atp (rt->entries, 0), | |
| 257 Dynarr_length (rt->entries)); | |
| 793 | 258 return wrap_range_table (rtnew); |
| 428 | 259 } |
| 260 | |
| 261 DEFUN ("get-range-table", Fget_range_table, 2, 3, 0, /* | |
| 444 | 262 Find value for position POS in RANGE-TABLE. |
| 428 | 263 If there is no corresponding value, return DEFAULT (defaults to nil). |
| 264 */ | |
| 444 | 265 (pos, range_table, default_)) |
| 428 | 266 { |
| 440 | 267 Lisp_Range_Table *rt; |
| 428 | 268 |
| 444 | 269 CHECK_RANGE_TABLE (range_table); |
| 270 rt = XRANGE_TABLE (range_table); | |
| 428 | 271 |
| 272 CHECK_INT_COERCE_CHAR (pos); | |
| 273 | |
| 274 return get_range_table (XINT (pos), Dynarr_length (rt->entries), | |
| 275 Dynarr_atp (rt->entries, 0), default_); | |
| 276 } | |
| 277 | |
| 278 void | |
| 279 put_range_table (Lisp_Object table, EMACS_INT first, | |
| 280 EMACS_INT last, Lisp_Object val) | |
| 281 { | |
| 282 int i; | |
| 283 int insert_me_here = -1; | |
| 440 | 284 Lisp_Range_Table *rt = XRANGE_TABLE (table); |
| 428 | 285 |
| 286 /* Now insert in the proper place. This gets tricky because | |
| 287 we may be overlapping one or more existing ranges and need | |
| 288 to fix them up. */ | |
| 289 | |
| 290 /* First delete all sections of any existing ranges that overlap | |
| 291 the new range. */ | |
| 292 for (i = 0; i < Dynarr_length (rt->entries); i++) | |
| 293 { | |
| 294 struct range_table_entry *entry = Dynarr_atp (rt->entries, i); | |
| 295 /* We insert before the first range that begins at or after the | |
| 296 new range. */ | |
| 297 if (entry->first >= first && insert_me_here < 0) | |
| 298 insert_me_here = i; | |
| 299 if (entry->last < first) | |
| 300 /* completely before the new range. */ | |
| 301 continue; | |
| 302 if (entry->first > last) | |
| 303 /* completely after the new range. No more possibilities of | |
| 304 finding overlapping ranges. */ | |
| 305 break; | |
| 306 if (entry->first < first && entry->last <= last) | |
| 307 { | |
| 308 /* looks like: | |
| 309 | |
| 310 [ NEW ] | |
| 311 [ EXISTING ] | |
| 312 | |
| 313 */ | |
| 314 /* truncate the end off of it. */ | |
| 315 entry->last = first - 1; | |
| 316 } | |
| 317 else if (entry->first < first && entry->last > last) | |
| 318 /* looks like: | |
| 319 | |
| 320 [ NEW ] | |
| 321 [ EXISTING ] | |
| 322 | |
| 323 */ | |
| 324 /* need to split this one in two. */ | |
| 325 { | |
| 326 struct range_table_entry insert_me_too; | |
| 327 | |
| 328 insert_me_too.first = last + 1; | |
| 329 insert_me_too.last = entry->last; | |
| 330 insert_me_too.val = entry->val; | |
| 331 entry->last = first - 1; | |
| 332 Dynarr_insert_many (rt->entries, &insert_me_too, 1, i + 1); | |
| 333 } | |
| 334 else if (entry->last > last) | |
| 335 { | |
| 336 /* looks like: | |
| 337 | |
| 338 [ NEW ] | |
| 339 [ EXISTING ] | |
| 340 | |
| 341 */ | |
| 342 /* truncate the start off of it. */ | |
| 343 entry->first = last + 1; | |
| 344 } | |
| 345 else | |
| 346 { | |
| 347 /* existing is entirely within new. */ | |
| 348 Dynarr_delete_many (rt->entries, i, 1); | |
| 349 i--; /* back up since everything shifted one to the left. */ | |
| 350 } | |
| 351 } | |
| 352 | |
| 353 /* Someone asked us to delete the range, not insert it. */ | |
| 354 if (UNBOUNDP (val)) | |
| 355 return; | |
| 356 | |
| 357 /* Now insert the new entry, maybe at the end. */ | |
| 358 | |
| 359 if (insert_me_here < 0) | |
| 360 insert_me_here = i; | |
| 361 | |
| 362 { | |
| 363 struct range_table_entry insert_me; | |
| 364 | |
| 365 insert_me.first = first; | |
| 366 insert_me.last = last; | |
| 367 insert_me.val = val; | |
| 368 | |
| 369 Dynarr_insert_many (rt->entries, &insert_me, 1, insert_me_here); | |
| 370 } | |
| 371 | |
| 372 /* Now see if we can combine this entry with adjacent ones just | |
| 373 before or after. */ | |
| 374 | |
| 375 if (insert_me_here > 0) | |
| 376 { | |
| 377 struct range_table_entry *entry = Dynarr_atp (rt->entries, | |
| 378 insert_me_here - 1); | |
| 379 if (EQ (val, entry->val) && entry->last == first - 1) | |
| 380 { | |
| 381 entry->last = last; | |
| 382 Dynarr_delete_many (rt->entries, insert_me_here, 1); | |
| 383 insert_me_here--; | |
| 384 /* We have morphed into a larger range. Update our records | |
| 385 in case we also combine with the one after. */ | |
| 386 first = entry->first; | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 if (insert_me_here < Dynarr_length (rt->entries) - 1) | |
| 391 { | |
| 392 struct range_table_entry *entry = Dynarr_atp (rt->entries, | |
| 393 insert_me_here + 1); | |
| 394 if (EQ (val, entry->val) && entry->first == last + 1) | |
| 395 { | |
| 396 entry->first = first; | |
| 397 Dynarr_delete_many (rt->entries, insert_me_here, 1); | |
| 398 } | |
| 399 } | |
| 400 } | |
| 401 | |
| 402 DEFUN ("put-range-table", Fput_range_table, 4, 4, 0, /* | |
| 444 | 403 Set the value for range (START, END) to be VALUE in RANGE-TABLE. |
| 428 | 404 */ |
| 444 | 405 (start, end, value, range_table)) |
| 428 | 406 { |
| 407 EMACS_INT first, last; | |
| 408 | |
| 444 | 409 CHECK_RANGE_TABLE (range_table); |
| 428 | 410 CHECK_INT_COERCE_CHAR (start); |
| 411 first = XINT (start); | |
| 412 CHECK_INT_COERCE_CHAR (end); | |
| 413 last = XINT (end); | |
| 414 if (first > last) | |
| 563 | 415 invalid_argument_2 ("start must be <= end", start, end); |
| 428 | 416 |
| 444 | 417 put_range_table (range_table, first, last, value); |
| 418 verify_range_table (XRANGE_TABLE (range_table)); | |
| 428 | 419 return Qnil; |
| 420 } | |
| 421 | |
| 422 DEFUN ("remove-range-table", Fremove_range_table, 3, 3, 0, /* | |
| 444 | 423 Remove the value for range (START, END) in RANGE-TABLE. |
| 428 | 424 */ |
| 444 | 425 (start, end, range_table)) |
| 428 | 426 { |
| 444 | 427 return Fput_range_table (start, end, Qunbound, range_table); |
| 428 | 428 } |
| 429 | |
| 430 DEFUN ("clear-range-table", Fclear_range_table, 1, 1, 0, /* | |
| 444 | 431 Flush RANGE-TABLE. |
| 428 | 432 */ |
| 444 | 433 (range_table)) |
| 428 | 434 { |
| 444 | 435 CHECK_RANGE_TABLE (range_table); |
| 436 Dynarr_reset (XRANGE_TABLE (range_table)->entries); | |
| 428 | 437 return Qnil; |
| 438 } | |
| 439 | |
| 440 DEFUN ("map-range-table", Fmap_range_table, 2, 2, 0, /* | |
| 444 | 441 Map FUNCTION over entries in RANGE-TABLE, calling it with three args, |
| 428 | 442 the beginning and end of the range and the corresponding value. |
| 442 | 443 |
| 444 Results are guaranteed to be correct (i.e. each entry processed | |
| 445 exactly once) if FUNCTION modifies or deletes the current entry | |
| 444 | 446 \(i.e. passes the current range to `put-range-table' or |
| 442 | 447 `remove-range-table'), but not otherwise. |
| 428 | 448 */ |
| 444 | 449 (function, range_table)) |
| 428 | 450 { |
| 442 | 451 Lisp_Range_Table *rt; |
| 452 int i; | |
| 453 | |
| 444 | 454 CHECK_RANGE_TABLE (range_table); |
| 442 | 455 CHECK_FUNCTION (function); |
| 456 | |
| 444 | 457 rt = XRANGE_TABLE (range_table); |
| 442 | 458 |
| 459 /* Do not "optimize" by pulling out the length computation below! | |
| 460 FUNCTION may have changed the table. */ | |
| 461 for (i = 0; i < Dynarr_length (rt->entries); i++) | |
| 462 { | |
| 463 struct range_table_entry *entry = Dynarr_atp (rt->entries, i); | |
| 464 EMACS_INT first, last; | |
| 465 Lisp_Object args[4]; | |
| 466 int oldlen; | |
| 467 | |
| 468 again: | |
| 469 first = entry->first; | |
| 470 last = entry->last; | |
| 471 oldlen = Dynarr_length (rt->entries); | |
| 472 args[0] = function; | |
| 473 args[1] = make_int (first); | |
| 474 args[2] = make_int (last); | |
| 475 args[3] = entry->val; | |
| 476 Ffuncall (countof (args), args); | |
| 477 /* Has FUNCTION removed the entry? */ | |
| 478 if (oldlen > Dynarr_length (rt->entries) | |
| 479 && i < Dynarr_length (rt->entries) | |
| 480 && (first != entry->first || last != entry->last)) | |
| 481 goto again; | |
| 482 } | |
| 483 | |
| 428 | 484 return Qnil; |
| 485 } | |
| 486 | |
| 487 | |
| 488 /************************************************************************/ | |
| 489 /* Range table read syntax */ | |
| 490 /************************************************************************/ | |
| 491 | |
| 492 static int | |
| 493 rangetab_data_validate (Lisp_Object keyword, Lisp_Object value, | |
| 578 | 494 Error_Behavior errb) |
| 428 | 495 { |
| 496 Lisp_Object rest; | |
| 497 | |
| 498 /* #### should deal with errb */ | |
| 499 EXTERNAL_LIST_LOOP (rest, value) | |
| 500 { | |
| 501 Lisp_Object range = XCAR (rest); | |
| 502 rest = XCDR (rest); | |
| 503 if (!CONSP (rest)) | |
| 563 | 504 sferror ("Invalid list format", value); |
| 428 | 505 if (!INTP (range) && !CHARP (range) |
| 506 && !(CONSP (range) && CONSP (XCDR (range)) | |
| 507 && NILP (XCDR (XCDR (range))) | |
| 508 && (INTP (XCAR (range)) || CHARP (XCAR (range))) | |
| 509 && (INTP (XCAR (XCDR (range))) || CHARP (XCAR (XCDR (range)))))) | |
| 563 | 510 sferror ("Invalid range format", range); |
| 428 | 511 } |
| 512 | |
| 513 return 1; | |
| 514 } | |
| 515 | |
| 516 static Lisp_Object | |
| 517 rangetab_instantiate (Lisp_Object data) | |
| 518 { | |
| 519 Lisp_Object rangetab = Fmake_range_table (); | |
| 520 | |
| 521 if (!NILP (data)) | |
| 522 { | |
| 523 data = Fcar (Fcdr (data)); /* skip over 'data keyword */ | |
| 524 while (!NILP (data)) | |
| 525 { | |
| 526 Lisp_Object range = Fcar (data); | |
| 527 Lisp_Object val = Fcar (Fcdr (data)); | |
| 528 | |
| 529 data = Fcdr (Fcdr (data)); | |
| 530 if (CONSP (range)) | |
| 531 Fput_range_table (Fcar (range), Fcar (Fcdr (range)), val, | |
| 532 rangetab); | |
| 533 else | |
| 534 Fput_range_table (range, range, val, rangetab); | |
| 535 } | |
| 536 } | |
| 537 | |
| 538 return rangetab; | |
| 539 } | |
| 540 | |
| 541 | |
| 542 /************************************************************************/ | |
| 543 /* Unified range tables */ | |
| 544 /************************************************************************/ | |
| 545 | |
| 546 /* A "unified range table" is a format for storing range tables | |
| 547 as contiguous blocks of memory. This is used by the regexp | |
| 548 code, which needs to use range tables to properly handle [] | |
| 549 constructs in the presence of extended characters but wants to | |
| 550 store an entire compiled pattern as a contiguous block of memory. | |
| 551 | |
| 552 Unified range tables are designed so that they can be placed | |
| 553 at an arbitrary (possibly mis-aligned) place in memory. | |
| 554 (Dealing with alignment is a pain in the ass.) | |
| 555 | |
| 556 WARNING: No provisions for garbage collection are currently made. | |
| 557 This means that there must not be any Lisp objects in a unified | |
| 558 range table that need to be marked for garbage collection. | |
| 559 Good candidates for objects that can go into a range table are | |
| 560 | |
| 561 -- numbers and characters (do not need to be marked) | |
| 562 -- nil, t (marked elsewhere) | |
| 563 -- charsets and coding systems (automatically marked because | |
| 564 they are in a marked list, | |
| 565 and can't be removed) | |
| 566 | |
| 567 Good but slightly less so: | |
| 568 | |
| 569 -- symbols (could be uninterned, but that is not likely) | |
| 570 | |
| 571 Somewhat less good: | |
| 572 | |
| 573 -- buffers, frames, devices (could get deleted) | |
| 574 | |
| 575 | |
| 576 It is expected that you work with range tables in the normal | |
| 577 format and then convert to unified format when you are done | |
| 578 making modifications. As such, no functions are provided | |
| 579 for modifying a unified range table. The only operations | |
| 580 you can do to unified range tables are | |
| 581 | |
| 582 -- look up a value | |
| 583 -- retrieve all the ranges in an iterative fashion | |
| 584 | |
| 585 */ | |
| 586 | |
| 587 /* The format of a unified range table is as follows: | |
| 588 | |
| 589 -- The first byte contains the number of bytes to skip to find the | |
| 590 actual start of the table. This deals with alignment constraints, | |
| 591 since the table might want to go at any arbitrary place in memory. | |
| 592 -- The next three bytes contain the number of bytes to skip (from the | |
| 593 *first* byte) to find the stuff after the table. It's stored in | |
| 594 little-endian format because that's how God intended things. We don't | |
| 595 necessarily start the stuff at the very end of the table because | |
| 596 we want to have at least ALIGNOF (EMACS_INT) extra space in case | |
| 597 we have to move the range table around. (It appears that some | |
| 598 architectures don't maintain alignment when reallocing.) | |
| 599 -- At the prescribed offset is a struct unified_range_table, containing | |
| 600 some number of `struct range_table_entry' entries. */ | |
| 601 | |
| 602 struct unified_range_table | |
| 603 { | |
| 604 int nentries; | |
| 605 struct range_table_entry first; | |
| 606 }; | |
| 607 | |
| 608 /* Return size in bytes needed to store the data in a range table. */ | |
| 609 | |
| 610 int | |
| 611 unified_range_table_bytes_needed (Lisp_Object rangetab) | |
| 612 { | |
| 613 return (sizeof (struct range_table_entry) * | |
| 614 (Dynarr_length (XRANGE_TABLE (rangetab)->entries) - 1) + | |
| 615 sizeof (struct unified_range_table) + | |
| 616 /* ALIGNOF a struct may be too big. */ | |
| 617 /* We have four bytes for the size numbers, and an extra | |
| 618 four or eight bytes for making sure we get the alignment | |
| 619 OK. */ | |
| 620 ALIGNOF (EMACS_INT) + 4); | |
| 621 } | |
| 622 | |
| 623 /* Convert a range table into unified format and store in DEST, | |
| 624 which must be able to hold the number of bytes returned by | |
| 625 range_table_bytes_needed(). */ | |
| 626 | |
| 627 void | |
| 628 unified_range_table_copy_data (Lisp_Object rangetab, void *dest) | |
| 629 { | |
| 630 /* We cast to the above structure rather than just casting to | |
| 631 char * and adding sizeof(int), because that will lead to | |
| 632 mis-aligned data on the Alpha machines. */ | |
| 633 struct unified_range_table *un; | |
| 634 range_table_entry_dynarr *rted = XRANGE_TABLE (rangetab)->entries; | |
| 635 int total_needed = unified_range_table_bytes_needed (rangetab); | |
| 826 | 636 void *new_dest = ALIGN_PTR ((char *) dest + 4, EMACS_INT); |
| 428 | 637 |
| 638 * (char *) dest = (char) ((char *) new_dest - (char *) dest); | |
| 639 * ((unsigned char *) dest + 1) = total_needed & 0xFF; | |
| 640 total_needed >>= 8; | |
| 641 * ((unsigned char *) dest + 2) = total_needed & 0xFF; | |
| 642 total_needed >>= 8; | |
| 643 * ((unsigned char *) dest + 3) = total_needed & 0xFF; | |
| 644 un = (struct unified_range_table *) new_dest; | |
| 645 un->nentries = Dynarr_length (rted); | |
| 646 memcpy (&un->first, Dynarr_atp (rted, 0), | |
| 647 sizeof (struct range_table_entry) * Dynarr_length (rted)); | |
| 648 } | |
| 649 | |
| 650 /* Return number of bytes actually used by a unified range table. */ | |
| 651 | |
| 652 int | |
| 653 unified_range_table_bytes_used (void *unrangetab) | |
| 654 { | |
| 655 return ((* ((unsigned char *) unrangetab + 1)) | |
| 656 + ((* ((unsigned char *) unrangetab + 2)) << 8) | |
| 657 + ((* ((unsigned char *) unrangetab + 3)) << 16)); | |
| 658 } | |
| 659 | |
| 660 /* Make sure the table is aligned, and move it around if it's not. */ | |
| 661 static void | |
| 662 align_the_damn_table (void *unrangetab) | |
| 663 { | |
| 664 void *cur_dest = (char *) unrangetab + * (char *) unrangetab; | |
| 826 | 665 if (cur_dest != ALIGN_PTR (cur_dest, EMACS_INT)) |
| 428 | 666 { |
| 667 int count = (unified_range_table_bytes_used (unrangetab) - 4 | |
| 668 - ALIGNOF (EMACS_INT)); | |
| 669 /* Find the proper location, just like above. */ | |
| 826 | 670 void *new_dest = ALIGN_PTR ((char *) unrangetab + 4, EMACS_INT); |
| 428 | 671 /* memmove() works in the presence of overlapping data. */ |
| 672 memmove (new_dest, cur_dest, count); | |
| 673 * (char *) unrangetab = (char) ((char *) new_dest - (char *) unrangetab); | |
| 674 } | |
| 675 } | |
| 676 | |
| 677 /* Look up a value in a unified range table. */ | |
| 678 | |
| 679 Lisp_Object | |
| 680 unified_range_table_lookup (void *unrangetab, EMACS_INT pos, | |
| 681 Lisp_Object default_) | |
| 682 { | |
| 683 void *new_dest; | |
| 684 struct unified_range_table *un; | |
| 685 | |
| 686 align_the_damn_table (unrangetab); | |
| 687 new_dest = (char *) unrangetab + * (char *) unrangetab; | |
| 688 un = (struct unified_range_table *) new_dest; | |
| 689 | |
| 690 return get_range_table (pos, un->nentries, &un->first, default_); | |
| 691 } | |
| 692 | |
| 693 /* Return number of entries in a unified range table. */ | |
| 694 | |
| 695 int | |
| 696 unified_range_table_nentries (void *unrangetab) | |
| 697 { | |
| 698 void *new_dest; | |
| 699 struct unified_range_table *un; | |
| 700 | |
| 701 align_the_damn_table (unrangetab); | |
| 702 new_dest = (char *) unrangetab + * (char *) unrangetab; | |
| 703 un = (struct unified_range_table *) new_dest; | |
| 704 return un->nentries; | |
| 705 } | |
| 706 | |
| 707 /* Return the OFFSETth range (counting from 0) in UNRANGETAB. */ | |
| 708 void | |
| 709 unified_range_table_get_range (void *unrangetab, int offset, | |
| 710 EMACS_INT *min, EMACS_INT *max, | |
| 711 Lisp_Object *val) | |
| 712 { | |
| 713 void *new_dest; | |
| 714 struct unified_range_table *un; | |
| 715 struct range_table_entry *tab; | |
| 716 | |
| 717 align_the_damn_table (unrangetab); | |
| 718 new_dest = (char *) unrangetab + * (char *) unrangetab; | |
| 719 un = (struct unified_range_table *) new_dest; | |
| 720 | |
| 721 assert (offset >= 0 && offset < un->nentries); | |
| 722 tab = (&un->first) + offset; | |
| 723 *min = tab->first; | |
| 724 *max = tab->last; | |
| 725 *val = tab->val; | |
| 726 } | |
| 727 | |
| 728 | |
| 729 /************************************************************************/ | |
| 730 /* Initialization */ | |
| 731 /************************************************************************/ | |
| 732 | |
| 733 void | |
| 734 syms_of_rangetab (void) | |
| 735 { | |
| 442 | 736 INIT_LRECORD_IMPLEMENTATION (range_table); |
| 737 | |
| 563 | 738 DEFSYMBOL_MULTIWORD_PREDICATE (Qrange_tablep); |
| 739 DEFSYMBOL (Qrange_table); | |
| 428 | 740 |
| 741 DEFSUBR (Frange_table_p); | |
| 742 DEFSUBR (Fmake_range_table); | |
| 743 DEFSUBR (Fcopy_range_table); | |
| 744 DEFSUBR (Fget_range_table); | |
| 745 DEFSUBR (Fput_range_table); | |
| 746 DEFSUBR (Fremove_range_table); | |
| 747 DEFSUBR (Fclear_range_table); | |
| 748 DEFSUBR (Fmap_range_table); | |
| 749 } | |
| 750 | |
| 751 void | |
| 752 structure_type_create_rangetab (void) | |
| 753 { | |
| 754 struct structure_type *st; | |
| 755 | |
| 756 st = define_structure_type (Qrange_table, 0, rangetab_instantiate); | |
| 757 | |
| 758 define_structure_type_keyword (st, Qdata, rangetab_data_validate); | |
| 759 } |