include/HsBase.h

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