d2c26daf7df2412997d7d2b59837f2875c005af4
[packages/base.git] / include / HsBase.h
1 /* -----------------------------------------------------------------------------
2 *
3 * (c) The University of Glasgow 2001-2004
4 *
5 * Definitions for package `base' which are visible in Haskell land.
6 *
7 * ---------------------------------------------------------------------------*/
8
9 #ifndef __HSBASE_H__
10 #define __HSBASE_H__
11
12 #ifdef __NHC__
13 # include "Nhc98BaseConfig.h"
14 #else
15 #include "HsBaseConfig.h"
16 #endif
17
18 /* ultra-evil... */
19 #undef PACKAGE_BUGREPORT
20 #undef PACKAGE_NAME
21 #undef PACKAGE_STRING
22 #undef PACKAGE_TARNAME
23 #undef PACKAGE_VERSION
24
25 /* Needed to get the macro version of errno on some OSs (eg. Solaris).
26 We must do this, because these libs are only compiled once, but
27 must work in both single-threaded and multi-threaded programs. */
28 #define _REENTRANT 1
29
30 #include "HsFFI.h"
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <math.h>
35
36 #if HAVE_SYS_TYPES_H
37 #include <sys/types.h>
38 #endif
39 #if HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
42 #if HAVE_SYS_STAT_H
43 #include <sys/stat.h>
44 #endif
45 #if HAVE_FCNTL_H
46 # include <fcntl.h>
47 #endif
48 #if HAVE_TERMIOS_H
49 #include <termios.h>
50 #endif
51 #if HAVE_SIGNAL_H
52 #include <signal.h>
53 /* Ultra-ugly: OpenBSD uses broken macros for sigemptyset and sigfillset (missing casts) */
54 #if __OpenBSD__
55 #undef sigemptyset
56 #undef sigfillset
57 #endif
58 #endif
59 #if HAVE_ERRNO_H
60 #include <errno.h>
61 #endif
62 #if HAVE_STRING_H
63 #include <string.h>
64 #endif
65 #if HAVE_DIRENT_H
66 #include <dirent.h>
67 #endif
68 #if HAVE_UTIME_H
69 #include <utime.h>
70 #endif
71 #if HAVE_SYS_UTSNAME_H
72 #include <sys/utsname.h>
73 #endif
74 #if HAVE_GETTIMEOFDAY
75 # if HAVE_SYS_TIME_H
76 # include <sys/time.h>
77 # endif
78 #elif HAVE_GETCLOCK
79 # if HAVE_SYS_TIMERS_H
80 # define POSIX_4D9 1
81 # include <sys/timers.h>
82 # endif
83 #endif
84 #if HAVE_TIME_H
85 #include <time.h>
86 #endif
87 #if HAVE_SYS_TIMEB_H
88 #include <sys/timeb.h>
89 #endif
90 #if HAVE_WINDOWS_H
91 #include <windows.h>
92 #endif
93 #if HAVE_SYS_TIMES_H
94 #include <sys/times.h>
95 #endif
96 #if HAVE_WINSOCK_H && defined(__MINGW32__)
97 #include <winsock.h>
98 #endif
99 #if HAVE_LIMITS_H
100 #include <limits.h>
101 #endif
102 #if HAVE_WCTYPE_H
103 #include <wctype.h>
104 #endif
105 #if HAVE_INTTYPES_H
106 # include <inttypes.h>
107 #elif HAVE_STDINT_H
108 # include <stdint.h>
109 #endif
110
111 #if !defined(__MINGW32__) && !defined(irix_HOST_OS)
112 # if HAVE_SYS_RESOURCE_H
113 # include <sys/resource.h>
114 # endif
115 #endif
116
117 #if !HAVE_GETRUSAGE && HAVE_SYS_SYSCALL_H
118 # include <sys/syscall.h>
119 # if defined(SYS_GETRUSAGE) /* hpux_HOST_OS */
120 # define getrusage(a, b) syscall(SYS_GETRUSAGE, a, b)
121 # define HAVE_GETRUSAGE 1
122 # endif
123 #endif
124
125 /* For System */
126 #if HAVE_SYS_WAIT_H
127 #include <sys/wait.h>
128 #endif
129 #if HAVE_VFORK_H
130 #include <vfork.h>
131 #endif
132 #include "dirUtils.h"
133 #include "WCsubst.h"
134
135 #if defined(__MINGW32__)
136 /* in Win32Utils.c */
137 extern void maperrno (void);
138 extern HsWord64 getUSecOfDay(void);
139 #endif
140
141 #if defined(__MINGW32__)
142 #include <io.h>
143 #include <fcntl.h>
144 #include <shlobj.h>
145 #include <share.h>
146 #endif
147
148 #if HAVE_SYS_SELECT_H
149 #include <sys/select.h>
150 #endif
151
152 /* in inputReady.c */
153 extern int fdReady(int fd, int write, int msecs, int isSock);
154
155 /* in Signals.c */
156 extern HsInt nocldstop;
157
158 /* -----------------------------------------------------------------------------
159 64-bit operations, defined in longlong.c
160 -------------------------------------------------------------------------- */
161
162 #ifdef SUPPORT_LONG_LONGS
163
164 HsBool hs_gtWord64 (HsWord64, HsWord64);
165 HsBool hs_geWord64 (HsWord64, HsWord64);
166 HsBool hs_eqWord64 (HsWord64, HsWord64);
167 HsBool hs_neWord64 (HsWord64, HsWord64);
168 HsBool hs_ltWord64 (HsWord64, HsWord64);
169 HsBool hs_leWord64 (HsWord64, HsWord64);
170
171 HsBool hs_gtInt64 (HsInt64, HsInt64);
172 HsBool hs_geInt64 (HsInt64, HsInt64);
173 HsBool hs_eqInt64 (HsInt64, HsInt64);
174 HsBool hs_neInt64 (HsInt64, HsInt64);
175 HsBool hs_ltInt64 (HsInt64, HsInt64);
176 HsBool hs_leInt64 (HsInt64, HsInt64);
177
178 HsWord64 hs_remWord64 (HsWord64, HsWord64);
179 HsWord64 hs_quotWord64 (HsWord64, HsWord64);
180
181 HsInt64 hs_remInt64 (HsInt64, HsInt64);
182 HsInt64 hs_quotInt64 (HsInt64, HsInt64);
183 HsInt64 hs_negateInt64 (HsInt64);
184 HsInt64 hs_plusInt64 (HsInt64, HsInt64);
185 HsInt64 hs_minusInt64 (HsInt64, HsInt64);
186 HsInt64 hs_timesInt64 (HsInt64, HsInt64);
187
188 HsWord64 hs_and64 (HsWord64, HsWord64);
189 HsWord64 hs_or64 (HsWord64, HsWord64);
190 HsWord64 hs_xor64 (HsWord64, HsWord64);
191 HsWord64 hs_not64 (HsWord64);
192
193 HsWord64 hs_uncheckedShiftL64 (HsWord64, HsInt);
194 HsWord64 hs_uncheckedShiftRL64 (HsWord64, HsInt);
195 HsInt64 hs_uncheckedIShiftL64 (HsInt64, HsInt);
196 HsInt64 hs_uncheckedIShiftRA64 (HsInt64, HsInt);
197 HsInt64 hs_uncheckedIShiftRL64 (HsInt64, HsInt);
198
199 HsInt64 hs_intToInt64 (HsInt);
200 HsInt hs_int64ToInt (HsInt64);
201 HsWord64 hs_int64ToWord64 (HsInt64);
202 HsWord64 hs_wordToWord64 (HsWord);
203 HsWord hs_word64ToWord (HsWord64);
204 HsInt64 hs_word64ToInt64 (HsWord64);
205
206 HsWord64 hs_integerToWord64 (HsInt sa, StgByteArray /* Really: mp_limb_t* */ da);
207 HsInt64 hs_integerToInt64 (HsInt sa, StgByteArray /* Really: mp_limb_t* */ da);
208
209 #endif /* SUPPORT_LONG_LONGS */
210
211 /* -----------------------------------------------------------------------------
212 INLINE functions.
213
214 These functions are given as inlines here for when compiling via C,
215 but we also generate static versions into the cbits library for
216 when compiling to native code.
217 -------------------------------------------------------------------------- */
218
219 #ifndef INLINE
220 # if defined(_MSC_VER)
221 # define INLINE extern __inline
222 # else
223 # define INLINE static inline
224 # endif
225 #endif
226
227 INLINE int __hscore_get_errno(void) { return errno; }
228 INLINE void __hscore_set_errno(int e) { errno = e; }
229
230 #if !defined(_MSC_VER)
231 INLINE int __hscore_s_isreg(mode_t m) { return S_ISREG(m); }
232 INLINE int __hscore_s_isdir(mode_t m) { return S_ISDIR(m); }
233 INLINE int __hscore_s_isfifo(mode_t m) { return S_ISFIFO(m); }
234 INLINE int __hscore_s_isblk(mode_t m) { return S_ISBLK(m); }
235 INLINE int __hscore_s_ischr(mode_t m) { return S_ISCHR(m); }
236 #if !defined(mingw32_HOST_OS) && !defined(__MINGW32__)
237 INLINE int __hscore_s_issock(mode_t m) { return S_ISSOCK(m); }
238 #endif
239 #endif
240
241 #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(_WIN32)
242 INLINE int
243 __hscore_sigemptyset( sigset_t *set )
244 { return sigemptyset(set); }
245
246 INLINE int
247 __hscore_sigfillset( sigset_t *set )
248 { return sigfillset(set); }
249
250 INLINE int
251 __hscore_sigaddset( sigset_t * set, int s )
252 { return sigaddset(set,s); }
253
254 INLINE int
255 __hscore_sigdelset( sigset_t * set, int s )
256 { return sigdelset(set,s); }
257
258 INLINE int
259 __hscore_sigismember( sigset_t * set, int s )
260 { return sigismember(set,s); }
261 #endif
262
263 INLINE void *
264 __hscore_memcpy_dst_off( char *dst, int dst_off, char *src, size_t sz )
265 { return memcpy(dst+dst_off, src, sz); }
266
267 INLINE void *
268 __hscore_memcpy_src_off( char *dst, char *src, int src_off, size_t sz )
269 { return memcpy(dst, src+src_off, sz); }
270
271 INLINE HsInt
272 __hscore_bufsiz()
273 {
274 return BUFSIZ;
275 }
276
277 INLINE int
278 __hscore_seek_cur()
279 {
280 return SEEK_CUR;
281 }
282
283 INLINE int
284 __hscore_o_binary()
285 {
286 #if defined(_MSC_VER)
287 return O_BINARY;
288 #else
289 return CONST_O_BINARY;
290 #endif
291 }
292
293 INLINE int
294 __hscore_o_rdonly()
295 {
296 #ifdef O_RDONLY
297 return O_RDONLY;
298 #else
299 return 0;
300 #endif
301 }
302
303 INLINE int
304 __hscore_o_wronly( void )
305 {
306 #ifdef O_WRONLY
307 return O_WRONLY;
308 #else
309 return 0;
310 #endif
311 }
312
313 INLINE int
314 __hscore_o_rdwr( void )
315 {
316 #ifdef O_RDWR
317 return O_RDWR;
318 #else
319 return 0;
320 #endif
321 }
322
323 INLINE int
324 __hscore_o_append( void )
325 {
326 #ifdef O_APPEND
327 return O_APPEND;
328 #else
329 return 0;
330 #endif
331 }
332
333 INLINE int
334 __hscore_o_creat( void )
335 {
336 #ifdef O_CREAT
337 return O_CREAT;
338 #else
339 return 0;
340 #endif
341 }
342
343 INLINE int
344 __hscore_o_excl( void )
345 {
346 #ifdef O_EXCL
347 return O_EXCL;
348 #else
349 return 0;
350 #endif
351 }
352
353 INLINE int
354 __hscore_o_trunc( void )
355 {
356 #ifdef O_TRUNC
357 return O_TRUNC;
358 #else
359 return 0;
360 #endif
361 }
362
363 INLINE int
364 __hscore_o_noctty( void )
365 {
366 #ifdef O_NOCTTY
367 return O_NOCTTY;
368 #else
369 return 0;
370 #endif
371 }
372
373 INLINE int
374 __hscore_o_nonblock( void )
375 {
376 #ifdef O_NONBLOCK
377 return O_NONBLOCK;
378 #else
379 return 0;
380 #endif
381 }
382
383 INLINE int
384 __hscore_seek_set( void )
385 {
386 return SEEK_SET;
387 }
388
389 INLINE int
390 __hscore_seek_end( void )
391 {
392 return SEEK_END;
393 }
394
395 INLINE int
396 __hscore_ftruncate( int fd, off_t where )
397 {
398 #if defined(HAVE_FTRUNCATE)
399 return ftruncate(fd,where);
400 #elif defined(HAVE__CHSIZE)
401 return _chsize(fd,where);
402 #else
403 // ToDo: we should use _chsize_s() on Windows which allows a 64-bit
404 // offset, but it doesn't seem to be available from mingw at this time
405 // --SDM (01/2008)
406 #error at least ftruncate or _chsize functions are required to build
407 #endif
408 }
409
410 INLINE int
411 __hscore_setmode( int fd, HsBool toBin )
412 {
413 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32)
414 return setmode(fd,(toBin == HS_BOOL_TRUE) ? _O_BINARY : _O_TEXT);
415 #else
416 return 0;
417 #endif
418 }
419
420 #if __GLASGOW_HASKELL__
421
422 INLINE int
423 __hscore_PrelHandle_write( int fd, void *ptr, HsInt off, int sz )
424 {
425 return write(fd,(char *)ptr + off, sz);
426 }
427
428 INLINE int
429 __hscore_PrelHandle_read( int fd, void *ptr, HsInt off, int sz )
430 {
431 return read(fd,(char *)ptr + off, sz);
432
433 }
434
435 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32)
436 INLINE int
437 __hscore_PrelHandle_send( int fd, void *ptr, HsInt off, int sz )
438 {
439 return send(fd,(char *)ptr + off, sz, 0);
440 }
441
442 INLINE int
443 __hscore_PrelHandle_recv( int fd, void *ptr, HsInt off, int sz )
444 {
445 return recv(fd,(char *)ptr + off, sz, 0);
446 }
447 #endif
448
449 #endif /* __GLASGOW_HASKELL__ */
450
451 INLINE int
452 __hscore_mkdir( char *pathName, int mode )
453 {
454 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(_WIN32)
455 return mkdir(pathName);
456 #else
457 return mkdir(pathName,mode);
458 #endif
459 }
460
461 INLINE int
462 __hscore_lstat( const char *fname, struct stat *st )
463 {
464 #if HAVE_LSTAT
465 return lstat(fname, st);
466 #else
467 return stat(fname, st);
468 #endif
469 }
470
471 INLINE char *
472 __hscore_d_name( struct dirent* d )
473 {
474 return (d->d_name);
475 }
476
477 INLINE int
478 __hscore_end_of_dir( void )
479 {
480 return READDIR_ERRNO_EOF;
481 }
482
483 INLINE void
484 __hscore_free_dirent(struct dirent *dEnt)
485 {
486 #if HAVE_READDIR_R
487 free(dEnt);
488 #endif
489 }
490
491 #if defined(__MINGW32__)
492 // We want the versions of stat/fstat/lseek that use 64-bit offsets,
493 // and you have to ask for those explicitly. Unfortunately there
494 // doesn't seem to be a 64-bit version of truncate/ftruncate, so while
495 // hFileSize and hSeek will work with large files, hSetFileSize will not.
496 #define stat(file,buf) _stati64(file,buf)
497 #define fstat(fd,buf) _fstati64(fd,buf)
498 typedef struct _stati64 struct_stat;
499 typedef off64_t stsize_t;
500 #else
501 typedef struct stat struct_stat;
502 typedef off_t stsize_t;
503 #endif
504
505 INLINE HsInt
506 __hscore_sizeof_stat( void )
507 {
508 return sizeof(struct_stat);
509 }
510
511 INLINE time_t __hscore_st_mtime ( struct_stat* st ) { return st->st_mtime; }
512 INLINE stsize_t __hscore_st_size ( struct_stat* st ) { return st->st_size; }
513 #if !defined(_MSC_VER)
514 INLINE mode_t __hscore_st_mode ( struct_stat* st ) { return st->st_mode; }
515 INLINE dev_t __hscore_st_dev ( struct_stat* st ) { return st->st_dev; }
516 INLINE ino_t __hscore_st_ino ( struct_stat* st ) { return st->st_ino; }
517 #endif
518
519 #if HAVE_TERMIOS_H
520 INLINE tcflag_t __hscore_lflag( struct termios* ts ) { return ts->c_lflag; }
521
522 INLINE void
523 __hscore_poke_lflag( struct termios* ts, tcflag_t t ) { ts->c_lflag = t; }
524
525 INLINE unsigned char*
526 __hscore_ptr_c_cc( struct termios* ts )
527 { return (unsigned char*) &ts->c_cc; }
528
529 INLINE HsInt
530 __hscore_sizeof_termios( void )
531 {
532 #ifndef __MINGW32__
533 return sizeof(struct termios);
534 #else
535 return 0;
536 #endif
537 }
538 #endif
539
540 #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(_WIN32)
541 INLINE HsInt
542 __hscore_sizeof_sigset_t( void )
543 {
544 return sizeof(sigset_t);
545 }
546 #endif
547
548 INLINE int
549 __hscore_echo( void )
550 {
551 #ifdef ECHO
552 return ECHO;
553 #else
554 return 0;
555 #endif
556
557 }
558
559 INLINE int
560 __hscore_tcsanow( void )
561 {
562 #ifdef TCSANOW
563 return TCSANOW;
564 #else
565 return 0;
566 #endif
567
568 }
569
570 INLINE int
571 __hscore_icanon( void )
572 {
573 #ifdef ICANON
574 return ICANON;
575 #else
576 return 0;
577 #endif
578 }
579
580 INLINE int __hscore_vmin( void )
581 {
582 #ifdef VMIN
583 return VMIN;
584 #else
585 return 0;
586 #endif
587 }
588
589 INLINE int __hscore_vtime( void )
590 {
591 #ifdef VTIME
592 return VTIME;
593 #else
594 return 0;
595 #endif
596 }
597
598 INLINE int __hscore_sigttou( void )
599 {
600 #ifdef SIGTTOU
601 return SIGTTOU;
602 #else
603 return 0;
604 #endif
605 }
606
607 INLINE int __hscore_sig_block( void )
608 {
609 #ifdef SIG_BLOCK
610 return SIG_BLOCK;
611 #else
612 return 0;
613 #endif
614 }
615
616 INLINE int __hscore_sig_setmask( void )
617 {
618 #ifdef SIG_SETMASK
619 return SIG_SETMASK;
620 #else
621 return 0;
622 #endif
623 }
624
625 #ifndef __MINGW32__
626 INLINE size_t __hscore_sizeof_siginfo_t (void)
627 {
628 return sizeof(siginfo_t);
629 }
630 #endif
631
632 INLINE int
633 __hscore_f_getfl( void )
634 {
635 #ifdef F_GETFL
636 return F_GETFL;
637 #else
638 return 0;
639 #endif
640 }
641
642 INLINE int
643 __hscore_f_setfl( void )
644 {
645 #ifdef F_SETFL
646 return F_SETFL;
647 #else
648 return 0;
649 #endif
650 }
651
652 INLINE int
653 __hscore_f_setfd( void )
654 {
655 #ifdef F_SETFD
656 return F_SETFD;
657 #else
658 return 0;
659 #endif
660 }
661
662 INLINE long
663 __hscore_fd_cloexec( void )
664 {
665 #ifdef FD_CLOEXEC
666 return FD_CLOEXEC;
667 #else
668 return 0;
669 #endif
670 }
671
672 // defined in rts/RtsStartup.c.
673 extern void* __hscore_get_saved_termios(int fd);
674 extern void __hscore_set_saved_termios(int fd, void* ts);
675
676 INLINE int __hscore_hs_fileno (FILE *f) { return fileno (f); }
677
678 INLINE int __hscore_open(char *file, int how, mode_t mode) {
679 #ifdef __MINGW32__
680 if ((how & O_WRONLY) || (how & O_RDWR) || (how & O_APPEND))
681 return _sopen(file,how | _O_NOINHERIT,_SH_DENYRW,mode);
682 // _O_NOINHERIT: see #2650
683 else
684 return _sopen(file,how | _O_NOINHERIT,_SH_DENYWR,mode);
685 // _O_NOINHERIT: see #2650
686 #else
687 return open(file,how,mode);
688 #endif
689 }
690
691 // These are wrapped because on some OSs (eg. Linux) they are
692 // macros which redirect to the 64-bit-off_t versions when large file
693 // support is enabled.
694 //
695 #if defined(__MINGW32__)
696 INLINE off64_t __hscore_lseek(int fd, off64_t off, int whence) {
697 return (_lseeki64(fd,off,whence));
698 }
699 #else
700 INLINE off_t __hscore_lseek(int fd, off_t off, int whence) {
701 return (lseek(fd,off,whence));
702 }
703 #endif
704
705 INLINE int __hscore_stat(char *file, struct_stat *buf) {
706 return (stat(file,buf));
707 }
708
709 INLINE int __hscore_fstat(int fd, struct_stat *buf) {
710 return (fstat(fd,buf));
711 }
712
713 // select-related stuff
714
715 #if !defined(__MINGW32__)
716 INLINE int hsFD_SETSIZE(void) { return FD_SETSIZE; }
717 INLINE int hsFD_ISSET(int fd, fd_set *fds) { return FD_ISSET(fd, fds); }
718 INLINE void hsFD_SET(int fd, fd_set *fds) { FD_SET(fd, fds); }
719 INLINE HsInt sizeof_fd_set(void) { return sizeof(fd_set); }
720 extern void hsFD_ZERO(fd_set *fds);
721 #endif
722
723 // gettimeofday()-related
724
725 #if !defined(__MINGW32__)
726
727 INLINE HsInt sizeofTimeVal(void) { return sizeof(struct timeval); }
728
729 INLINE HsWord64 getUSecOfDay(void)
730 {
731 struct timeval tv;
732 gettimeofday(&tv, (struct timezone *) NULL);
733 // Don't forget to cast *before* doing the arithmetic, otherwise
734 // the arithmetic happens at the type of tv_sec, which is probably
735 // only 'int'.
736 return ((HsWord64)tv.tv_sec * 1000000 + (HsWord64)tv.tv_usec);
737 }
738
739 INLINE void setTimevalTicks(struct timeval *p, HsWord64 usecs)
740 {
741 p->tv_sec = usecs / 1000000;
742 p->tv_usec = usecs % 1000000;
743 }
744 #endif /* !defined(__MINGW32__) */
745
746 /* ToDo: write a feature test that doesn't assume 'environ' to
747 * be in scope at link-time. */
748 extern char** environ;
749 INLINE char **__hscore_environ() { return environ; }
750
751 /* lossless conversions between pointers and integral types */
752 INLINE void * __hscore_from_uintptr(uintptr_t n) { return (void *)n; }
753 INLINE void * __hscore_from_intptr (intptr_t n) { return (void *)n; }
754 INLINE uintptr_t __hscore_to_uintptr (void *p) { return (uintptr_t)p; }
755 INLINE intptr_t __hscore_to_intptr (void *p) { return (intptr_t)p; }
756
757 void errorBelch2(const char*s, char *t);
758 void debugBelch2(const char*s, char *t);
759
760 #if !defined(mingw32_HOST_OS) && !defined(__MINGW32__)
761
762 INLINE int fcntl_read(int fd, int cmd) {
763 return fcntl(fd, cmd);
764 }
765 INLINE int fcntl_write(int fd, int cmd, long arg) {
766 return fcntl(fd, cmd, arg);
767 }
768 INLINE int fcntl_lock(int fd, int cmd, struct flock *lock) {
769 return fcntl(fd, cmd, lock);
770 }
771
772 #endif
773
774 #endif /* __HSBASE_H__ */
775