update.
[chise/xemacs-chise.git] / src / console-tty.c
1 /* TTY console functions.
2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
3    Copyright (C) 1994, 1995 Free Software Foundation, Inc.
4    Copyright (C) 1996 Ben Wing.
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
30 #include "console-tty.h"
31 #include "console-stream.h"
32 #include "faces.h"
33 #include "frame.h"
34 #include "lstream.h"
35 #include "glyphs.h"
36 #include "sysdep.h"
37 #include "sysfile.h"
38 #ifdef FILE_CODING
39 #include "file-coding.h"
40 #endif
41
42 DEFINE_CONSOLE_TYPE (tty);
43 DECLARE_IMAGE_INSTANTIATOR_FORMAT (nothing);
44 DECLARE_IMAGE_INSTANTIATOR_FORMAT (string);
45 DECLARE_IMAGE_INSTANTIATOR_FORMAT (formatted_string);
46 DECLARE_IMAGE_INSTANTIATOR_FORMAT (inherit);
47
48 Lisp_Object Qterminal_type;
49 Lisp_Object Qcontrolling_process;
50
51 \f
52 static void
53 allocate_tty_console_struct (struct console *con)
54 {
55   /* zero out all slots except the lisp ones ... */
56   CONSOLE_TTY_DATA (con) = xnew_and_zero (struct tty_console);
57   CONSOLE_TTY_DATA (con)->terminal_type = Qnil;
58   CONSOLE_TTY_DATA (con)->instream = Qnil;
59   CONSOLE_TTY_DATA (con)->outstream = Qnil;
60 }
61
62 static void
63 tty_init_console (struct console *con, Lisp_Object props)
64 {
65   Lisp_Object tty = CONSOLE_CONNECTION (con);
66   Lisp_Object terminal_type = Qnil;
67   Lisp_Object controlling_process = Qnil;
68   struct tty_console *tty_con;
69   struct gcpro gcpro1, gcpro2;
70
71   GCPRO2 (terminal_type, controlling_process);
72
73   terminal_type = Fplist_get (props, Qterminal_type, Qnil);
74   controlling_process = Fplist_get (props, Qcontrolling_process, Qnil);
75
76   /* Determine the terminal type */
77
78   if (!NILP (terminal_type))
79     CHECK_STRING (terminal_type);
80   else
81     {
82       char *temp_type = getenv ("TERM");
83
84       if (!temp_type)
85         {
86           error ("Cannot determine terminal type");
87         }
88       else
89         terminal_type = build_string (temp_type);
90     }
91
92   /* Determine the controlling process */
93   if (!NILP (controlling_process))
94     CHECK_INT (controlling_process);
95
96   /* Open the specified console */
97
98   allocate_tty_console_struct (con);
99   tty_con = CONSOLE_TTY_DATA (con);
100
101   if (internal_equal (tty, Vstdio_str, 0))
102     {
103       tty_con->infd  = fileno (stdin);
104       tty_con->outfd = fileno (stdout);
105       tty_con->is_stdio = 1;
106     }
107   else
108     {
109       tty_con->infd = tty_con->outfd =
110         open ((char *) XSTRING_DATA (tty), O_RDWR);
111       if (tty_con->infd < 0)
112         error ("Unable to open tty %s", XSTRING_DATA (tty));
113       tty_con->is_stdio = 0;
114     }
115
116   tty_con->instream  = make_filedesc_input_stream  (tty_con->infd,  0, -1, 0);
117   tty_con->outstream = make_filedesc_output_stream (tty_con->outfd, 0, -1, 0);
118 #ifdef FILE_CODING
119   tty_con->instream =
120     make_decoding_input_stream (XLSTREAM (tty_con->instream),
121                                 Fget_coding_system (Qkeyboard));
122   Lstream_set_character_mode (XLSTREAM (tty_con->instream));
123   tty_con->outstream =
124     make_encoding_output_stream (XLSTREAM (tty_con->outstream),
125                                  Fget_coding_system (Qterminal));
126 #endif /* FILE_CODING */
127   tty_con->terminal_type = terminal_type;
128   tty_con->controlling_process = controlling_process;
129
130   if (NILP (CONSOLE_NAME (con)))
131     CONSOLE_NAME (con) = Ffile_name_nondirectory (tty);
132   {
133     pid_t tty_pg;
134     pid_t controlling_tty_pg;
135     int cfd;
136
137     /* OK, the only sure-fire way I can think of to determine
138        whether a particular TTY is our controlling TTY is to check
139        if it has the same foreground process group as our controlling
140        TTY.  This is OK because a process group can never simultaneously
141        be the foreground process group of two TTY's (in that case it
142        would have two controlling TTY's, which is not allowed). */
143
144     EMACS_GET_TTY_PROCESS_GROUP (tty_con->infd, &tty_pg);
145     cfd = open ("/dev/tty", O_RDWR, 0);
146     EMACS_GET_TTY_PROCESS_GROUP (cfd, &controlling_tty_pg);
147     close (cfd);
148     if (tty_pg == controlling_tty_pg)
149       {
150         tty_con->controlling_terminal = 1;
151         XSETCONSOLE (Vcontrolling_terminal, con);
152         munge_tty_process_group ();
153       }
154     else
155       tty_con->controlling_terminal = 0;
156   }
157
158   UNGCPRO;
159 }
160
161 static void
162 tty_mark_console (struct console *con)
163 {
164   struct tty_console *tty_con = CONSOLE_TTY_DATA (con);
165   mark_object (tty_con->terminal_type);
166   mark_object (tty_con->instream);
167   mark_object (tty_con->outstream);
168 }
169
170 static int
171 tty_initially_selected_for_input (struct console *con)
172 {
173   return 1;
174 }
175
176 static void
177 free_tty_console_struct (struct console *con)
178 {
179   struct tty_console *tty_con = CONSOLE_TTY_DATA (con);
180   if (tty_con)
181     {
182       if (tty_con->term_entry_buffer) /* allocated in term_init () */
183         {
184           xfree (tty_con->term_entry_buffer);
185           tty_con->term_entry_buffer = NULL;
186         }
187       xfree (tty_con);
188       CONSOLE_TTY_DATA (con) = NULL;
189     }
190 }
191
192 static void
193 tty_delete_console (struct console *con)
194 {
195   Lstream_close (XLSTREAM (CONSOLE_TTY_DATA (con)->instream));
196   Lstream_close (XLSTREAM (CONSOLE_TTY_DATA (con)->outstream));
197   if (!CONSOLE_TTY_DATA (con)->is_stdio)
198     close (CONSOLE_TTY_DATA (con)->infd);
199   if (CONSOLE_TTY_DATA (con)->controlling_terminal)
200     {
201       Vcontrolling_terminal = Qnil;
202       unmunge_tty_process_group ();
203     }
204   free_tty_console_struct (con);
205 }
206
207 \f
208 static struct console *
209 decode_tty_console (Lisp_Object console)
210 {
211   XSETCONSOLE (console, decode_console (console));
212   CHECK_TTY_CONSOLE (console);
213   return XCONSOLE (console);
214 }
215
216 DEFUN ("console-tty-terminal-type", Fconsole_tty_terminal_type,
217        0, 1, 0, /*
218 Return the terminal type of TTY console CONSOLE.
219 */
220        (console))
221 {
222   return CONSOLE_TTY_DATA (decode_tty_console (console))->terminal_type;
223 }
224
225 DEFUN ("console-tty-controlling-process", Fconsole_tty_controlling_process,
226        0, 1, 0, /*
227 Return the controlling process of tty console CONSOLE.
228 */
229        (console))
230 {
231   return CONSOLE_TTY_DATA (decode_tty_console (console))->controlling_process;
232 }
233
234 #ifdef FILE_CODING
235 \f
236 DEFUN ("console-tty-input-coding-system", Fconsole_tty_input_coding_system,
237        0, 1, 0, /*
238 Return the input coding system of tty console CONSOLE.
239 */
240        (console))
241 {
242   return decoding_stream_coding_system
243     (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->instream));
244 }
245
246 DEFUN ("set-console-tty-input-coding-system", Fset_console_tty_input_coding_system,
247        0, 2, 0, /*
248 Set the input coding system of tty console CONSOLE to CODESYS.
249 CONSOLE defaults to the selected console.
250 CODESYS defaults to the value of `keyboard-coding-system'.
251 */
252         (console, codesys))
253 {
254   set_decoding_stream_coding_system
255     (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->instream),
256      Fget_coding_system (NILP (codesys) ? Qkeyboard : codesys));
257   return Qnil;
258 }
259
260 DEFUN ("console-tty-output-coding-system", Fconsole_tty_output_coding_system,
261        0, 1, 0, /*
262 Return TTY CONSOLE's output coding system.
263 */
264        (console))
265 {
266   return encoding_stream_coding_system
267     (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->outstream));
268 }
269
270 DEFUN ("set-console-tty-output-coding-system", Fset_console_tty_output_coding_system,
271        0, 2, 0, /*
272 Set the coding system of tty output of console CONSOLE to CODESYS.
273 CONSOLE defaults to the selected console.
274 CODESYS defaults to the value of `terminal-coding-system'.
275 */
276         (console, codesys))
277 {
278   set_encoding_stream_coding_system
279     (XLSTREAM (CONSOLE_TTY_DATA (decode_tty_console (console))->outstream),
280      Fget_coding_system (NILP (codesys) ? Qterminal : codesys));
281   /* Redraw tty */
282   face_property_was_changed (Vdefault_face, Qfont, Qtty);
283   return Qnil;
284 }
285
286 /* #### Move this function to lisp */
287 DEFUN ("set-console-tty-coding-system", Fset_console_tty_coding_system,
288        0, 2, 0, /*
289 Set the input and output coding systems of tty console CONSOLE to CODESYS.
290 CONSOLE defaults to the selected console.
291 If CODESYS is nil, the values of `keyboard-coding-system' and
292 `terminal-coding-system' will be used for the input and
293 output coding systems of CONSOLE.
294 */
295         (console, codesys))
296 {
297   Fset_console_tty_input_coding_system (console, codesys);
298   Fset_console_tty_output_coding_system (console, codesys);
299   return Qnil;
300 }
301 #endif /* FILE_CODING */
302 \f
303
304 Lisp_Object
305 tty_semi_canonicalize_console_connection (Lisp_Object connection,
306                                           Error_behavior errb)
307 {
308   return stream_semi_canonicalize_console_connection (connection, errb);
309 }
310
311 Lisp_Object
312 tty_canonicalize_console_connection (Lisp_Object connection,
313                                      Error_behavior errb)
314 {
315   return stream_canonicalize_console_connection (connection, errb);
316 }
317
318 Lisp_Object
319 tty_semi_canonicalize_device_connection (Lisp_Object connection,
320                                          Error_behavior errb)
321 {
322   return stream_semi_canonicalize_console_connection (connection, errb);
323 }
324
325 Lisp_Object
326 tty_canonicalize_device_connection (Lisp_Object connection,
327                                     Error_behavior errb)
328 {
329   return stream_canonicalize_console_connection (connection, errb);
330 }
331
332 \f
333 /************************************************************************/
334 /*                            initialization                            */
335 /************************************************************************/
336
337 void
338 syms_of_console_tty (void)
339 {
340   DEFSUBR (Fconsole_tty_terminal_type);
341   DEFSUBR (Fconsole_tty_controlling_process);
342   defsymbol (&Qterminal_type, "terminal-type");
343   defsymbol (&Qcontrolling_process, "controlling-process");
344 #ifdef FILE_CODING
345   DEFSUBR (Fconsole_tty_output_coding_system);
346   DEFSUBR (Fset_console_tty_output_coding_system);
347   DEFSUBR (Fconsole_tty_input_coding_system);
348   DEFSUBR (Fset_console_tty_input_coding_system);
349   DEFSUBR (Fset_console_tty_coding_system);
350 #endif /* FILE_CODING */
351 }
352
353 void
354 console_type_create_tty (void)
355 {
356   INITIALIZE_CONSOLE_TYPE (tty, "tty", "console-tty-p");
357
358   /* console methods */
359   CONSOLE_HAS_METHOD (tty, init_console);
360   CONSOLE_HAS_METHOD (tty, mark_console);
361   CONSOLE_HAS_METHOD (tty, initially_selected_for_input);
362   CONSOLE_HAS_METHOD (tty, delete_console);
363   CONSOLE_HAS_METHOD (tty, canonicalize_console_connection);
364   CONSOLE_HAS_METHOD (tty, canonicalize_device_connection);
365   CONSOLE_HAS_METHOD (tty, semi_canonicalize_console_connection);
366   CONSOLE_HAS_METHOD (tty, semi_canonicalize_device_connection);
367 }
368
369 void
370 reinit_console_type_create_tty (void)
371 {
372   REINITIALIZE_CONSOLE_TYPE (tty);
373 }
374
375 void
376 image_instantiator_format_create_glyphs_tty (void)
377 {
378   IIFORMAT_VALID_CONSOLE (tty, nothing);
379   IIFORMAT_VALID_CONSOLE (tty, string);
380   IIFORMAT_VALID_CONSOLE (tty, formatted_string);
381   IIFORMAT_VALID_CONSOLE (tty, inherit);
382 }
383
384 void
385 vars_of_console_tty (void)
386 {
387   Fprovide (Qtty);
388 }