/* Asynchronous subprocess control for GNU Emacs.
Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
1996, 1998, 1999, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#endif
#endif /* HAVE_SOCKETS */
-#if defined(BSD_SYSTEM)
+#if defined(HAVE_SYS_IOCTL_H)
#include <sys/ioctl.h>
#if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
#include <fcntl.h>
#endif /* HAVE_PTYS and no O_NDELAY */
-#endif /* BSD_SYSTEM */
+#endif /* HAVE_SYS_IOCTL_H */
#ifdef NEED_BSDTTY
#include <bsdtty.h>
#include "composite.h"
#include "atimer.h"
+#if defined (USE_GTK) || defined (HAVE_GCONF)
+#include "xgselect.h"
+#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+
Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal;
Lisp_Object Qopen, Qclosed, Qconnect, Qfailed, Qlisten;
-Lisp_Object Qlocal, Qipv4, Qdatagram;
+Lisp_Object Qlocal, Qipv4, Qdatagram, Qseqpacket;
Lisp_Object Qreal, Qnetwork, Qserial;
#ifdef AF_INET6
Lisp_Object Qipv6;
extern void serial_configure (struct Lisp_Process *p, Lisp_Object contact);
#endif
-#ifndef USE_CRT_DLL
-extern int errno;
-#endif
-
#ifndef HAVE_H_ERRNO
extern int h_errno;
#endif
#endif /* DATAGRAM_SOCKETS */
#endif /* BROKEN_DATAGRAM_SOCKETS */
+#if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
+# define HAVE_SEQPACKET
+#endif
+
#if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
#ifdef EMACS_HAS_USECS
#define ADAPTIVE_READ_BUFFERING
static Lisp_Object get_process ();
static void exec_sentinel ();
-extern EMACS_TIME timer_check ();
extern int timers_run;
\f
/* Mask of bits indicating the descriptors that we wait for input on. */
if (! NILP (Vlocale_coding_system))
string = (code_convert_string_norecord
(string, Vlocale_coding_system, 0));
- c1 = STRING_CHAR ((char *) SDATA (string), 0);
+ c1 = STRING_CHAR ((char *) SDATA (string));
c2 = DOWNCASE (c1);
if (c1 != c2)
Faset (string, make_number (0), make_number (c2));
#ifdef AIX
struct sigaction sighup_action;
#endif
-#else /* !POSIX_SIGNALS */
-#if 0
-#ifdef SIGCHLD
- SIGTYPE (*sigchld)();
-#endif
-#endif /* 0 */
-#endif /* !POSIX_SIGNALS */
+#endif /* POSIX_SIGNALS */
/* Use volatile to protect variables from being clobbered by longjmp. */
volatile int forkin, forkout;
volatile int pty_flag = 0;
sigprocmask (SIG_BLOCK, &blocked, &procmask);
#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
-#if defined (BSD_SYSTEM) || defined (HPUX)
+#if defined (BSD_SYSTEM)
sigsetmask (sigmask (SIGCHLD));
-#else /* ordinary USG */
-#if 0
- sigchld_deferred = 0;
- sigchld = signal (SIGCHLD, create_process_sigchld);
-#endif
-#endif /* ordinary USG */
+#endif /* BSD_SYSTEM */
#endif /* SIGCHLD */
#endif /* !POSIX_SIGNALS */
sigprocmask (SIG_SETMASK, &procmask, 0);
#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
-#if defined (BSD_SYSTEM) || defined (HPUX)
+#if defined (BSD_SYSTEM)
sigsetmask (SIGEMPTYMASK);
-#else /* ordinary USG */
-#if 0
- signal (SIGCHLD, sigchld);
-#endif
-#endif /* ordinary USG */
+#endif /* BSD_SYSTEM */
#endif /* SIGCHLD */
#endif /* !POSIX_SIGNALS */
sigprocmask (SIG_SETMASK, &procmask, 0);
#else /* !POSIX_SIGNALS */
#ifdef SIGCHLD
-#if defined (BSD_SYSTEM) || defined (HPUX)
+#if defined (BSD_SYSTEM)
sigsetmask (SIGEMPTYMASK);
-#else /* ordinary USG */
-#if 0
- signal (SIGCHLD, sigchld);
- /* Now really handle any of these signals
- that came in during this function. */
- if (sigchld_deferred)
- kill (getpid (), SIGCHLD);
-#endif
-#endif /* ordinary USG */
+#endif /* BSD_SYSTEM */
#endif /* SIGCHLD */
#endif /* !POSIX_SIGNALS */
#endif
\f
-static struct socket_options {
+static const struct socket_options {
/* The name of this option. Should be lowercase version of option
name without SO_ prefix. */
char *name;
Lisp_Object opt, val;
{
char *name;
- struct socket_options *sopt;
+ const struct socket_options *sopt;
int ret = 0;
CHECK_SYMBOL (opt);
string, e.g. "80", as well as an integer. This is not portable.)
:type TYPE -- TYPE is the type of connection. The default (nil) is a
-stream type connection, `datagram' creates a datagram type connection.
+stream type connection, `datagram' creates a datagram type connection,
+`seqpacket' creates a reliable datagram connection.
:family FAMILY -- FAMILY is the address (and protocol) family for the
service specified by HOST and SERVICE. The default (nil) is to use
#ifdef DATAGRAM_SOCKETS
else if (EQ (tem, Qdatagram))
socktype = SOCK_DGRAM;
+#endif
+#ifdef HAVE_SEQPACKET
+ else if (EQ (tem, Qseqpacket))
+ socktype = SOCK_SEQPACKET;
#endif
else
error ("Unsupported connection type");
QCaddress = is_server ? QClocal : QCremote;
/* :nowait BOOL */
- if (!is_server && socktype == SOCK_STREAM
+ if (!is_server && socktype != SOCK_DGRAM
&& (tem = Fplist_get (contact, QCnowait), !NILP (tem)))
{
#ifndef NON_BLOCKING_CONNECT
Some kernels have a bug which causes retrying connect to fail
after a connect. Polling can interfere with gethostbyname too. */
#ifdef POLL_FOR_INPUT
- if (socktype == SOCK_STREAM)
+ if (socktype != SOCK_DGRAM)
{
record_unwind_protect (unwind_stop_other_atimers, Qnil);
bind_polling_period (10);
}
#endif
- if (socktype == SOCK_STREAM && listen (s, backlog))
+ if (socktype != SOCK_DGRAM && listen (s, backlog))
report_file_error ("Cannot listen on server socket", Qnil);
break;
immediate_quit = 1;
QUIT;
- /* This turns off all alarm-based interrupts; the
- bind_polling_period call above doesn't always turn all the
- short-interval ones off, especially if interrupt_input is
- set.
-
- It'd be nice to be able to control the connect timeout
- though. Would non-blocking connect calls be portable?
-
- This used to be conditioned by HAVE_GETADDRINFO. Why? */
-
- turn_on_atimers (0);
-
ret = connect (s, lres->ai_addr, lres->ai_addrlen);
xerrno = errno;
- turn_on_atimers (1);
-
if (ret == 0 || xerrno == EISCONN)
{
/* The unwind-protect will be discarded afterwards.
#endif
#endif
+#ifndef WINDOWSNT
+ if (xerrno == EINTR)
+ {
+ /* Unlike most other syscalls connect() cannot be called
+ again. (That would return EALREADY.) The proper way to
+ wait for completion is select(). */
+ int sc, len;
+ SELECT_TYPE fdset;
+ retry_select:
+ FD_ZERO (&fdset);
+ FD_SET (s, &fdset);
+ QUIT;
+ sc = select (s + 1, (SELECT_TYPE *)0, &fdset, (SELECT_TYPE *)0,
+ (EMACS_TIME *)0);
+ if (sc == -1)
+ {
+ if (errno == EINTR)
+ goto retry_select;
+ else
+ report_file_error ("select failed", Qnil);
+ }
+ eassert (sc > 0);
+
+ len = sizeof xerrno;
+ eassert (FD_ISSET (s, &fdset));
+ if (getsockopt (s, SOL_SOCKET, SO_ERROR, &xerrno, &len) == -1)
+ report_file_error ("getsockopt failed", Qnil);
+ if (xerrno)
+ errno = xerrno, report_file_error ("error during connect", Qnil);
+ else
+ break;
+ }
+#endif /* !WINDOWSNT */
+
immediate_quit = 0;
/* Discard the unwind protect closing S. */
emacs_close (s);
s = -1;
+#ifdef WINDOWSNT
if (xerrno == EINTR)
goto retry_connect;
+#endif
}
if (s >= 0)
p->pid = 0;
p->infd = inch;
p->outfd = outch;
- if (is_server && socktype == SOCK_STREAM)
+ if (is_server && socktype != SOCK_DGRAM)
p->status = Qlisten;
/* Make the process marker point into the process buffer (if any). */
struct ifflag_def {
int flag_bit;
- char *flag_sym;
+ const char *flag_sym;
};
-static struct ifflag_def ifflag_table[] = {
+static const struct ifflag_def ifflag_table[] = {
#ifdef IFF_UP
{ IFF_UP, "up" },
#endif
if (ioctl (s, SIOCGIFFLAGS, &rq) == 0)
{
int flags = rq.ifr_flags;
- struct ifflag_def *fp;
+ const struct ifflag_def *fp;
int fnum;
any++;
}
/* Use a wrapper around select to work around a bug in gdb 5.3.
- Normally, the wrapper is optimzed away by inlining.
+ Normally, the wrapper is optimized away by inlining.
If emacs is stopped inside select, the gdb backtrace doesn't
show the function which called select, so it is practically
FD_ZERO (&Connecting);
#endif
+ if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit)
+ && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
+ message ("Blocking call to accept-process-output with quit inhibited!!");
+
/* If wait_proc is a process to watch, set wait_channel accordingly. */
if (wait_proc != NULL)
wait_channel = wait_proc->infd;
process_output_skip = 0;
}
#endif
-#ifdef HAVE_NS
+#if defined (USE_GTK) || defined (HAVE_GCONF)
+ nfds = xg_select
+#elif defined (HAVE_NS)
nfds = ns_select
#else
nfds = select
struct coding_system *coding = proc_decode_coding_system[channel];
int carryover = p->decoding_carryover;
int readmax = 4096;
+ int count = SPECPDL_INDEX ();
+ Lisp_Object odeactivate;
chars = (char *) alloca (carryover + readmax);
if (carryover)
/* Now set NBYTES how many bytes we must decode. */
nbytes += carryover;
+ odeactivate = Vdeactivate_mark;
+ /* There's no good reason to let process filters change the current
+ buffer, and many callers of accept-process-output, sit-for, and
+ friends don't expect current-buffer to be changed from under them. */
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
/* Read and dispose of the process output. */
outstream = p->filter;
if (!NILP (outstream))
{
- /* We inhibit quit here instead of just catching it so that
- hitting ^G when a filter happens to be running won't screw
- it up. */
- int count = SPECPDL_INDEX ();
- Lisp_Object odeactivate;
Lisp_Object obuffer, okeymap;
Lisp_Object text;
int outer_running_asynch_code = running_asynch_code;
/* No need to gcpro these, because all we do with them later
is test them for EQness, and none of them should be a string. */
- odeactivate = Vdeactivate_mark;
XSETBUFFER (obuffer, current_buffer);
okeymap = current_buffer->keymap;
+ /* We inhibit quit here instead of just catching it so that
+ hitting ^G when a filter happens to be running won't screw
+ it up. */
specbind (Qinhibit_quit, Qt);
specbind (Qlast_nonmenu_event, Qt);
restore_search_regs ();
running_asynch_code = outer_running_asynch_code;
- /* Handling the process output should not deactivate the mark. */
- Vdeactivate_mark = odeactivate;
-
/* Restore waiting_for_user_input_p as it was
when we were called, in case the filter clobbered it. */
waiting_for_user_input_p = waiting;
cause trouble (for example it would make sit_for return). */
if (waiting_for_user_input_p == -1)
record_asynch_buffer_change ();
-
- unbind_to (count, Qnil);
- return nbytes;
}
/* If no filter, write into buffer if it isn't dead. */
- if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
+ else if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
{
Lisp_Object old_read_only;
int old_begv, old_zv;
int old_begv_byte, old_zv_byte;
- Lisp_Object odeactivate;
int before, before_byte;
int opoint_byte;
Lisp_Object text;
struct buffer *b;
- int count = SPECPDL_INDEX ();
-
- odeactivate = Vdeactivate_mark;
- record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
Fset_buffer (p->buffer);
opoint = PT;
opoint_byte = PT_BYTE;
if (old_begv != BEGV || old_zv != ZV)
Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
- /* Handling the process output should not deactivate the mark. */
- Vdeactivate_mark = odeactivate;
current_buffer->read_only = old_read_only;
SET_PT_BOTH (opoint, opoint_byte);
- unbind_to (count, Qnil);
}
+ /* Handling the process output should not deactivate the mark. */
+ Vdeactivate_mark = odeactivate;
+
+ unbind_to (count, Qnil);
return nbytes;
}
{
int this = len;
- /* Decide how much data we can send in one batch.
- Long lines need to be split into multiple batches. */
- if (p->pty_flag)
- {
- /* Starting this at zero is always correct when not the first
- iteration because the previous iteration ended by sending C-d.
- It may not be correct for the first iteration
- if a partial line was sent in a separate send_process call.
- If that proves worth handling, we need to save linepos
- in the process object. */
- int linepos = 0;
- unsigned char *ptr = (unsigned char *) buf;
- unsigned char *end = (unsigned char *) buf + len;
-
- /* Scan through this text for a line that is too long. */
- while (ptr != end && linepos < pty_max_bytes)
- {
- if (*ptr == '\n')
- linepos = 0;
- else
- linepos++;
- ptr++;
- }
- /* If we found one, break the line there
- and put in a C-d to force the buffer through. */
- this = ptr - buf;
- }
-
/* Send this batch, using one or more write calls. */
while (this > 0)
{
len -= rv;
this -= rv;
}
-
- /* If we sent just part of the string, put in an EOF (C-d)
- to force it through, before we send the rest. */
- if (len > 0)
- Fprocess_send_eof (proc);
}
}
else
/* PID == 0 means no processes found, PID == -1 means a real
failure. We have done all our job, so return. */
- /* USG systems forget handlers when they are used;
- must reestablish each time */
-#if defined (USG) && !defined (POSIX_SIGNALS)
- signal (signo, sigchld_handler); /* WARNING - must come after wait3() */
-#endif
errno = old_errno;
return;
}
#if (defined WINDOWSNT \
|| (defined USG && !defined GNU_LINUX \
&& !(defined HPUX && defined WNOHANG)))
-#if defined (USG) && ! defined (POSIX_SIGNALS)
- signal (signo, sigchld_handler);
-#endif
errno = old_errno;
return;
#endif /* USG, but not HPUX with WNOHANG */
XSETBUFFER (obuffer, current_buffer);
okeymap = current_buffer->keymap;
+ /* There's no good reason to let sentinels change the current
+ buffer, and many callers of accept-process-output, sit-for, and
+ friends don't expect current-buffer to be changed from under them. */
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
sentinel = p->sentinel;
if (NILP (sentinel))
return;
record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel));
/* Inhibit quit so that random quits don't screw up a running filter. */
specbind (Qinhibit_quit, Qt);
- specbind (Qlast_nonmenu_event, Qt);
+ specbind (Qlast_nonmenu_event, Qt); /* Why? --Stef */
/* In case we get recursively called,
and we already saved the match data nonrecursively,
when a process becomes runnable. */
else if (!EQ (symbol, Qrun) && !NILP (buffer))
{
- Lisp_Object ro, tem;
+ Lisp_Object tem;
struct buffer *old = current_buffer;
int opoint, opoint_byte;
int before, before_byte;
- ro = XBUFFER (buffer)->read_only;
-
/* Avoid error if buffer is deleted
(probably that's why the process is dead, too) */
if (NILP (XBUFFER (buffer)->name))
#ifdef HAVE_SOCKETS
{
Lisp_Object subfeatures = Qnil;
- struct socket_options *sopt;
+ const struct socket_options *sopt;
#define ADD_SUBFEATURE(key, val) \
- subfeatures = Fcons (Fcons (key, Fcons (val, Qnil)), subfeatures)
+ subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
#ifdef NON_BLOCKING_CONNECT
ADD_SUBFEATURE (QCnowait, Qt);
#ifdef DATAGRAM_SOCKETS
ADD_SUBFEATURE (QCtype, Qdatagram);
#endif
+#ifdef HAVE_SEQPACKET
+ ADD_SUBFEATURE (QCtype, Qseqpacket);
+#endif
#ifdef HAVE_LOCAL_SOCKETS
ADD_SUBFEATURE (QCfamily, Qlocal);
#endif
#endif
for (sopt = socket_options; sopt->name; sopt++)
- subfeatures = Fcons (intern (sopt->name), subfeatures);
+ subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
- Fprovide (intern ("make-network-process"), subfeatures);
+ Fprovide (intern_c_string ("make-network-process"), subfeatures);
}
#endif /* HAVE_SOCKETS */
void
syms_of_process ()
{
- Qprocessp = intern ("processp");
+ Qprocessp = intern_c_string ("processp");
staticpro (&Qprocessp);
- Qrun = intern ("run");
+ Qrun = intern_c_string ("run");
staticpro (&Qrun);
- Qstop = intern ("stop");
+ Qstop = intern_c_string ("stop");
staticpro (&Qstop);
- Qsignal = intern ("signal");
+ Qsignal = intern_c_string ("signal");
staticpro (&Qsignal);
/* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
here again.
- Qexit = intern ("exit");
+ Qexit = intern_c_string ("exit");
staticpro (&Qexit); */
- Qopen = intern ("open");
+ Qopen = intern_c_string ("open");
staticpro (&Qopen);
- Qclosed = intern ("closed");
+ Qclosed = intern_c_string ("closed");
staticpro (&Qclosed);
- Qconnect = intern ("connect");
+ Qconnect = intern_c_string ("connect");
staticpro (&Qconnect);
- Qfailed = intern ("failed");
+ Qfailed = intern_c_string ("failed");
staticpro (&Qfailed);
- Qlisten = intern ("listen");
+ Qlisten = intern_c_string ("listen");
staticpro (&Qlisten);
- Qlocal = intern ("local");
+ Qlocal = intern_c_string ("local");
staticpro (&Qlocal);
- Qipv4 = intern ("ipv4");
+ Qipv4 = intern_c_string ("ipv4");
staticpro (&Qipv4);
#ifdef AF_INET6
- Qipv6 = intern ("ipv6");
+ Qipv6 = intern_c_string ("ipv6");
staticpro (&Qipv6);
#endif
- Qdatagram = intern ("datagram");
+ Qdatagram = intern_c_string ("datagram");
staticpro (&Qdatagram);
+ Qseqpacket = intern_c_string ("seqpacket");
+ staticpro (&Qseqpacket);
- QCport = intern (":port");
+ QCport = intern_c_string (":port");
staticpro (&QCport);
- QCspeed = intern (":speed");
+ QCspeed = intern_c_string (":speed");
staticpro (&QCspeed);
- QCprocess = intern (":process");
+ QCprocess = intern_c_string (":process");
staticpro (&QCprocess);
- QCbytesize = intern (":bytesize");
+ QCbytesize = intern_c_string (":bytesize");
staticpro (&QCbytesize);
- QCstopbits = intern (":stopbits");
+ QCstopbits = intern_c_string (":stopbits");
staticpro (&QCstopbits);
- QCparity = intern (":parity");
+ QCparity = intern_c_string (":parity");
staticpro (&QCparity);
- Qodd = intern ("odd");
+ Qodd = intern_c_string ("odd");
staticpro (&Qodd);
- Qeven = intern ("even");
+ Qeven = intern_c_string ("even");
staticpro (&Qeven);
- QCflowcontrol = intern (":flowcontrol");
+ QCflowcontrol = intern_c_string (":flowcontrol");
staticpro (&QCflowcontrol);
- Qhw = intern ("hw");
+ Qhw = intern_c_string ("hw");
staticpro (&Qhw);
- Qsw = intern ("sw");
+ Qsw = intern_c_string ("sw");
staticpro (&Qsw);
- QCsummary = intern (":summary");
+ QCsummary = intern_c_string (":summary");
staticpro (&QCsummary);
- Qreal = intern ("real");
+ Qreal = intern_c_string ("real");
staticpro (&Qreal);
- Qnetwork = intern ("network");
+ Qnetwork = intern_c_string ("network");
staticpro (&Qnetwork);
- Qserial = intern ("serial");
+ Qserial = intern_c_string ("serial");
staticpro (&Qserial);
- QCname = intern (":name");
+ QCname = intern_c_string (":name");
staticpro (&QCname);
- QCbuffer = intern (":buffer");
+ QCbuffer = intern_c_string (":buffer");
staticpro (&QCbuffer);
- QChost = intern (":host");
+ QChost = intern_c_string (":host");
staticpro (&QChost);
- QCservice = intern (":service");
+ QCservice = intern_c_string (":service");
staticpro (&QCservice);
- QCtype = intern (":type");
+ QCtype = intern_c_string (":type");
staticpro (&QCtype);
- QClocal = intern (":local");
+ QClocal = intern_c_string (":local");
staticpro (&QClocal);
- QCremote = intern (":remote");
+ QCremote = intern_c_string (":remote");
staticpro (&QCremote);
- QCcoding = intern (":coding");
+ QCcoding = intern_c_string (":coding");
staticpro (&QCcoding);
- QCserver = intern (":server");
+ QCserver = intern_c_string (":server");
staticpro (&QCserver);
- QCnowait = intern (":nowait");
+ QCnowait = intern_c_string (":nowait");
staticpro (&QCnowait);
- QCsentinel = intern (":sentinel");
+ QCsentinel = intern_c_string (":sentinel");
staticpro (&QCsentinel);
- QClog = intern (":log");
+ QClog = intern_c_string (":log");
staticpro (&QClog);
- QCnoquery = intern (":noquery");
+ QCnoquery = intern_c_string (":noquery");
staticpro (&QCnoquery);
- QCstop = intern (":stop");
+ QCstop = intern_c_string (":stop");
staticpro (&QCstop);
- QCoptions = intern (":options");
+ QCoptions = intern_c_string (":options");
staticpro (&QCoptions);
- QCplist = intern (":plist");
+ QCplist = intern_c_string (":plist");
staticpro (&QCplist);
- Qlast_nonmenu_event = intern ("last-nonmenu-event");
+ Qlast_nonmenu_event = intern_c_string ("last-nonmenu-event");
staticpro (&Qlast_nonmenu_event);
staticpro (&Vprocess_alist);
staticpro (&deleted_pid_list);
#endif
- Qeuid = intern ("euid");
+ Qeuid = intern_c_string ("euid");
staticpro (&Qeuid);
- Qegid = intern ("egid");
+ Qegid = intern_c_string ("egid");
staticpro (&Qegid);
- Quser = intern ("user");
+ Quser = intern_c_string ("user");
staticpro (&Quser);
- Qgroup = intern ("group");
+ Qgroup = intern_c_string ("group");
staticpro (&Qgroup);
- Qcomm = intern ("comm");
+ Qcomm = intern_c_string ("comm");
staticpro (&Qcomm);
- Qstate = intern ("state");
+ Qstate = intern_c_string ("state");
staticpro (&Qstate);
- Qppid = intern ("ppid");
+ Qppid = intern_c_string ("ppid");
staticpro (&Qppid);
- Qpgrp = intern ("pgrp");
+ Qpgrp = intern_c_string ("pgrp");
staticpro (&Qpgrp);
- Qsess = intern ("sess");
+ Qsess = intern_c_string ("sess");
staticpro (&Qsess);
- Qttname = intern ("ttname");
+ Qttname = intern_c_string ("ttname");
staticpro (&Qttname);
- Qtpgid = intern ("tpgid");
+ Qtpgid = intern_c_string ("tpgid");
staticpro (&Qtpgid);
- Qminflt = intern ("minflt");
+ Qminflt = intern_c_string ("minflt");
staticpro (&Qminflt);
- Qmajflt = intern ("majflt");
+ Qmajflt = intern_c_string ("majflt");
staticpro (&Qmajflt);
- Qcminflt = intern ("cminflt");
+ Qcminflt = intern_c_string ("cminflt");
staticpro (&Qcminflt);
- Qcmajflt = intern ("cmajflt");
+ Qcmajflt = intern_c_string ("cmajflt");
staticpro (&Qcmajflt);
- Qutime = intern ("utime");
+ Qutime = intern_c_string ("utime");
staticpro (&Qutime);
- Qstime = intern ("stime");
+ Qstime = intern_c_string ("stime");
staticpro (&Qstime);
- Qtime = intern ("time");
+ Qtime = intern_c_string ("time");
staticpro (&Qtime);
- Qcutime = intern ("cutime");
+ Qcutime = intern_c_string ("cutime");
staticpro (&Qcutime);
- Qcstime = intern ("cstime");
+ Qcstime = intern_c_string ("cstime");
staticpro (&Qcstime);
- Qctime = intern ("ctime");
+ Qctime = intern_c_string ("ctime");
staticpro (&Qctime);
- Qpri = intern ("pri");
+ Qpri = intern_c_string ("pri");
staticpro (&Qpri);
- Qnice = intern ("nice");
+ Qnice = intern_c_string ("nice");
staticpro (&Qnice);
- Qthcount = intern ("thcount");
+ Qthcount = intern_c_string ("thcount");
staticpro (&Qthcount);
- Qstart = intern ("start");
+ Qstart = intern_c_string ("start");
staticpro (&Qstart);
- Qvsize = intern ("vsize");
+ Qvsize = intern_c_string ("vsize");
staticpro (&Qvsize);
- Qrss = intern ("rss");
+ Qrss = intern_c_string ("rss");
staticpro (&Qrss);
- Qetime = intern ("etime");
+ Qetime = intern_c_string ("etime");
staticpro (&Qetime);
- Qpcpu = intern ("pcpu");
+ Qpcpu = intern_c_string ("pcpu");
staticpro (&Qpcpu);
- Qpmem = intern ("pmem");
+ Qpmem = intern_c_string ("pmem");
staticpro (&Qpmem);
- Qargs = intern ("args");
+ Qargs = intern_c_string ("args");
staticpro (&Qargs);
DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
void
syms_of_process ()
{
- QCtype = intern (":type");
+ QCtype = intern_c_string (":type");
staticpro (&QCtype);
- QCname = intern (":name");
+ QCname = intern_c_string (":name");
staticpro (&QCname);
- QCtype = intern (":type");
+ QCtype = intern_c_string (":type");
staticpro (&QCtype);
- QCname = intern (":name");
+ QCname = intern_c_string (":name");
staticpro (&QCname);
- Qeuid = intern ("euid");
+ Qeuid = intern_c_string ("euid");
staticpro (&Qeuid);
- Qegid = intern ("egid");
+ Qegid = intern_c_string ("egid");
staticpro (&Qegid);
- Quser = intern ("user");
+ Quser = intern_c_string ("user");
staticpro (&Quser);
- Qgroup = intern ("group");
+ Qgroup = intern_c_string ("group");
staticpro (&Qgroup);
- Qcomm = intern ("comm");
+ Qcomm = intern_c_string ("comm");
staticpro (&Qcomm);
- Qstate = intern ("state");
+ Qstate = intern_c_string ("state");
staticpro (&Qstate);
- Qppid = intern ("ppid");
+ Qppid = intern_c_string ("ppid");
staticpro (&Qppid);
- Qpgrp = intern ("pgrp");
+ Qpgrp = intern_c_string ("pgrp");
staticpro (&Qpgrp);
- Qsess = intern ("sess");
+ Qsess = intern_c_string ("sess");
staticpro (&Qsess);
- Qttname = intern ("ttname");
+ Qttname = intern_c_string ("ttname");
staticpro (&Qttname);
- Qtpgid = intern ("tpgid");
+ Qtpgid = intern_c_string ("tpgid");
staticpro (&Qtpgid);
- Qminflt = intern ("minflt");
+ Qminflt = intern_c_string ("minflt");
staticpro (&Qminflt);
- Qmajflt = intern ("majflt");
+ Qmajflt = intern_c_string ("majflt");
staticpro (&Qmajflt);
- Qcminflt = intern ("cminflt");
+ Qcminflt = intern_c_string ("cminflt");
staticpro (&Qcminflt);
- Qcmajflt = intern ("cmajflt");
+ Qcmajflt = intern_c_string ("cmajflt");
staticpro (&Qcmajflt);
- Qutime = intern ("utime");
+ Qutime = intern_c_string ("utime");
staticpro (&Qutime);
- Qstime = intern ("stime");
+ Qstime = intern_c_string ("stime");
staticpro (&Qstime);
- Qtime = intern ("time");
+ Qtime = intern_c_string ("time");
staticpro (&Qtime);
- Qcutime = intern ("cutime");
+ Qcutime = intern_c_string ("cutime");
staticpro (&Qcutime);
- Qcstime = intern ("cstime");
+ Qcstime = intern_c_string ("cstime");
staticpro (&Qcstime);
- Qctime = intern ("ctime");
+ Qctime = intern_c_string ("ctime");
staticpro (&Qctime);
- Qpri = intern ("pri");
+ Qpri = intern_c_string ("pri");
staticpro (&Qpri);
- Qnice = intern ("nice");
+ Qnice = intern_c_string ("nice");
staticpro (&Qnice);
- Qthcount = intern ("thcount");
+ Qthcount = intern_c_string ("thcount");
staticpro (&Qthcount);
- Qstart = intern ("start");
+ Qstart = intern_c_string ("start");
staticpro (&Qstart);
- Qvsize = intern ("vsize");
+ Qvsize = intern_c_string ("vsize");
staticpro (&Qvsize);
- Qrss = intern ("rss");
+ Qrss = intern_c_string ("rss");
staticpro (&Qrss);
- Qetime = intern ("etime");
+ Qetime = intern_c_string ("etime");
staticpro (&Qetime);
- Qpcpu = intern ("pcpu");
+ Qpcpu = intern_c_string ("pcpu");
staticpro (&Qpcpu);
- Qpmem = intern ("pmem");
+ Qpmem = intern_c_string ("pmem");
staticpro (&Qpmem);
- Qargs = intern ("args");
+ Qargs = intern_c_string ("args");
staticpro (&Qargs);
defsubr (&Sget_buffer_process);