URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [expect/] [exp_select.c] - Blame information for rev 1778

Go to most recent revision | Details | Compare with Previous | View Log


/* exp_select.c - select() interface for Expect
 
Written by: Don Libes, NIST, 2/6/90
 
Design and implementation of this program was paid for by U.S. tax
dollars.  Therefore it is public domain.  However, the author and NIST
would appreciate credit if this program or parts of it are used.
 
*/
 
/* suppress file-empty warnings produced by some compilers */
void exp_unused() {}
 
#if 0 /* WHOLE FILE!!!! */
#include "expect_cf.h"
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
 
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
 
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
 
#ifdef HAVE_SYSSELECT_H
#  include <sys/select.h>       /* Intel needs this for timeval */
#endif
 
#ifdef HAVE_PTYTRAP
#  include <sys/ptyio.h>
#endif
 
#ifdef HAVE_UNISTD_H
#  include <unistd.h>
#endif
 
#ifdef _AIX
/* AIX has some unusual definition of FD_SET */
#include <sys/select.h>
#endif
 
#if !defined( FD_SET )  &&  defined( HAVE_SYS_BSDTYPES_H )
    /* like AIX, ISC has it's own definition of FD_SET */
#   include <sys/bsdtypes.h>
#endif /*  ! FD_SET  &&  HAVE_SYS_BSDTYPES_H */
 
#include "tcl.h"
#include "exp_prog.h"
#include "exp_command.h"        /* for struct exp_f defs */
#include "exp_event.h"
 
#ifdef HAVE_SYSCONF_H
#include <sys/sysconfig.h>
#endif
 
#ifndef FD_SET
#define FD_SET(fd,fdset)        (fdset)->fds_bits[0] |= (1<<(fd))
#define FD_CLR(fd,fdset)        (fdset)->fds_bits[0] &= ~(1<<(fd))
#define FD_ZERO(fdset)          (fdset)->fds_bits[0] = 0
#define FD_ISSET(fd,fdset)      (((fdset)->fds_bits[0]) & (1<<(fd)))
#ifndef AUX2
typedef struct fd_set {
        long fds_bits[1];
        /* any implementation so pathetic as to not define FD_SET will just */
        /* have to suffer with only 32 bits worth of fds */
} fd_set;
#endif /* AUX2 */
#endif
 
static struct timeval zerotime = {0, 0};
static struct timeval anytime = {0, 0};   /* can be changed by user */
 
