ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/rtprocess.h
(Generate patch)

Comparing ray/src/common/rtprocess.h (file contents):
Revision 3.9 by schorsch, Fri Nov 14 17:22:06 2003 UTC vs.
Revision 3.25 by greg, Tue Oct 29 00:35:06 2024 UTC

# Line 8 | Line 8
8   #ifndef _RAD_PROCESS_H_
9   #define _RAD_PROCESS_H_
10  
11 < #include  <errno.h>
12 < #ifdef _WIN32
11 > #include <errno.h>
12 > #include "paths.h"
13 > #if defined(_WIN32) || defined(_WIN64)
14    #include <windows.h> /* DWORD etc. */
15 <  #include <stdio.h>
15 <  typedef DWORD pid_t;
15 >  typedef DWORD RT_PID;
16    #include <process.h> /* getpid() and others */
17 <  #define nice(inc) win_nice(inc)
18 <
19 <  #ifdef __cplusplus
20 <  extern "C" {
17 >  #define getpid _getpid
18 >  #define execv _execv
19 >  #define execvp _execvp
20 >  #ifdef _MSC_VER
21 >    #include <BaseTsd.h>
22 >    typedef SSIZE_T ssize_t;
23    #endif
22 –  extern FILE *win_popen(char *command, char *type);
23 –  extern int win_pclose(FILE *p);
24 –  #ifdef __cplusplus
25 –  }
26 –  #endif
27 –
28 –  #define popen(cmd,mode) win_popen(cmd,mode)
29 –  #define pclose(p) win_pclose(p)
24   #else
25 <  #include <stdio.h>
32 <  #include <sys/param.h>
25 >  typedef pid_t RT_PID;
26   #endif
27  
35 – #include "paths.h"
28  
29   #ifdef __cplusplus
30   extern "C" {
# Line 43 | Line 35 | extern "C" {
35  
36     This means that we shouldn't rely on PIDs and file descriptors
37     being the same type, so we have to describe processes with a struct,
38 <   instead of the original int[3]. To keep things simple, we typedef
39 <   the posix pid_t on those systems that don't have it already.
38 >   instead of the original int[3]. For that purpose, we typedef a
39 >   platform independent RT_PID.
40   */
41  
42 + /* On Unix, we can set flags and assign descriptors before opening a
43 +   process, coupling an existing input or output to the new process rather
44 +   than opening both pipes.  If PF_FILT_INP is passed in the flags member of
45 +   SUBPROC, then the given r stream will be attached to the standard input
46 +   of the child process, and subsequent reads from that descriptor in the
47 +   parent get data from the standard output of the child, instead.  The
48 +   returned w descriptor is set to -1, since there is no longer any way
49 +   to write to the input of the child.  The default r descriptor of 0 will
50 +   compel the child to act as a filter on the standard input of the parent.
51 +   Whatever r handle you specify, the child will filter its read operations.
52 +   Note that this should be called before anything has been buffered using r.
53 +   If PF_FILT_OUT is set in flags, then the given w stream will be
54 +   attached to the standard output of the child, and subsequent writes
55 +   to that descriptor in the parent send data to the standard input
56 +   of the child. The returned r descriptor is set to -1, since
57 +   there is no longer any output to read from the child.  The
58 +   default w descriptor of 1 will cause the child to act as a filter
59 +   on the output of the parent.  Make sure to call fflush(stdout) first
60 +   if any data was buffered.  It is illegal to set both PF_FILT_INP and
61 +   PF_FILT_OUT, as a circular process is guaranteed to hang.
62 +  
63 +   If you want behavior similar to popen(cmd, "w") (again Unix-only),
64 +   keeping stdout open in parent, use a duplicate descriptor like so:
65 +   {
66 +        SUBPROC rtp = sp_inactive;
67 +        FILE    *fout;
68 +        fflush(stdout);
69 +        rtp.w = dup(fileno(stdout));
70 +        rtp.flags |= PF_FILT_OUT;
71 +        if (open_process(&rtp, cmd_argv) <= 0) {
72 +                perror(cmd_argv[0]); exit(1);
73 +        }
74 +        fout = fdopen(rtp.w, "w");
75 +        ...write data to filter using fout until finished...
76 +        fclose(fout);
77 +        if (close_process(&rtp)) {
78 +                perror(cmd_argv[0]); exit(1);
79 +        }
80 +        ...can continue sending data directly to stdout...
81 +    }
82 +    We could also have called open_process() after fdopen() above, or after
83 +    using fopen() on a file if we wanted to insert our filter before it.
84 +    A similar sequence may be used to filter from stdin without closing
85 +    it, though process termination becomes more difficult with two readers.
86 +    Filtering input from a file works better, since the file is then read by
87 +    the child only, as in:
88 +    {
89 +        SUBPROC rtp = sp_inactive;
90 +        FILE    *fin = fopen(fname, "r");
91 +        if (fin == NULL) {
92 +                open_error(fname); exit(1);
93 +        }
94 +        rtp.r = fileno(fin);
95 +        rtp.flags |= PF_FILT_INP;
96 +        if (open_process(&rtp, cmd_argv) <= 0) {
97 +                perror(cmd_argv[0]); fclose(fin); exit(1);
98 +        }
99 +        ...read filtered file data from fin until EOF...
100 +        fclose(fin);
101 +        if (close_process(&rtp)) {
102 +                perror(cmd_argv[0]); exit(1);
103 +        }
104 +    }
105 + */
106  
107 +
108   #ifndef PIPE_BUF
109    #ifdef PIPSIZ
110      #define PIPE_BUF    PIPSIZ
# Line 59 | Line 116 | extern "C" {
116      #endif
117    #endif
118   #endif
119 +                                /* process flags */
120 + #define PF_RUNNING      1               /* process is running */
121 + #define PF_FILT_INP     2               /* use assigned read descriptor */
122 + #define PF_FILT_OUT     4               /* use assigned write descriptor */
123  
124   typedef struct {
125 <        int r; /* read handle */
126 <        int w; /* write handle */
127 <        int running; /* doing something */
128 <        pid_t pid; /* process ID */
125 >        int     flags;          /* what is being done */
126 >        int     r;              /* read handle */
127 >        int     w;              /* write handle */
128 >        RT_PID  pid;            /* process ID */
129   } SUBPROC;
130  
131 < #define SP_INACTIVE {-1,-1,0,0} /* for static initializations */
131 > #define SP_INACTIVE {0,0,1,-1}  /* for static initializations */
132  
133 + #define close_process(pd)       close_processes(pd,1)
134 +
135   extern int open_process(SUBPROC *pd, char *av[]);
136 < extern int close_process(SUBPROC *pd);
137 < extern int process(SUBPROC *pd, char *recvbuf, char *sendbuf, int nbr, int nbs);
138 < extern int readbuf(int fd, char *bpos, int siz);
139 < extern int writebuf(int fd, char *bpos, int siz);
136 > extern int close_processes(SUBPROC pd[], int nproc);
137 > extern int process(SUBPROC *pd, void *recvbuf, void *sendbuf, int nbr, int nbs);
138 > extern ssize_t readbuf(int fd, void *bpos, ssize_t siz);
139 > extern ssize_t writebuf(int fd, const void *bpos, ssize_t siz);
140  
141 < #ifdef _WIN32
141 > #if defined(_WIN32) || defined(_WIN64)
142   /* any non-negative increment will send the process to IDLE_PRIORITY_CLASS. */
143 + extern int win_kill(RT_PID pid, int sig /* ignored */);
144   extern int win_nice(int inc);
145   #endif
146  
147 + extern SUBPROC  sp_inactive;
148  
149   #ifdef __cplusplus
150   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines