Mercurial > hg > xemacs-beta
annotate src/console-tty.c @ 5124:623d57b7fbe8 ben-lisp-object
separate regular and disksave finalization, print method fixes.
Create separate disksave method and make the finalize method only be for
actual object finalization, not disksave finalization.
Fix places where 0 was given in place of a printer -- print methods are
mandatory, and internal objects formerly without a print method now must
explicitly specify internal_object_printer().
Change the defn of CONSOLE_LIVE_P to avoid problems in some weird situations.
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-01-20 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (very_old_free_lcrecord):
* alloc.c (disksave_object_finalization_1):
* alloc.c (make_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* buffer.c:
* bytecode.c:
* bytecode.c (Fcompiled_function_p):
* chartab.c:
* console-impl.h:
* console-impl.h (CONSOLE_TYPE_P):
* console.c:
* console.c (set_quit_events):
* data.c:
* data.c (Fmake_ephemeron):
* database.c:
* database.c (finalize_database):
* database.c (Fclose_database):
* device-msw.c:
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device.c:
* elhash.c:
* elhash.c (finalize_hash_table):
* eval.c:
* eval.c (bind_multiple_value_limits):
* event-stream.c:
* event-stream.c (finalize_command_builder):
* events.c:
* events.c (mark_event):
* extents.c:
* extents.c (finalize_extent_info):
* extents.c (uninit_buffer_extents):
* faces.c:
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.h:
* file-coding.h (struct coding_system_methods):
* file-coding.h (struct detector):
* floatfns.c:
* floatfns.c (extract_float):
* fns.c:
* fns.c (Fidentity):
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (finalize_fc_config):
* frame.c:
* glyphs.c:
* glyphs.c (finalize_image_instance):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* gui.c:
* gui.c (gui_error):
* keymap.c:
* lisp.h (struct Lisp_Symbol):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE):
* lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (MAKE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (MAKE_MODULE_LISP_OBJECT):
* lstream.c:
* lstream.c (finalize_lstream):
* lstream.c (disksave_lstream):
* marker.c:
* marker.c (finalize_marker):
* mule-charset.c (make_charset):
* number.c:
* objects.c:
* objects.c (finalize_color_instance):
* objects.c (finalize_font_instance):
* opaque.c:
* opaque.c (make_opaque_ptr):
* process-nt.c:
* process-nt.c (nt_finalize_process_data):
* process-nt.c (nt_deactivate_process):
* process.c:
* process.c (finalize_process):
* procimpl.h (struct process_methods):
* scrollbar.c:
* scrollbar.c (free_scrollbar_instance):
* specifier.c (finalize_specifier):
* symbols.c:
* toolbar.c:
* toolbar.c (Ftoolbar_button_p):
* tooltalk.c:
* ui-gtk.c:
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* window.c:
* window.c (finalize_window):
* window.c (mark_window_as_deleted):
Separate out regular and disksave finalization. Instead of a
FOR_DISKSAVE argument to the finalizer, create a separate object
method `disksaver'. Make `finalizer' have only one argument.
Go through and separate out all finalize methods into finalize
and disksave. Delete lots of thereby redundant disksave checking.
Delete places that signal an error if we attempt to disksave --
all of these objects are non-dumpable and we will get an error
from pdump anyway if we attempt to dump them. After this is done,
only one object remains that has a disksave method -- lstream.
Change DEFINE_*_LISP_OBJECT_WITH_PROPS to DEFINE_*_GENERAL_LISP_OBJECT,
which is used for specifying either property methods or disksave
methods (or in the future, any other less-used methods).
Remove the for_disksave argument to finalize_process_data. Don't
provide a disksaver for processes because no one currently needs
it.
Clean up various places where objects didn't provide a print method.
It was made mandatory in previous changes, and all methods now
either provide their own print method or use internal_object_printer
or external_object_printer.
Change the definition of CONSOLE_LIVE_P to use the contype enum
rather than looking into the conmeths structure -- in some weird
situations with dead objects, the conmeths structure is NULL,
and printing such objects from debug_print() will crash if we try
to look into the conmeths structure.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 20 Jan 2010 07:05:57 -0600 |
| parents | d1247f3cc363 |
| children | b5df3737028a |
| 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 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
78 CONSOLE_TTY_DATA (con) = XTTY_CONSOLE (ALLOC_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 | |
| 771 | 114 terminal_type = build_intstring (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 { | |
| 1726 | 216 xfree (tty_con->term_entry_buffer, char *); |
| 428 | 217 tty_con->term_entry_buffer = NULL; |
| 218 } | |
| 4117 | 219 #ifndef NEW_GC |
| 1726 | 220 xfree (tty_con, struct tty_console *); |
| 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 } |