xemacs-beta: src/process.c comparison

comparison src/process.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	2d532a89d707
children	a2f645c6b9f8

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 static void
 print_process (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 struct Lisp_Process *proc = XPROCESS (obj);
 if (print_readably)
 error ("printing unreadable object #<process %s>",
 XSTRING_DATA (proc->name));
 if (!escapeflag)
 {
 print_internal (proc->name, printcharfun, 0);
 }
 else
 static Lisp_Object
 make_process_internal (Lisp_Object name)
 {
 Lisp_Object val, name1;
 int i;
-struct Lisp_Process *p
+struct Lisp_Process *p =
-= alloc_lcrecord (sizeof (struct Lisp_Process), lrecord_process);
+alloc_lcrecord_type (struct Lisp_Process, lrecord_process);
 /* If name is already in use, modify it until it is unused.  */
 name1 = name;
 for (i = 1; ; i++)
 {
 char suffix[10];
 Lisp_Object tem = Fget_process (name1);
 if (NILP (tem))
 break;
 sprintf (suffix, "<%d>", i);
 name1 = concat2 (name, build_string (suffix));
 }
 name = name1;
 static Bufbyte
 get_eof_char (struct Lisp_Process *p)
 {
 /* Figure out the eof character for the outfd of the given process.
 * The following code is similar to that in process_send_signal, and
 * should probably be merged with that code somehow. */
 CONST Bufbyte ctrl_d = (Bufbyte) '\004';
 if (!isatty (p->outfd))
 return ctrl_d;
 #ifdef HAVE_TERMIOS
 {
 struct termios t;
 return ctrl_d;
 else
 return (Bufbyte) t.c_cc[VINTR];
 }
 #else /* ! defined (TCGETA) */
 /* Rather than complain, we'll just guess ^D, which is what
 * earlier emacsen always used. */
 return ctrl_d;
 #endif /* ! defined (TCGETA) */
 #endif /* ! defined (TIOCGETC) */
 #endif /* ! defined (HAVE_TERMIOS) */
 What's going on here? */
 #endif /* MULE */
 }
 static void
 create_process (Lisp_Object process,
 char **new_argv, CONST char *current_dir)
 {
 /* This function rewritten by wing@666.com. */
 int pid, inchannel, outchannel;
 #  endif /* USG or not TIOCSCTTY */
 	    /* Miscellaneous setup required for some systems.
 Must be done before using tc* functions on xforkin.
 This guarantees that isatty(xforkin) is true. */
 # ifdef SETUP_SLAVE_PTY
 	    SETUP_SLAVE_PTY;
 # endif /* SETUP_SLAVE_PTY */
 #  ifdef TIOCSCTTY
 	    /* We ignore the return value
 	       because faith@cs.unc.edu says that is necessary on Linux.  */
 assert (isatty (xforkin));
 	    ioctl (xforkin, TIOCSCTTY, 0);
 	  }
 #ifdef WINDOWSNT
 	pid = child_setup (xforkin, xforkout, xforkout,
 			   new_argv, current_dir);
 #else  /* not WINDOWSNT */
 	child_setup (xforkin, xforkout, xforkout, new_argv, current_dir);
 #endif /* not WINDOWSNT */
 #endif /* not MSDOS */
 }
 #ifdef EMACS_BTL
 if (!NILP (Ffile_directory_p (program)))
 	error ("Specified program for new process is a directory");
 }
 /* Nothing below here GCs so our string pointers shouldn't move. */
-new_argv = (char **) alloca ((nargs - 1) * sizeof (char *));
+new_argv = alloca_array (char *, nargs - 1);
 new_argv[0] = (char *) XSTRING_DATA (program);
 for (i = 3; i < nargs; i++)
 {
 tem = args[i];
 CHECK_STRING (tem);
 get_internet_address (host, &address, ERROR_ME);
 address.sin_port = port;
 s = socket (address.sin_family, SOCK_STREAM, 0);
 if (s < 0)
 report_file_error ("error creating socket", list1 (name));
 /* Turn off interrupts here -- see comments below.  There used to
 be code which called bind_polling_period() to slow the polling
 period down rather than turn it off, but that seems rather
 	       specially inside of the filedesc stream. */
 	    report_file_error ("writing to process",
 			       list1 (proc));
 	  while (filedesc_stream_was_blocked (XLSTREAM (p->filedesc_stream)))
 	    {
 	      /* Buffer is full.  Wait, accepting input;
 		 that may allow the program
 		 to finish doing output and read more.  */
 	      Faccept_process_output (Qnil, make_int (1), Qnil);
 	      old_sigpipe =
 		(SIGTYPE (*) (int)) signal (SIGPIPE, send_process_trap);
 	     XSTRING_DATA (p->name));
 #endif
 }
 Lstream_flush (XLSTREAM (p->outstream));
 UNGCPRO;
