emacs: src/process.c comparison

comparison src/process.c @ 57840:8abbe69dfdb2

(connect_wait_mask, num_pending_connects): Only declare and use them if NON_BLOCKING_CONNECT is defined. (IF_NON_BLOCKING_CONNECT): New helper macro. (wait_reading_process_output): Only declare and use local vars Connecting and check_connect when NON_BLOCKING_CONNECT is defined. (init_process): Initialize them if NON_BLOCKING_CONNECT defined.

author	Kim F. Storm <storm@cua.dk>
date	Mon, 01 Nov 2004 11:04:11 +0000
parents	d27beaf1c61c
children	4ebc52bf6429 7a0245dd1848 e24e2e78deda

comparison

equal deleted inserted replaced

-:75b388c4e9e1
+:8abbe69dfdb2
 /* Mask that excludes process input descriptor (s).  */
 static SELECT_TYPE non_process_wait_mask;
+#ifdef NON_BLOCKING_CONNECT
 /* Mask of bits indicating the descriptors that we wait for connect to
 complete on.  Once they complete, they are removed from this mask
 and added to the input_wait_mask and non_keyboard_wait_mask.  */
 static SELECT_TYPE connect_wait_mask;
 /* Number of bits set in connect_wait_mask.  */
 static int num_pending_connects;
+#define IF_NON_BLOCKING_CONNECT(s) s
+#else
+#define IF_NON_BLOCKING_CONNECT(s)
+#endif
 /* The largest descriptor currently in use for a process object.  */
 static int max_process_desc;
 /* The largest descriptor currently in use for keyboard input.  */
 	}
 #endif
 chan_process[inchannel] = Qnil;
 FD_CLR (inchannel, &input_wait_mask);
 FD_CLR (inchannel, &non_keyboard_wait_mask);
+#ifdef NON_BLOCKING_CONNECT
 if (FD_ISSET (inchannel, &connect_wait_mask))
 	{
 	  FD_CLR (inchannel, &connect_wait_mask);
 	  if (--num_pending_connects < 0)
 	    abort ();
 	}
+#endif
 if (inchannel == max_process_desc)
 	{
 	  int i;
 	  /* We just closed the highest-numbered process input descriptor,
 	     so recompute the highest-numbered one now.  */
 struct Lisp_Process *wait_proc;
 int just_wait_proc;
 {
 register int channel, nfds;
 SELECT_TYPE Available;
+#ifdef NON_BLOCKING_CONNECT
 SELECT_TYPE Connecting;
-int check_connect, check_delay, no_avail;
+int check_connect;
+#endif
+int check_delay, no_avail;
 int xerrno;
 Lisp_Object proc;
 EMACS_TIME timeout, end_time;
 int wait_channel = -1;
 int got_some_input = 0;
 /* Either nil or a cons cell, the car of which is of interest and
 may be changed outside of this routine.  */
 int saved_waiting_for_user_input_p = waiting_for_user_input_p;
 FD_ZERO (&Available);
+#ifdef NON_BLOCKING_CONNECT
 FD_ZERO (&Connecting);
+#endif
 /* If wait_proc is a process to watch, set wait_channel accordingly.  */
 if (wait_proc != NULL)
 wait_channel = XINT (wait_proc->infd);
 	 available, notify the user of the change right away.  After
 	 this explicit check, we'll let the SIGCHLD handler zap
 	 timeout to get our attention.  */
 if (update_tick != process_tick && do_display)
 	{
-	  SELECT_TYPE Atemp, Ctemp;
+	  SELECT_TYPE Atemp;
+#ifdef NON_BLOCKING_CONNECT
+	  SELECT_TYPE Ctemp;
+#endif
 	  Atemp = input_wait_mask;
 #if 0
 /* On Mac OS X 10.0, the SELECT system call always says input is
 present (for reading) at stdin, even when none is.  This
 status_notify not to be called.  As a result output of
 subprocesses are incorrectly discarded.
 	  */
 FD_CLR (0, &Atemp);
 #endif
-	  Ctemp = connect_wait_mask;
+	  IF_NON_BLOCKING_CONNECT (Ctemp = connect_wait_mask);
 	  EMACS_SET_SECS_USECS (timeout, 0, 0);
 	  if ((select (max (max_process_desc, max_keyboard_desc) + 1,
 		       &Atemp,
+#ifdef NON_BLOCKING_CONNECT
 		       (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0),
+#else
+		       (SELECT_TYPE *)0,
+#endif
 		       (SELECT_TYPE *)0, &timeout)
 	       <= 0))
 	    {
 	      /* It's okay for us to do this and then continue with
 		 the loop, since timeout has already been zeroed out.  */
 if (wait_proc && just_wait_proc)
 	{
 	  if (XINT (wait_proc->infd) < 0)  /* Terminated */
 	    break;
 	  FD_SET (XINT (wait_proc->infd), &Available);
-	  check_connect = check_delay = 0;
+	  check_delay = 0;
+	  IF_NON_BLOCKING_CONNECT (check_connect = 0);
 	}
 else if (!NILP (wait_for_cell))
 	{
 	  Available = non_process_wait_mask;
-	  check_connect = check_delay = 0;
+	  check_delay = 0;
+	  IF_NON_BLOCKING_CONNECT (check_connect = 0);
 	}
 else
 	{
 	  if (! read_kbd)
 	    Available = non_keyboard_wait_mask;
 	  else
 	    Available = input_wait_mask;
-	  check_connect = (num_pending_connects > 0);
+	  IF_NON_BLOCKING_CONNECT (check_connect = (num_pending_connects > 0));
 	  check_delay = wait_channel >= 0 ? 0 : process_output_delay_count;
 	}
 /* If frame size has changed or the window is newly mapped,
 	 redisplay now, before we start to wait.  There is a race
 	  nfds = 0;
 	  no_avail = 1;
 	}
 else
 	{
+#ifdef NON_BLOCKING_CONNECT
 	  if (check_connect)
 	    Connecting = connect_wait_mask;
+#endif
 #ifdef ADAPTIVE_READ_BUFFERING
 	  if (process_output_skip && check_delay > 0)
 	    {
 	      int usecs = EMACS_USECS (timeout);
 	    }
 #endif
 	  nfds = select (max (max_process_desc, max_keyboard_desc) + 1,
 			 &Available,
+#ifdef NON_BLOCKING_CONNECT
 			 (check_connect ? &Connecting : (SELECT_TYPE *)0),
+#else
+			 (SELECT_TYPE *)0,
+#endif
 			 (SELECT_TYPE *)0, &timeout);
 	}
 xerrno = errno;
 	}
 if (no_avail)
 	{
 	  FD_ZERO (&Available);
-	  check_connect = 0;
+	  IF_NON_BLOCKING_CONNECT (check_connect = 0);
 	}
 #if defined(sun) && !defined(USG5_4)
 if (nfds > 0 && keyboard_bit_set (&Available)
 	  && interrupt_input)
 FD_ZERO (&input_wait_mask);
 FD_ZERO (&non_keyboard_wait_mask);
 FD_ZERO (&non_process_wait_mask);
 max_process_desc = 0;
+#ifdef NON_BLOCKING_CONNECT
+FD_ZERO (&connect_wait_mask);
+num_pending_connects = 0;
+#endif
 #ifdef ADAPTIVE_READ_BUFFERING
 process_output_delay_count = 0;
 process_output_skip = 0;
 #endif

Mercurial > emacs

comparison src/process.c @ 57840:8abbe69dfdb2