Mercurial > hg > xemacs-beta
annotate src/specifier.h @ 2720:6fa9919a9a0b
[xemacs-hg @ 2005-04-08 23:10:01 by crestani]
ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
New configure flag: `MC_ALLOC':
* configure.ac (XE_COMPLEX_ARG_ENABLE): Add `--enable-mc-alloc' as
a new configure flag.
* configure.in (AC_INIT_PARSE_ARGS): Add `--mc-alloc' as a new
configure flag.
* configure.usage: Add description for `mc-alloc'.
DUMP_IN_EXEC:
* Makefile.in.in: Condition the installation of a separate dump
file on !DUMP_ON_EXEC.
* configure.ac (XE_COMPLEX_ARG_ENABLE): Add
`--enable-dump-in-exec' as a new configure flag.
* configure.ac: DUMP_IN_EXEC is define as default for PDUMP but
not default for MC_ALLOC.
* configure.in (AC_INIT_PARSE_ARGS): Add `--dump-in-exec' as a
new configure flag.
* configure.in: DUMP_IN_EXEC is define as default for PDUMP but
not default for MC_ALLOC.
* configure.usage: Add description for `dump-in-exec'.
lib-src/ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
DUMP_IN_EXEC:
* Makefile.in.in: Only compile insert-data-in-exec if
DUMP_IN_EXEC is defined.
lisp/ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
MEMORY_USAGE_STATS
* diagnose.el: Add new lisp function to pretty print statistics
about the new allocator.
* diagnose.el (show-mc-alloc-memory-usage): New.
modules/ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
Remove Lcrecords:
* postgresql/postgresql.c (allocate_pgconn): Allocate with new
allocator.
* postgresql/postgresql.c (allocate_pgresult): Allocate PGresult
with new allocator.
* postgresql/postgresql.h (struct Lisp_PGconn): Add
lrecord_header.
* postgresql/postgresql.h (struct Lisp_PGresult): Add
lrecord_header.
* ldap/eldap.c (allocate_ldap): Allocate with new allocator.
* ldap/eldap.h (struct Lisp_LDAP): Add lrecord_header.
nt/ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
New configure flag: `MC_ALLOC':
* config.inc.samp: Add new flag `MC_ALLOC'.
* xemacs.mak: Add flag and configuration output for `MC_ALLOC'.
New files:
* xemacs.dsp: Add source files mc-alloc.c and mc-alloc.h.
* xemacs.mak: Add new object file mc-alloc.obj to dependencies.
src/ChangeLog addition:
2005-04-01 Marcus Crestani <crestani@xemacs.org>
The new allocator.
New configure flag: `MC_ALLOC':
* config.h.in: Add new flag `MC_ALLOC'.
New files:
* Makefile.in.in: Add new object file mc-alloc.o.
* depend: Add new files to dependencies.
* mc-alloc.c: New.
* mc-alloc.h: New.
Running the new allocator from XEmacs:
* alloc.c (deadbeef_memory): Moved to mc-alloc.c.
* emacs.c (main_1): Initialize the new allocator and add
syms_of_mc_alloc.
* symsinit.h: Add syms_of_mc_alloc.
New lrecord allocation and free functions:
* alloc.c (alloc_lrecord): New. Allocates an lrecord, includes
type checking and initializing of the lrecord_header.
* alloc.c (noseeum_alloc_lrecord): Same as above, but increments
the NOSEEUM cons counter.
* alloc.c (free_lrecord): New. Calls the finalizer and frees the
lrecord.
* lrecord.h: Add lrecord allocation prototypes and comments.
Remove old lrecord FROB block allocation:
* alloc.c (allocate_lisp_storage): Former function to expand
heap. Not needed anymore, remove.
* alloc.c: Completely remove `Fixed-size type macros'
* alloc.c (release_breathing_space): Remove.
* alloc.c (memory_full): Remove release_breathing_space.
* alloc.c (refill_memory_reserve): Remove.
* alloc.c (TYPE_ALLOC_SIZE): Remove.
* alloc.c (DECLARE_FIXED_TYPE_ALLOC): Remove.
* alloc.c (ALLOCATE_FIXED_TYPE_FROM_BLOCK): Remove.
* alloc.c (ALLOCATE_FIXED_TYPE_1): Remove.
* alloc.c (ALLOCATE_FIXED_TYPE): Remove.
* alloc.c (NOSEEUM_ALLOCATE_FIXED_TYPE): Remove.
* alloc.c (struct Lisp_Free): Remove.
* alloc.c (LRECORD_FREE_P): Remove.
* alloc.c (MARK_LRECORD_AS_FREE): Remove.
* alloc.c (MARK_LRECORD_AS_NOT_FREE): Remove.
* alloc.c (PUT_FIXED_TYPE_ON_FREE_LIST): Remove.
* alloc.c (FREE_FIXED_TYPE): Remove.
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC): Remove.
Allocate old lrecords with new allocator:
* alloc.c: DECLARE_FIXED_TYPE_ALLOC removed for all lrecords
defined in alloc.c.
* alloc.c (Fcons): Allocate with new allocator.
* alloc.c (noseeum_cons): Allocate with new allocator.
* alloc.c (make_float): Allocate with new allocator.
* alloc.c (make_bignum): Allocate with new allocator.
* alloc.c (make_bignum_bg): Allocate with new allocator.
* alloc.c (make_ratio): Allocate with new allocator.
* alloc.c (make_ratio_bg): Allocate with new allocator.
* alloc.c (make_ratio_rt): Allocate with new allocator.
* alloc.c (make_bigfloat): Allocate with new allocator.
* alloc.c (make_bigfloat_bf): Allocate with new allocator.
* alloc.c (make_compiled_function): Allocate with new allocator.
* alloc.c (Fmake_symbol): Allocate with new allocator.
* alloc.c (allocate_extent): Allocate with new allocator.
* alloc.c (allocate_event): Allocate with new allocator.
* alloc.c (make_key_data): Allocate with new allocator.
* alloc.c (make_button_data): Allocate with new allocator.
* alloc.c (make_motion_data): Allocate with new allocator.
* alloc.c (make_process_data): Allocate with new allocator.
* alloc.c (make_timeout_data): Allocate with new allocator.
* alloc.c (make_magic_data): Allocate with new allocator.
* alloc.c (make_magic_eval_data): Allocate with new allocator.
* alloc.c (make_eval_data): Allocate with new allocator.
* alloc.c (make_misc_user_data): Allocate with new allocator.
* alloc.c (Fmake_marker): Allocate with new allocator.
* alloc.c (noseeum_make_marker): Allocate with new allocator.
* alloc.c (make_uninit_string): Allocate with new allocator.
* alloc.c (resize_string): Allocate with new allocator.
* alloc.c (make_string_nocopy): Allocate with new allocator.
Garbage Collection:
* alloc.c (GC_CHECK_NOT_FREE): Remove obsolete assertions.
* alloc.c (SWEEP_FIXED_TYPE_BLOCK): Remove.
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1): Remove.
* alloc.c (sweep_conses): Remove.
* alloc.c (free_cons): Use new allocator to free.
* alloc.c (sweep_compiled_functions): Remove.
* alloc.c (sweep_floats): Remove.
* alloc.c (sweep_bignums): Remove.
* alloc.c (sweep_ratios): Remove.
* alloc.c (sweep_bigfloats): Remove.
* alloc.c (sweep_symbols): Remove.
* alloc.c (sweep_extents): Remove.
* alloc.c (sweep_events): Remove.
* alloc.c (sweep_key_data): Remove.
* alloc.c (free_key_data): Use new allocator to free.
* alloc.c (sweep_button_data): Remove.
* alloc.c (free_button_data): Use new allocator to free.
* alloc.c (sweep_motion_data): Remove.
* alloc.c (free_motion_data): Use new allocator to free.
* alloc.c (sweep_process_data): Remove.
* alloc.c (free_process_data): Use new allocator to free.
* alloc.c (sweep_timeout_data): Remove.
* alloc.c (free_timeout_data): Use new allocator to free.
* alloc.c (sweep_magic_data): Remove.
* alloc.c (free_magic_data): Use new allocator to free.
* alloc.c (sweep_magic_eval_data): Remove.
* alloc.c (free_magic_eval_data): Use new allocator to free.
* alloc.c (sweep_eval_data): Remove.
* alloc.c (free_eval_data): Use new allocator to free.
* alloc.c (sweep_misc_user_data): Remove.
* alloc.c (free_misc_user_data): Use new allocator to free.
* alloc.c (sweep_markers): Remove.
* alloc.c (free_marker): Use new allocator to free.
* alloc.c (garbage_collect_1): Remove release_breathing_space.
* alloc.c (gc_sweep): Remove all the old lcrecord and lrecord
related stuff. Sweeping now works like this: compact string
chars, finalize, sweep.
* alloc.c (common_init_alloc_early): Remove old lrecord
initializations, remove breathing_space.
* emacs.c (Fdump_emacs): Remove release_breathing_space.
* lisp.h: Remove prototype for release_breathing_space.
* lisp.h: Adjust the special cons mark makros.
Lrecord Finalizer:
* alloc.c: Add finalizer to lrecord definition.
* alloc.c (finalize_string): Add finalizer for string.
* bytecode.c: Add finalizer to lrecord definition.
* bytecode.c (finalize_compiled_function): Add finalizer for
compiled function.
* marker.c: Add finalizer to lrecord definition.
* marker.c (finalize_marker): Add finalizer for marker.
These changes build the interface to mc-alloc:
* lrecord.h (MC_ALLOC_CALL_FINALIZER): Tell mc-alloc how to
finalize lrecords.
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE): Tell
mc-alloc how to finalize for disksave.
Unify lrecords and lcrecords:
* lisp.h (struct Lisp_String): Adjust string union hack to
new lrecord header.
* lrecord.h: Adjust comments.
* lrecord.h (struct lrecord_header): The new lrecord header
includes type, lisp-readonly, free, and uid.
* lrecord.h (set_lheader_implementation): Adjust to new
lrecord_header.
* lrecord.h (struct lrecord_implementation): The field basic_p
for indication of an old lrecord is not needed anymore, remove.
* lrecord.h (MAKE_LRECORD_IMPLEMENTATION): Remove basic_p.
* lrecord.h (MAKE_EXTERNAL_LRECORD_IMPLEMENTATION): Remove
basic_p.
* lrecord.h (copy_sized_lrecord): Remove distinction between
old lrecords and lcrecords.
* lrecord.h (copy_lrecord): Remove distinction between old
lrecords and lcrecords.
* lrecord.h (zero_sized_lrecord): Remove distinction between
old lrecords and lcrecords.
* lrecord.h (zero_lrecord): Remove distinction between old
lrecords and lcrecords.
Remove lcrecords and lcrecord lists:
* alloc.c (basic_alloc_lcrecord): Not needed anymore, remove.
* alloc.c (very_old_free_lcrecord): Not needed anymore, remove.
* alloc.c (copy_lisp_object): No more distinction between
lrecords and lcrecords.
* alloc.c (all_lcrecords): Not needed anymore, remove.
* alloc.c (make_vector_internal): Allocate as lrecord.
* alloc.c (make_bit_vector_internal): Allocate as lrecord.
* alloc.c: Completely remove `lcrecord lists'.
* alloc.c (free_description): Remove.
* alloc.c (lcrecord_list_description): Remove.
* alloc.c (mark_lcrecord_list): Remove.
* alloc.c (make_lcrecord_list): Remove.
* alloc.c (alloc_managed_lcrecord): Remove.
* alloc.c (free_managed_lcrecord): Remove.
* alloc.c (alloc_automanaged_lcrecord): Remove.
* alloc.c (free_lcrecord): Remove.
* alloc.c (lcrecord_stats): Remove.
* alloc.c (tick_lcrecord_stats): Remove.
* alloc.c (disksave_object_finalization_1): Add call to
mc_finalize_for_disksave. Remove the lcrecord way to visit all
objects.
* alloc.c (kkcc_marking): Remove XD_FLAG_FREE_LISP_OBJECT
* alloc.c (sweep_lcrecords_1): Remove.
* alloc.c (common_init_alloc_early): Remove everything related
to lcrecords, remove old lrecord initializations,
* alloc.c (init_lcrecord_lists): Not needed anymore, remove.
* alloc.c (reinit_alloc_early): Remove everything related to
lcrecords.
* alloc.c (init_alloc_once_early): Remove everything related to
lcrecords.
* buffer.c (allocate_buffer): Allocate as lrecord.
* buffer.c (nuke_all_buffer_slots): Use lrecord functions.
* buffer.c (common_init_complex_vars_of_buffer): Allocate as
lrecord.
* buffer.h (struct buffer): Add lrecord_header.
* casetab.c (allocate_case_table): Allocate as lrecord.
* casetab.h (struct Lisp_Case_Table): Add lrecord_header.
* charset.h (struct Lisp_Charset): Add lrecord_header.
* chartab.c (fill_char_table): Use lrecord functions.
* chartab.c (Fmake_char_table): Allocate as lrecord.
* chartab.c (make_char_table_entry): Allocate as lrecord.
* chartab.c (copy_char_table_entry): Allocate as lrecord.
* chartab.c (Fcopy_char_table): Allocate as lrecord.
* chartab.c (put_char_table): Use lrecord functions.
* chartab.h (struct Lisp_Char_Table_Entry): Add lrecord_header.
* chartab.h (struct Lisp_Char_Table): Add lrecord_header.
* console-impl.h (struct console): Add lrecord_header.
* console-msw-impl.h (struct Lisp_Devmode): Add lrecord_header.
* console-msw-impl.h (struct mswindows_dialog_id): Add
lrecord_header.
* console.c (allocate_console): Allocate as lrecord.
* console.c (nuke_all_console_slots): Use lrecord functions.
* console.c (common_init_complex_vars_of_console): Allocate as
lrecord.
* data.c (make_weak_list): Allocate as lrecord.
* data.c (make_weak_box): Allocate as lrecord.
* data.c (make_ephemeron): Allocate as lrecord.
* database.c (struct Lisp_Database): Add lrecord_header.
* database.c (allocate_database): Allocate as lrecord.
* device-impl.h (struct device): Add lrecord_header.
* device-msw.c (allocate_devmode): Allocate as lrecord.
* device.c (nuke_all_device_slots): Use lrecord functions.
* device.c (allocate_device): Allocate as lrecord.
* dialog-msw.c (handle_question_dialog_box): Allocate as lrecord.
* elhash.c (struct Lisp_Hash_Table): Add lrecord_header.
* elhash.c (make_general_lisp_hash_table): Allocate as lrecord.
* elhash.c (Fcopy_hash_table): Allocate as lrecord.
* event-stream.c: Lcrecord lists Vcommand_builder_free_list and
Vtimeout_free_list are no longer needed. Remove.
* event-stream.c (allocate_command_builder): Allocate as lrecord.
* event-stream.c (free_command_builder): Use lrecord functions.
* event-stream.c (event_stream_generate_wakeup): Allocate as
lrecord.
* event-stream.c (event_stream_resignal_wakeup): Use lrecord
functions.
* event-stream.c (event_stream_disable_wakeup): Use lrecord
functions.
* event-stream.c (reinit_vars_of_event_stream): Lcrecord lists
remove.
* events.h (struct Lisp_Timeout): Add lrecord_header.
* events.h (struct command_builder): Add lrecord_header.
* extents-impl.h (struct extent_auxiliary): Add lrecord_header.
* extents-impl.h (struct extent_info): Add lrecord_header.
* extents.c (allocate_extent_auxiliary): Allocate as lrecord.
* extents.c (allocate_extent_info): Allocate as lrecord.
* extents.c (copy_extent): Allocate as lrecord.
* faces.c (allocate_face): Allocate as lrecord.
* faces.h (struct Lisp_Face): Add lrecord_header.
* file-coding.c (allocate_coding_system): Allocate as lrecord.
* file-coding.c (Fcopy_coding_system): Allocate as lrecord.
* file-coding.h (struct Lisp_Coding_System): Add lrecord_header.
* fns.c (Ffillarray): Allocate as lrecord.
* frame-impl.h (struct frame): Add lrecord_header.
* frame.c (nuke_all_frame_slots): Use lrecord functions.
* frame.c (allocate_frame_core): Allocate as lrecord.
* glyphs.c (allocate_image_instance): Allocate as lrecord.
* glyphs.c (Fcolorize_image_instance): Allocate as lrecord.
* glyphs.c (allocate_glyph): Allocate as lrecord.
* glyphs.h (struct Lisp_Image_Instance): Add lrecord_header.
* glyphs.h (struct Lisp_Glyph): Add lrecord_header.
* gui.c (allocate_gui_item): Allocate as lrecord.
* gui.h (struct Lisp_Gui_Item): Add lrecord_header.
* keymap.c (struct Lisp_Keymap): Add lrecord_header.
* keymap.c (make_keymap): Allocate as lrecord.
* lisp.h (struct Lisp_Vector): Add lrecord_header.
* lisp.h (struct Lisp_Bit_Vector): Add lrecord_header.
* lisp.h (struct weak_box): Add lrecord_header.
* lisp.h (struct ephemeron): Add lrecord_header.
* lisp.h (struct weak_list): Add lrecord_header.
* lrecord.h (struct lcrecord_header): Not used, remove.
* lrecord.h (struct free_lcrecord_header): Not used, remove.
* lrecord.h (struct lcrecord_list): Not needed anymore, remove.
* lrecord.h (lcrecord_list): Not needed anymore, remove.
* lrecord.h: (enum data_description_entry_flags): Remove
XD_FLAG_FREE_LISP_OBJECT.
* lstream.c: Lrecord list Vlstream_free_list remove.
* lstream.c (Lstream_new): Allocate as lrecord.
* lstream.c (Lstream_delete): Use lrecod functions.
* lstream.c (reinit_vars_of_lstream): Vlstream_free_list
initialization remove.
* lstream.h (struct lstream): Add lrecord_header.
* emacs.c (main_1): Remove lstream initialization.
* mule-charset.c (make_charset): Allocate as lrecord.
* objects-impl.h (struct Lisp_Color_Instance): Add
lrecord_header.
* objects-impl.h (struct Lisp_Font_Instance): Add lrecord_header.
* objects.c (Fmake_color_instance): Allocate as lrecord.
* objects.c (Fmake_font_instance): Allocate as lrecord.
* objects.c (reinit_vars_of_objects): Allocate as lrecord.
* opaque.c: Lcreord list Vopaque_ptr_list remove.
* opaque.c (make_opaque): Allocate as lrecord.
* opaque.c (make_opaque_ptr): Allocate as lrecord.
* opaque.c (free_opaque_ptr): Use lrecord functions.
* opaque.c (reinit_opaque_early):
* opaque.c (init_opaque_once_early): Vopaque_ptr_list
initialization remove.
* opaque.h (Lisp_Opaque): Add lrecord_header.
* opaque.h (Lisp_Opaque_Ptr): Add lrecord_header.
* emacs.c (main_1): Remove opaque variable initialization.
* print.c (default_object_printer): Use new lrecord_header.
* print.c (print_internal): Use new lrecord_header.
* print.c (debug_p4): Use new lrecord_header.
* process.c (make_process_internal): Allocate as lrecord.
* procimpl.h (struct Lisp_Process): Add lrecord_header.
* rangetab.c (Fmake_range_table): Allocate as lrecord.
* rangetab.c (Fcopy_range_table): Allocate as lrecord.
* rangetab.h (struct Lisp_Range_Table): Add lrecord_header.
* scrollbar.c (create_scrollbar_instance): Allocate as lrecord.
* scrollbar.h (struct scrollbar_instance): Add lrecord_header.
* specifier.c (make_specifier_internal): Allocate as lrecord.
* specifier.h (struct Lisp_Specifier): Add lrecord_header.
* symbols.c:
* symbols.c (Fmake_variable_buffer_local): Allocate as lrecord.
* symbols.c (Fdontusethis_set_symbol_value_handler): Allocate
as lrecord.
* symbols.c (Fdefvaralias): Allocate as lrecord.
* symeval.h (struct symbol_value_magic): Add lrecord_header.
* toolbar.c (update_toolbar_button): Allocate as lrecord.
* toolbar.h (struct toolbar_button): Add lrecord_header.
* tooltalk.c (struct Lisp_Tooltalk_Message): Add lrecord_header.
* tooltalk.c (make_tooltalk_message): Allocate as lrecord.
* tooltalk.c (struct Lisp_Tooltalk_Pattern): Add lrecord_header.
* tooltalk.c (make_tooltalk_pattern): Allocate as lrecord.
* ui-gtk.c (allocate_ffi_data): Allocate as lrecord.
* ui-gtk.c (allocate_emacs_gtk_object_data): Allocate as lrecord.
* ui-gtk.c (allocate_emacs_gtk_boxed_data): Allocate as lrecord.
* ui-gtk.h (structs): Add lrecord_header.
* window-impl.h (struct window): Add lrecord_header.
* window-impl.h (struct window_mirror): Add lrecord_header.
* window.c (allocate_window): Allocate as lrecord.
* window.c (new_window_mirror): Allocate as lrecord.
* window.c (make_dummy_parent): Allocate as lrecord.
MEMORY_USAGE_STATS
* alloc.c (fixed_type_block_overhead): Not used anymore, remove.
* buffer.c (compute_buffer_usage): Get storage size from new
allocator.
* marker.c (compute_buffer_marker_usage): Get storage size from
new allocator.
* mule-charset.c (compute_charset_usage): Get storage size from
new allocator.
* scrollbar-gtk.c (gtk_compute_scrollbar_instance_usage): Get
storage size from new allocator.
* scrollbar-msw.c (mswindows_compute_scrollbar_instance_usage):
Get storage size from new allocator.
* scrollbar-x.c (x_compute_scrollbar_instance_usage): Get
storage size from new allocator.
* scrollbar.c (compute_scrollbar_instance_usage): Get storage
size from new allocator.
* unicode.c (compute_from_unicode_table_size_1): Get storage
size from new allocator.
* unicode.c (compute_to_unicode_table_size_1): Get storage size
from new allocator.
* window.c (compute_window_mirror_usage): Get storage size from
new allocator.
* window.c (compute_window_usage): Get storage size from new
allocator.
MC_ALLOC_TYPE_STATS:
* alloc.c (alloc_lrecord): Bump lrecord count.
* alloc.c (noseeum_alloc_lrecord): Bump lrecord count.
* alloc.c (struct lrecord_stats): Storage for counts.
* alloc.c (init_lrecord_stats): Zero statistics.
* alloc.c (inc_lrecord_stats): Increase the statistic.
* alloc.c (dec_lrecord_stats): Decrease the statistic.
* alloc.c (gc_plist_hack): Used to print the information.
* alloc.c (Fgarbage_collect): Return the collected information.
* mc-alloc.c (remove_cell): Decrease lrecord count.
* mc-alloc.h: Set flag MC_ALLOC_TYPE_STATS.
* emacs.c (main_1): Init lrecord statistics.
* lrecord.h: Add prototypes for *_lrecord_stats.
Strings:
* alloc.c (Fmake_string): Initialize ascii_begin to zero.
* alloc.c (gc_count_num_short_string_in_use): Remove.
* alloc.c (gc_count_string_total_size): Remove.
* alloc.c (gc_count_short_string_total_size): Remove.
* alloc.c (debug_string_purity): Remove.
* alloc.c (debug_string_purity_print): Remove.
* alloc.c (sweep_strings): Remove.
Remove static C-readonly Lisp objects:
* alloc.c (c_readonly): Not needed anymore, remove.
* alloc.c (GC_CHECK_LHEADER_INVARIANTS): Remove some obsolete
lheader invariants assertions.
* buffer.c (DEFVAR_BUFFER_LOCAL_1): Allocate dynamically.
* console.c (DEFVAR_CONSOLE_LOCAL_1): Allocate dynamically.
* gpmevent.c: Indirection via MC_ALLOC_Freceive_gpm_event.
* gpmevent.c (Fgpm_enable): Allocate dynamically.
* gpmevent.c (syms_of_gpmevent): Allocate dynamically.
* lisp.h (C_READONLY): Not needed anymore, remove.
* lisp.h (DEFUN): Allocate dynamically.
* lrecord.h (C_READONLY_RECORD_HEADER_P): Not needed anymore,
remove.
* lrecord.h (SET_C_READONLY_RECORD_HEADER): Not needed anymore,
remove.
* symbols.c (guts_of_unbound_marker):
* symeval.h (defsubr): Allocate dynamically.
* symeval.h (DEFSUBR_MACRO): Allocate dynamically.
* symeval.h (DEFVAR_ SYMVAL_FWD): Allocate dynamically.
* tests.c (TESTS_DEFSUBR): Allocate dynamically.
Definition of mcpro:
* lisp.h: Add mcpro prototypes.
* alloc.c (common_init_alloc_early): Add initialization for
mcpros.
* alloc.c (mcpro_description_1): New.
* alloc.c (mcpro_description): New.
* alloc.c (mcpros_description_1): New.
* alloc.c (mcpros_description): New.
* alloc.c (mcpro_one_name_description_1): New.
* alloc.c (mcpro_one_name_description): New.
* alloc.c (mcpro_names_description_1): New.
* alloc.c (mcpro_names_description): New.
* alloc.c (mcpros): New.
* alloc.c (mcpro_names): New.
* alloc.c (mcpro_1): New.
* alloc.c (mc_pro): New.
* alloc.c (garbage_collect_1): Add mcpros to root set.
Usage of mcpro:
* alloc.c (make_string_nocopy): Add string to root set.
* symbols.c (init_symbols_once_early): Add Qunbound to root set.
Changes to the Portable Dumper:
* alloc.c (FREE_OR_REALLOC_BEGIN): Since dumped objects can be
freed with the new allocator, remove assertion for !DUMPEDP.
* dumper.c: Adjust comments, increase PDUMP_HASHSIZE.
* dumper.c (pdump_make_hash): Shift address only 2 bytes, to
avoid collisions.
* dumper.c (pdump_objects_unmark): No more mark bits within
the object, remove.
* dumper.c (mc_addr_elt): New. Element data structure for mc
hash table.
* dumper.c (pdump_mc_hash): New hash table: `lookup table'.
* dumper.c (pdump_get_mc_addr): New. Lookup for hash table.
* dumper.c (pdump_get_indirect_mc_addr): New. Lookup for
convertibles.
* dumper.c (pdump_put_mc_addr): New. Putter for hash table.
* dumper.c (pdump_dump_mc_data): New. Writes the table for
relocation at load time to the dump file.
* dumper.c (pdump_scan_lisp_objects_by_alignment): New.
Visits all dumped Lisp objects.
* dumper.c (pdump_scan_non_lisp_objects_by_alignment): New.
Visits all other dumped objects.
* dumper.c (pdump_reloc_one_mc): New. Updates all pointers
of an object by using the hash table pdump_mc_hash.
* dumper.c (pdump_reloc_one): Replaced by pdump_reloc_one_mc.
* dumper.c (pdump): Change the structure of the dump file, add
the mc post dump relocation table to dump file.
* dumper.c (pdump_load_finish): Hand all dumped objects to the
new allocator and use the mc post dump relocation table for
relocating the dumped objects at dump file load time, free not
longer used data structures.
* dumper.c (pdump_load): Free the dump file.
* dumper.h: Remove pdump_objects_unmark.
* lrecord.h (DUMPEDP): Dumped objects can be freed, remove.
DUMP_IN_EXEC:
* Makefile.in.in: Linking for and with dump in executable only if
DUMP_IN_EXEC is defined.
* config.h.in: Add new flag `DUMP_IN_EXEC'
* emacs.c: Condition dump-data.h on DUMP_IN_EXEC.
* emacs.c (main_1): Flag `-si' only works if dump image is
written into executable.
Miscellanious
* lrecord.h (enum lrecord_type): Added numbers to all types,
very handy for debugging.
* xemacs.def.in.in: Add mc-alloc functions to make them visible
to the modules.
| author | crestani |
|---|---|
| date | Fri, 08 Apr 2005 23:11:35 +0000 |
| parents | de9952d2ed18 |
| children | 1e7cc382eb16 |
| rev | line source |
|---|---|
| 428 | 1 /* Generic specifier list implementation |
| 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
| 826 | 3 Copyright (C) 1995, 1996, 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 | |
| 440 | 24 #ifndef INCLUDED_specifier_h_ |
| 25 #define INCLUDED_specifier_h_ | |
| 428 | 26 |
| 27 /* | |
| 28 MAGIC SPECIFIERS | |
| 29 ================ | |
| 30 | |
| 31 Magic specifiers are used to provide fallback values for window | |
| 32 system provided specifications, reflecting user preferences on the | |
| 33 window system, such as default fonts, colors, scrollbar thickness | |
| 34 etc. | |
| 35 | |
| 36 A magic specifier consists of two specifier objects. The first one | |
| 37 behaves like a normal specifier in all senses. The second one, a | |
| 38 ghost specifier, is a fallback value for the first one, and contains | |
| 39 values provided by window system, resources etc. which reflect | |
| 40 default settings for values being specified. | |
| 41 | |
| 42 A magic specifier has an "ultimate" fallback value, as any usual | |
| 43 specifier does. This value, an inst-list, is stored in the fallback | |
| 44 slot of the ghost specifier object. | |
| 45 | |
| 46 Ghost specifiers have the following properties: | |
| 47 - Have back pointers to their parent specifiers. | |
| 48 - Do not have instance data. Instead, they share parent's instance | |
| 49 data. | |
| 50 - Have the same methods structure pointer. | |
| 51 - Share parent's caching scheme. | |
| 52 - Store fallback value instead of their parents. | |
| 53 | |
| 54 Ghost specifiers normally are not modifiable at the lisp level, and | |
| 55 only used to supply fallback instance values. They are accessible | |
| 56 via (specifier-fallback), but are read-only. Although, under | |
| 57 certain rare conditions, modification of ghost objects is allowed. | |
| 58 This behavior is controlled by the global variable | |
| 59 Vunlock_ghost_specifiers. It is not exposed to lisp, and is set | |
| 60 during calls to lisp functions which initialize global, device and | |
| 61 frame defaults, such as | |
| 62 init-{global,frame,device}-{faces,toolbars,etc}. | |
| 63 | |
| 64 Thus, values supplied by resources or other means of a window system | |
| 65 stored in externally unmodifiable ghost objects. Regular lisp code | |
| 66 may thus freely modify the normal part of a magic specifier, and | |
| 67 removing a specification for a particular domain causes the | |
| 68 specification to consider ghost-provided fallback values, or its own | |
| 69 fallback value. | |
| 70 | |
| 71 Rules of conduct for magic specifiers | |
| 72 ------------------------------------- | |
| 73 1. recompute_*() functions always operate on the whole specifier | |
| 74 when passed only a ghost object, by substituting it with their | |
| 75 parent bodily object. | |
| 76 2. All specifier methods, except for instantiate method, are passed | |
| 77 the bodily object of the magic specifier. Instantiate method is | |
| 78 passed the specifier being instantiated. | |
| 79 3. Only bodily objects are passed to set_specifier_caching function, | |
| 80 and only these may be cached. | |
| 81 4. All specifiers are added to Vall_specifiers list, both bodily and | |
| 82 ghost. The pair of objects is always removed from the list at the | |
| 83 same time. | |
| 84 */ | |
| 85 | |
| 1204 | 86 extern const struct sized_memory_description specifier_methods_description; |
| 428 | 87 |
| 88 struct specifier_methods | |
| 89 { | |
| 442 | 90 const char *name; |
| 428 | 91 Lisp_Object predicate_symbol; |
| 92 | |
| 93 /* Implementation specific methods: */ | |
| 94 | |
| 95 /* Create method: Initialize specifier data. Optional. */ | |
| 96 void (*create_method) (Lisp_Object specifier); | |
| 97 | |
| 98 /* Mark method: Mark any lisp object within specifier data | |
| 99 structure. Not required if no specifier data are Lisp_Objects. */ | |
| 100 void (*mark_method) (Lisp_Object specifier); | |
| 101 | |
| 102 /* Equal method: Compare two specifiers. This is called after | |
| 103 ensuring that the two specifiers are of the same type, and have | |
| 104 the same specs. Quit is inhibited during the call so it is safe | |
| 105 to call internal_equal(). | |
| 106 | |
| 107 If this function is not present, specifiers considered equal when | |
| 108 the above conditions are met, i.e. as if the method returned | |
| 109 non-zero. */ | |
| 110 int (*equal_method) (Lisp_Object sp1, Lisp_Object sp2, int depth); | |
| 111 | |
| 112 /* Hash method: Hash specifier instance data. This has to hash only | |
| 113 data structure of the specifier, as specs are hashed by the core | |
| 114 code. | |
| 115 | |
| 116 If this function is not present, hashing behaves as if it | |
| 117 returned zero. */ | |
| 2515 | 118 Hashcode (*hash_method) (Lisp_Object specifier, int depth); |
| 428 | 119 |
| 120 /* Validate method: Given an instantiator, verify that it's | |
| 121 valid for this specifier type. If not, signal an error. | |
| 122 | |
| 123 If this function is not present, all instantiators are considered | |
| 124 valid. */ | |
| 125 void (*validate_method) (Lisp_Object instantiator); | |
| 126 | |
| 434 | 127 |
| 128 /* Copy method: Given an instantiator, copy the bits that we need to | |
| 129 for this specifier type. | |
| 130 | |
| 131 If this function is not present, then Fcopy_tree is used. */ | |
| 132 Lisp_Object (*copy_instantiator_method) (Lisp_Object instantiator); | |
| 133 | |
| 428 | 134 /* Validate-matchspec method: Given a matchspec, verify that it's |
| 135 valid for this specifier type. If not, signal an error. | |
| 136 | |
| 137 If this function is not present, *no* matchspecs are considered | |
| 138 valid. Note that this differs from validate_method(). */ | |
| 139 void (*validate_matchspec_method) (Lisp_Object matchspec); | |
| 140 | |
| 141 /* Instantiate method: Return SPECIFIER instance in DOMAIN, | |
| 142 specified by INSTANTIATOR. MATCHSPEC specifies an additional | |
| 143 constraints on the instance value (see the docstring for | |
| 144 Fspecifier_matching_instance function). MATCHSPEC is passed | |
| 145 Qunbound when no matching constraints are imposed. The method is | |
| 146 called via call_with_suspended_errors(), so allowed to eval | |
| 147 safely. | |
| 148 | |
| 149 DEPTH is a lisp integer denoting current depth of instantiation | |
| 150 calls. This parameter should be passed as the initial depth value | |
| 151 to functions which also instantiate specifiers (of which I can | |
| 152 name specifier_instance) to avoid creating "external" | |
| 153 specification loops. | |
| 154 | |
| 442 | 155 This method must presume that both INSTANTIATOR and MATCHSPEC are |
| 428 | 156 already validated by the corresponding validate_* methods, and |
| 157 may abort if they are invalid. | |
| 158 | |
| 159 Return value is an instance, which is returned immediately to the | |
| 160 caller, or Qunbound to continue instantiation lookup chain. | |
| 161 | |
| 162 If this function is not present, INSTANTIATOR is used as the | |
| 163 specifier instance. This is the usual case for "simple" | |
| 164 specifiers, like integer and boolean. */ | |
| 165 Lisp_Object (*instantiate_method) (Lisp_Object specifier, | |
| 166 Lisp_Object matchspec, | |
| 167 Lisp_Object domain, | |
| 168 Lisp_Object instantiator, | |
| 169 Lisp_Object depth); | |
| 170 | |
| 171 /* Going-to-add method: Called when an instantiator is about | |
| 172 to be added to a specifier. This function can specify | |
| 173 that different instantiators should be used instead by | |
| 174 returning an inst-list (possibly containing zero elements). | |
| 175 If the instantiator is fine as-is, return Qt. The | |
| 176 instantiator has been copied with copy-tree, so feel | |
| 177 free to reuse parts of it to create a new instantiator. | |
| 178 The tag-set, however, is not copied and is not canonicalized | |
| 179 (that will be done on the result of this function). */ | |
| 180 Lisp_Object (*going_to_add_method) (Lisp_Object specifier, | |
| 181 Lisp_Object locale, | |
| 182 Lisp_Object tag_set, | |
| 183 Lisp_Object instantiator); | |
| 184 | |
| 185 /* After-change method: Called when the SPECIFIER has just been | |
| 186 changed in LOCALE. The method is called upon: | |
| 187 * Removing and adding specs to/from the specifier; | |
| 188 * Changing the specifier fallback. | |
| 189 | |
| 190 #### The method may have called more than once per each specifier | |
| 191 change. | |
| 192 | |
| 193 #### Do not still know if this can safely eval. */ | |
| 194 void (*after_change_method) (Lisp_Object specifier, | |
| 195 Lisp_Object locale); | |
| 196 | |
| 1204 | 197 /* Specifier extra data: Specifier objects can have extra data, specific |
| 198 to the type of specifier, stored at the end of the object. To have | |
| 199 this, a specifier declares a structure of type `struct TYPE_specifier' | |
| 200 containing the data and uses DEFINE_SPECIFIER_TYPE_WITH_DATA and | |
| 201 INITIALIZE_SPECIFIER_TYPE_WITH_DATA instead of the plain versions. | |
| 202 Then, a pointer to the `struct TYPE_specifier' can be obtained from a | |
| 203 specifier object using SPECIFIER_TYPE_DATA. | |
| 771 | 204 |
| 1204 | 205 A data description of the extra data must also be provided, in the |
| 206 form of a memory_description named TYPE_specifier_description. */ | |
| 207 | |
| 208 /* Description of extra data structure; initialized when | |
| 771 | 209 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */ |
| 1204 | 210 const struct sized_memory_description *extra_description; |
| 771 | 211 |
| 212 /* Size of extra data structure; initialized when | |
| 213 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */ | |
| 428 | 214 int extra_data_size; |
| 215 }; | |
| 216 | |
| 217 struct Lisp_Specifier | |
| 218 { | |
| 2720 | 219 #ifdef MC_ALLOC |
| 220 struct lrecord_header header; | |
| 221 #else /* MC_ALLOC */ | |
| 428 | 222 struct lcrecord_header header; |
| 2720 | 223 #endif /* MC_ALLOC */ |
| 428 | 224 struct specifier_methods *methods; |
| 225 | |
| 226 /* we keep a chained list of all current specifiers, for GC cleanup | |
| 227 purposes. Do NOT mark through this, or specifiers will never | |
| 228 be GC'd. */ | |
| 229 Lisp_Object next_specifier; | |
| 230 | |
| 231 /* This is a straight list of instantiators. */ | |
| 232 Lisp_Object global_specs; | |
| 233 | |
| 234 /* These are all assoc lists where the key is the type of object the | |
| 235 list represents (buffer, window, etc.) and the associated list is | |
| 236 the actual list of instantiators. */ | |
| 237 Lisp_Object device_specs; | |
| 238 Lisp_Object frame_specs; | |
| 239 /* window_specs is actually a key-assoc weak list. See specifier.c | |
| 240 for an explanation of why (it boils down to the fact that | |
| 241 dead windows can become live again through window configurations). | |
| 242 */ | |
| 243 Lisp_Object window_specs; | |
| 244 Lisp_Object buffer_specs; | |
| 245 | |
| 246 struct specifier_caching *caching; | |
| 247 | |
| 248 /* This can be either nil, for a plain, non-magic specifier object, | |
| 249 t for the normal part of the magic specifier, or #<specifier> for | |
| 250 the ghost part of the magic specifier, a pointer to its parent | |
| 251 object */ | |
| 252 Lisp_Object magic_parent; | |
| 253 | |
| 254 /* Fallback value. For magic specifiers, it is a pointer to the ghost. */ | |
| 255 Lisp_Object fallback; | |
| 256 | |
| 257 /* type-specific extra data attached to a specifier */ | |
| 456 | 258 max_align_t data[1]; |
| 428 | 259 }; |
| 440 | 260 typedef struct Lisp_Specifier Lisp_Specifier; |
| 428 | 261 |
| 440 | 262 DECLARE_LRECORD (specifier, Lisp_Specifier); |
| 263 #define XSPECIFIER(x) XRECORD (x, specifier, Lisp_Specifier) | |
| 617 | 264 #define wrap_specifier(p) wrap_record (p, specifier) |
| 428 | 265 #define SPECIFIERP(x) RECORDP (x, specifier) |
| 266 #define CHECK_SPECIFIER(x) CHECK_RECORD (x, specifier) | |
| 267 #define CONCHECK_SPECIFIER(x) CONCHECK_RECORD (x, specifier) | |
| 268 | |
| 269 /***** Calling a specifier method *****/ | |
| 270 | |
| 271 #define RAW_SPECMETH(sp, m) ((sp)->methods->m##_method) | |
| 272 #define HAS_SPECMETH_P(sp, m) (!!RAW_SPECMETH (sp, m)) | |
| 273 #define SPECMETH(sp, m, args) (((sp)->methods->m##_method) args) | |
| 274 | |
| 275 /* Call a void-returning specifier method, if it exists. */ | |
| 440 | 276 #define MAYBE_SPECMETH(sp, m, args) do { \ |
| 277 Lisp_Specifier *maybe_specmeth_sp = (sp); \ | |
| 278 if (HAS_SPECMETH_P (maybe_specmeth_sp, m)) \ | |
| 279 SPECMETH (maybe_specmeth_sp, m, args); \ | |
| 428 | 280 } while (0) |
| 281 | |
| 282 /***** Defining new specifier types *****/ | |
| 283 | |
| 1204 | 284 extern const struct sized_memory_description specifier_empty_extra_description; |
| 428 | 285 |
| 800 | 286 #ifdef ERROR_CHECK_TYPES |
| 428 | 287 #define DECLARE_SPECIFIER_TYPE(type) \ |
| 288 extern struct specifier_methods * type##_specifier_methods; \ | |
| 826 | 289 DECLARE_INLINE_HEADER ( \ |
| 290 struct type##_specifier * \ | |
| 440 | 291 error_check_##type##_specifier_data (Lisp_Specifier *sp) \ |
| 826 | 292 ) \ |
| 428 | 293 { \ |
| 294 if (SPECIFIERP (sp->magic_parent)) \ | |
| 295 { \ | |
| 296 assert (SPECIFIER_TYPE_P (sp, type)); \ | |
| 297 sp = XSPECIFIER (sp->magic_parent); \ | |
| 298 } \ | |
| 299 else \ | |
| 300 assert (NILP (sp->magic_parent) || EQ (sp->magic_parent, Qt)); \ | |
| 301 assert (SPECIFIER_TYPE_P (sp, type)); \ | |
| 302 return (struct type##_specifier *) sp->data; \ | |
| 303 } \ | |
| 826 | 304 DECLARE_INLINE_HEADER ( \ |
| 305 Lisp_Specifier * \ | |
| 438 | 306 error_check_##type##_specifier_type (Lisp_Object obj) \ |
| 826 | 307 ) \ |
| 438 | 308 { \ |
| 440 | 309 Lisp_Specifier *sp = XSPECIFIER (obj); \ |
| 438 | 310 assert (SPECIFIER_TYPE_P (sp, type)); \ |
| 311 return sp; \ | |
| 312 } \ | |
| 428 | 313 DECLARE_NOTHING |
| 314 #else | |
| 442 | 315 #define DECLARE_SPECIFIER_TYPE(type) \ |
| 428 | 316 extern struct specifier_methods * type##_specifier_methods |
| 800 | 317 #endif /* ERROR_CHECK_TYPES */ |
| 428 | 318 |
| 442 | 319 #define DEFINE_SPECIFIER_TYPE(type) \ |
| 428 | 320 struct specifier_methods * type##_specifier_methods |
| 321 | |
| 1204 | 322 #define DEFINE_SPECIFIER_TYPE_WITH_DATA(type) \ |
| 323 struct specifier_methods * type##_specifier_methods; \ | |
| 324 static const struct sized_memory_description type##_specifier_description_0 \ | |
| 325 = { \ | |
| 326 sizeof (struct type##_specifier), \ | |
| 327 type##_specifier_description \ | |
| 328 } | |
| 329 | |
| 771 | 330 #define INITIALIZE_SPECIFIER_TYPE(type, obj_name, pred_sym) do { \ |
| 331 type##_specifier_methods = xnew_and_zero (struct specifier_methods); \ | |
| 332 type##_specifier_methods->name = obj_name; \ | |
| 333 type##_specifier_methods->extra_description = \ | |
| 1204 | 334 &specifier_empty_extra_description; \ |
| 771 | 335 defsymbol_nodump (&type##_specifier_methods->predicate_symbol, pred_sym); \ |
| 336 add_entry_to_specifier_type_list (Q##type, type##_specifier_methods); \ | |
| 2367 | 337 dump_add_root_block_ptr (&type##_specifier_methods, \ |
| 771 | 338 &specifier_methods_description); \ |
| 428 | 339 } while (0) |
| 340 | |
| 442 | 341 #define REINITIALIZE_SPECIFIER_TYPE(type) do { \ |
| 428 | 342 staticpro_nodump (&type##_specifier_methods->predicate_symbol); \ |
| 343 } while (0) | |
| 344 | |
| 345 #define INITIALIZE_SPECIFIER_TYPE_WITH_DATA(type, obj_name, pred_sym) \ | |
| 346 do { \ | |
| 347 INITIALIZE_SPECIFIER_TYPE (type, obj_name, pred_sym); \ | |
| 348 type##_specifier_methods->extra_data_size = \ | |
| 349 sizeof (struct type##_specifier); \ | |
| 350 type##_specifier_methods->extra_description = \ | |
| 1204 | 351 &type##_specifier_description_0; \ |
| 428 | 352 } while (0) |
| 353 | |
| 354 /* Declare that specifier-type TYPE has method METH; used in | |
| 355 initialization routines */ | |
| 356 #define SPECIFIER_HAS_METHOD(type, meth) \ | |
| 357 (type##_specifier_methods->meth##_method = type##_##meth) | |
| 358 | |
| 359 /***** Macros for accessing specifier types *****/ | |
| 360 | |
| 361 #define SPECIFIER_TYPE_P(sp, type) \ | |
| 362 ((sp)->methods == type##_specifier_methods) | |
| 363 | |
| 364 /* Any of the two of the magic spec */ | |
| 365 #define MAGIC_SPECIFIER_P(sp) (!NILP((sp)->magic_parent)) | |
| 366 /* Normal part of the magic specifier */ | |
| 367 #define BODILY_SPECIFIER_P(sp) EQ ((sp)->magic_parent, Qt) | |
| 368 /* Ghost part of the magic specifier */ | |
| 369 #define GHOST_SPECIFIER_P(sp) SPECIFIERP((sp)->magic_parent) | |
| 370 | |
| 371 #define GHOST_SPECIFIER(sp) XSPECIFIER ((sp)->fallback) | |
| 372 | |
| 800 | 373 #ifdef ERROR_CHECK_TYPES |
| 428 | 374 # define SPECIFIER_TYPE_DATA(sp, type) \ |
| 375 error_check_##type##_specifier_data (sp) | |
| 376 #else | |
| 377 # define SPECIFIER_TYPE_DATA(sp, type) \ | |
| 378 ((struct type##_specifier *) \ | |
| 379 (GHOST_SPECIFIER_P(sp) \ | |
| 380 ? XSPECIFIER((sp)->magic_parent)->data \ | |
| 381 : (sp)->data)) | |
| 382 #endif | |
| 383 | |
| 800 | 384 #ifdef ERROR_CHECK_TYPES |
| 438 | 385 # define XSPECIFIER_TYPE(x, type) \ |
| 386 error_check_##type##_specifier_type (x) | |
| 387 #else | |
| 388 # define XSPECIFIER_TYPE(x, type) XSPECIFIER (x) | |
| 800 | 389 #endif /* ERROR_CHECK_TYPES */ |
| 428 | 390 |
| 442 | 391 #define SPECIFIER_TYPEP(x, type) \ |
| 428 | 392 (SPECIFIERP (x) && SPECIFIER_TYPE_P (XSPECIFIER (x), type)) |
| 393 #define CHECK_SPECIFIER_TYPE(x, type) do { \ | |
| 394 CHECK_SPECIFIER (x); \ | |
| 395 if (!SPECIFIER_TYPE_P (XSPECIFIER (x), type)) \ | |
| 396 dead_wrong_type_argument \ | |
| 397 (type##_specifier_methods->predicate_symbol, x); \ | |
| 398 } while (0) | |
| 399 #define CONCHECK_SPECIFIER_TYPE(x, type) do { \ | |
| 400 CONCHECK_SPECIFIER (x); \ | |
| 401 if (!(SPECIFIER_TYPEP (x, type))) \ | |
| 402 x = wrong_type_argument \ | |
| 403 (type##_specifier_methods->predicate_symbol, x); \ | |
| 404 } while (0) | |
| 405 | |
| 406 /***** Miscellaneous structures *****/ | |
| 407 | |
| 408 enum spec_locale_type | |
| 409 { | |
| 410 LOCALE_GLOBAL, | |
| 411 LOCALE_DEVICE, | |
| 412 LOCALE_FRAME, | |
| 413 LOCALE_WINDOW, | |
| 414 LOCALE_BUFFER | |
| 415 }; | |
| 416 | |
| 417 enum spec_add_meth | |
| 418 { | |
| 419 SPEC_PREPEND, | |
| 420 SPEC_APPEND, | |
| 421 SPEC_REMOVE_TAG_SET_PREPEND, | |
| 422 SPEC_REMOVE_TAG_SET_APPEND, | |
| 423 SPEC_REMOVE_LOCALE, | |
| 424 SPEC_REMOVE_LOCALE_TYPE, | |
| 425 SPEC_REMOVE_ALL | |
| 426 }; | |
| 427 | |
| 428 struct specifier_caching | |
| 429 { | |
| 430 int offset_into_struct_window; | |
| 431 void (*value_changed_in_window) (Lisp_Object specifier, struct window *w, | |
| 432 Lisp_Object oldval); | |
| 433 int offset_into_struct_frame; | |
| 434 void (*value_changed_in_frame) (Lisp_Object specifier, struct frame *f, | |
| 435 Lisp_Object oldval); | |
| 444 | 436 int always_recompute; |
| 428 | 437 }; |
| 438 | |
| 442 | 439 /* #### get image instances out of domains! */ |
| 440 | |
| 2500 | 441 /* #### I think the following should ABORT() rather than return nil |
| 442 | 442 when an invalid domain is given; much more likely we'll catch design |
| 443 errors early. --ben */ | |
| 444 | |
| 445 /* This turns out to be used heavily so we make it a macro to make it | |
| 446 inline. Also, the majority of the time the object will turn out to | |
| 447 be a window so we move it from being checked last to being checked | |
| 448 first. */ | |
| 449 #define DOMAIN_DEVICE(obj) \ | |
| 450 (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj)) \ | |
| 451 : (FRAMEP (obj) ? FRAME_DEVICE (XFRAME (obj)) \ | |
| 452 : (DEVICEP (obj) ? obj \ | |
| 453 : (IMAGE_INSTANCEP (obj) ? image_instance_device (obj) \ | |
| 454 : Qnil)))) | |
| 455 | |
| 456 #define DOMAIN_FRAME(obj) \ | |
| 457 (WINDOWP (obj) ? WINDOW_FRAME (XWINDOW (obj)) \ | |
| 458 : (FRAMEP (obj) ? obj \ | |
| 459 : (IMAGE_INSTANCEP (obj) ? image_instance_frame (obj) \ | |
| 460 : Qnil))) | |
| 461 | |
| 462 #define DOMAIN_WINDOW(obj) \ | |
| 463 (WINDOWP (obj) ? obj \ | |
| 464 : (IMAGE_INSTANCEP (obj) ? image_instance_window (obj) \ | |
| 465 : Qnil)) | |
| 466 | |
| 467 #define DOMAIN_LIVE_P(obj) \ | |
| 468 (WINDOWP (obj) ? WINDOW_LIVE_P (XWINDOW (obj)) \ | |
| 469 : (FRAMEP (obj) ? FRAME_LIVE_P (XFRAME (obj)) \ | |
| 470 : (DEVICEP (obj) ? DEVICE_LIVE_P (XDEVICE (obj)) \ | |
| 471 : (IMAGE_INSTANCEP (obj) ? image_instance_live_p (obj) \ | |
| 472 : 0)))) | |
| 473 | |
| 474 #define DOMAIN_XDEVICE(obj) \ | |
| 475 (XDEVICE (DOMAIN_DEVICE (obj))) | |
| 476 #define DOMAIN_XFRAME(obj) \ | |
| 477 (XFRAME (DOMAIN_FRAME (obj))) | |
| 478 #define DOMAIN_XWINDOW(obj) \ | |
| 479 (XWINDOW (DOMAIN_WINDOW (obj))) | |
| 480 | |
| 428 | 481 EXFUN (Fcopy_specifier, 6); |
| 482 EXFUN (Fmake_specifier, 1); | |
| 483 EXFUN (Fset_specifier_dirty_flag, 1); | |
| 484 EXFUN (Fspecifier_instance, 4); | |
| 485 EXFUN (Fvalid_specifier_locale_p, 1); | |
| 486 | |
| 487 extern Lisp_Object Qfallback, Qnatnum; | |
| 488 | |
| 489 Lisp_Object make_magic_specifier (Lisp_Object type); | |
| 490 Lisp_Object decode_locale_list (Lisp_Object locale); | |
| 491 extern enum spec_add_meth | |
| 492 decode_how_to_add_specification (Lisp_Object how_to_add); | |
| 493 Lisp_Object decode_specifier_tag_set (Lisp_Object tag_set); | |
| 442 | 494 Lisp_Object decode_domain (Lisp_Object domain); |
| 428 | 495 |
| 496 void add_entry_to_specifier_type_list (Lisp_Object symbol, | |
| 497 struct specifier_methods *meths); | |
| 498 void set_specifier_caching (Lisp_Object specifier, | |
| 499 int struct_window_offset, | |
| 500 void (*value_changed_in_window) | |
| 501 (Lisp_Object specifier, struct window *w, | |
| 502 Lisp_Object oldval), | |
| 503 int struct_frame_offset, | |
| 504 void (*value_changed_in_frame) | |
| 505 (Lisp_Object specifier, struct frame *f, | |
| 444 | 506 Lisp_Object oldval), |
| 507 int always_recompute); | |
| 428 | 508 void set_specifier_fallback (Lisp_Object specifier, |
| 509 Lisp_Object fallback); | |
| 510 void recompute_all_cached_specifiers_in_window (struct window *w); | |
| 511 void recompute_all_cached_specifiers_in_frame (struct frame *f); | |
| 512 | |
| 513 /* Counterparts of Fadd_spec_to_specifier and Fremove_specifier, which | |
| 514 operate directly on ghost objects given a magic specifier. */ | |
| 515 void add_spec_to_ghost_specifier (Lisp_Object specifier, Lisp_Object instantiator, | |
| 516 Lisp_Object locale, Lisp_Object tag_set, | |
| 517 Lisp_Object how_to_add); | |
| 518 void remove_ghost_specifier (Lisp_Object specifier, Lisp_Object locale, | |
| 519 Lisp_Object tag_set, Lisp_Object exact_p); | |
| 520 | |
| 521 int unlock_ghost_specifiers_protected (void); | |
| 522 | |
| 523 void cleanup_specifiers (void); | |
| 524 void prune_specifiers (void); | |
| 525 void setup_device_initial_specifier_tags (struct device *d); | |
| 526 void kill_specifier_buffer_locals (Lisp_Object buffer); | |
| 527 | |
| 528 DECLARE_SPECIFIER_TYPE (generic); | |
| 529 #define XGENERIC_SPECIFIER(x) XSPECIFIER_TYPE (x, generic) | |
| 530 #define GENERIC_SPECIFIERP(x) SPECIFIER_TYPEP (x, generic) | |
| 531 #define CHECK_GENERIC_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, generic) | |
| 532 #define CONCHECK_GENERIC_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, generic) | |
| 533 | |
| 534 DECLARE_SPECIFIER_TYPE (integer); | |
| 535 #define XINTEGER_SPECIFIER(x) XSPECIFIER_TYPE (x, integer) | |
| 536 #define INTEGER_SPECIFIERP(x) SPECIFIER_TYPEP (x, integer) | |
| 537 #define CHECK_INTEGER_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, integer) | |
| 538 #define CONCHECK_INTEGER_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, integer) | |
| 539 | |
| 540 DECLARE_SPECIFIER_TYPE (natnum); | |
| 541 #define XNATNUM_SPECIFIER(x) XSPECIFIER_TYPE (x, natnum) | |
| 542 #define NATNUM_SPECIFIERP(x) SPECIFIER_TYPEP (x, natnum) | |
| 543 #define CHECK_NATNUM_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, natnum) | |
| 544 #define CONCHECK_NATNUM_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, natnum) | |
| 545 | |
| 546 DECLARE_SPECIFIER_TYPE (boolean); | |
| 547 #define XBOOLEAN_SPECIFIER(x) XSPECIFIER_TYPE (x, boolean) | |
| 548 #define BOOLEAN_SPECIFIERP(x) SPECIFIER_TYPEP (x, boolean) | |
| 549 #define CHECK_BOOLEAN_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, boolean) | |
| 550 #define CONCHECK_BOOLEAN_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, boolean) | |
| 551 | |
| 552 DECLARE_SPECIFIER_TYPE (display_table); | |
| 553 #define XDISPLAYTABLE_SPECIFIER(x) XSPECIFIER_TYPE (x, display_table) | |
| 554 #define DISPLAYTABLE_SPECIFIERP(x) SPECIFIER_TYPEP (x, display_table) | |
| 555 #define CHECK_DISPLAYTABLE_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, display_table) | |
| 556 #define CONCHECK_DISPLAYTABLE_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, display_table) | |
| 557 | |
| 440 | 558 #endif /* INCLUDED_specifier_h_ */ |