/* returns status, one of EOF, TIMEOUT, ERROR or DATA */
int
exp_get_next_event(interp,masters, n,master_out,timeout,key)
Tcl_Interp *interp;
int *masters;
int n;                  /* # of masters */
int *master_out;        /* 1st event master, not set if none */
int timeout;            /* seconds */
int key;
{
        static rr = 0;   /* round robin ptr */
 
        int i;  /* index into in-array */
        struct timeval *t;
 
        fd_set rdrs;
        fd_set excep;
/* FIXME: This is really gross, but the folks at Lynx said their select is
 *        way hosed and to ignore all exceptions.
 */
#ifdef __Lynx__
#define EXCEP 0
#else
#define EXCEP &excep
#endif
 
        for (i=0;i<n;i++) {
                struct exp_f *f;
                int m;
 
                rr++;
                if (rr >= n) rr = 0;
 
                m = masters[rr];
                f = exp_fs + m;
 
                if (f->key != key) {
                        f->key = key;
                        f->force_read = FALSE;
                        *master_out = m;
                        return(EXP_DATA_OLD);
                } else if ((!f->force_read) && (f->size != 0)) {
                        *master_out = m;
                        return(EXP_DATA_OLD);
                }
        }
 
        if (timeout >= 0) {
                t = &anytime;
                t->tv_sec = timeout;
        } else {
                t = NULL;
        }
 
 restart:
        if (Tcl_AsyncReady()) {
                int rc = Tcl_AsyncInvoke(interp,TCL_OK);
                if (rc != TCL_OK) return(exp_tcl2_returnvalue(rc));
 
                /* anything in the environment could have changed */
                return EXP_RECONFIGURE;
        }
 
        FD_ZERO(&rdrs);
        FD_ZERO(&excep);
        for (i = 0;i < n;i++) {
                FD_SET(masters[i],&rdrs);
                FD_SET(masters[i],&excep);
        }
 
        /* The reason all fd masks are (seemingly) redundantly cast to */
        /* SELECT_MASK_TYPE is that the HP defines its mask in terms of */
        /* of int * and yet defines FD_SET in terms of fd_set. */
 
        if (-1 == select(exp_fd_max+1,
                        (SELECT_MASK_TYPE *)&rdrs,
                        (SELECT_MASK_TYPE *)0,
                        (SELECT_MASK_TYPE *)EXCEP,
                        t)) {
                /* window refreshes trigger EINTR, ignore */
                if (errno == EINTR) goto restart;
                else if (errno == EBADF) {
                    /* someone is rotten */
                    for (i=0;i<n;i++) {
                        fd_set suspect;
                        FD_ZERO(&suspect);
                        FD_SET(masters[i],&suspect);
                        if (-1 == select(exp_fd_max+1,
                                        (SELECT_MASK_TYPE *)&suspect,
                                        (SELECT_MASK_TYPE *)0,
                                        (SELECT_MASK_TYPE *)0,
                                        &zerotime)) {
                                exp_error(interp,"invalid spawn_id (%d)\r",masters[i]);
                                return(EXP_TCLERROR);
                        }
                   }
                } else {
                        /* not prepared to handle anything else */
                        exp_error(interp,"select: %s\r",Tcl_PosixError(interp));
                        return(EXP_TCLERROR);
                }
        }
 
        for (i=0;i<n;i++) {
                rr++;
                if (rr >= n) rr = 0;     /* ">" catches previous readys that */
                                /* used more fds then we're using now */
 
                if (FD_ISSET(masters[rr],&rdrs)) {
                        *master_out = masters[rr];
                        return(EXP_DATA_NEW);
/*#ifdef HAVE_PTYTRAP*/
                } else if (FD_ISSET(masters[rr], &excep)) {
#ifndef HAVE_PTYTRAP
                        *master_out = masters[rr];
                        return(EXP_EOF);
#else
                        struct request_info ioctl_info;
                        if (ioctl(masters[rr],TIOCREQCHECK,&ioctl_info) < 0) {
                                exp_debuglog("ioctl error on TIOCREQCHECK: %s",Tcl_ErrnoMsg(errno));
                                break;
                        }
                        if (ioctl_info.request == TIOCCLOSE) {
                                /* eof */
                                *master_out = masters[rr];
                                return(EXP_EOF);
                        }
                        if (ioctl(masters[rr], TIOCREQSET, &ioctl_info) < 0)
                                exp_debuglog("ioctl error on TIOCREQSET after ioctl or open on slave: %s", Tcl_ErrnoMsg(errno));
                        /* presumably, we trapped an open here */
                        goto restart;
#endif /* HAVE_PTYTRAP */
                }
        }
        return(EXP_TIMEOUT);
}
 
/*ARGSUSED*/
int
exp_get_next_event_info(interp,fd,ready_mask)
Tcl_Interp *interp;
int fd;
int ready_mask;
{
        /* this function is only used when running with Tk */
        /* hence, it is merely a stub in this file but to */
        /* pacify lint, return something */
        return 0;
}
 
int     /* returns TCL_XXX */
exp_dsleep(interp,sec)
Tcl_Interp *interp;
double sec;
{
        struct timeval t;
 
        t.tv_sec = sec;
        t.tv_usec = (sec - t.tv_sec) * 1000000L;
 restart:
        if (Tcl_AsyncReady()) {
                int rc = Tcl_AsyncInvoke(interp,TCL_OK);
                if (rc != TCL_OK) return rc;
        }
        if (-1 == select(1,
                        (SELECT_MASK_TYPE *)0,
                        (SELECT_MASK_TYPE *)0,
                        (SELECT_MASK_TYPE *)0,
                        &t)
                                && errno == EINTR)
                goto restart;
        return TCL_OK;
}
 