+Lstream_delete (XLSTREAM (lstream));
 }
 DEFUN ("process-tty-name", Fprocess_tty_name, 1, 1, 0, /*
 Return the name of the terminal PROCESS uses, or nil if none.
 This is the terminal that the process itself reads and writes on,
 	{
 	  /* Change the status of the process that was found.  */
 	  p->tick++;
 	  process_tick++;
 	  update_status_from_wait_code (p, &w);
 /* If process has terminated, stop waiting for its output.  */
 	  if (WIFSIGNALED (w) || WIFEXITED (w))
 	    {
 	      if (p->infd >= 0)
 		{
 	    }
 }
 }
 exited_processes_index = 0;
 EMACS_UNBLOCK_SIGNAL (SIGCHLD);
 }
 /* On receipt of a signal that a child status has changed,
 loop asking about children with changed statuses until
 while (sigchld_happened)
 {
 int pid;
 int w;
 /* Keep trying to get a status until we get a definitive result.  */
 do
 	{
 	  errno = 0;
 #ifdef WNOHANG
 #  ifndef WUNTRACED
 #    define WUNTRACED 0
 #else /* not WNOHANG */
 	  pid = wait (&w);
 #endif /* not WNOHANG */
 	}
 while (pid <= 0 && errno == EINTR);
 if (pid <= 0)
 	break;
 if (exited_processes_index < MAX_EXITED_PROCESSES)
 	{
 	  exited_processes[exited_processes_index] = pid;
 	  exited_processes_status[exited_processes_index] = w;
 	  exited_processes_index++;
 	}
 /* On systems with WNOHANG, we just ignore the number
 	 of times that SIGCHLD was signalled, and keep looping
 	 until there are no more processes to wait on.  If we
 	 don't have WNOHANG, we have to rely on the count in
 	 SIGCHLD_HAPPENED. */
 will be called again, resulting in an infinite loop.  The relevant
 portion of the documentation reads "SIGCLD signals will be queued
 and the signal-catching function will be continually reentered until
 the queue is empty".  Invoking signal() causes the kernel to reexamine
 the SIGCLD queue.   Fred Fish, UniSoft Systems Inc.
 (Note that now this only applies in SYS V Release 2 and before.
 On SYS V Release 3, we use sigset() to set the signal handler for
 the first time, and so we don't have to reestablish the signal handler
 in the handler below.  On SYS V Release 4, we don't get this weirdo
 behavior when we use sigaction(), which we do use.) */
 #endif /* SIGCHLD */
 /* Return a string describing a process status list.  */
 static Lisp_Object
 status_message (struct Lisp_Process *p)
 {
 Lisp_Object symbol = p->status_symbol;
 int code = p->exit_code;
 int coredump = p->core_dumped;
 	  msg = status_message (p);
 	  /* If process is terminated, deactivate it or delete it.  */
 	  symbol = p->status_symbol;
 	  if (EQ (symbol, Qsignal)
 || EQ (symbol, Qexit))
 	    {
 	      if (delete_exited_processes)
 		remove_process (proc);
 	      else
 return;
 }
 }
 #endif /* ! defined (SIGNALS_VIA_CHARACTERS) */
 #ifdef TIOCGPGRP
 /* Get the pgrp using the tty itself, if we have that.
 	 Otherwise, use the pty to get the pgrp.
 	 On pfa systems, saka@pfu.fujitsu.co.JP writes:
 	 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
 	 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
 	     case, p->pid is nil: p->pid is set at the same time that
 	     the process is selected for input. */
 #ifdef VMS
 	  {
 	    VMS_PROC_STUFF *get_vms_process_pointer (), *vs;
 	    if (outchannel >= 0)
 	      sys$dassgn (outchannel);
 	    vs = get_vms_process_pointer (XINT (p->pid));
 	    if (vs)
 	      give_back_vms_process_stuff (vs);
 	  }
 defsymbol (&Qprocessp, "processp");
 defsymbol (&Qrun, "run");
 defsymbol (&Qstop, "stop");
 defsymbol (&Qsignal, "signal");
 /* Qexit is already defined by syms_of_eval
 * defsymbol (&Qexit, "exit");
 */
 defsymbol (&Qopen, "open");
 defsymbol (&Qclosed, "closed");
 DEFSUBR (Fprocessp);

Mercurial > hg > xemacs-beta

comparison src/process.c @ 185:3d6bfa290dbd r20-3b19