]>
Commit | Line | Data |
---|---|---|
b4c522fa IB |
1 | /** |
2 | * D header file for POSIX. | |
3 | * | |
4 | * Copyright: Copyright Sean Kelly 2005 - 2016. | |
5 | * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). | |
6 | * Authors: Sean Kelly, Alex Rønne Petersen | |
7 | * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition | |
8 | */ | |
9 | module core.sys.posix.sys.select; | |
10 | ||
92dd3e71 | 11 | import core.sys.posix.config; |
b4c522fa IB |
12 | public import core.stdc.time; // for timespec |
13 | public import core.sys.posix.sys.time; // for timeval | |
14 | public import core.sys.posix.sys.types; // for time_t | |
15 | public import core.sys.posix.signal; // for sigset_t | |
16 | ||
17 | //debug=select; // uncomment to turn on debugging printf's | |
b4c522fa IB |
18 | |
19 | version (OSX) | |
20 | version = Darwin; | |
21 | else version (iOS) | |
22 | version = Darwin; | |
23 | else version (TVOS) | |
24 | version = Darwin; | |
25 | else version (WatchOS) | |
26 | version = Darwin; | |
27 | ||
28 | version (Posix): | |
29 | extern (C) nothrow @nogc: | |
30 | ||
31 | // | |
32 | // Required | |
33 | // | |
34 | /* | |
35 | NOTE: This module requires timeval from core.sys.posix.sys.time, but timeval | |
36 | is supposedly an XOpen extension. As a result, this header will not | |
37 | compile on platforms that are not XSI-compliant. This must be resolved | |
38 | on a per-platform basis. | |
39 | ||
40 | fd_set | |
41 | ||
42 | void FD_CLR(int fd, fd_set* fdset); | |
43 | int FD_ISSET(int fd, const(fd_set)* fdset); | |
44 | void FD_SET(int fd, fd_set* fdset); | |
45 | void FD_ZERO(fd_set* fdset); | |
46 | ||
47 | FD_SETSIZE | |
48 | ||
92dd3e71 | 49 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
50 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
51 | */ | |
52 | ||
53 | version (CRuntime_Glibc) | |
54 | { | |
55 | private | |
56 | { | |
57 | alias c_long __fd_mask; | |
58 | enum uint __NFDBITS = 8 * __fd_mask.sizeof; | |
59 | ||
60 | extern (D) auto __FDELT( int d ) pure | |
61 | { | |
62 | return d / __NFDBITS; | |
63 | } | |
64 | ||
65 | extern (D) auto __FDMASK( int d ) pure | |
66 | { | |
67 | return cast(__fd_mask) 1 << ( d % __NFDBITS ); | |
68 | } | |
69 | } | |
70 | ||
71 | enum FD_SETSIZE = 1024; | |
72 | ||
73 | struct fd_set | |
74 | { | |
75 | __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits; | |
76 | } | |
77 | ||
78 | extern (D) void FD_CLR( int fd, fd_set* fdset ) pure | |
79 | { | |
80 | fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd ); | |
81 | } | |
82 | ||
83 | extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure | |
84 | { | |
85 | return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0; | |
86 | } | |
87 | ||
88 | extern (D) void FD_SET( int fd, fd_set* fdset ) pure | |
89 | { | |
90 | fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd ); | |
91 | } | |
92 | ||
93 | extern (D) void FD_ZERO( fd_set* fdset ) pure | |
94 | { | |
95 | fdset.fds_bits[0 .. $] = 0; | |
96 | } | |
97 | ||
98 | /+ | |
99 | + GNU ASM Implementation | |
100 | + | |
101 | # define __FD_ZERO(fdsp) \ | |
102 | do { \ | |
103 | int __d0, __d1; \ | |
104 | __asm__ __volatile__ ("cld; rep; stosl" \ | |
105 | : "=c" (__d0), "=D" (__d1) \ | |
106 | : "a" (0), "0" (sizeof (fd_set) \ | |
107 | / sizeof (__fd_mask)), \ | |
108 | "1" (&__FDS_BITS (fdsp)[0]) \ | |
109 | : "memory"); \ | |
110 | } while (0) | |
111 | ||
112 | # define __FD_SET(fd, fdsp) \ | |
113 | __asm__ __volatile__ ("btsl %1,%0" \ | |
114 | : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \ | |
115 | : "r" (((int) (fd)) % __NFDBITS) \ | |
116 | : "cc","memory") | |
117 | # define __FD_CLR(fd, fdsp) \ | |
118 | __asm__ __volatile__ ("btrl %1,%0" \ | |
119 | : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \ | |
120 | : "r" (((int) (fd)) % __NFDBITS) \ | |
121 | : "cc","memory") | |
122 | # define __FD_ISSET(fd, fdsp) \ | |
123 | (__extension__ \ | |
124 | ({register char __result; \ | |
125 | __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" \ | |
126 | : "=q" (__result) \ | |
127 | : "r" (((int) (fd)) % __NFDBITS), \ | |
128 | "m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \ | |
129 | : "cc"); \ | |
130 | __result; })) | |
131 | +/ | |
132 | ||
92dd3e71 | 133 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
134 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
135 | } | |
136 | else version (Darwin) | |
137 | { | |
138 | private | |
139 | { | |
140 | enum uint __DARWIN_NBBY = 8; /* bits in a byte */ | |
141 | enum uint __DARWIN_NFDBITS = (int.sizeof * __DARWIN_NBBY); /* bits per mask */ | |
142 | } | |
143 | ||
144 | enum FD_SETSIZE = 1024; | |
145 | ||
146 | struct fd_set | |
147 | { | |
148 | int[(FD_SETSIZE + (__DARWIN_NFDBITS - 1)) / __DARWIN_NFDBITS] fds_bits; | |
149 | } | |
150 | ||
151 | extern (D) void FD_CLR( int fd, fd_set* fdset ) pure | |
152 | { | |
153 | fdset.fds_bits[fd / __DARWIN_NFDBITS] &= ~(1 << (fd % __DARWIN_NFDBITS)); | |
154 | } | |
155 | ||
156 | extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure | |
157 | { | |
158 | return (fdset.fds_bits[fd / __DARWIN_NFDBITS] & (1 << (fd % __DARWIN_NFDBITS))) != 0; | |
159 | } | |
160 | ||
161 | extern (D) void FD_SET( int fd, fd_set* fdset ) pure | |
162 | { | |
163 | fdset.fds_bits[fd / __DARWIN_NFDBITS] |= 1 << (fd % __DARWIN_NFDBITS); | |
164 | } | |
165 | ||
166 | extern (D) void FD_ZERO( fd_set* fdset ) pure | |
167 | { | |
168 | fdset.fds_bits[0 .. $] = 0; | |
169 | } | |
170 | ||
92dd3e71 | 171 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
172 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
173 | } | |
174 | else version (FreeBSD) | |
175 | { | |
176 | private | |
177 | { | |
178 | alias c_ulong __fd_mask; | |
179 | enum _NFDBITS = __fd_mask.sizeof * 8; | |
180 | } | |
181 | ||
182 | enum uint FD_SETSIZE = 1024; | |
183 | ||
184 | struct fd_set | |
185 | { | |
186 | __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; | |
187 | } | |
188 | ||
189 | extern (D) __fd_mask __fdset_mask(uint n) pure | |
190 | { | |
191 | return cast(__fd_mask) 1 << (n % _NFDBITS); | |
192 | } | |
193 | ||
194 | extern (D) void FD_CLR( int n, fd_set* p ) pure | |
195 | { | |
196 | p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); | |
197 | } | |
198 | ||
199 | extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure | |
200 | { | |
201 | return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; | |
202 | } | |
203 | ||
204 | extern (D) void FD_SET( int n, fd_set* p ) pure | |
205 | { | |
206 | p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); | |
207 | } | |
208 | ||
209 | extern (D) void FD_ZERO( fd_set* p ) pure | |
210 | { | |
211 | fd_set *_p; | |
212 | size_t _n; | |
213 | ||
214 | _p = p; | |
215 | _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS; | |
216 | while (_n > 0) | |
217 | _p.__fds_bits[--_n] = 0; | |
218 | } | |
219 | ||
92dd3e71 | 220 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
221 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
222 | } | |
223 | else version (NetBSD) | |
224 | { | |
225 | private | |
226 | { | |
227 | alias c_ulong __fd_mask; | |
228 | enum _NFDBITS = __fd_mask.sizeof * 8; | |
229 | } | |
230 | ||
231 | enum uint FD_SETSIZE = 256; | |
232 | ||
233 | struct fd_set | |
234 | { | |
235 | __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; | |
236 | } | |
237 | ||
238 | extern (D) __fd_mask __fdset_mask(uint n) pure | |
239 | { | |
240 | return cast(__fd_mask) 1 << (n % _NFDBITS); | |
241 | } | |
242 | ||
243 | extern (D) void FD_CLR( int n, fd_set* p ) pure | |
244 | { | |
245 | p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); | |
246 | } | |
247 | ||
248 | extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure | |
249 | { | |
250 | return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; | |
251 | } | |
252 | ||
253 | extern (D) void FD_SET( int n, fd_set* p ) pure | |
254 | { | |
255 | p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); | |
256 | } | |
257 | ||
258 | extern (D) void FD_ZERO( fd_set* p ) pure | |
259 | { | |
260 | fd_set *_p; | |
261 | size_t _n; | |
262 | ||
263 | _p = p; | |
264 | _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS; | |
265 | while (_n > 0) | |
266 | _p.__fds_bits[--_n] = 0; | |
267 | } | |
268 | ||
92dd3e71 | 269 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
270 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
271 | } | |
0234a917 IB |
272 | else version (OpenBSD) |
273 | { | |
274 | private | |
275 | { | |
276 | alias uint __fd_mask; | |
277 | enum _NFDBITS = __fd_mask.sizeof * 8; | |
278 | } | |
279 | ||
280 | enum uint FD_SETSIZE = 1024; | |
281 | ||
282 | struct fd_set | |
283 | { | |
284 | __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; | |
285 | } | |
286 | ||
287 | extern (D) __fd_mask __fdset_mask(uint n) pure | |
288 | { | |
289 | return cast(__fd_mask) 1 << (n % _NFDBITS); | |
290 | } | |
291 | ||
292 | extern (D) void FD_CLR(int n, fd_set* p) pure | |
293 | { | |
294 | p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); | |
295 | } | |
296 | ||
297 | extern (D) bool FD_ISSET(int n, const(fd_set)* p) pure | |
298 | { | |
299 | return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; | |
300 | } | |
301 | ||
302 | extern (D) void FD_SET(int n, fd_set* p) pure | |
303 | { | |
304 | p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); | |
305 | } | |
306 | ||
307 | extern (D) void FD_ZERO(fd_set* p) pure | |
308 | { | |
309 | fd_set *_p = p; | |
310 | size_t _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS; | |
311 | ||
312 | while (_n > 0) | |
313 | _p.__fds_bits[--_n] = 0; | |
314 | } | |
315 | ||
92dd3e71 | 316 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
0234a917 IB |
317 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
318 | } | |
b4c522fa IB |
319 | else version (DragonFlyBSD) |
320 | { | |
321 | private | |
322 | { | |
323 | alias c_ulong __fd_mask; | |
324 | enum _NFDBITS = __fd_mask.sizeof * 8; | |
325 | } | |
326 | ||
327 | enum uint FD_SETSIZE = 1024; | |
328 | ||
329 | struct fd_set | |
330 | { | |
331 | __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; | |
332 | } | |
333 | ||
334 | extern (D) __fd_mask __fdset_mask(uint n) pure | |
335 | { | |
336 | return cast(__fd_mask) 1 << (n % _NFDBITS); | |
337 | } | |
338 | ||
339 | extern (D) void FD_CLR( int n, fd_set* p ) pure | |
340 | { | |
341 | p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); | |
342 | } | |
343 | ||
344 | extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure | |
345 | { | |
346 | return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; | |
347 | } | |
348 | ||
349 | extern (D) void FD_SET( int n, fd_set* p ) pure | |
350 | { | |
351 | p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); | |
352 | } | |
353 | ||
354 | extern (D) void FD_ZERO( fd_set* p ) pure | |
355 | { | |
356 | fd_set *_p; | |
357 | size_t _n; | |
358 | ||
359 | _p = p; | |
360 | _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS; | |
361 | while (_n > 0) | |
362 | _p.__fds_bits[--_n] = 0; | |
363 | } | |
364 | ||
92dd3e71 | 365 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
366 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
367 | } | |
368 | else version (Solaris) | |
369 | { | |
370 | private | |
371 | { | |
372 | alias c_long fds_mask; | |
373 | ||
374 | enum _NBBY = 8; | |
375 | enum FD_NFDBITS = fds_mask.sizeof * _NBBY; | |
376 | } | |
377 | ||
378 | version (D_LP64) | |
379 | enum uint FD_SETSIZE = 65536; | |
380 | else | |
381 | enum uint FD_SETSIZE = 1024; | |
382 | ||
383 | struct fd_set | |
384 | { | |
385 | c_long[(FD_SETSIZE + (FD_NFDBITS - 1)) / FD_NFDBITS] fds_bits; | |
386 | } | |
387 | ||
388 | extern (D) void FD_SET(int __n, fd_set* __p) pure | |
389 | { | |
390 | __p.fds_bits[__n / FD_NFDBITS] |= 1UL << (__n % FD_NFDBITS); | |
391 | } | |
392 | ||
393 | extern (D) void FD_CLR(int __n, fd_set* __p) pure | |
394 | { | |
395 | __p.fds_bits[__n / FD_NFDBITS] &= ~(1UL << (__n % FD_NFDBITS)); | |
396 | } | |
397 | ||
398 | extern (D) bool FD_ISSET(int __n, const(fd_set)* __p) pure | |
399 | { | |
400 | return (__p.fds_bits[__n / FD_NFDBITS] & (1UL << (__n % FD_NFDBITS))) != 0; | |
401 | } | |
402 | ||
403 | extern (D) void FD_ZERO(fd_set* __p) pure | |
404 | { | |
405 | __p.fds_bits[0 .. $] = 0; | |
406 | } | |
407 | ||
408 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); | |
92dd3e71 | 409 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
410 | } |
411 | else version (CRuntime_Bionic) | |
412 | { | |
413 | private | |
414 | { | |
415 | alias c_ulong __fd_mask; | |
416 | enum uint __NFDBITS = 8 * __fd_mask.sizeof; | |
417 | ||
418 | extern (D) auto __FDELT( int d ) pure | |
419 | { | |
420 | return d / __NFDBITS; | |
421 | } | |
422 | ||
423 | extern (D) auto __FDMASK( int d ) pure | |
424 | { | |
425 | return cast(__fd_mask) 1 << ( d % __NFDBITS ); | |
426 | } | |
427 | } | |
428 | ||
429 | enum FD_SETSIZE = 1024; | |
430 | ||
431 | struct fd_set | |
432 | { | |
433 | __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits; | |
434 | } | |
435 | ||
436 | // These functions are generated in assembly in bionic. | |
437 | extern (D) void FD_CLR( int fd, fd_set* fdset ) pure | |
438 | { | |
439 | fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd ); | |
440 | } | |
441 | ||
442 | extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure | |
443 | { | |
444 | return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0; | |
445 | } | |
446 | ||
447 | extern (D) void FD_SET( int fd, fd_set* fdset ) pure | |
448 | { | |
449 | fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd ); | |
450 | } | |
451 | ||
452 | extern (D) void FD_ZERO( fd_set* fdset ) pure | |
453 | { | |
454 | fdset.fds_bits[0 .. $] = 0; | |
455 | } | |
456 | ||
92dd3e71 | 457 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
458 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
459 | } | |
460 | else version (CRuntime_Musl) | |
461 | { | |
462 | enum FD_SETSIZE = 1024; | |
463 | ||
464 | alias ulong fd_mask; | |
465 | ||
466 | private | |
467 | { | |
468 | enum uint __NFDBITS = 8 * fd_mask.sizeof; | |
469 | ||
470 | extern (D) auto __FDELT( int d ) pure | |
471 | { | |
472 | return d / __NFDBITS; | |
473 | } | |
474 | ||
475 | extern (D) auto __FDMASK( int d ) pure | |
476 | { | |
477 | return cast(fd_mask) 1 << ( d % __NFDBITS ); | |
478 | } | |
479 | } | |
480 | ||
481 | struct fd_set { | |
482 | ulong[FD_SETSIZE / 8 / long.sizeof] fds_bits; | |
483 | } | |
484 | ||
485 | extern (D) void FD_CLR( int fd, fd_set* fdset ) pure | |
486 | { | |
487 | fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd ); | |
488 | } | |
489 | ||
490 | extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure | |
491 | { | |
492 | return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0; | |
493 | } | |
494 | ||
495 | extern (D) void FD_SET( int fd, fd_set* fdset ) pure | |
496 | { | |
497 | fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd ); | |
498 | } | |
499 | ||
500 | extern (D) void FD_ZERO( fd_set* fdset ) pure | |
501 | { | |
502 | fdset.fds_bits[0 .. $] = 0; | |
503 | } | |
8da8c7d3 | 504 | pragma(mangle, muslRedirTime64Mangle!("pselect", "__pselect_time64")) |
92dd3e71 | 505 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
8da8c7d3 | 506 | pragma(mangle, muslRedirTime64Mangle!("select", "__select_time64")) |
b4c522fa IB |
507 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
508 | } | |
509 | else version (CRuntime_UClibc) | |
510 | { | |
511 | private | |
512 | { | |
513 | alias c_long __fd_mask; | |
514 | enum uint __NFDBITS = 8 * __fd_mask.sizeof; | |
515 | ||
516 | extern (D) auto __FDELT( int d ) pure | |
517 | { | |
518 | return d / __NFDBITS; | |
519 | } | |
520 | ||
521 | extern (D) auto __FDMASK( int d ) pure | |
522 | { | |
523 | return cast(__fd_mask) 1 << ( d % __NFDBITS ); | |
524 | } | |
525 | } | |
526 | ||
527 | enum FD_SETSIZE = 1024; | |
528 | ||
529 | struct fd_set | |
530 | { | |
531 | __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits; | |
532 | } | |
533 | ||
534 | extern (D) void FD_CLR( int fd, fd_set* fdset ) pure | |
535 | { | |
536 | fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd ); | |
537 | } | |
538 | ||
539 | extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure | |
540 | { | |
541 | return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0; | |
542 | } | |
543 | ||
544 | extern (D) void FD_SET( int fd, fd_set* fdset ) pure | |
545 | { | |
546 | fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd ); | |
547 | } | |
548 | ||
549 | extern (D) void FD_ZERO( fd_set* fdset ) pure | |
550 | { | |
551 | fdset.fds_bits[0 .. $] = 0; | |
552 | } | |
553 | ||
92dd3e71 | 554 | int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*); |
b4c522fa IB |
555 | int select(int, fd_set*, fd_set*, fd_set*, timeval*); |
556 | } | |
557 | else | |
558 | { | |
559 | static assert(false, "Unsupported platform"); | |
560 | } | |
561 | ||
562 | pure unittest | |
563 | { | |
6dffa67b IB |
564 | import core.stdc.stdio: printf; |
565 | ||
b4c522fa IB |
566 | debug(select) printf("core.sys.posix.sys.select unittest\n"); |
567 | ||
568 | fd_set fd; | |
569 | ||
570 | for (auto i = 0; i < FD_SETSIZE; i++) | |
571 | { | |
572 | assert(!FD_ISSET(i, &fd)); | |
573 | } | |
574 | ||
575 | for (auto i = 0; i < FD_SETSIZE; i++) | |
576 | { | |
577 | if ((i & -i) == i) | |
578 | FD_SET(i, &fd); | |
579 | } | |
580 | ||
581 | for (auto i = 0; i < FD_SETSIZE; i++) | |
582 | { | |
583 | if ((i & -i) == i) | |
584 | assert(FD_ISSET(i, &fd)); | |
585 | else | |
586 | assert(!FD_ISSET(i, &fd)); | |
587 | } | |
588 | ||
589 | for (auto i = 0; i < FD_SETSIZE; i++) | |
590 | { | |
591 | if ((i & -i) == i) | |
592 | FD_CLR(i, &fd); | |
593 | else | |
594 | FD_SET(i, &fd); | |
595 | } | |
596 | ||
597 | for (auto i = 0; i < FD_SETSIZE; i++) | |
598 | { | |
599 | if ((i & -i) == i) | |
600 | assert(!FD_ISSET(i, &fd)); | |
601 | else | |
602 | assert(FD_ISSET(i, &fd)); | |
603 | } | |
604 | ||
605 | FD_ZERO(&fd); | |
606 | ||
607 | for (auto i = 0; i < FD_SETSIZE; i++) | |
608 | { | |
609 | assert(!FD_ISSET(i, &fd)); | |
610 | } | |
611 | } |