Add some GT code points.
[chise/xemacs-chise.git.1] / src / procimpl.h
1 /* Processes implementation header
2    Copyright (C) 1985, 1992, 1993, 1994 Free Software Foundation, Inc.
3
4 This file is part of XEmacs.
5
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
9 later version.
10
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; see the file COPYING.  If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21 /* This file must be only included by the process implementation files:
22    process-unix.c, process-msw.c etc. The Lisp_Process structure and other
23    contents of this file is not exported to the rest of the world */
24
25 #ifndef INCLUDED_procimpl_h_
26 #define INCLUDED_procimpl_h_
27
28 /*
29  * Structure which keeps methods of the process implementation.
30  * There is only one object of this class exists in a particular
31  * XEmacs implementation.
32  */
33
34 /* #### Comment me... */
35
36 struct process_methods
37 {
38   void (*mark_process_data) (Lisp_Process *proc);
39   void (*print_process_data) (Lisp_Process *proc, Lisp_Object printcharfun);
40   void (*finalize_process_data) (Lisp_Process *proc, int for_disksave);
41   void (*alloc_process_data) (Lisp_Process *p);
42   void (*init_process_io_handles) (Lisp_Process *p,
43                                    void* in, void* out, int flags);
44   int  (*create_process) (Lisp_Process *p,
45                           Lisp_Object *argv, int nargv,
46                           Lisp_Object program, Lisp_Object cur_dir);
47   int  (*tooltalk_connection_p) (Lisp_Process *p);
48 #ifdef HAVE_SOCKETS
49   void (*open_network_stream) (Lisp_Object name, Lisp_Object host,
50                                Lisp_Object service, Lisp_Object protocol,
51                                void** vinfd, void** voutfd);
52 #ifdef HAVE_MULTICAST
53   void (*open_multicast_group) (Lisp_Object name, Lisp_Object dest,
54                                 Lisp_Object port, Lisp_Object ttl,
55                                 void** vinfd, void** voutfd);
56 #endif /* HAVE_MULTICAST */
57 #endif /* HAVE_SOCKETS */
58   Lisp_Object (*canonicalize_host_name) (Lisp_Object host);
59   int  (*set_window_size) (Lisp_Process* p, int height, int width);
60   void (*send_process) (Lisp_Object proc, struct lstream* lstream);
61   void (*reap_exited_processes) (void);
62   void (*update_status_if_terminated) (Lisp_Process* p);
63   void (*kill_child_process) (Lisp_Object proc, int signo,
64                               int current_group, int nomsg);
65   int  (*kill_process_by_pid) (int pid, int sigcode);
66   int  (*process_send_eof) (Lisp_Object proc);
67   Lisp_Object (*get_tty_name) (Lisp_Process *p);
68   USID (*deactivate_process) (Lisp_Process *p);
69   void (*init_process) (void);
70 };
71
72 extern struct process_methods the_process_methods;
73
74 /*
75  * Accessors for process_methods
76  */
77
78 #define HAS_PROCMETH_P(name) (the_process_methods.name != 0)
79 #define PROCMETH(name, par) ((the_process_methods.name) par)
80 #define PROCMETH_OR_GIVEN(name, par, given) (HAS_PROCMETH_P(name) ? PROCMETH(name, par) : (given))
81 #define MAYBE_PROCMETH(name, par) do { if (HAS_PROCMETH_P(name)) PROCMETH(name, par); } while (0);
82 #define MAYBE_LISP_PROCMETH(name, par) PROCMETH_OR_GIVEN(name, par, Qnil)
83 #define MAYBE_INT_PROCMETH(name, par) PROCMETH_OR_GIVEN(name, par, 0)
84 #define PROCESS_HAS_METHOD(os, name) the_process_methods.name = os##_##name
85
86 /*
87  * Structure records pertinent information about open channels.
88  * There is one channel associated with each process.
89  */
90
91 struct Lisp_Process
92 {
93   struct lcrecord_header header;
94   /* Name of this process */
95   Lisp_Object name;
96   /* List of command arguments that this process was run with */
97   Lisp_Object command;
98   /* (funcall FILTER PROC STRING)  (if FILTER is non-nil)
99      to dispose of a bunch of chars from the process all at once */
100   Lisp_Object filter;
101   /* (funcall SENTINEL PROCESS) when process state changes */
102   Lisp_Object sentinel;
103   /* Buffer that output is going to */
104   Lisp_Object buffer;
105   /* Marker set to end of last buffer-inserted output from this process */
106   Lisp_Object mark;
107   /* Lisp_Int of subprocess' PID, or a cons of
108      service/host if this is really a network connection */
109   Lisp_Object pid;
110
111   /* Symbol indicating status of process.
112      This may be a symbol: run, stop, exit, signal */
113   Lisp_Object status_symbol;
114
115   /* Exit code if process has terminated,
116      signal which stopped/interrupted process
117      or 0 if process is running */
118   int exit_code;
119   /* Non-false if process has exited and "dumped core" on its way down */
120   char core_dumped;
121
122   /* This next field is only actually used #ifdef ENERGIZE */
123   /* if this flag is not NIL, then filter will do the read on the
124      channel, rather than having a call to make_string.
125      This only works if the filter is a subr. */
126   char filter_does_read;
127   /* Non-nil means kill silently if Emacs is exited.  */
128   char kill_without_query;
129   char selected;
130   /* Event-count of last event in which this process changed status.  */
131   volatile int tick;
132   /* Event-count of last such event reported.  */
133   int update_tick;
134   /* Low level streams used in input and output, connected to child */
135   Lisp_Object pipe_instream;
136   Lisp_Object pipe_outstream;
137 #ifdef FILE_CODING
138   /* Data end streams, decoding and encoding pipe_* streams */
139   Lisp_Object coding_instream;
140   Lisp_Object coding_outstream;
141 #endif
142
143   /* Implementation dependent data */
144   void *process_data;
145 };
146
147 /* Macros to refer to data connection streams */
148 #ifdef FILE_CODING
149 #define DATA_INSTREAM(p) (p)->coding_instream
150 #define DATA_OUTSTREAM(p) (p)->coding_outstream
151 #else
152 #define DATA_INSTREAM(p) (p)->pipe_instream
153 #define DATA_OUTSTREAM(p) (p)->pipe_outstream
154 #endif
155
156 /* Random externs from process.c */
157 extern Lisp_Object Qrun, Qstop, Qopen, Qclosed;
158 extern Lisp_Object Qtcp, Qudp;
159 extern Lisp_Object Vprocess_connection_type;
160 extern Lisp_Object Vprocess_list;
161
162 extern struct hash_table *usid_to_process;
163
164 extern volatile int process_tick;
165
166 extern int windowed_process_io;
167
168 #ifdef HAVE_MULTICAST
169 extern Lisp_Object Qmulticast;
170 #endif
171
172 #ifdef PROCESS_IO_BLOCKING
173 extern Lisp_Object network_stream_blocking_port_list;
174 #endif  /* PROCESS_IO_BLOCKING */
175
176 Lisp_Object make_process_internal (Lisp_Object name);
177 void init_process_io_handles (Lisp_Process *p, void* in,
178                               void* out, int flags);
179 void send_process (Lisp_Object proc,
180                    Lisp_Object relocatable,
181                    const Bufbyte *nonrelocatable,
182                    int start, int len);
183
184 #endif /* INCLUDED_procimpl_h_ */