Mercurial > hg > xemacs-beta
annotate src/lstream.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 | e22b0213b713 |
| children | 1e7cc382eb16 |
| rev | line source |
|---|---|
| 428 | 1 /* Generic stream implementation -- header file. |
| 2 Copyright (C) 1995 Free Software Foundation, Inc. | |
| 788 | 3 Copyright (C) 1996, 2001, 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. */ | |
| 25 | |
| 440 | 26 #ifndef INCLUDED_lstream_h_ |
| 27 #define INCLUDED_lstream_h_ | |
| 428 | 28 |
| 29 /************************************************************************/ | |
| 30 /* definition of Lstream object */ | |
| 31 /************************************************************************/ | |
| 32 | |
| 33 DECLARE_LRECORD (lstream, struct lstream); | |
| 34 #define XLSTREAM(x) XRECORD (x, lstream, struct lstream) | |
| 617 | 35 #define wrap_lstream(p) wrap_record (p, lstream) |
| 428 | 36 #define LSTREAMP(x) RECORDP (x, lstream) |
| 37 /* #define CHECK_LSTREAM(x) CHECK_RECORD (x, lstream) | |
| 38 Lstream pointers should never escape to the Lisp level, so | |
| 39 functions should not be doing this. */ | |
| 40 | |
| 41 #ifndef EOF | |
| 42 #define EOF (-1) | |
| 43 #endif | |
| 44 | |
| 771 | 45 /* There have been some arguments over the what the type should be that |
| 665 | 46 specifies a count of bytes in a data block to be written out or read in, |
| 47 using Lstream_read(), Lstream_write(), and related functions. | |
| 48 Originally it was long, which worked fine; Martin "corrected" these to | |
| 49 size_t and ssize_t on the grounds that this is theoretically cleaner and | |
| 50 is in keeping with the C standards. Unfortunately, this practice is | |
| 51 horribly error-prone due to design flaws in the way that mixed | |
| 52 signed/unsigned arithmetic happens. In fact, by doing this change, | |
| 53 Martin introduced a subtle but fatal error that caused the operation of | |
| 54 sending large mail messages to the SMTP server under Windows to fail. | |
| 55 By putting all values back to be signed, avoiding any signed/unsigned | |
| 56 mixing, the bug immediately went away. The type then in use was | |
| 57 Lstream_Data_Count, so that it be reverted cleanly if a vote came to | |
| 58 that. Now it is Bytecount. | |
| 59 | |
| 60 Some earlier comments about why the type must be signed: This MUST BE | |
| 61 SIGNED, since it also is used in functions that return the number of | |
| 62 bytes actually read to or written from in an operation, and these | |
| 63 functions can return -1 to signal error. | |
| 462 | 64 |
| 65 Note that the standard Unix read() and write() functions define the | |
| 66 count going in as a size_t, which is UNSIGNED, and the count going | |
| 67 out as an ssize_t, which is SIGNED. This is a horrible design | |
| 68 flaw. Not only is it highly likely to lead to logic errors when a | |
| 69 -1 gets interpreted as a large positive number, but operations are | |
| 70 bound to fail in all sorts of horrible ways when a number in the | |
| 71 upper-half of the size_t range is passed in -- this number is | |
| 72 unrepresentable as an ssize_t, so code that checks to see how many | |
| 73 bytes are actually written (which is mandatory if you are dealing | |
| 74 with certain types of devices) will get completely screwed up. | |
| 771 | 75 |
| 665 | 76 --ben |
| 462 | 77 */ |
| 428 | 78 typedef enum lstream_buffering |
| 79 { | |
| 80 /* No buffering. */ | |
| 81 LSTREAM_UNBUFFERED, | |
| 82 /* Buffer until a '\n' character is reached. */ | |
| 83 LSTREAM_LINE_BUFFERED, | |
| 84 /* Buffer in standard-size (i.e. 512-byte) blocks. */ | |
| 85 LSTREAM_BLOCK_BUFFERED, | |
| 86 /* Buffer in blocks of a specified size. */ | |
| 87 LSTREAM_BLOCKN_BUFFERED, | |
| 88 /* Buffer until the stream is closed (only applies to write-only | |
| 89 streams). Only one call to the stream writer will be made, | |
| 90 and that is when the stream is closed. */ | |
| 91 LSTREAM_UNLIMITED | |
| 92 } Lstream_buffering; | |
| 93 | |
| 771 | 94 #if 0 |
| 95 | |
| 96 /* #### not currently implemented; correct EOF handling is quite tricky | |
| 97 in the presence of various levels of filtering streams, and simply | |
| 98 interpreting 0 as EOF works fairly well as long as the amount of | |
| 99 data you're attempting to read is large and you know whether the | |
| 100 source stream at the end of the chain is a pipe (or other blocking | |
| 101 source) or not. we really should fix this, though. */ | |
| 102 | |
| 103 /* Return values from Lstream_read(). We do NOT use the C lib trick | |
| 104 of returning 0 to maybe indicate EOF because that is simply too | |
| 105 random and error-prone. It is quite legitimate for there to be no | |
| 106 data available but no EOF, even when not in the presence of | |
| 107 non-blocking I/O. For example, decoding/encoding streams (and in | |
| 108 general, any type of filtering stream) may only be able to return | |
| 109 data after a certain amount of data on the other end is | |
| 110 available. */ | |
| 111 | |
| 112 #define LSTREAM_EOF -2 | |
| 113 | |
| 114 #endif /* 0 */ | |
| 115 | |
| 116 #define LSTREAM_ERROR -1 | |
| 117 | |
| 428 | 118 /* Methods defining how this stream works. Some may be undefined. */ |
| 119 | |
| 120 /* We do not implement the seek/tell paradigm. I tried to do that, | |
| 121 but getting the semantics right in the presence of buffering is | |
| 122 extremely tricky and very error-prone and basically not worth it. | |
| 123 This is especially the case with complicated streams like | |
| 124 decoding streams -- the seek pointer in this case can't be a single | |
| 125 integer but has to be a whole complicated structure that records | |
| 126 all of the stream's state at the time. | |
| 127 | |
| 128 Rewind semantics are generally easy to implement, so we do provide | |
| 129 a rewind method. Even rewind() may not be available on a stream, | |
| 130 however -- e.g. on process output. */ | |
| 131 | |
| 132 typedef struct lstream_implementation | |
| 133 { | |
| 442 | 134 const char *name; |
| 665 | 135 Bytecount size; /* Number of additional bytes to be |
| 814 | 136 allocated with this stream. Access this |
| 137 data using Lstream_data(). */ | |
| 1204 | 138 |
| 139 /* Description of the extra data (struct foo_lstream) attached to a | |
| 140 coding system. */ | |
| 141 const struct sized_memory_description *extra_description; | |
| 142 | |
| 428 | 143 /* Read some data from the stream's end and store it into DATA, which |
| 144 can hold SIZE bytes. Return the number of bytes read. A return | |
| 145 value of 0 means no bytes can be read at this time. This may | |
| 146 be because of an EOF, or because there is a granularity greater | |
| 147 than one byte that the stream imposes on the returned data, and | |
| 148 SIZE is less than this granularity. (This will happen frequently | |
| 149 for streams that need to return whole characters, because | |
| 150 Lstream_read() calls the reader function repeatedly until it | |
| 151 has the number of bytes it wants or until 0 is returned.) | |
| 152 The lstream functions do not treat a 0 return as EOF or do | |
| 153 anything special; however, the calling function will interpret | |
| 154 any 0 it gets back as EOF. This will normally not happen unless | |
| 155 the caller calls Lstream_read() with a very small size. | |
| 156 | |
| 157 This function can be NULL if the stream is output-only. */ | |
| 442 | 158 /* The omniscient mly, blinded by the irresistible thrall of Common |
| 428 | 159 Lisp, thinks that it is bogus that the types and implementations |
| 160 of input and output streams are the same. */ | |
| 665 | 161 Bytecount (*reader) (Lstream *stream, unsigned char *data, |
| 814 | 162 Bytecount size); |
| 428 | 163 /* Send some data to the stream's end. Data to be sent is in DATA |
| 164 and is SIZE bytes. Return the number of bytes sent. This | |
| 165 function can send and return fewer bytes than is passed in; in | |
| 166 that case, the function will just be called again until there is | |
| 167 no data left or 0 is returned. A return value of 0 means that no | |
| 168 more data can be currently stored, but there is no error; the | |
| 169 data will be squirrelled away until the writer can accept | |
| 170 data. (This is useful, e.g., of you're dealing with a | |
| 171 non-blocking file descriptor and are getting EWOULDBLOCK errors.) | |
| 172 This function can be NULL if the stream is input-only. */ | |
| 665 | 173 Bytecount (*writer) (Lstream *stream, const unsigned char *data, |
| 814 | 174 Bytecount size); |
| 428 | 175 /* Return non-zero if the last write operation on the stream resulted |
| 176 in an attempt to block (EWOULDBLOCK). If this method does not | |
| 177 exists, the implementation returns 0 */ | |
| 178 int (*was_blocked_p) (Lstream *stream); | |
| 179 /* Rewind the stream. If this is NULL, the stream is not seekable. */ | |
| 180 int (*rewinder) (Lstream *stream); | |
| 181 /* Indicate whether this stream is seekable -- i.e. it can be rewound. | |
| 182 This method is ignored if the stream does not have a rewind | |
| 183 method. If this method is not present, the result is determined | |
| 184 by whether a rewind method is present. */ | |
| 185 int (*seekable_p) (Lstream *stream); | |
| 186 /* Perform any additional operations necessary to flush the | |
| 187 data in this stream. */ | |
| 188 int (*flusher) (Lstream *stream); | |
| 771 | 189 /* Perform any additional operations necessary to close this stream down. |
| 190 May be NULL. This function is called when Lstream_close() is called | |
| 191 (which will be called automatically on any open streams when they are | |
| 192 garbage-collected or deleted with Lstream_delete()). When this | |
| 193 function is called, all pending data in the stream will already have | |
| 194 been written out; however, the closer write more data, e.g. an "end" | |
| 195 section at the end of a file. */ | |
| 428 | 196 int (*closer) (Lstream *stream); |
| 771 | 197 /* Clean up any remaining data at the time that a stream is |
| 198 garbage-collected or deleted with Lstream_delete(). If the stream was | |
| 199 open at this point, the finalizer is called after calling | |
| 200 Lstream_close(). Called only once (NOT called at disksave time). */ | |
| 201 void (*finalizer) (Lstream *stream); | |
| 428 | 202 /* Mark this object for garbage collection. Same semantics as |
| 203 a standard Lisp_Object marker. This function can be NULL. */ | |
| 204 Lisp_Object (*marker) (Lisp_Object lstream); | |
| 205 } Lstream_implementation; | |
| 206 | |
| 771 | 207 #define DEFINE_LSTREAM_IMPLEMENTATION(name, c_name) \ |
| 208 Lstream_implementation lstream_##c_name[1] = \ | |
| 1204 | 209 { { (name), sizeof (struct c_name##_stream), \ |
| 210 &lstream_empty_extra_description } } | |
| 211 | |
| 212 #define DEFINE_LSTREAM_IMPLEMENTATION_WITH_DATA(name, c_name) \ | |
| 213 static const struct sized_memory_description c_name##_lstream_description_0 \ | |
| 214 = { \ | |
| 215 sizeof (struct c_name##_stream), \ | |
| 216 c_name##_lstream_description \ | |
| 217 }; \ | |
| 218 Lstream_implementation lstream_##c_name[1] = \ | |
| 219 { { (name), sizeof (struct c_name##_stream), \ | |
| 220 &c_name##_lstream_description_0 } } | |
| 771 | 221 |
| 222 #define DECLARE_LSTREAM(c_name) \ | |
| 223 extern Lstream_implementation lstream_##c_name[] | |
| 428 | 224 |
| 225 #define LSTREAM_FL_IS_OPEN 1 | |
| 226 #define LSTREAM_FL_READ 2 | |
| 227 #define LSTREAM_FL_WRITE 4 | |
| 228 #define LSTREAM_FL_NO_PARTIAL_CHARS 8 | |
| 229 #define LSTREAM_FL_CLOSE_AT_DISKSAVE 16 | |
| 230 | |
| 231 struct lstream | |
| 232 { | |
| 2720 | 233 #ifdef MC_ALLOC |
| 234 struct lrecord_header header; | |
| 235 #else /* MC_ALLOC */ | |
| 428 | 236 struct lcrecord_header header; |
| 2720 | 237 #endif /* MC_ALLOC */ |
| 442 | 238 const Lstream_implementation *imp; /* methods for this stream */ |
| 428 | 239 Lstream_buffering buffering; /* type of buffering in use */ |
| 665 | 240 Bytecount buffering_size; /* number of bytes buffered */ |
| 428 | 241 |
| 242 unsigned char *in_buffer; /* holds characters read from stream end */ | |
| 665 | 243 Bytecount in_buffer_size; /* allocated size of buffer */ |
| 244 Bytecount in_buffer_current; /* number of characters in buffer */ | |
| 245 Bytecount in_buffer_ind; /* pointer to next character to | |
| 462 | 246 take from buffer */ |
| 428 | 247 |
| 248 unsigned char *out_buffer; /* holds characters to write to stream end */ | |
| 665 | 249 Bytecount out_buffer_size; /* allocated size of buffer */ |
| 250 Bytecount out_buffer_ind; /* pointer to next buffer spot to | |
| 462 | 251 write a character */ |
| 428 | 252 |
| 253 /* The unget buffer is more or less a stack -- things get pushed | |
| 254 onto the end and read back from the end. Lstream_read() | |
| 255 basically reads backwards from the end to get stuff; Lstream_unread() | |
| 256 similarly has to push the data on backwards. */ | |
| 257 unsigned char *unget_buffer; /* holds characters pushed back onto input */ | |
| 665 | 258 Bytecount unget_buffer_size; /* allocated size of buffer */ |
| 259 Bytecount unget_buffer_ind; /* pointer to next buffer spot | |
| 462 | 260 to write a character */ |
| 428 | 261 |
| 665 | 262 Bytecount byte_count; |
| 456 | 263 int flags; |
| 264 max_align_t data[1]; | |
| 428 | 265 }; |
| 266 | |
| 1204 | 267 extern const struct sized_memory_description lstream_empty_extra_description; |
| 268 | |
| 428 | 269 #define LSTREAM_TYPE_P(lstr, type) \ |
| 270 ((lstr)->imp == lstream_##type) | |
| 271 | |
| 800 | 272 #ifdef ERROR_CHECK_TYPES |
| 826 | 273 DECLARE_INLINE_HEADER ( |
| 274 struct lstream * | |
| 428 | 275 error_check_lstream_type (struct lstream *stream, |
| 442 | 276 const Lstream_implementation *imp) |
| 826 | 277 ) |
| 428 | 278 { |
| 279 assert (stream->imp == imp); | |
| 280 return stream; | |
| 281 } | |
| 771 | 282 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 283 ((struct type##_stream *) \ | |
| 284 Lstream_data (error_check_lstream_type (lstr, lstream_##type))) | |
| 428 | 285 #else |
| 771 | 286 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 428 | 287 ((struct type##_stream *) Lstream_data (lstr)) |
| 288 #endif | |
| 289 | |
| 771 | 290 /* Declare that lstream-type TYPE has method M; used in initialization |
| 291 routines */ | |
| 428 | 292 #define LSTREAM_HAS_METHOD(type, m) \ |
| 293 (lstream_##type->m = type##_##m) | |
| 294 | |
| 295 | |
| 442 | 296 Lstream *Lstream_new (const Lstream_implementation *imp, |
| 297 const char *mode); | |
| 428 | 298 void Lstream_reopen (Lstream *lstr); |
| 299 void Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering, | |
| 300 int buffering_size); | |
| 301 int Lstream_flush (Lstream *lstr); | |
| 302 int Lstream_flush_out (Lstream *lstr); | |
| 303 int Lstream_fputc (Lstream *lstr, int c); | |
| 304 int Lstream_fgetc (Lstream *lstr); | |
| 305 void Lstream_fungetc (Lstream *lstr, int c); | |
| 665 | 306 Bytecount Lstream_read (Lstream *lstr, void *data, |
| 307 Bytecount size); | |
| 771 | 308 int Lstream_write (Lstream *lstr, const void *data, |
| 309 Bytecount size); | |
| 428 | 310 int Lstream_was_blocked_p (Lstream *lstr); |
| 665 | 311 void Lstream_unread (Lstream *lstr, const void *data, Bytecount size); |
| 428 | 312 int Lstream_rewind (Lstream *lstr); |
| 313 int Lstream_seekable_p (Lstream *lstr); | |
| 314 int Lstream_close (Lstream *lstr); | |
| 771 | 315 |
| 428 | 316 void Lstream_delete (Lstream *lstr); |
| 317 void Lstream_set_character_mode (Lstream *str); | |
| 771 | 318 void Lstream_unset_character_mode (Lstream *lstr); |
| 428 | 319 |
| 771 | 320 /* Lstream_putc: Write out one byte to the stream. This is a macro |
| 321 and so it is very efficient. The C argument is only evaluated once | |
| 322 but the STREAM argument is evaluated more than once. Returns 0 on | |
| 323 success, -1 on error. */ | |
| 428 | 324 |
| 771 | 325 #define Lstream_putc(stream, c) \ |
| 326 /* Call the function equivalent if the out buffer is full. Otherwise, \ | |
| 327 add to the end of the out buffer and, if line buffering is called for \ | |
| 328 and the character marks the end of a line, write out the buffer. */ \ | |
| 329 ((stream)->out_buffer_ind >= (stream)->out_buffer_size ? \ | |
| 330 Lstream_fputc (stream, c) : \ | |
| 331 ((stream)->out_buffer[(stream)->out_buffer_ind++] = \ | |
| 332 (unsigned char) (c), \ | |
| 333 (stream)->byte_count++, \ | |
| 334 (stream)->buffering == LSTREAM_LINE_BUFFERED && \ | |
| 335 (stream)->out_buffer[(stream)->out_buffer_ind - 1] == '\n' ? \ | |
| 428 | 336 Lstream_flush_out (stream) : 0)) |
| 337 | |
| 771 | 338 /* Lstream_getc: Read one byte from the stream and returns it as an |
| 339 unsigned char cast to an int, or EOF on end of file or error. This | |
| 340 is a macro and so it is very efficient. The STREAM argument is | |
| 341 evaluated more than once. */ | |
| 342 | |
| 343 #define Lstream_getc(stream) \ | |
| 344 /* Retrieve from unget buffer if there are any characters there; \ | |
| 345 else retrieve from in buffer if there's anything there; \ | |
| 346 else call the function equivalent */ \ | |
| 428 | 347 ((stream)->unget_buffer_ind > 0 ? \ |
| 348 ((stream)->byte_count++, \ | |
| 349 (stream)->unget_buffer[--(stream)->unget_buffer_ind]) : \ | |
| 350 (stream)->in_buffer_ind < (stream)->in_buffer_current ? \ | |
| 351 ((stream)->byte_count++, \ | |
| 352 (stream)->in_buffer[(stream)->in_buffer_ind++]) : \ | |
| 353 Lstream_fgetc (stream)) | |
| 354 | |
| 771 | 355 /* Lstream_ungetc: Push one byte back onto the input queue, cast to |
| 356 unsigned char. This will be the next byte read from the stream. | |
| 357 Any number of bytes can be pushed back and will be read in the | |
| 358 reverse order they were pushed back -- most recent first. (This is | |
| 359 necessary for consistency -- if there are a number of bytes that | |
| 360 have been unread and I read and unread a byte, it needs to be the | |
| 361 first to be read again.) This is a macro and so it is very | |
| 362 efficient. The C argument is only evaluated once but the STREAM | |
| 363 argument is evaluated more than once. | |
| 364 */ | |
| 365 | |
| 428 | 366 #define Lstream_ungetc(stream, c) \ |
| 771 | 367 /* Add to the end if it won't overflow buffer; otherwise call the \ |
| 368 function equivalent */ \ | |
| 428 | 369 ((stream)->unget_buffer_ind >= (stream)->unget_buffer_size ? \ |
| 370 Lstream_fungetc (stream, c) : \ | |
| 371 (void) ((stream)->byte_count--, \ | |
| 372 ((stream)->unget_buffer[(stream)->unget_buffer_ind++] = \ | |
| 373 (unsigned char) (c)))) | |
| 374 | |
| 375 #define Lstream_data(stream) ((void *) ((stream)->data)) | |
| 376 #define Lstream_byte_count(stream) ((stream)->byte_count) | |
| 377 | |
| 378 | |
| 379 /************************************************************************/ | |
| 867 | 380 /* working with an Lstream as a stream of Ichars */ |
| 428 | 381 /************************************************************************/ |
| 382 | |
| 383 #ifdef MULE | |
| 384 | |
| 826 | 385 DECLARE_INLINE_HEADER ( |
| 867 | 386 Ichar |
| 387 Lstream_get_ichar (Lstream *stream) | |
| 826 | 388 ) |
| 428 | 389 { |
| 390 int c = Lstream_getc (stream); | |
| 826 | 391 return (c < 0x80 /* c == EOF || byte_ascii_p (c) */ |
| 867 | 392 ? (Ichar) c |
| 393 : Lstream_get_ichar_1 (stream, c)); | |
| 428 | 394 } |
| 395 | |
| 867 | 396 /* Write an Ichar to a stream. Return value is 0 for success, -1 for |
| 771 | 397 failure. */ |
| 398 | |
| 826 | 399 DECLARE_INLINE_HEADER ( |
| 400 int | |
| 867 | 401 Lstream_put_ichar (Lstream *stream, Ichar ch) |
| 826 | 402 ) |
| 428 | 403 { |
| 867 | 404 return ichar_ascii_p (ch) ? |
| 428 | 405 Lstream_putc (stream, ch) : |
| 867 | 406 Lstream_fput_ichar (stream, ch); |
| 428 | 407 } |
| 408 | |
| 826 | 409 DECLARE_INLINE_HEADER ( |
| 410 void | |
| 867 | 411 Lstream_unget_ichar (Lstream *stream, Ichar ch) |
| 826 | 412 ) |
| 428 | 413 { |
| 867 | 414 if (ichar_ascii_p (ch)) |
| 428 | 415 Lstream_ungetc (stream, ch); |
| 416 else | |
| 867 | 417 Lstream_funget_ichar (stream, ch); |
| 428 | 418 } |
| 419 #else /* not MULE */ | |
| 420 | |
| 867 | 421 # define Lstream_get_ichar(stream) Lstream_getc (stream) |
| 422 # define Lstream_put_ichar(stream, ch) Lstream_putc (stream, ch) | |
| 423 # define Lstream_unget_ichar(stream, ch) Lstream_ungetc (stream, ch) | |
| 428 | 424 |
| 425 #endif /* not MULE */ | |
| 426 | |
| 427 | |
| 428 /************************************************************************/ | |
| 429 /* Lstream implementations */ | |
| 430 /************************************************************************/ | |
| 431 | |
| 432 /* Flags we can pass to the filedesc and stdio streams. */ | |
| 433 | |
| 434 /* If set, close the descriptor or FILE * when the stream is closed. */ | |
| 435 #define LSTR_CLOSING 1 | |
| 436 | |
| 437 /* If set, allow quitting out of the actual I/O. */ | |
| 438 #define LSTR_ALLOW_QUIT 2 | |
| 439 | |
| 440 /* If set and filedesc_stream_set_pty_flushing() has been called | |
| 441 on the stream, do not send more than pty_max_bytes on a single | |
| 442 line without flushing the data out using the eof_char. */ | |
| 443 #define LSTR_PTY_FLUSHING 4 | |
| 444 | |
| 445 /* If set, an EWOULDBLOCK error is not treated as an error but | |
| 446 simply causes the write function to return 0 as the number | |
| 447 of bytes written out. */ | |
| 448 #define LSTR_BLOCKED_OK 8 | |
| 449 | |
| 450 Lisp_Object make_stdio_input_stream (FILE *stream, int flags); | |
| 451 Lisp_Object make_stdio_output_stream (FILE *stream, int flags); | |
| 452 Lisp_Object make_filedesc_input_stream (int filedesc, int offset, int count, | |
| 453 int flags); | |
| 454 Lisp_Object make_filedesc_output_stream (int filedesc, int offset, int count, | |
| 455 int flags); | |
| 456 void filedesc_stream_set_pty_flushing (Lstream *stream, | |
| 457 int pty_max_bytes, | |
| 867 | 458 Ibyte eof_char); |
| 428 | 459 int filedesc_stream_fd (Lstream *stream); |
| 460 Lisp_Object make_lisp_string_input_stream (Lisp_Object string, | |
| 461 Bytecount offset, | |
| 462 Bytecount len); | |
| 462 | 463 Lisp_Object make_fixed_buffer_input_stream (const void *buf, |
| 665 | 464 Bytecount size); |
| 462 | 465 Lisp_Object make_fixed_buffer_output_stream (void *buf, |
| 665 | 466 Bytecount size); |
| 442 | 467 const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream); |
| 428 | 468 unsigned char *fixed_buffer_output_stream_ptr (Lstream *stream); |
| 469 Lisp_Object make_resizing_buffer_output_stream (void); | |
| 470 unsigned char *resizing_buffer_stream_ptr (Lstream *stream); | |
| 788 | 471 Lisp_Object resizing_buffer_to_lisp_string (Lstream *stream); |
| 428 | 472 Lisp_Object make_dynarr_output_stream (unsigned_char_dynarr *dyn); |
| 473 #define LSTR_SELECTIVE 1 | |
| 474 #define LSTR_IGNORE_ACCESSIBLE 2 | |
| 665 | 475 Lisp_Object make_lisp_buffer_input_stream (struct buffer *buf, Charbpos start, |
| 476 Charbpos end, int flags); | |
| 477 Lisp_Object make_lisp_buffer_output_stream (struct buffer *buf, Charbpos pos, | |
| 428 | 478 int flags); |
| 665 | 479 Charbpos lisp_buffer_stream_startpos (Lstream *stream); |
| 428 | 480 |
| 440 | 481 #endif /* INCLUDED_lstream_h_ */ |