"Pause, without updating display, for ARG seconds.\n\
Optional second arg non-nil means ARG is measured in milliseconds.\n\
\(Not all operating systems support milliseconds.)")
- (n, millisec)
- Lisp_Object n, millisec;
+ (arg, millisec)
+ Lisp_Object arg, millisec;
{
int usec = 0;
int sec;
- CHECK_NUMBER (n, 0);
- sec = XINT (n);
+ CHECK_NUMBER (arg, 0);
+ sec = XINT (arg);
if (sec <= 0)
return Qnil;
#endif
}
- wait_reading_process_input (sec, usec, 0, 0);
+ {
+ Lisp_Object zero;
+
+ XFASTINT (zero) = 0;
+ wait_reading_process_input (sec, usec, zero, 0);
+ }
#if 0 /* No wait_reading_process_input */
immediate_quit = 1;
return Qnil;
}
-DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
- "Perform redisplay, then wait for ARG seconds or until input is available.\n\
-Optional second arg non-nil means ARG counts in milliseconds.\n\
-Optional third arg non-nil means don't redisplay, just wait for input.\n\
-Redisplay is preempted as always if input arrives, and does not happen\n\
-if input is available before it starts.\n\
-Value is t if waited the full time with no input arriving.")
- (n, millisec, nodisp)
- Lisp_Object n, millisec, nodisp;
-{
- int usec = 0;
- int sec;
+/* This is just like wait_reading_process_input, except that
+ it does the redisplay.
+
+ It's also just like Fsit_for, except that it can be used for
+ waiting for input as well. */
- CHECK_NUMBER (n, 0);
+Lisp_Object
+sit_for (sec, usec, reading, display)
+ int sec, usec, reading, display;
+{
+ Lisp_Object read_kbd;
if (detect_input_pending ())
return Qnil;
-
- if (EQ (nodisp, Qnil))
- redisplay_preserve_echo_area ();
-
- sec = XINT (n);
- if (sec <= 0)
- return Qt;
- if (!NILP (millisec))
- {
-#ifndef EMACS_HAS_USECS
- error ("millisecond sleep-for not supported on %s", SYSTEM_TYPE);
-#else
- usec = sec % 1000 * 1000;
- sec /= 1000;
-#endif
- }
+ if (display)
+ redisplay_preserve_echo_area ();
#ifdef SIGIO
gobble_input ();
-#endif /* SIGIO */
- wait_reading_process_input (sec, usec, 1, 1);
+#endif
+
+ XSET (read_kbd, Lisp_Int, reading ? -1 : 1);
+ wait_reading_process_input (sec, usec, read_kbd, display);
+
#if 0 /* No wait_reading_process_input available. */
immediate_quit = 1;
waitchannels = 1;
#ifdef VMS
- input_wait_timeout (XINT (n));
+ input_wait_timeout (XINT (arg));
#else /* not VMS */
#ifndef HAVE_TIMEVAL
timeout_sec = sec;
return detect_input_pending () ? Qnil : Qt;
}
+DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
+ "Perform redisplay, then wait for ARG seconds or until input is available.\n\
+Optional second arg non-nil means ARG counts in milliseconds.\n\
+Optional third arg non-nil means don't redisplay, just wait for input.\n\
+Redisplay is preempted as always if input arrives, and does not happen\n\
+if input is available before it starts.\n\
+Value is t if waited the full time with no input arriving.")
+ (arg, millisec, nodisp)
+ Lisp_Object arg, millisec, nodisp;
+{
+ int usec = 0;
+ int sec = 0;
+
+ CHECK_NUMBER (arg, 0);
+
+ sec = XINT (arg);
+ if (sec <= 0)
+ return Qt;
+
+ if (!NILP (millisec))
+ {
+#ifndef EMACS_HAS_USECS
+ error ("millisecond sit-for not supported on %s", SYSTEM_TYPE);
+#else
+ usec = (sec % 1000) * 1000;
+ sec /= 1000;
+#endif
+ }
+
+ return sit_for (sec, usec, 0, NILP (nodisp));
+}
+
DEFUN ("sleep-for-millisecs", Fsleep_for_millisecs, Ssleep_for_millisecs,
1, 1, 0,
"Pause, without updating display, for ARG milliseconds.")
- (n)
- Lisp_Object n;
+ (arg)
+ Lisp_Object arg;
{
+ Lisp_Object zero;
+
#ifndef EMACS_HAS_USECS
error ("sleep-for-millisecs not supported on %s", SYSTEM_TYPE);
#else
- CHECK_NUMBER (n, 0);
- wait_reading_process_input (XINT (n) / 1000, XINT (n) % 1000 * 1000,
- 0, 0);
+ CHECK_NUMBER (arg, 0);
+
+ XFASTINT (zero) = 0;
+ wait_reading_process_input (XINT (arg) / 1000, XINT (arg) % 1000 * 1000,
+ zero, 0);
return Qnil;
#endif /* EMACS_HAS_USECS */
}
}
/* Save outer setjmp data, in case called recursively. */
- bcopy (getcjmp, save_jump, sizeof getcjmp);
+ save_getcjmp (save_jump);
stop_polling ();
XSET (Vlast_event_screen, Lisp_Screen, selected_screen);
#endif
- clear_waiting_for_input ();
-
goto non_reread;
}
{
Lisp_Object tem0;
- tem0 = Fsit_for (make_number (echo_keystrokes), Qnil, Qt);
+ tem0 = sit_for (echo_keystrokes, 0, 1, 1);
if (EQ (tem0, Qt))
echo ();
}
{
Lisp_Object tem0;
int delay = delay_level * XFASTINT (Vauto_save_timeout) / 4;
- tem0 = Fsit_for (make_number (delay), Qnil, Qt);
+ tem0 = sit_for (delay, 0, 1, 1);
if (EQ (tem0, Qt))
{
jmp_buf temp;
non_reread:
- bcopy (save_jump, getcjmp, sizeof getcjmp);
+ restore_getcjmp (save_jump);
start_polling ();
#endif /* SIGIO */
if (EVENT_QUEUES_EMPTY)
{
- wait_reading_process_input (0, 0, -1, 1);
+ Lisp_Object minus_one;
+
+ XSET (minus_one, Lisp_Int, -1);
+ wait_reading_process_input (0, 0, minus_one, 1);
if (!interrupt_input && EVENT_QUEUES_EMPTY)
{
quit_error_check ();
sigfree ();
/* Prevent another signal from doing this before we finish. */
- waiting_for_input = 0;
+ clear_waiting_for_input ();
input_pending = 0;
#if 0
seconds = 0;
}
+ if (NILP (proc))
+ XFASTINT (proc) = 0;
+
return
- (wait_reading_process_input (seconds, useconds,
- (NILP (proc)
- ? XPROCESS (get_process (proc)) : 0), 0)
+ (wait_reading_process_input (seconds, useconds, proc, 0)
? Qt : Qnil);
}
zero for no limit, or
-1 means gobble data immediately available but don't wait for any.
- read_kbd is:
+ read_kbd is a lisp value:
0 to ignore keyboard input, or
1 to return when input is available, or
-1 means caller will actually read the input, so don't throw to
the quit handler, or
- a pointer to a struct Lisp_Process, meaning wait until something
- arrives from that process. The return value is true iff we read
- some input from that process.
+ a process object, meaning wait until something arrives from that
+ process. The return value is true iff we read some input from
+ that process.
do_display != 0 means redisplay should be done to show subprocess
output that arrives.
Otherwise, return true iff we recieved input from any process. */
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
- int time_limit, microsecs, read_kbd, do_display;
+ int time_limit, microsecs;
+ Lisp_Object read_kbd;
+ int do_display;
{
register int channel, nfds, m;
static SELECT_TYPE Available;
FD_ZERO (&Available);
- /* Detect when read_kbd is really the address of a Lisp_Process. */
- if (read_kbd > 10 || read_kbd < -1)
+ /* If read_kbd is a process to watch, set wait_proc and wait_channel
+ accordingly. */
+ if (XTYPE (read_kbd) == Lisp_Process)
{
- wait_proc = (struct Lisp_Process *) read_kbd;
+ wait_proc = XPROCESS (read_kbd);
wait_channel = XFASTINT (wait_proc->infd);
- read_kbd = 0;
+ XFASTINT (read_kbd) = 0;
}
- waiting_for_user_input_p = read_kbd;
+ waiting_for_user_input_p = XINT (read_kbd);
/* Since we may need to wait several times,
compute the absolute time to return at. */
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
Otherwise, do pending quit if requested. */
- if (read_kbd >= 0)
+ if (XINT (read_kbd) >= 0)
QUIT;
/* If status of something has changed, and no input is available,
/* Cause C-g and alarm signals to take immediate action,
and cause input available signals to zero out timeout */
- if (read_kbd < 0)
+ if (XINT (read_kbd) < 0)
set_waiting_for_input (&timeout);
/* Wait till there is something to do */
Available = input_wait_mask;
- if (!read_kbd)
+ if (! XINT (read_kbd))
FD_CLR (0, &Available);
/* If screen size has changed or the window is newly mapped,
if (screen_garbaged)
redisplay_preserve_echo_area ();
- if (read_kbd && detect_input_pending ())
+ if (XINT (read_kbd) && detect_input_pending ())
nfds = 0;
else
nfds = select (MAXDESC, &Available, 0, 0, &timeout);
/* If there is any, return immediately
to give it higher priority than subprocesses */
- if (read_kbd && detect_input_pending ())
+ if (XINT (read_kbd) && detect_input_pending ())
break;
#ifdef SIGIO
but select says there is input. */
/*
- if (read_kbd && interrupt_input && (Available & fileno (stdin)))
+ if (XINT (read_kbd) && interrupt_input && (Available & fileno (stdin)))
*/
- if (read_kbd && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
+ if (XINT (read_kbd) && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
kill (0, SIGIO);
#endif
/* If checking input just got us a size-change event from X,
obey it now if we should. */
- if (read_kbd)
+ if (XINT (read_kbd))
do_pending_window_change ();
/* Check for data from a process or a command channel */
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
Otherwise, do pending quit if requested. */
- if (read_kbd >= 0)
+ if (XINT (read_kbd) >= 0)
{
/* Prevent input_pending from remaining set if we quit. */
clear_input_pending ();
/* Allow input from processes between bursts of sending.
Otherwise things may get stopped up. */
if (len > 0)
- wait_reading_process_input (-1, 0, 0, 0);
+ {
+ Lisp_Object zero;
+
+ XFASTINT (zero) = 0;
+ wait_reading_process_input (-1, 0, zero, 0);
+ }
}
#endif
else
zero for no limit, or
-1 means gobble data immediately available but don't wait for any.
- read_kbd is:
+ read_kbd is a Lisp_Object:
0 to ignore keyboard input, or
1 to return when input is available, or
-1 means caller will actually read the input, so don't throw to
do_display != 0 means redisplay should be done to show subprocess
output that arrives. This version of the function ignores it.
- If read_kbd is a pointer to a struct Lisp_Process, then the
- function returns true iff we received input from that process
- before the timeout elapsed.
- Otherwise, return true iff we recieved input from any process. */
+ Return true iff we recieved input from any process. */
int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
- int time_limit, microsecs, read_kbd, do_display;
+ int time_limit, microsecs;
+ Lisp_Object read_kbd;
+ int do_display;
{
EMACS_TIME end_time, timeout, *timeout_p;
int waitchannels;
{
int nfds;
- waitchannels = read_kbd ? 1 : 0;
+ waitchannels = XINT (read_kbd) ? 1 : 0;
/* If calling from keyboard input, do not quit
since we want to return C-g as an input character.
Otherwise, do pending quit if requested. */
- if (read_kbd >= 0)
+ if (XINT (read_kbd) >= 0)
QUIT;
if (timeout_p)
/* Cause C-g and alarm signals to take immediate action,
and cause input available signals to zero out timeout. */
- if (read_kbd < 0)
+ if (XINT (read_kbd) < 0)
set_waiting_for_input (&timeout);
/* If a screen has been newly mapped and needs updating,
if (screen_garbaged)
redisplay_preserve_echo_area ();
- if (read_kbd && detect_input_pending ())
+ if (XINT (read_kbd) && detect_input_pending ())
nfds = 0;
else
nfds = select (1, &waitchannels, 0, 0, timeout_p);
/* System sometimes fails to deliver SIGIO. */
kill (getpid (), SIGIO);
#endif
- if (read_kbd && interrupt_input && (waitchannels & 1))
+ if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
kill (0, SIGIO);
/* If we have timed out (nfds == 0) or found some input (nfds > 0),