[project @ 2002-09-06 14:34:15 by simonmar]
[packages/random.git] / include / HsBase.h
1 /* -----------------------------------------------------------------------------
2 * $Id: HsBase.h,v 1.13 2002/09/06 14:34:15 simonmar Exp $
3 *
4 * (c) The University of Glasgow 2001-2002
5 *
6 * Definitions for package `core' which are visible in Haskell land.
7 *
8 * ---------------------------------------------------------------------------*/
9
10 #ifndef HSCORE_H
11 #define HSCORE_H
12
13 #include "config.h"
14 #include "HsFFI.h"
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <math.h>
19
20 #ifdef HAVE_SYS_TYPES_H
21 #include <sys/types.h>
22 #endif
23 #ifdef HAVE_UNISTD_H
24 #include <unistd.h>
25 #endif
26 #ifdef HAVE_SYS_STAT_H
27 #include <sys/stat.h>
28 #endif
29 #ifdef HAVE_FCNTL_H
30 # include <fcntl.h>
31 #endif
32 #ifdef HAVE_TERMIOS_H
33 #include <termios.h>
34 #endif
35 #ifdef HAVE_SIGNAL_H
36 #include <signal.h>
37 #endif
38 #ifdef HAVE_ERRNO_H
39 #include <errno.h>
40 #endif
41 #ifdef HAVE_STRING_H
42 #include <string.h>
43 #endif
44 #ifdef HAVE_DIRENT_H
45 #include <dirent.h>
46 #endif
47 #ifdef HAVE_UTIME_H
48 #include <utime.h>
49 #endif
50 #if defined(HAVE_GETTIMEOFDAY)
51 # ifdef HAVE_SYS_TIME_H
52 # include <sys/time.h>
53 # endif
54 #elif defined(HAVE_GETCLOCK)
55 # ifdef HAVE_SYS_TIMERS_H
56 # define POSIX_4D9 1
57 # include <sys/timers.h>
58 # endif
59 #endif
60 #if defined(HAVE_TIME_H)
61 # include <time.h>
62 #endif
63 #ifdef HAVE_SYS_TIMEB_H
64 #include <sys/timeb.h>
65 #endif
66 #ifdef HAVE_WINDOWS_H
67 #include <windows.h>
68 #endif
69 #ifdef HAVE_SYS_TIMES_H
70 #include <sys/times.h>
71 #endif
72 #if defined(HAVE_WINSOCK_H) && defined(__MINGW32__)
73 #include <winsock.h>
74 #endif
75 #ifdef HAVE_LIMITS_H
76 #include <limits.h>
77 #endif
78
79 #if !defined(mingw32_TARGET_OS) && !defined(irix_TARGET_OS)
80 # if defined(HAVE_SYS_RESOURCE_H)
81 # include <sys/resource.h>
82 # endif
83 #endif
84
85 #ifdef hpux_TARGET_OS
86 #include <sys/syscall.h>
87 #define getrusage(a, b) syscall(SYS_GETRUSAGE, a, b)
88 #define HAVE_GETRUSAGE
89 #endif
90
91 /* For System */
92 #ifdef HAVE_SYS_WAIT_H
93 #include <sys/wait.h>
94 #endif
95 #ifdef HAVE_VFORK_H
96 #include <vfork.h>
97 #endif
98 #include "lockFile.h"
99 #include "dirUtils.h"
100 #include "errUtils.h"
101
102 #if defined(__MINGW32__)
103 #include <io.h>
104 #include <fcntl.h>
105 #include "timeUtils.h"
106 #endif
107
108 /* in ghc_errno.c */
109 int *ghcErrno(void);
110
111 /* in system.c */
112 HsInt systemCmd(HsAddr cmd);
113
114 /* in rawSystem.c */
115 HsInt rawSystemCmd(HsAddr cmd);
116
117 /* in inputReady.c */
118 int inputReady(int fd, int msecs, int isSock);
119
120 /* -----------------------------------------------------------------------------
121 64-bit operations, defined in longlong.c
122 -------------------------------------------------------------------------- */
123
124 #ifdef SUPPORT_LONG_LONGS
125
126 StgInt stg_gtWord64 (StgWord64, StgWord64);
127 StgInt stg_geWord64 (StgWord64, StgWord64);
128 StgInt stg_eqWord64 (StgWord64, StgWord64);
129 StgInt stg_neWord64 (StgWord64, StgWord64);
130 StgInt stg_ltWord64 (StgWord64, StgWord64);
131 StgInt stg_leWord64 (StgWord64, StgWord64);
132
133 StgInt stg_gtInt64 (StgInt64, StgInt64);
134 StgInt stg_geInt64 (StgInt64, StgInt64);
135 StgInt stg_eqInt64 (StgInt64, StgInt64);
136 StgInt stg_neInt64 (StgInt64, StgInt64);
137 StgInt stg_ltInt64 (StgInt64, StgInt64);
138 StgInt stg_leInt64 (StgInt64, StgInt64);
139
140 StgWord64 stg_remWord64 (StgWord64, StgWord64);
141 StgWord64 stg_quotWord64 (StgWord64, StgWord64);
142
143 StgInt64 stg_remInt64 (StgInt64, StgInt64);
144 StgInt64 stg_quotInt64 (StgInt64, StgInt64);
145 StgInt64 stg_negateInt64 (StgInt64);
146 StgInt64 stg_plusInt64 (StgInt64, StgInt64);
147 StgInt64 stg_minusInt64 (StgInt64, StgInt64);
148 StgInt64 stg_timesInt64 (StgInt64, StgInt64);
149
150 StgWord64 stg_and64 (StgWord64, StgWord64);
151 StgWord64 stg_or64 (StgWord64, StgWord64);
152 StgWord64 stg_xor64 (StgWord64, StgWord64);
153 StgWord64 stg_not64 (StgWord64);
154
155 StgWord64 stg_uncheckedShiftL64 (StgWord64, StgInt);
156 StgWord64 stg_uncheckedShiftRL64 (StgWord64, StgInt);
157 StgInt64 stg_uncheckedIShiftL64 (StgInt64, StgInt);
158 StgInt64 stg_uncheckedIShiftRL64 (StgInt64, StgInt);
159 StgInt64 stg_uncheckedIShiftRA64 (StgInt64, StgInt);
160
161 StgInt64 stg_intToInt64 (StgInt);
162 StgInt stg_int64ToInt (StgInt64);
163 StgWord64 stg_int64ToWord64 (StgInt64);
164
165 StgWord64 stg_wordToWord64 (StgWord);
166 StgWord stg_word64ToWord (StgWord64);
167 StgInt64 stg_word64ToInt64 (StgWord64);
168
169 StgInt64 stg_integerToInt64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da);
170 StgWord64 stg_integerToWord64 (StgInt sa, StgByteArray /* Really: mp_limb_t* */ da);
171
172 #endif /* SUPPORT_LONG_LONGS */
173
174 /* -----------------------------------------------------------------------------
175 INLINE functions.
176
177 These functions are given as inlines here for when compiling via C,
178 but we also generate static versions into the cbits library for
179 when compiling to native code.
180 -------------------------------------------------------------------------- */
181
182 #ifndef INLINE
183 #define INLINE extern inline
184 #endif
185
186 INLINE int __hscore_s_isreg(m) { return S_ISREG(m); }
187 INLINE int __hscore_s_isdir(m) { return S_ISDIR(m); }
188 INLINE int __hscore_s_isfifo(m) { return S_ISFIFO(m); }
189 INLINE int __hscore_s_isblk(m) { return S_ISBLK(m); }
190 INLINE int __hscore_s_ischr(m) { return S_ISCHR(m); }
191 #ifdef S_ISSOCK
192 INLINE int __hscore_s_issock(m) { return S_ISSOCK(m); }
193 #endif
194
195 #ifndef mingw32_TARGET_OS
196 INLINE int
197 __hscore_sigemptyset( sigset_t *set )
198 { return sigemptyset(set); }
199
200 INLINE int
201 __hscore_sigfillset( sigset_t *set )
202 { return sigfillset(set); }
203
204 INLINE int
205 __hscore_sigaddset( sigset_t * set, int s )
206 { return sigaddset(set,s); }
207
208 INLINE int
209 __hscore_sigdelset( sigset_t * set, int s )
210 { return sigdelset(set,s); }
211
212 INLINE int
213 __hscore_sigismember( sigset_t * set, int s )
214 { return sigismember(set,s); }
215 #endif
216
217 INLINE void *
218 __hscore_memcpy_dst_off( char *dst, int dst_off, char *src, size_t sz )
219 { return memcpy(dst+dst_off, src, sz); }
220
221 INLINE void *
222 __hscore_memcpy_src_off( char *dst, char *src, int src_off, size_t sz )
223 { return memcpy(dst, src+src_off, sz); }
224
225 INLINE HsBool
226 __hscore_supportsTextMode()
227 {
228 #if defined(mingw32_TARGET_OS)
229 return HS_BOOL_FALSE;
230 #else
231 return HS_BOOL_TRUE;
232 #endif
233 }
234
235 INLINE HsInt
236 __hscore_bufsiz()
237 {
238 return BUFSIZ;
239 }
240
241 INLINE HsInt
242 __hscore_seek_cur()
243 {
244 return SEEK_CUR;
245 }
246
247 INLINE HsInt
248 __hscore_o_binary()
249 {
250 #ifdef HAVE_O_BINARY
251 return O_BINARY;
252 #else
253 return 0;
254 #endif
255 }
256
257 INLINE int
258 __hscore_o_rdonly()
259 {
260 #ifdef O_RDONLY
261 return O_RDONLY;
262 #else
263 return 0;
264 #endif
265 }
266
267 INLINE int
268 __hscore_o_wronly( void )
269 {
270 #ifdef O_WRONLY
271 return O_WRONLY;
272 #else
273 return 0;
274 #endif
275 }
276
277 INLINE int
278 __hscore_o_rdwr( void )
279 {
280 #ifdef O_RDWR
281 return O_RDWR;
282 #else
283 return 0;
284 #endif
285 }
286
287 INLINE int
288 __hscore_o_append( void )
289 {
290 #ifdef O_APPEND
291 return O_APPEND;
292 #else
293 return 0;
294 #endif
295 }
296
297 INLINE int
298 __hscore_o_creat( void )
299 {
300 #ifdef O_CREAT
301 return O_CREAT;
302 #else
303 return 0;
304 #endif
305 }
306
307 INLINE int
308 __hscore_o_excl( void )
309 {
310 #ifdef O_EXCL
311 return O_EXCL;
312 #else
313 return 0;
314 #endif
315 }
316
317 INLINE int
318 __hscore_o_trunc( void )
319 {
320 #ifdef O_TRUNC
321 return O_TRUNC;
322 #else
323 return 0;
324 #endif
325 }
326
327 INLINE int
328 __hscore_o_noctty( void )
329 {
330 #ifdef O_NOCTTY
331 return O_NOCTTY;
332 #else
333 return 0;
334 #endif
335 }
336
337 INLINE int
338 __hscore_o_nonblock( void )
339 {
340 #ifdef O_NONBLOCK
341 return O_NONBLOCK;
342 #else
343 return 0;
344 #endif
345 }
346
347 INLINE HsInt
348 __hscore_seek_set( void )
349 {
350 return SEEK_SET;
351 }
352
353 INLINE HsInt
354 __hscore_seek_end( void )
355 {
356 return SEEK_END;
357 }
358
359 INLINE HsInt
360 __hscore_setmode( HsInt fd, HsBool toBin )
361 {
362 #if defined(__MINGW32__)
363 return setmode(fd,(toBin == HS_BOOL_TRUE) ? _O_BINARY : _O_TEXT);
364 #else
365 return 0;
366 #endif
367 }
368
369 INLINE HsInt
370 __hscore_PrelHandle_write( HsInt fd, HsBool isSock, HsAddr ptr,
371 HsInt off, int sz )
372 {
373 #if defined(__MINGW32__)
374 if (isSock) {
375 return send(fd,ptr + off, sz, 0);
376 }
377 #endif
378 return write(fd,ptr + off, sz);
379 }
380
381 INLINE HsInt
382 __hscore_PrelHandle_read( HsInt fd, HsBool isSock, HsAddr ptr,
383 HsInt off, int sz )
384 {
385 #if defined(__MINGW32__)
386 if (isSock) {
387 return recv(fd,ptr + off, sz, 0);
388 }
389 #endif
390 return read(fd,ptr + off, sz);
391
392 }
393
394 #if defined(__MINGW32__)
395 INLINE long *
396 __hscore_Time_ghcTimezone( void ) { return &_timezone; }
397
398 INLINE char **
399 __hscore_Time_ghcTzname( void ) { return _tzname; }
400 #endif
401
402 INLINE HsInt
403 __hscore_mkdir( HsAddr pathName, HsInt mode )
404 {
405 #if defined(__MINGW32__)
406 return mkdir(pathName);
407 #else
408 return mkdir(pathName,mode);
409 #endif
410 }
411
412 INLINE HsInt
413 __hscore_lstat( HsAddr fname, HsAddr st )
414 {
415 #ifdef HAVE_LSTAT
416 return lstat((const char*)fname, (struct stat*)st);
417 #else
418 return stat((const char*)fname, (struct stat*)st);
419 #endif
420 }
421
422 INLINE HsInt __hscore_path_max() { return PATH_MAX; }
423
424 INLINE mode_t __hscore_R_OK() { return R_OK; }
425 INLINE mode_t __hscore_W_OK() { return W_OK; }
426 INLINE mode_t __hscore_X_OK() { return X_OK; }
427
428 INLINE mode_t __hscore_S_IRUSR() { return S_IRUSR; }
429 INLINE mode_t __hscore_S_IWUSR() { return S_IWUSR; }
430 INLINE mode_t __hscore_S_IXUSR() { return S_IXUSR; }
431
432 INLINE HsAddr
433 __hscore_d_name( struct dirent* d )
434 {
435 #ifndef mingw32_TARGET_OS
436 return (HsAddr)(&d->d_name);
437 #else
438 return (HsAddr)(d->d_name);
439 #endif
440 }
441
442 INLINE HsInt
443 __hscore_end_of_dir( void )
444 {
445 #ifndef mingw32_TARGET_OS
446 return 0;
447 #else
448 return ENOENT;
449 #endif
450 }
451
452 INLINE void
453 __hscore_free_dirent(HsAddr dEnt)
454 {
455 #if HAVE_READDIR_R
456 free(dEnt);
457 #endif
458 }
459
460 INLINE HsInt
461 __hscore_sizeof_stat( void )
462 {
463 return sizeof(struct stat);
464 }
465
466 INLINE time_t __hscore_st_mtime ( struct stat* st ) { return st->st_mtime; }
467 INLINE off_t __hscore_st_size ( struct stat* st ) { return st->st_size; }
468 INLINE mode_t __hscore_st_mode ( struct stat* st ) { return st->st_mode; }
469
470 #if HAVE_TERMIOS_H
471 INLINE tcflag_t __hscore_lflag( struct termios* ts ) { return ts->c_lflag; }
472
473 INLINE void
474 __hscore_poke_lflag( struct termios* ts, tcflag_t t ) { ts->c_lflag = t; }
475
476 INLINE unsigned char*
477 __hscore_ptr_c_cc( struct termios* ts )
478 { return (unsigned char*) &ts->c_cc; }
479 #endif
480
481 INLINE HsInt
482 __hscore_sizeof_termios( void )
483 {
484 #ifndef mingw32_TARGET_OS
485 return sizeof(struct termios);
486 #else
487 return 0;
488 #endif
489 }
490
491 INLINE HsInt
492 __hscore_sizeof_sigset_t( void )
493 {
494 #ifndef mingw32_TARGET_OS
495 return sizeof(sigset_t);
496 #else
497 return 0;
498 #endif
499 }
500
501 INLINE int
502 __hscore_echo( void )
503 {
504 #ifdef ECHO
505 return ECHO;
506 #else
507 return 0;
508 #endif
509
510 }
511
512 INLINE int
513 __hscore_tcsanow( void )
514 {
515 #ifdef TCSANOW
516 return TCSANOW;
517 #else
518 return 0;
519 #endif
520
521 }
522
523 INLINE int
524 __hscore_icanon( void )
525 {
526 #ifdef ICANON
527 return ICANON;
528 #else
529 return 0;
530 #endif
531 }
532
533 INLINE int __hscore_vmin( void )
534 {
535 #ifdef VMIN
536 return VMIN;
537 #else
538 return 0;
539 #endif
540 }
541
542 INLINE int __hscore_vtime( void )
543 {
544 #ifdef VTIME
545 return VTIME;
546 #else
547 return 0;
548 #endif
549 }
550
551 INLINE int __hscore_sigttou( void )
552 {
553 #ifdef SIGTTOU
554 return SIGTTOU;
555 #else
556 return 0;
557 #endif
558 }
559
560 INLINE int __hscore_sig_block( void )
561 {
562 #ifdef SIG_BLOCK
563 return SIG_BLOCK;
564 #else
565 return 0;
566 #endif
567 }
568
569 INLINE int __hscore_sig_setmask( void )
570 {
571 #ifdef SIG_SETMASK
572 return SIG_SETMASK;
573 #else
574 return 0;
575 #endif
576 }
577
578 INLINE int
579 __hscore_f_getfl( void )
580 {
581 #ifdef F_GETFL
582 return F_GETFL;
583 #else
584 return 0;
585 #endif
586 }
587
588 INLINE int
589 __hscore_f_setfl( void )
590 {
591 #ifdef F_SETFL
592 return F_SETFL;
593 #else
594 return 0;
595 #endif
596 }
597
598 INLINE int __hscore_hs_fileno (FILE *f) { return fileno (f); }
599
600 #ifndef mingw32_TARGET_OS
601 INLINE int __hsposix_SIGABRT() { return SIGABRT; }
602 INLINE int __hsposix_SIGALRM() { return SIGALRM; }
603 INLINE int __hsposix_SIGBUS() { return SIGBUS; }
604 INLINE int __hsposix_SIGCHLD() { return SIGCHLD; }
605 INLINE int __hsposix_SIGCONT() { return SIGCONT; }
606 INLINE int __hsposix_SIGFPE() { return SIGFPE; }
607 INLINE int __hsposix_SIGHUP() { return SIGHUP; }
608 INLINE int __hsposix_SIGILL() { return SIGILL; }
609 INLINE int __hsposix_SIGINT() { return SIGINT; }
610 INLINE int __hsposix_SIGKILL() { return SIGKILL; }
611 INLINE int __hsposix_SIGPIPE() { return SIGPIPE; }
612 INLINE int __hsposix_SIGQUIT() { return SIGQUIT; }
613 INLINE int __hsposix_SIGSEGV() { return SIGSEGV; }
614 INLINE int __hsposix_SIGSTOP() { return SIGSTOP; }
615 INLINE int __hsposix_SIGTERM() { return SIGTERM; }
616 INLINE int __hsposix_SIGTSTP() { return SIGTSTP; }
617 INLINE int __hsposix_SIGTTIN() { return SIGTTIN; }
618 INLINE int __hsposix_SIGTTOU() { return SIGTTOU; }
619 INLINE int __hsposix_SIGUSR1() { return SIGUSR1; }
620 INLINE int __hsposix_SIGUSR2() { return SIGUSR2; }
621 INLINE int __hsposix_SIGPOLL() { return SIGPOLL; }
622 INLINE int __hsposix_SIGPROF() { return SIGPROF; }
623 INLINE int __hsposix_SIGSYS() { return SIGSYS; }
624 INLINE int __hsposix_SIGTRAP() { return SIGTRAP; }
625 INLINE int __hsposix_SIGURG() { return SIGURG; }
626 INLINE int __hsposix_SIGVTALRM() { return SIGVTALRM; }
627 INLINE int __hsposix_SIGXCPU() { return SIGXCPU; }
628 INLINE int __hsposix_SIGXFSZ() { return SIGXFSZ; }
629
630 INLINE int __hsposix_SIG_BLOCK() { return SIG_BLOCK; }
631 INLINE int __hsposix_SIG_UNBLOCK() { return SIG_SETMASK; }
632 INLINE int __hsposix_SIG_SETMASK() { return SIG_UNBLOCK; }
633 #endif // mingw32_TARGET_OS
634
635 #endif
636