comparison src/process.c @ 21514:fa9ff387d260

Fix -Wimplicit warnings.

21513:984881b316fc

#include "termhooks.h"
#include "termopts.h"
#include "commands.h"
#include "frame.h"
#include "blockinput.h"

#define max(a, b) ((a) > (b) ? (a) : (b))

Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed;

/* Compute the Lisp form of the process status, p->status, from
   the numeric status that was returned by `wait'.  */

Lisp_Object status_convert ();

update_status (p)
     struct Lisp_Process *p;
{
  union { int i; WAITTYPE wt; } u;
  u.i = XFASTINT (p->raw_status_low) + (XFASTINT (p->raw_status_high) << 16);

int
allocate_pty ()
{
  struct stat stb;
  register c, i;
  int fd;

  /* Some systems name their pseudoterminals so that there are gaps in
     the usual sequence - for example, on HP9000/S700 systems, there
     are no pseudoterminals with names ending in 'f'.  So we wait for

  XSETPROCESS (val, p);
  Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
  return val;
}

remove_process (proc)
     register Lisp_Object proc;
{
  register Lisp_Object pair;

   For that purpose, this must be 0
   when not inside wait_reading_process_input.  */
static int waiting_for_user_input_p;

/* This is here so breakpoints can be put on it.  */
static
wait_reading_process_input_1 ()
{
}

/* Read and dispose of subprocess output while waiting for timeout to

   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 received input from any process.  */

wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs;
     Lisp_Object read_kbd;
     int do_display;
{

   you must call it repeatedly until it returns zero.

   The characters read are decoded according to PROC's coding-system
   for decoding.  */

read_process_output (proc, channel)
     Lisp_Object proc;
     register int channel;
{
  register int nchars, nbytes;

   is sent.  But if the data ends at the middle of multi-byte
   representation, that incomplete sequence of bytes are sent without
   being encoded.  Should we store them in a buffer to prepend them to
   the data send later?  */

send_process (proc, buf, len, object)
     volatile Lisp_Object proc;
     unsigned char *buf;
     int len;
     Lisp_Object object;

      return 1;

  return 0;
}

init_process ()
{
  register int i;

#ifdef SIGCHLD

    }
  bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
  bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
}

syms_of_process ()
{
  Qprocessp = intern ("processp");
  staticpro (&Qprocessp);
  Qrun = intern ("run");

21514:fa9ff387d260

#include "termhooks.h"
#include "termopts.h"
#include "commands.h"
#include "frame.h"
#include "blockinput.h"
#include "keyboard.h"
#include "dispextern.h"

#define max(a, b) ((a) > (b) ? (a) : (b))

Lisp_Object Qprocessp;
Lisp_Object Qrun, Qstop, Qsignal, Qopen, Qclosed;

/* Compute the Lisp form of the process status, p->status, from
   the numeric status that was returned by `wait'.  */

Lisp_Object status_convert ();

void
update_status (p)
     struct Lisp_Process *p;
{
  union { int i; WAITTYPE wt; } u;
  u.i = XFASTINT (p->raw_status_low) + (XFASTINT (p->raw_status_high) << 16);

int
allocate_pty ()
{
  struct stat stb;
  register int c, i;
  int fd;

  /* Some systems name their pseudoterminals so that there are gaps in
     the usual sequence - for example, on HP9000/S700 systems, there
     are no pseudoterminals with names ending in 'f'.  So we wait for

  XSETPROCESS (val, p);
  Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
  return val;
}

void
remove_process (proc)
     register Lisp_Object proc;
{
  register Lisp_Object pair;

   For that purpose, this must be 0
   when not inside wait_reading_process_input.  */
static int waiting_for_user_input_p;

/* This is here so breakpoints can be put on it.  */
static void
wait_reading_process_input_1 ()
{
}

/* Read and dispose of subprocess output while waiting for timeout to

   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 received input from any process.  */

int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs;
     Lisp_Object read_kbd;
     int do_display;
{

   you must call it repeatedly until it returns zero.

   The characters read are decoded according to PROC's coding-system
   for decoding.  */

int
read_process_output (proc, channel)
     Lisp_Object proc;
     register int channel;
{
  register int nchars, nbytes;

   is sent.  But if the data ends at the middle of multi-byte
   representation, that incomplete sequence of bytes are sent without
   being encoded.  Should we store them in a buffer to prepend them to
   the data send later?  */

void
send_process (proc, buf, len, object)
     volatile Lisp_Object proc;
     unsigned char *buf;
     int len;
     Lisp_Object object;

      return 1;

  return 0;
}

void
init_process ()
{
  register int i;

#ifdef SIGCHLD

    }
  bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
  bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
}

void
syms_of_process ()
{
  Qprocessp = intern ("processp");
  staticpro (&Qprocessp);
  Qrun = intern ("run");