include/HsBase.h

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