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