#if 0
int     /* returns TCL_XXX */
exp_usleep(interp,usec)
Tcl_Interp *interp;
long usec;              /* microseconds */
{
        struct timeval t;
 
        t.tv_sec = usec/1000000L;
        t.tv_usec = usec%1000000L;
 restart:
        if (Tcl_AsyncReady()) {
                int rc = Tcl_AsyncInvoke(interp,TCL_OK);
                if (rc != TCL_OK) return(exp_tcl2_returnvalue(rc));
        }
        if (-1 == select(1,
                        (SELECT_MASK_TYPE *)0,
                        (SELECT_MASK_TYPE *)0,
                        (SELECT_MASK_TYPE *)0,
                        &t)
                                && errno == EINTR)
                goto restart;
        return TCL_OK;
}
#endif /*0*/
 
/* set things up for later calls to event handler */
void
exp_init_event()
{
#if 0
#ifdef _SC_OPEN_MAX
        maxfds = sysconf(_SC_OPEN_MAX);
#else
        maxfds = getdtablesize();
#endif
#endif
 
        exp_event_exit = 0;
}
#endif /* WHOLE FILE !!!! */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [expect/] [exp_select.c] - Blame information for rev 1778

Line No.	Rev	Author	Line
1	578	markom	`/* exp_select.c - select() interface for Expect`
2
3			`Written by: Don Libes, NIST, 2/6/90`
4
5			`Design and implementation of this program was paid for by U.S. tax`
6			`dollars. Therefore it is public domain. However, the author and NIST`
7			`would appreciate credit if this program or parts of it are used.`
8
9			`*/`
10
11			`/* suppress file-empty warnings produced by some compilers */`
12			`void exp_unused() {}`
13
14			`#if 0 /* WHOLE FILE!!!! */`
15			`#include "expect_cf.h"`
16			`#include <stdio.h>`
17			`#include <errno.h>`
18			`#include <sys/types.h>`
19
20			`#ifdef HAVE_SYS_WAIT_H`
21			`#include <sys/wait.h>`
22			`#endif`
23
24			`#ifdef HAVE_SYS_TIME_H`
25			`#include <sys/time.h>`
26			`#endif`
27
28			`#ifdef HAVE_SYSSELECT_H`
29			`# include <sys/select.h> /* Intel needs this for timeval */`
30			`#endif`
31
32			`#ifdef HAVE_PTYTRAP`
33			`# include <sys/ptyio.h>`
34			`#endif`
35
36			`#ifdef HAVE_UNISTD_H`
37			`# include <unistd.h>`
38			`#endif`
39
40			`#ifdef _AIX`
41			`/* AIX has some unusual definition of FD_SET */`
42			`#include <sys/select.h>`
43			`#endif`
44
45			`#if !defined( FD_SET ) && defined( HAVE_SYS_BSDTYPES_H )`
46			`/* like AIX, ISC has it's own definition of FD_SET */`
47			`# include <sys/bsdtypes.h>`
48			`#endif /* ! FD_SET && HAVE_SYS_BSDTYPES_H */`
49
50			`#include "tcl.h"`
51			`#include "exp_prog.h"`
52			`#include "exp_command.h" /* for struct exp_f defs */`
53			`#include "exp_event.h"`
54
55			`#ifdef HAVE_SYSCONF_H`
56			`#include <sys/sysconfig.h>`
57			`#endif`
58
59			`#ifndef FD_SET`
60			`#define FD_SET(fd,fdset) (fdset)->fds_bits[0] \|= (1<<(fd))`
61			`#define FD_CLR(fd,fdset) (fdset)->fds_bits[0] &= ~(1<<(fd))`
62			`#define FD_ZERO(fdset) (fdset)->fds_bits[0] = 0`
63			`#define FD_ISSET(fd,fdset) (((fdset)->fds_bits[0]) & (1<<(fd)))`
64			`#ifndef AUX2`
65			`typedef struct fd_set {`
66			`long fds_bits[1];`
67			`/* any implementation so pathetic as to not define FD_SET will just */`
68			`/* have to suffer with only 32 bits worth of fds */`
69			`} fd_set;`
70			`#endif /* AUX2 */`
71			`#endif`
72
73			`static struct timeval zerotime = {0, 0};`
74			`static struct timeval anytime = {0, 0}; /* can be changed by user */`
75
76			`/* returns status, one of EOF, TIMEOUT, ERROR or DATA */`
77			`int`
78			`exp_get_next_event(interp,masters, n,master_out,timeout,key)`
79			`Tcl_Interp *interp;`
80			`int *masters;`
81			`int n; /* # of masters */`
82			`int master_out; / 1st event master, not set if none */`
83			`int timeout; /* seconds */`
84			`int key;`
85			`{`
86			`static rr = 0; /* round robin ptr */`
87
88			`int i; /* index into in-array */`
89			`struct timeval *t;`
90
91			`fd_set rdrs;`
92			`fd_set excep;`
93			`/* FIXME: This is really gross, but the folks at Lynx said their select is`
94			`* way hosed and to ignore all exceptions.`
95			`*/`
96			`#ifdef __Lynx__`
97			`#define EXCEP 0`
98			`#else`
99			`#define EXCEP &excep`
100			`#endif`
101
102			`for (i=0;i<n;i++) {`
103			`struct exp_f *f;`
104			`int m;`
105
106			`rr++;`
107			`if (rr >= n) rr = 0;`
108
109			`m = masters[rr];`
110			`f = exp_fs + m;`
111
112			`if (f->key != key) {`
113			`f->key = key;`
114			`f->force_read = FALSE;`
115			`*master_out = m;`
116			`return(EXP_DATA_OLD);`
117			`} else if ((!f->force_read) && (f->size != 0)) {`
118			`*master_out = m;`
119			`return(EXP_DATA_OLD);`
120			`}`
121			`}`
122
123			`if (timeout >= 0) {`
124			`t = &anytime;`
125			`t->tv_sec = timeout;`
126			`} else {`
127			`t = NULL;`
128			`}`
129
130			`restart:`
131			`if (Tcl_AsyncReady()) {`
132			`int rc = Tcl_AsyncInvoke(interp,TCL_OK);`
133			`if (rc != TCL_OK) return(exp_tcl2_returnvalue(rc));`
134
135			`/* anything in the environment could have changed */`
136			`return EXP_RECONFIGURE;`
137			`}`
138
139			`FD_ZERO(&rdrs);`
140			`FD_ZERO(&excep);`
141			`for (i = 0;i < n;i++) {`
142			`FD_SET(masters[i],&rdrs);`
143			`FD_SET(masters[i],&excep);`
144			`}`
145
146			`/* The reason all fd masks are (seemingly) redundantly cast to */`
147			`/* SELECT_MASK_TYPE is that the HP defines its mask in terms of */`
148			`/* of int * and yet defines FD_SET in terms of fd_set. */`
149
150			`if (-1 == select(exp_fd_max+1,`
151			`(SELECT_MASK_TYPE *)&rdrs,`
152			`(SELECT_MASK_TYPE *)0,`
153			`(SELECT_MASK_TYPE *)EXCEP,`
154			`t)) {`
155			`/* window refreshes trigger EINTR, ignore */`
156			`if (errno == EINTR) goto restart;`
157			`else if (errno == EBADF) {`
158			`/* someone is rotten */`
159			`for (i=0;i<n;i++) {`
160			`fd_set suspect;`
161			`FD_ZERO(&suspect);`
162			`FD_SET(masters[i],&suspect);`
163			`if (-1 == select(exp_fd_max+1,`
164			`(SELECT_MASK_TYPE *)&suspect,`
165			`(SELECT_MASK_TYPE *)0,`
166			`(SELECT_MASK_TYPE *)0,`
167			`&zerotime)) {`
168			`exp_error(interp,"invalid spawn_id (%d)\r",masters[i]);`
169			`return(EXP_TCLERROR);`
170			`}`
171			`}`
172			`} else {`
173			`/* not prepared to handle anything else */`
174			`exp_error(interp,"select: %s\r",Tcl_PosixError(interp));`
175			`return(EXP_TCLERROR);`
176			`}`
177			`}`
178
179			`for (i=0;i<n;i++) {`
180			`rr++;`
181			`if (rr >= n) rr = 0; /* ">" catches previous readys that */`
182			`/* used more fds then we're using now */`
183
184			`if (FD_ISSET(masters[rr],&rdrs)) {`
185			`*master_out = masters[rr];`
186			`return(EXP_DATA_NEW);`
187			`/#ifdef HAVE_PTYTRAP/`
188			`} else if (FD_ISSET(masters[rr], &excep)) {`
189			`#ifndef HAVE_PTYTRAP`
190			`*master_out = masters[rr];`
191			`return(EXP_EOF);`
192			`#else`
193			`struct request_info ioctl_info;`
194			`if (ioctl(masters[rr],TIOCREQCHECK,&ioctl_info) < 0) {`
195			`exp_debuglog("ioctl error on TIOCREQCHECK: %s",Tcl_ErrnoMsg(errno));`
196			`break;`
197			`}`
198			`if (ioctl_info.request == TIOCCLOSE) {`
199			`/* eof */`
200			`*master_out = masters[rr];`
201			`return(EXP_EOF);`
202			`}`
203			`if (ioctl(masters[rr], TIOCREQSET, &ioctl_info) < 0)`
204			`exp_debuglog("ioctl error on TIOCREQSET after ioctl or open on slave: %s", Tcl_ErrnoMsg(errno));`
205			`/* presumably, we trapped an open here */`
206			`goto restart;`
207			`#endif /* HAVE_PTYTRAP */`
208			`}`
209			`}`
210			`return(EXP_TIMEOUT);`
211			`}`
212
213			`/ARGSUSED/`
214			`int`
215			`exp_get_next_event_info(interp,fd,ready_mask)`
216			`Tcl_Interp *interp;`
217			`int fd;`
218			`int ready_mask;`
219			`{`
220			`/* this function is only used when running with Tk */`
221			`/* hence, it is merely a stub in this file but to */`
222			`/* pacify lint, return something */`
223			`return 0;`
224			`}`
225
226			`int /* returns TCL_XXX */`
227			`exp_dsleep(interp,sec)`
228			`Tcl_Interp *interp;`
229			`double sec;`
230			`{`
231			`struct timeval t;`
232
233			`t.tv_sec = sec;`
234			`t.tv_usec = (sec - t.tv_sec) * 1000000L;`
235			`restart:`
236			`if (Tcl_AsyncReady()) {`
237			`int rc = Tcl_AsyncInvoke(interp,TCL_OK);`
238			`if (rc != TCL_OK) return rc;`
239			`}`
240			`if (-1 == select(1,`
241			`(SELECT_MASK_TYPE *)0,`
242			`(SELECT_MASK_TYPE *)0,`
243			`(SELECT_MASK_TYPE *)0,`
244			`&t)`
245			`&& errno == EINTR)`
246			`goto restart;`
247			`return TCL_OK;`
248			`}`
249
250			`#if 0`
251			`int /* returns TCL_XXX */`
252			`exp_usleep(interp,usec)`
253			`Tcl_Interp *interp;`
254			`long usec; /* microseconds */`
255			`{`
256			`struct timeval t;`
257
258			`t.tv_sec = usec/1000000L;`
259			`t.tv_usec = usec%1000000L;`
260			`restart:`
261			`if (Tcl_AsyncReady()) {`
262			`int rc = Tcl_AsyncInvoke(interp,TCL_OK);`
263			`if (rc != TCL_OK) return(exp_tcl2_returnvalue(rc));`
264			`}`
265			`if (-1 == select(1,`
266			`(SELECT_MASK_TYPE *)0,`
267			`(SELECT_MASK_TYPE *)0,`
268			`(SELECT_MASK_TYPE *)0,`
269			`&t)`
270			`&& errno == EINTR)`
271			`goto restart;`
272			`return TCL_OK;`
273			`}`
274			`#endif /0/`
275
276			`/* set things up for later calls to event handler */`
277			`void`
278			`exp_init_event()`
279			`{`
280			`#if 0`
281			`#ifdef _SC_OPEN_MAX`
282			`maxfds = sysconf(_SC_OPEN_MAX);`
283			`#else`
284			`maxfds = getdtablesize();`
285			`#endif`
286			`#endif`
287
288			`exp_event_exit = 0;`
289			`}`
290			`#endif /* WHOLE FILE !!!! */`