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