Mercurial > hg > xemacs-beta
annotate src/console-tty.c @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | b5df3737028a |
| children | 71ee43b8a74d |
| rev | line source |
|---|---|
| 428 | 1 /* TTY console functions. |
| 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
| 3 Copyright (C) 1994, 1995 Free Software Foundation, Inc. | |
| 800 | 4 Copyright (C) 1996, 2001, 2002 Ben Wing. |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
| 8 XEmacs is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 10 Free Software Foundation; either version 2, or (at your option) any | |
| 11 later version. | |
| 12 | |
| 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with XEmacs; see the file COPYING. If not, write to | |
| 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 21 Boston, MA 02111-1307, USA. */ | |
| 22 | |
| 23 /* Synched up with: Not in FSF. */ | |
| 24 | |
| 25 /* Authors: Ben Wing and Chuck Thompson. */ | |
| 26 | |
| 27 #include <config.h> | |
| 28 #include "lisp.h" | |
| 29 | |
| 872 | 30 #include "console-tty-impl.h" |
| 428 | 31 #include "console-stream.h" |
| 872 | 32 |
| 2828 | 33 #include "elhash.h" |
| 428 | 34 #include "faces.h" |
| 872 | 35 #include "file-coding.h" |
| 428 | 36 #include "frame.h" |
| 872 | 37 #include "glyphs.h" |
| 428 | 38 #include "lstream.h" |
| 872 | 39 #include "process.h" |
| 40 | |
| 428 | 41 #include "sysdep.h" |
| 42 #include "sysfile.h" | |
| 43 | |
| 44 DEFINE_CONSOLE_TYPE (tty); | |
| 45 DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing); | |
| 46 DECLARE_IMAGE_INSTANTIATOR_FORMAT (string); | |
| 47 DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string); | |
| 48 DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit); | |
| 49 | |
| 50 Lisp_Object Qterminal_type; | |
| 51 Lisp_Object Qcontrolling_process; | |
| 52 | |
| 2850 | 53 Lisp_Object Vtty_seen_characters; |
| 2828 | 54 |
| 1204 | 55 static const struct memory_description tty_console_data_description_1 [] = { |
| 56 { XD_LISP_OBJECT, offsetof (struct tty_console, terminal_type) }, | |
| 57 { XD_LISP_OBJECT, offsetof (struct tty_console, instream) }, | |
| 58 { XD_LISP_OBJECT, offsetof (struct tty_console, outstream) }, | |
| 59 { XD_END } | |
| 60 }; | |
| 61 | |
| 3092 | 62 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
63 DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT ("tty-console", tty_console, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
64 0, tty_console_data_description_1, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
65 Lisp_Tty_Console); |
| 3092 | 66 #else /* not NEW_GC */ |
| 1204 | 67 const struct sized_memory_description tty_console_data_description = { |
| 68 sizeof (struct tty_console), tty_console_data_description_1 | |
| 69 }; | |
| 3092 | 70 #endif /* not NEW_GC */ |
| 1204 | 71 |
| 428 | 72 |
| 73 static void | |
| 74 allocate_tty_console_struct (struct console *con) | |
| 75 { | |
| 76 /* zero out all slots except the lisp ones ... */ | |
| 3092 | 77 #ifdef NEW_GC |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5125
diff
changeset
|
78 CONSOLE_TTY_DATA (con) = XTTY_CONSOLE (ALLOC_NORMAL_LISP_OBJECT (tty_console)); |
| 3092 | 79 #else /* not NEW_GC */ |
| 428 | 80 CONSOLE_TTY_DATA (con) = xnew_and_zero (struct tty_console); |
| 3092 | 81 #endif /* not NEW_GC */ |
| 428 | 82 CONSOLE_TTY_DATA (con)->terminal_type = Qnil; |
| 83 CONSOLE_TTY_DATA (con)->instream = Qnil; | |
| 84 CONSOLE_TTY_DATA (con)->outstream = Qnil; | |
| 85 } | |
| 86 | |
| 87 static void | |
| 88 tty_init_console (struct console *con, Lisp_Object props) | |
| 89 { | |
| 90 Lisp_Object tty = CONSOLE_CONNECTION (con); | |
| 91 Lisp_Object terminal_type = Qnil; | |
| 92 Lisp_Object controlling_process = Qnil; | |
| 93 struct tty_console *tty_con; | |
| 94 struct gcpro gcpro1, gcpro2; | |
| 95 | |
| 96 GCPRO2 (terminal_type, controlling_process); | |
| 97 | |
| 98 terminal_type = Fplist_get (props, Qterminal_type, Qnil); | |
| 99 controlling_process = Fplist_get (props, Qcontrolling_process, Qnil); | |
| 100 | |
| 101 /* Determine the terminal type */ | |
| 102 | |
| 103 if (!NILP (terminal_type)) | |
| 104 CHECK_STRING (terminal_type); | |
| 105 else | |
| 106 { | |
| 867 | 107 Ibyte *temp_type = egetenv ("TERM"); |
| 428 | 108 |
| 109 if (!temp_type) | |
| 110 { | |
| 563 | 111 invalid_state ("Cannot determine terminal type", Qunbound); |
| 428 | 112 } |
| 113 else | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
114 terminal_type = build_istring (temp_type); |
| 428 | 115 } |
| 116 | |
| 117 /* Determine the controlling process */ | |
| 118 if (!NILP (controlling_process)) | |
| 119 CHECK_INT (controlling_process); | |
| 120 | |
| 121 /* Open the specified console */ | |
| 122 | |
| 123 allocate_tty_console_struct (con); | |
| 124 tty_con = CONSOLE_TTY_DATA (con); | |
| 125 | |
| 126 if (internal_equal (tty, Vstdio_str, 0)) | |
| 127 { | |
| 128 tty_con->infd = fileno (stdin); | |
| 129 tty_con->outfd = fileno (stdout); | |
| 130 tty_con->is_stdio = 1; | |
| 131 } | |
| 132 else | |
| 133 { | |
| 134 tty_con->infd = tty_con->outfd = | |
| 771 | 135 qxe_open (XSTRING_DATA (tty), O_RDWR); |
| 428 | 136 if (tty_con->infd < 0) |
| 563 | 137 signal_error (Qio_error, "Unable to open tty", tty); |
| 428 | 138 tty_con->is_stdio = 0; |
| 139 } | |
| 140 | |
| 802 | 141 /* set_descriptor_non_blocking (tty_con->infd); */ |
| 428 | 142 tty_con->instream = make_filedesc_input_stream (tty_con->infd, 0, -1, 0); |
| 771 | 143 Lstream_set_buffering (XLSTREAM (tty_con->instream), LSTREAM_UNBUFFERED, 0); |
| 428 | 144 tty_con->instream = |
| 771 | 145 make_coding_input_stream (XLSTREAM (tty_con->instream), |
| 146 get_coding_system_for_text_file (Qkeyboard, 0), | |
| 814 | 147 CODING_DECODE, |
| 148 LSTREAM_FL_READ_ONE_BYTE_AT_A_TIME); | |
| 771 | 149 Lstream_set_buffering (XLSTREAM (tty_con->instream), LSTREAM_UNBUFFERED, 0); |
| 150 tty_con->outstream = make_filedesc_output_stream (tty_con->outfd, 0, -1, 0); | |
| 428 | 151 tty_con->outstream = |
| 771 | 152 make_coding_output_stream (XLSTREAM (tty_con->outstream), |
| 153 get_coding_system_for_text_file (Qterminal, 0), | |
| 800 | 154 CODING_ENCODE, 0); |
| 428 | 155 tty_con->terminal_type = terminal_type; |
| 156 tty_con->controlling_process = controlling_process; | |
| 157 | |
| 3571 | 158 /* Defaults to 1 with Mule, 0 without. In the latter case the attribute is |
| 159 read-only from Lisp. */ | |
| 160 tty_con->multiple_width = CONSOLE_TTY_SUPPORTS_MULTIPLE_WIDTH(c); | |
| 161 | |
| 428 | 162 if (NILP (CONSOLE_NAME (con))) |
| 163 CONSOLE_NAME (con) = Ffile_name_nondirectory (tty); | |
| 164 { | |
| 442 | 165 pid_t tty_pg; |
| 166 pid_t controlling_tty_pg; | |
| 428 | 167 int cfd; |
| 168 | |
| 169 /* OK, the only sure-fire way I can think of to determine | |
| 170 whether a particular TTY is our controlling TTY is to check | |
| 171 if it has the same foreground process group as our controlling | |
| 172 TTY. This is OK because a process group can never simultaneously | |
| 173 be the foreground process group of two TTY's (in that case it | |
| 174 would have two controlling TTY's, which is not allowed). */ | |
| 175 | |
| 176 EMACS_GET_TTY_PROCESS_GROUP (tty_con->infd, &tty_pg); | |
| 867 | 177 cfd = qxe_open ((Ibyte *) "/dev/tty", O_RDWR, 0); |
| 428 | 178 EMACS_GET_TTY_PROCESS_GROUP (cfd, &controlling_tty_pg); |
| 771 | 179 retry_close (cfd); |
| 428 | 180 if (tty_pg == controlling_tty_pg) |
| 181 { | |
| 182 tty_con->controlling_terminal = 1; | |
| 793 | 183 Vcontrolling_terminal = wrap_console (con); |
| 428 | 184 munge_tty_process_group (); |
| 185 } | |
| 186 else | |
| 187 tty_con->controlling_terminal = 0; | |
| 188 } | |
| 189 | |
| 190 UNGCPRO; | |
| 191 } | |
| 192 | |
| 193 static void | |
| 194 tty_mark_console (struct console *con) | |
| 195 { | |
| 196 struct tty_console *tty_con = CONSOLE_TTY_DATA (con); | |
| 197 mark_object (tty_con->terminal_type); | |
| 198 mark_object (tty_con->instream); | |
| 199 mark_object (tty_con->outstream); | |
| 200 } | |
| 201 | |
| 202 static int | |
| 2286 | 203 tty_initially_selected_for_input (struct console *UNUSED (con)) |
| 428 | 204 { |
| 205 return 1; | |
| 206 } | |
| 207 | |
| 208 static void | |
| 209 free_tty_console_struct (struct console *con) | |
| 210 { | |
| 211 struct tty_console *tty_con = CONSOLE_TTY_DATA (con); | |
| 212 if (tty_con) | |
| 213 { | |
| 214 if (tty_con->term_entry_buffer) /* allocated in term_init () */ | |
| 215 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
216 xfree (tty_con->term_entry_buffer); |
| 428 | 217 tty_con->term_entry_buffer = NULL; |
| 218 } | |
| 4117 | 219 #ifndef NEW_GC |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
220 xfree (tty_con); |
| 3092 | 221 #endif /* not NEW_GC */ |
| 428 | 222 CONSOLE_TTY_DATA (con) = NULL; |
| 223 } | |
| 224 } | |
| 225 | |
| 226 static void | |
| 227 tty_delete_console (struct console *con) | |
| 228 { | |
| 229 Lstream_close (XLSTREAM (CONSOLE_TTY_DATA (con)->instream)); | |
| 230 Lstream_close (XLSTREAM (CONSOLE_TTY_DATA (con)->outstream)); | |
| 231 if (!CONSOLE_TTY_DATA (con)->is_stdio) | |
| 771 | 232 retry_close (CONSOLE_TTY_DATA (con)->infd); |
| 428 | 233 if (CONSOLE_TTY_DATA (con)->controlling_terminal) |
| 234 { | |
| 235 Vcontrolling_terminal = Qnil; | |
| 236 unmunge_tty_process_group (); | |
| 237 } | |
| 238 free_tty_console_struct (con); | |
| 239 } | |
| 240 | |
| 241 | |
| 242 static struct console * | |
| 243 decode_tty_console (Lisp_Object console) | |
| 244 { | |
| 793 | 245 console = wrap_console (decode_console (console)); |
| 428 | 246 CHECK_TTY_CONSOLE (console); |
| 247 return XCONSOLE (console); | |
| 248 } | |
| 249 | |
| 250 DEFUN ("console-tty-terminal-type", Fconsole_tty_terminal_type, | |
| 251 0, 1, 0, /* | |
| 252 Return the terminal type of TTY console CONSOLE. | |
| 253 */ | |
| 254 (console)) | |
| 255 { | |
| 256 return CONSOLE_TTY_DATA (decode_tty_console (console))->terminal_type; | |
| 257 } | |
| 258 | |
| 259 DEFUN ("console-tty-controlling-process", Fconsole_tty_controlling_process, | |
| 260 0, 1, 0, /* | |
| 261 Return the controlling process of tty console CONSOLE. | |
| 262 */ | |
| 263 (console)) | |
| 264 { | |
| 265 return CONSOLE_TTY_DATA (decode_tty_console (console))->controlling_process; | |
| 266 } | |
| 267 | |
| 268 | |
| 269 DEFUN ("console-tty-input-coding-system", Fconsole_tty_input_coding_system, | |
| 270 0, 1, 0, /* | |
| 271 Return the input coding system of tty console CONSOLE. | |
| 272 */ | |
| 273 (console)) | |
| 274 { | |
| 771 | 275 return coding_stream_detected_coding_system |
| 428 | 276 (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->instream)); |
| 277 } | |
| 278 | |
| 279 DEFUN ("set-console-tty-input-coding-system", Fset_console_tty_input_coding_system, | |
| 280 0, 2, 0, /* | |
| 281 Set the input coding system of tty console CONSOLE to CODESYS. | |
| 282 CONSOLE defaults to the selected console. | |
| 283 CODESYS defaults to the value of `keyboard-coding-system'. | |
| 284 */ | |
| 285 (console, codesys)) | |
| 286 { | |
| 771 | 287 set_coding_stream_coding_system |
| 428 | 288 (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->instream), |
| 771 | 289 get_coding_system_for_text_file (NILP (codesys) ? Qkeyboard : codesys, |
| 290 0)); | |
| 428 | 291 return Qnil; |
| 292 } | |
| 293 | |
| 294 DEFUN ("console-tty-output-coding-system", Fconsole_tty_output_coding_system, | |
| 295 0, 1, 0, /* | |
| 296 Return TTY CONSOLE's output coding system. | |
| 297 */ | |
| 298 (console)) | |
| 299 { | |
| 771 | 300 return coding_stream_coding_system |
| 428 | 301 (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->outstream)); |
| 302 } | |
| 303 | |
| 304 DEFUN ("set-console-tty-output-coding-system", Fset_console_tty_output_coding_system, | |
| 305 0, 2, 0, /* | |
| 306 Set the coding system of tty output of console CONSOLE to CODESYS. | |
| 307 CONSOLE defaults to the selected console. | |
| 308 CODESYS defaults to the value of `terminal-coding-system'. | |
| 309 */ | |
| 310 (console, codesys)) | |
| 311 { | |
| 771 | 312 set_coding_stream_coding_system |
| 428 | 313 (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->outstream), |
| 771 | 314 get_coding_system_for_text_file (NILP (codesys) ? Qterminal : codesys, |
| 315 0)); | |
| 438 | 316 /* Redraw tty */ |
| 317 face_property_was_changed (Vdefault_face, Qfont, Qtty); | |
| 428 | 318 return Qnil; |
| 319 } | |
| 320 | |
| 3571 | 321 DEFUN ("console-tty-multiple-width", Fconsole_tty_multiple_width, |
| 322 0, 1, 0, /* | |
| 323 Return whether CONSOLE treats East Asian double-width chars as such. | |
| 324 | |
| 325 CONSOLE defaults to the selected console. Without XEmacs support for | |
| 326 double-width characters, this always gives nil. | |
| 327 */ | |
| 328 (console)) | |
| 329 { | |
| 330 return CONSOLE_TTY_MULTIPLE_WIDTH (decode_tty_console(console)) | |
| 331 ? Qt : Qnil; | |
| 332 } | |
| 333 | |
| 334 DEFUN ("set-console-tty-multiple-width", Fset_console_tty_multiple_width, | |
| 335 0, 2, 0, /* | |
| 336 Set whether CONSOLE treats East Asian double-width characters as such. | |
| 337 | |
| 338 CONSOLE defaults to the selected console, and VALUE defaults to nil. | |
| 339 Without XEmacs support for double-width characters, this throws an error if | |
| 340 VALUE is non-nil. | |
| 341 */ | |
| 342 (console, value)) | |
| 343 { | |
| 344 struct console *c = decode_tty_console (console); | |
| 345 | |
| 346 /* So people outside of East Asia can put (set-console-tty-multiple-width | |
| 347 (selected-console) nil) in their init files, independent of whether | |
| 348 Mule is enabled. */ | |
| 349 if (!CONSOLE_TTY_MULTIPLE_WIDTH (c) && NILP(value)) | |
| 350 { | |
| 351 return Qnil; | |
| 352 } | |
| 353 | |
| 354 if (!CONSOLE_TTY_SUPPORTS_MULTIPLE_WIDTH (c)) | |
| 355 { | |
| 356 invalid_change | |
| 357 ("No console support for double-width chars", | |
| 358 Fmake_symbol(CONSOLE_NAME(c))); | |
| 359 } | |
| 360 | |
| 361 CONSOLE_TTY_DATA(c)->multiple_width = NILP(value) ? 0 : 1; | |
| 362 | |
| 363 return Qnil; | |
| 364 } | |
| 365 | |
| 440 | 366 /* #### Move this function to lisp */ |
| 428 | 367 DEFUN ("set-console-tty-coding-system", Fset_console_tty_coding_system, |
| 368 0, 2, 0, /* | |
| 369 Set the input and output coding systems of tty console CONSOLE to CODESYS. | |
| 370 CONSOLE defaults to the selected console. | |
| 371 If CODESYS is nil, the values of `keyboard-coding-system' and | |
| 372 `terminal-coding-system' will be used for the input and | |
| 373 output coding systems of CONSOLE. | |
| 374 */ | |
| 375 (console, codesys)) | |
| 376 { | |
| 377 Fset_console_tty_input_coding_system (console, codesys); | |
| 378 Fset_console_tty_output_coding_system (console, codesys); | |
| 379 return Qnil; | |
| 380 } | |
| 381 | |
| 382 | |
| 383 Lisp_Object | |
| 384 tty_semi_canonicalize_console_connection (Lisp_Object connection, | |
| 578 | 385 Error_Behavior errb) |
| 428 | 386 { |
| 387 return stream_semi_canonicalize_console_connection (connection, errb); | |
| 388 } | |
| 389 | |
| 390 Lisp_Object | |
| 391 tty_canonicalize_console_connection (Lisp_Object connection, | |
| 578 | 392 Error_Behavior errb) |
| 428 | 393 { |
| 394 return stream_canonicalize_console_connection (connection, errb); | |
| 395 } | |
| 396 | |
| 397 Lisp_Object | |
| 398 tty_semi_canonicalize_device_connection (Lisp_Object connection, | |
| 578 | 399 Error_Behavior errb) |
| 428 | 400 { |
| 401 return stream_semi_canonicalize_console_connection (connection, errb); | |
| 402 } | |
| 403 | |
| 404 Lisp_Object | |
| 405 tty_canonicalize_device_connection (Lisp_Object connection, | |
| 578 | 406 Error_Behavior errb) |
| 428 | 407 { |
| 408 return stream_canonicalize_console_connection (connection, errb); | |
| 409 } | |
| 410 | |
| 2828 | 411 static Lisp_Object |
| 412 tty_perhaps_init_unseen_key_defaults (struct console *UNUSED(con), | |
| 413 Lisp_Object key) | |
| 414 { | |
| 415 Ichar val; | |
| 416 extern Lisp_Object Vcurrent_global_map; | |
| 417 | |
| 418 if (SYMBOLP(key)) | |
| 419 { | |
| 420 /* We've no idea what to default an unknown symbol to on the TTY. */ | |
| 421 return Qnil; | |
| 422 } | |
| 423 | |
| 424 CHECK_CHAR(key); | |
| 425 | |
| 2850 | 426 if (!(HASH_TABLEP(Vtty_seen_characters))) |
| 2828 | 427 { |
| 428 /* All the keysyms we deal with are character objects; therefore, we | |
| 429 can use eq as the test without worrying. */ | |
| 2850 | 430 Vtty_seen_characters = make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, |
| 2828 | 431 HASH_TABLE_EQ); |
| 432 } | |
| 433 | |
| 434 /* Might give the user an opaque error if make_lisp_hash_table fails, | |
| 435 but it won't crash. */ | |
| 2850 | 436 CHECK_HASH_TABLE(Vtty_seen_characters); |
| 2828 | 437 |
| 438 val = XCHAR(key); | |
| 439 | |
| 440 /* Same logic as in x_has_keysym; I'm not convinced it's always sane. */ | |
| 441 if (val < 0x80) | |
| 442 { | |
| 443 return Qnil; | |
| 444 } | |
| 445 | |
| 2850 | 446 if (!NILP(Fgethash(key, Vtty_seen_characters, Qnil))) |
| 2828 | 447 { |
| 448 return Qnil; | |
| 449 } | |
| 450 | |
| 451 if (NILP (Flookup_key (Vcurrent_global_map, key, Qnil))) | |
| 452 { | |
| 2850 | 453 Fputhash(key, Qt, Vtty_seen_characters); |
| 2828 | 454 Fdefine_key (Vcurrent_global_map, key, Qself_insert_command); |
| 455 return Qt; | |
| 456 } | |
| 457 | |
| 458 return Qnil; | |
| 459 } | |
| 460 | |
| 428 | 461 |
| 462 /************************************************************************/ | |
| 463 /* initialization */ | |
| 464 /************************************************************************/ | |
| 465 | |
| 466 void | |
| 467 syms_of_console_tty (void) | |
| 468 { | |
| 469 DEFSUBR (Fconsole_tty_terminal_type); | |
| 470 DEFSUBR (Fconsole_tty_controlling_process); | |
| 563 | 471 DEFSYMBOL (Qterminal_type); |
| 472 DEFSYMBOL (Qcontrolling_process); | |
| 428 | 473 DEFSUBR (Fconsole_tty_output_coding_system); |
| 474 DEFSUBR (Fset_console_tty_output_coding_system); | |
| 475 DEFSUBR (Fconsole_tty_input_coding_system); | |
| 476 DEFSUBR (Fset_console_tty_input_coding_system); | |
| 477 DEFSUBR (Fset_console_tty_coding_system); | |
| 3571 | 478 DEFSUBR (Fconsole_tty_multiple_width); |
| 479 DEFSUBR (Fset_console_tty_multiple_width); | |
| 428 | 480 } |
| 481 | |
| 482 void | |
| 483 console_type_create_tty (void) | |
| 484 { | |
| 485 INITIALIZE_CONSOLE_TYPE (tty, "tty", "console-tty-p"); | |
| 486 | |
| 487 /* console methods */ | |
| 488 CONSOLE_HAS_METHOD (tty, init_console); | |
| 489 CONSOLE_HAS_METHOD (tty, mark_console); | |
| 490 CONSOLE_HAS_METHOD (tty, initially_selected_for_input); | |
| 491 CONSOLE_HAS_METHOD (tty, delete_console); | |
| 492 CONSOLE_HAS_METHOD (tty, canonicalize_console_connection); | |
| 493 CONSOLE_HAS_METHOD (tty, canonicalize_device_connection); | |
| 494 CONSOLE_HAS_METHOD (tty, semi_canonicalize_console_connection); | |
| 495 CONSOLE_HAS_METHOD (tty, semi_canonicalize_device_connection); | |
| 2828 | 496 CONSOLE_HAS_METHOD (tty, perhaps_init_unseen_key_defaults); |
| 428 | 497 } |
| 498 | |
| 499 void | |
| 500 reinit_console_type_create_tty (void) | |
| 501 { | |
| 502 REINITIALIZE_CONSOLE_TYPE (tty); | |
| 503 } | |
| 504 | |
| 505 void | |
| 506 image_instantiator_format_create_glyphs_tty (void) | |
| 507 { | |
| 508 IIFORMAT_VALID_CONSOLE (tty, nothing); | |
| 509 IIFORMAT_VALID_CONSOLE (tty, string); | |
| 510 IIFORMAT_VALID_CONSOLE (tty, formatted_string); | |
| 511 IIFORMAT_VALID_CONSOLE (tty, inherit); | |
| 512 } | |
| 513 | |
| 514 void | |
| 515 vars_of_console_tty (void) | |
| 516 { | |
| 2850 | 517 DEFVAR_LISP ("tty-seen-characters", &Vtty_seen_characters /* |
| 518 Hash table of non-ASCII characters the TTY subsystem has seen. | |
| 519 */ ); | |
| 520 Vtty_seen_characters = Qnil; | |
| 428 | 521 Fprovide (Qtty); |
| 522 } |